chore(docs): R5.6 switch patch with the M1 correction (inactive)

This commit is contained in:
bchanot committed 2026-10-25 01:28:09 +02:00
1 parent bc36d3d639
commit 8e77e37633
1 file changed
+460 -122
+460 -122
View File
@@ -9,6 +9,28 @@ index a9140e4..aaeef54 100644
+# Written by the Rust pipeline (`pnpm r5:import-equine`, R5.6): byte-exact, never reformatted.
+supabase/seed/anatomical-sheets/equine/legacy-import/
+supabase/seed/anatomical-sheets/equine/draft/
diff --git a/CLAUDE.md b/CLAUDE.md
index e664250..7773db9 100644
--- a/CLAUDE.md
+++ b/CLAUDE.md
@@ -118,7 +118,7 @@ pnpm db:types:check # CI diff
# Reference sheet in the app: the dev server bundles the curated draft; a build does not
pnpm build:preview # SHEET_BUNDLE=draft build (manual validation, preview deployments)
pnpm preview:draft # same, then serves it
-pnpm import:equine # regenerate legacy-import/ and draft/ (document, migration map, review drawings): the TypeScript writer of the seed until the R5 switch
+pnpm import:equine --check | --out <dir> # since R5.6 the official seed writer: the Rust pipeline (same as `pnpm r5:import-equine`), fingerprint `sha256-rfc8785-validated-v1`; `pnpm import:equine:legacy` = the TypeScript generator (pre-switch convention) until R5.7
pnpm r5:import-equine --check | --out <dir> # the Rust pipeline (R5.2 importer, R5.3 draft, R5.4 review files): compare the 18 generated files with the committed folders (bytes; app drawings under the declared R3 rule), or write <dir>/{legacy-import,draft} into an empty folder; never deletes (scripts/import-equine.sh, first run compiles)
pnpm assets:upload [--check] <seed folder> # R5.5: uploads the sheet drawings of a generated seed folder to the LOCAL stack's private bucket (Rust `upload-sheet-assets`, feature `upload`; SUPABASE_URL local with a port, SUPABASE_SERVICE_ROLE_KEY typed, never printed; no overwrite, confirm after verify; run by hand, scripts/upload-sheet-assets.sh); the TypeScript one is `assets:upload:legacy` until R5.7
pnpm e2e:sheet-assets # scripts/sheet-assets-e2e.sh: that tool against the local stack (upload, rerun, anon and wrong key, refused destinations); run by hand
@@ -502,7 +502,7 @@ Database (Supabase)
`publish_sheet_version`. Integrity rule codes are shared by `validateSheetDocument` (TS) and
`private.sheet_document_issues` (SQL); add a rule on both sides and in the spec table.
- Document schema change → bump `SHEET_DOCUMENT_SCHEMA_VERSION`, extend the SQL CHECK on `document_schema_version`.
-- Official equine sheet = generated seed `draft/` (`pnpm import:equine`, never edit `legacy-import/` or `draft/` by hand;
+- Official equine sheet = generated seed `draft/` (`pnpm import:equine --out` into an empty folder, then reviewed and copied; never edit `legacy-import/` or `draft/` by hand;
the golden test fails on drift). Every content change goes through `curation/changes.json` (traced in CHANGELOG.md).
It is a DRAFT until a platform admin publishes it after business review of `REVIEW-REPORT.md`.
- Sheet SVG bytes live in Storage bucket `anatomical-sheet-assets` as `<sha256>.svg`; uploads are an operator task
diff --git a/apps/app/tests/helpers/goldenReports.ts b/apps/app/tests/helpers/goldenReports.ts
index ef46bce..d66fb68 100644
--- a/apps/app/tests/helpers/goldenReports.ts
@@ -181,19 +203,22 @@ index ce5a2fd..7c15f76 100644
+name = "r5_6_switch"
+required-features = ["pdf-read", "pdf-write"]
diff --git a/crates/core/src/bin/report_compare.rs b/crates/core/src/bin/report_compare.rs
index 59cf060..91b34ef 100644
index 59cf060..0748403 100644
--- a/crates/core/src/bin/report_compare.rs
+++ b/crates/core/src/bin/report_compare.rs
@@ -37,6 +37,8 @@ struct SeedRef {
@@ -37,6 +37,11 @@ struct SeedRef {
document_sha256: String,
schema_version: f64,
species_id: String,
+ #[serde(default)]
+ #[serde(
+ default,
+ deserialize_with = "faunosteo_core::domain::sheet::loaded::present_block"
+ )]
+ fingerprint: Option<faunosteo_core::domain::sheet::loaded::DeclaredFingerprint>,
}
fn seed_json<T: for<'de> Deserialize<'de>>(name: &str) -> Result<T, String> {
@@ -58,6 +60,7 @@ fn load_sheet() -> Result<LoadedSheet, String> {
@@ -58,6 +63,7 @@ fn load_sheet() -> Result<LoadedSheet, String> {
document_sha256: reference.document_sha256,
schema_version,
species_id: reference.species_id,
@@ -287,37 +312,60 @@ index 19126aa..dcc19b6 100644
files.push(("CHANGELOG.md".to_owned(), format_report(&changelog)?));
files.push(("REVIEW-REPORT.md".to_owned(), format_report(&review)?));
files.push((DRAFT_SEED_SQL_FILE.to_owned(), seed));
diff --git a/crates/core/src/domain/archive/snapshot_rules.rs b/crates/core/src/domain/archive/snapshot_rules.rs
index 6e00fb4..ebdcb00 100644
--- a/crates/core/src/domain/archive/snapshot_rules.rs
+++ b/crates/core/src/domain/archive/snapshot_rules.rs
@@ -51,13 +51,27 @@ impl SnapshotRejection {
/// The snapshot of `sheet` that `report` needs: pure, deterministic (document order
/// everywhere). A missing asset is left out and caught by `assert_snapshot`.
+///
+/// M1 (owner 2026-10-25, R5.6): a report of this sheet stamped with the registered historical
+/// value of its verified, recomputed content gets a snapshot carrying that same stamp, so its
+/// archive holds one value and every reader (the frozen N-1 one, a rollback build) keeps it.
+/// In every other case the snapshot carries the sheet's own value, and the export's strict
+/// equality refuses a report that differs.
pub fn build_sheet_snapshot(sheet: &LoadedSheet, report: &Report) -> SheetSnapshot {
+ let stamp = &report.sheet.document_sha256;
+ let document_sha256 = if report.sheet.sheet_id == sheet.reference.sheet_id
+ && sheet.recognises_historical_stamp(&report.sheet.sheet_id, stamp)
+ {
+ stamp.clone()
+ } else {
+ sheet.reference.document_sha256.clone()
+ };
SheetSnapshot {
status: sheet.status,
reference: SheetSnapshotRef {
sheet_id: sheet.reference.sheet_id.clone(),
version_id: sheet.reference.version_id.clone(),
- document_sha256: sheet.reference.document_sha256.clone(),
+ document_sha256,
schema_version: sheet.schema_version,
species_id: sheet.species_id.clone(),
},
diff --git a/crates/core/src/domain/report/rebase.rs b/crates/core/src/domain/report/rebase.rs
index 9281642..9084cae 100644
index 9281642..9df79ed 100644
--- a/crates/core/src/domain/report/rebase.rs
+++ b/crates/core/src/domain/report/rebase.rs
@@ -5,6 +5,7 @@
//! snapshot when the report carries none, and the report now references the loaded sheet.
//! Nothing happens when the report already sits on the loaded sheet.
+use crate::domain::sheet::fingerprint::equivalence;
use serde::Serialize;
#[cfg(feature = "ts")]
use ts_rs::TS;
@@ -37,7 +38,15 @@ pub fn rebase_report_on_sheet(
@@ -37,7 +37,13 @@ pub fn rebase_report_on_sheet(
sheet: &LoadedSheet,
archived: Option<&SheetSnapshot>,
) -> Result<RebaseOutcome, ReadFailure> {
- if report.sheet.document_sha256 == sheet.reference.document_sha256 {
+ // Same document: equal fingerprints, or the registry's pair for this very sheet once its
+ // `v1` value was verified at load (R5.6).
+ let same_sheet =
+ report.sheet.sheet_id == sheet.reference.sheet_id && sheet.fingerprint_verified;
+ // Same document: equal fingerprints, or the registered historical value of this very sheet,
+ // proven against its verified, recomputed `v1` value (R5.6).
+ let stamped = &report.sheet.document_sha256;
+ let current = &sheet.reference.document_sha256;
+ if stamped == current
+ || (same_sheet && equivalence(&sheet.reference.sheet_id, stamped, current).same_document())
+ if *stamped == sheet.reference.document_sha256
+ || (report.sheet.sheet_id == sheet.reference.sheet_id
+ && sheet.recognises_historical_stamp(&report.sheet.sheet_id, stamped))
+ {
return Ok(RebaseOutcome {
report: report.clone(),
unresolved_zones: 0,
diff --git a/crates/core/src/domain/sheet/fingerprint.rs b/crates/core/src/domain/sheet/fingerprint.rs
index 0fca332..eda9746 100644
index 0fca332..81f25f6 100644
--- a/crates/core/src/domain/sheet/fingerprint.rs
+++ b/crates/core/src/domain/sheet/fingerprint.rs
@@ -1,6 +1,5 @@
@@ -364,7 +412,92 @@ index 0fca332..eda9746 100644
}
/// Checks what a `sheet-ref.json` declares (descriptive only): the convention must be `v1` and
@@ -189,10 +191,8 @@ fn write_string(text: &str, out: &mut String) {
@@ -116,20 +118,39 @@ pub fn check_declared(
Ok(())
}
-/// RFC 8785 text of a JSON value. `None` for a number with no I-JSON form (never produced by
-/// the core's parser, which refuses non-finite values).
-pub fn canonical_json(value: &Value) -> Option<String> {
+/// The deepest nesting `canonical_json` writes: serde_json's own parse limit, so every value the
+/// core parsed fits; a value built in code beyond it is refused, never a stack overflow.
+pub const MAX_CANONICAL_DEPTH: usize = 128;
+
+/// Why a value has no RFC 8785 text.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum CanonicalError {
+ /// A number with no I-JSON form (never produced by the core's parser).
+ NonFinite,
+ /// Containers nested deeper than `MAX_CANONICAL_DEPTH`.
+ TooDeep,
+}
+
+/// RFC 8785 text of a JSON value.
+pub fn canonical_json(value: &Value) -> Result<String, CanonicalError> {
let mut out = String::new();
- write_value(value, &mut out)?;
- Some(out)
+ write_value(value, 0, &mut out)?;
+ Ok(out)
}
-fn write_value(value: &Value, out: &mut String) -> Option<()> {
+fn write_value(value: &Value, depth: usize, out: &mut String) -> Result<(), CanonicalError> {
+ let nested = matches!(value, Value::Array(_) | Value::Object(_));
+ if nested && depth >= MAX_CANONICAL_DEPTH {
+ return Err(CanonicalError::TooDeep);
+ }
match value {
Value::Null => out.push_str("null"),
Value::Bool(flag) => out.push_str(if *flag { "true" } else { "false" }),
Value::Number(number) => {
- let float = number.as_f64().filter(|f| f.is_finite())?;
+ let float = number
+ .as_f64()
+ .filter(|f| f.is_finite())
+ .ok_or(CanonicalError::NonFinite)?;
out.push_str(&js_number(float));
}
Value::String(text) => write_string(text, out),
@@ -139,16 +160,20 @@ fn write_value(value: &Value, out: &mut String) -> Option<()> {
if index > 0 {
out.push(',');
}
- write_value(item, out)?;
+ write_value(item, depth + 1, out)?;
}
out.push(']');
}
- Value::Object(map) => write_object(map, out)?,
+ Value::Object(map) => write_object(map, depth, out)?,
}
- Some(())
+ Ok(())
}
-fn write_object(map: &serde_json::Map<String, Value>, out: &mut String) -> Option<()> {
+fn write_object(
+ map: &serde_json::Map<String, Value>,
+ depth: usize,
+ out: &mut String,
+) -> Result<(), CanonicalError> {
let mut entries: Vec<(Vec<u16>, &String, &Value)> = map
.iter()
.map(|(key, item)| (key.encode_utf16().collect(), key, item))
@@ -161,10 +186,10 @@ fn write_object(map: &serde_json::Map<String, Value>, out: &mut String) -> Optio
}
write_string(key, out);
out.push(':');
- write_value(item, out)?;
+ write_value(item, depth + 1, out)?;
}
out.push('}');
- Some(())
+ Ok(())
}
/// `JSON.stringify` of a string: `"` `\` and the controls escaped (short forms where JSON has
@@ -189,41 +214,49 @@ fn write_string(text: &str, out: &mut String) {
out.push('"');
}
@@ -376,7 +509,20 @@ index 0fca332..eda9746 100644
mod hashing {
use sha2::{Digest, Sha256};
@@ -211,18 +211,26 @@ mod hashing {
use super::canonical_json;
use crate::domain::js::parse_json;
use crate::domain::sheet::schema::AnatomicalSheetDocument;
- use crate::domain::sheet::validate::validate_sheet_document;
+ use crate::domain::sheet::validate::{is_publishable, validate_sheet_document};
/// Why a document has no fingerprint: an invalid sheet is never stamped.
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum FingerprintError {
Parse(String),
Shape(String),
- /// The integrity rules found issues (their count).
+ /// The integrity rules found errors (the count of every issue found).
Invalid(usize),
Canonical,
}
@@ -389,6 +535,7 @@ index 0fca332..eda9746 100644
let document: AnatomicalSheetDocument =
serde_json::from_value(value).map_err(|e| FingerprintError::Shape(e.to_string()))?;
- let issues = validate_sheet_document(&document);
- if !issues.is_empty() {
+ document_fingerprint(&document)
+ }
+
@@ -397,37 +544,51 @@ index 0fca332..eda9746 100644
+ pub fn document_fingerprint(
+ document: &AnatomicalSheetDocument,
+ ) -> Result<String, FingerprintError> {
+ // Integrity errors refuse a fingerprint; warnings do not (`is_publishable`: a draft may
+ // hold an annotation with no finding zone or an unreferenced zone, R5.6 rehearsal).
+ let issues = validate_sheet_document(document);
if !issues.is_empty() {
+ if !is_publishable(&issues) {
return Err(FingerprintError::Invalid(issues.len()));
}
let validated =
- serde_json::to_value(&document).map_err(|e| FingerprintError::Shape(e.to_string()))?;
- let canonical = canonical_json(&validated).ok_or(FingerprintError::Canonical)?;
+ serde_json::to_value(document).map_err(|e| FingerprintError::Shape(e.to_string()))?;
let canonical = canonical_json(&validated).ok_or(FingerprintError::Canonical)?;
+ let canonical = canonical_json(&validated).map_err(|_| FingerprintError::Canonical)?;
Ok(Sha256::digest(canonical.as_bytes())
.iter()
.map(|byte| format!("{byte:02x}"))
diff --git a/crates/core/src/domain/sheet/loaded.rs b/crates/core/src/domain/sheet/loaded.rs
index 4065978..3030989 100644
index 4065978..afc7f33 100644
--- a/crates/core/src/domain/sheet/loaded.rs
+++ b/crates/core/src/domain/sheet/loaded.rs
@@ -6,6 +6,7 @@ use std::collections::HashMap;
@@ -6,6 +6,9 @@ use std::collections::HashMap;
use serde::Deserialize;
+use super::fingerprint::{AliasRefusal, check_declared, document_fingerprint};
+use super::fingerprint::{
+ AliasRefusal, Equivalence, check_declared, document_fingerprint, equivalence,
+};
use super::index::{IndexedDocument, NoMainView, SheetIndex};
use super::schema::AnatomicalSheetDocument;
use crate::anatomy::svg::{Element, read_svg};
@@ -33,6 +34,16 @@ pub struct BundledRef {
@@ -33,6 +36,24 @@ pub struct BundledRef {
pub document_sha256: String,
pub schema_version: JsInt,
pub species_id: String,
+ /// Descriptive (R5.6): checked against the core's registry at load, never trusted alone.
+ #[serde(default)]
+ /// Absent: a historical (v0) reference; present, it must be a valid block (`null` refused).
+ #[serde(default, deserialize_with = "present_block")]
+ pub fingerprint: Option<DeclaredFingerprint>,
+}
+
+/// `fingerprint` present means a block: an explicit `null` is refused, not read as absent.
+pub fn present_block<'de, D: serde::Deserializer<'de>>(
+ deserializer: D,
+) -> Result<Option<DeclaredFingerprint>, D::Error> {
+ DeclaredFingerprint::deserialize(deserializer).map(Some)
+}
+
+#[derive(Debug, Clone, Deserialize)]
+#[serde(deny_unknown_fields)]
+pub struct DeclaredFingerprint {
@@ -436,18 +597,17 @@ index 4065978..3030989 100644
}
/// A loaded, indexed sheet.
@@ -49,6 +60,10 @@ pub struct LoadedSheet {
@@ -49,6 +70,9 @@ pub struct LoadedSheet {
/// sha256 by `svg_asset_id`; carried into an archive as provenance.
pub asset_hashes: HashMap<String, String>,
pub migration_map: ReportMigrationMap,
+ /// The reference declared `v1` and its value was recomputed from the document (R5.6): only
+ /// then does a registered historical stamp count as this sheet's. A historical reference
+ /// (no block) loads as before, with no alias privilege.
+ pub fingerprint_verified: bool,
+ /// The `v1` value the loader recomputed from the document and found declared (R5.6); `None`
+ /// for a historical reference (no block). Private: only `from_bundle` sets it.
+ verified_fingerprint: Option<String>,
index: SheetIndex,
/// Each asset read once at load (R3): the sanitised tree, or why it cannot be drawn. A
/// rejection only affects the views on that asset; `assets` keeps the raw texts (the
@@ -76,6 +91,8 @@ pub enum LoadError {
@@ -76,6 +100,8 @@ pub enum LoadError {
Shape(serde_json::Error),
/// The document has no main view.
NoMainView,
@@ -456,24 +616,50 @@ index 4065978..3030989 100644
}
impl From<serde_json::Error> for LoadError {
@@ -102,6 +119,8 @@ impl LoadedSheet {
@@ -102,6 +128,9 @@ impl LoadedSheet {
.map(|(id, text)| (id.clone(), read_drawing(text)))
.collect();
let r = data.reference;
+ let fingerprint_verified =
+ check_reference(&r, &document).map_err(LoadError::Fingerprint)?;
+ let verified_fingerprint = check_reference(&r, &document)
+ .map_err(LoadError::Fingerprint)?
+ .then(|| r.document_sha256.clone());
Ok(Self {
status: data.status,
reference: SheetRef {
@@ -115,6 +134,7 @@ impl LoadedSheet {
@@ -115,11 +144,32 @@ impl LoadedSheet {
assets: data.assets,
asset_hashes: data.asset_hashes,
migration_map,
+ fingerprint_verified,
+ verified_fingerprint,
index,
drawings,
})
@@ -133,3 +153,28 @@ impl LoadedSheet {
}
+ /// Whether the loader verified a `v1` reference (no alias privilege otherwise).
+ pub fn is_fingerprint_verified(&self) -> bool {
+ self.verified_fingerprint.is_some()
+ }
+
+ /// Whether `stamp`, carried by a report of this sheet, is the registered historical value of
+ /// this sheet's current content (R5.6, owner M1 rules): the loader verified a `v1` reference,
+ /// the document as it stands now recomputes to that same value, and the registry binds `stamp`
+ /// to it for this sheet. No declared or stored value stands in for the recomputation, so a
+ /// mutated document or reference, a v0 sheet, another sheet or a forged stamp never qualify.
+ pub fn recognises_historical_stamp(&self, sheet_id: &str, stamp: &str) -> bool {
+ let Some(verified) = &self.verified_fingerprint else {
+ return false;
+ };
+ sheet_id == self.reference.sheet_id
+ && *verified == self.reference.document_sha256
+ && equivalence(sheet_id, stamp, verified) == Equivalence::TrustedAlias
+ && document_fingerprint(&self.document).is_ok_and(|now| now == *verified)
+ }
+
pub fn indexed(&self) -> IndexedDocument<'_> {
self.index.over(&self.document)
}
@@ -133,3 +183,28 @@ impl LoadedSheet {
self.drawings.get(asset_id)
}
}
@@ -515,31 +701,32 @@ index f0c6997..7f73cff 100644
}
diff --git a/crates/core/src/pdf/compare/lines.rs b/crates/core/src/pdf/compare/lines.rs
index 35e8dd2..3753529 100644
index 35e8dd2..7a33db6 100644
--- a/crates/core/src/pdf/compare/lines.rs
+++ b/crates/core/src/pdf/compare/lines.rs
@@ -2,6 +2,7 @@
//! current label next to the archived one, `!! UNRESOLVED` with the reason where the sheet
//! cannot place an item. Every untrusted string goes through [`esc`].
+use crate::domain::sheet::fingerprint::{Equivalence, equivalence};
+use crate::domain::sheet::fingerprint::Equivalence;
use serde::Deserialize;
use serde_json::Value;
@@ -346,13 +347,32 @@ fn archive_line(outcome: &ArchiveReadOutcome) -> Vec<String> {
@@ -346,13 +347,33 @@ fn archive_line(outcome: &ArchiveReadOutcome) -> Vec<String> {
fn sheet_line(report: &Report, sheet: &LoadedSheet) -> String {
let reference = &sheet.reference;
- let same_sheet = report.sheet.sheet_id == reference.sheet_id
- && report.sheet.document_sha256 == reference.document_sha256;
+ let same = match equivalence(
+ &reference.sheet_id,
+ &report.sheet.document_sha256,
+ &reference.document_sha256,
+ ) {
+ // The alias privilege needs the loaded sheet's verified `v1` value (R5.6).
+ Equivalence::TrustedAlias if !sheet.fingerprint_verified => Equivalence::Different,
+ other => other,
+ let same = if report.sheet.document_sha256 == reference.document_sha256 {
+ Equivalence::Identical
+ } else if sheet
+ .recognises_historical_stamp(&report.sheet.sheet_id, &report.sheet.document_sha256)
+ {
+ // The registered historical value of this sheet's verified, recomputed content (R5.6).
+ Equivalence::TrustedAlias
+ } else {
+ Equivalence::Different
+ };
+ let same_sheet = report.sheet.sheet_id == reference.sheet_id && same.same_document();
if same_sheet {
@@ -561,66 +748,6 @@ index 35e8dd2..3753529 100644
return format!(
"sheet {} ({status}, matches the bundled sheet)",
esc(&reference.sheet_id)
diff --git a/crates/core/src/pdf/write/input.rs b/crates/core/src/pdf/write/input.rs
index 120249a..23734ac 100644
--- a/crates/core/src/pdf/write/input.rs
+++ b/crates/core/src/pdf/write/input.rs
@@ -2,6 +2,7 @@
//! branding and the labels through their schemas again, the snapshot gate with every asset
//! accepted by the SVG reader, the report's sheet and the page caps. Today's error kinds.
+use crate::domain::sheet::fingerprint::{Equivalence, equivalence};
use std::collections::HashMap;
use serde::{Deserialize, Serialize};
@@ -203,9 +204,12 @@ fn reason_of(rejection: SnapshotRejection) -> String {
/// Steps 2 and 3: the report belongs to this sheet and fits the page budget.
fn assert_exportable(report: &Report, snapshot: &SheetSnapshot) -> Result<(), ExportError> {
let reference = &snapshot.reference;
- if report.sheet.sheet_id != reference.sheet_id
- || report.sheet.document_sha256 != reference.document_sha256
- {
+ let same = equivalence(
+ &reference.sheet_id,
+ &report.sheet.document_sha256,
+ &reference.document_sha256,
+ );
+ if report.sheet.sheet_id != reference.sheet_id || !same.same_document() {
return Err(error(ExportErrorKind::SheetMismatch, ""));
}
if report.observations.len() > MAX_OBSERVATIONS {
@@ -225,11 +229,30 @@ fn assert_exportable(report: &Report, snapshot: &SheetSnapshot) -> Result<(), Ex
Ok(())
}
+/// M1 (owner 2026-10-24, option 1): an old report on the registered historical fingerprint of
+/// this very sheet, exported against the sheet's verified canonical value, archives a snapshot
+/// that carries the report's own stamp, so the envelope holds one value and every reader (the
+/// frozen N-1 one, a rollback build) keeps the snapshot. Only the registered pair of the same
+/// sheet: any other combination was refused by `assert_exportable`, and a new report already
+/// carries the canonical value.
+fn keep_the_report_stamp(report: &Report, snapshot: &mut SheetSnapshot) {
+ let reference = &snapshot.reference;
+ let same = equivalence(
+ &reference.sheet_id,
+ &report.sheet.document_sha256,
+ &reference.document_sha256,
+ );
+ if same == Equivalence::TrustedAlias && report.sheet.sheet_id == reference.sheet_id {
+ snapshot.reference.document_sha256 = report.sheet.document_sha256.clone();
+ }
+}
+
/// Every check of export.ts before a page is drawn, in its order.
pub fn check_input(input: ExportInput) -> Result<CheckedInput, ExportError> {
let (branding, labels) = typed_branding(&input)?;
- let (snapshot, assets) = checked_snapshot(&input.sheet_snapshot)?;
+ let (mut snapshot, assets) = checked_snapshot(&input.sheet_snapshot)?;
assert_exportable(&input.report, &snapshot)?;
+ keep_the_report_stamp(&input.report, &mut snapshot);
let index = SheetIndex::build(&snapshot.document)
.map_err(|NoMainView| error(ExportErrorKind::SnapshotInvalid, "no main view"))?;
Ok(CheckedInput {
diff --git a/crates/core/tests/curation_draft.rs b/crates/core/tests/curation_draft.rs
index 31c9ffc..ba3b2c1 100644
--- a/crates/core/tests/curation_draft.rs
@@ -1762,7 +1889,7 @@ index 0000000..5633394
+ "species_id": "equine"
+}
diff --git a/crates/core/tests/pdf_compare.rs b/crates/core/tests/pdf_compare.rs
index c864071..c445999 100644
index c864071..d3fc0e1 100644
--- a/crates/core/tests/pdf_compare.rs
+++ b/crates/core/tests/pdf_compare.rs
@@ -27,24 +27,58 @@ use serde_json::{Value, json};
@@ -1896,7 +2023,7 @@ index c864071..c445999 100644
+ assert_eq!(got.exit_code, row.exit_code, "exit code of `{args}`");
+ }
+ assert_eq!(aliased, 77, "rows through the alias");
+ assert!(switched_sheet().fingerprint_verified && !draft_sheet().fingerprint_verified);
+ assert!(switched_sheet().is_fingerprint_verified() && !draft_sheet().is_fingerprint_verified());
}
diff --git a/crates/core/tests/pdf_import.rs b/crates/core/tests/pdf_import.rs
index 97f13ec..05fcdf3 100644
@@ -2003,10 +2130,10 @@ index 97f13ec..05fcdf3 100644
file: &str,
diff --git a/crates/core/tests/r5_6_switch.rs b/crates/core/tests/r5_6_switch.rs
new file mode 100644
index 0000000..44b07e5
index 0000000..07d5064
--- /dev/null
+++ b/crates/core/tests/r5_6_switch.rs
@@ -0,0 +1,265 @@
@@ -0,0 +1,427 @@
+//! The R5.6 switch on the switched seed (owner 2026-10-24 « corrections préalables à la
+//! bascule » §1, M1 option 1): an old PDF stamped with the registered historical value opens
+//! with no rebase; re-exported, its snapshot keeps the report's stamp, so the current reader,
@@ -2260,20 +2387,182 @@ index 0000000..44b07e5
+ json_file(&format!("{PRE_SWITCH}/sheet-ref.json")),
+ map.clone(),
+ );
+ assert!(!rollback.unwrap().fingerprint_verified);
+ assert!(!rollback.unwrap().is_fingerprint_verified());
+ let mut v0_with_v1_value = good.clone();
+ v0_with_v1_value
+ .as_object_mut()
+ .unwrap()
+ .remove("fingerprint");
+ let unverified = sheet_with_ref(v0_with_v1_value, map).unwrap();
+ assert!(!unverified.fingerprint_verified);
+ assert!(!unverified.is_fingerprint_verified());
+ let import = import_archive(&unverified, &old_envelope().to_string()).unwrap();
+ assert!(import.rebase.rebased);
+ assert!(draft_sheet().fingerprint_verified);
+ assert!(draft_sheet().is_fingerprint_verified());
+}
+
+// ---------------------------------------------------------------------------
+// M1 correction (owner 2026-10-25): the direct APIs, not only the application's paths.
+
+fn old_report() -> faunosteo_core::domain::report::Report {
+ from(old_envelope()["report"].clone())
+}
+
+/// The direct export: a snapshot built by the core for `sheet`, then `export_pdf`.
+fn export_on(
+ sheet: &LoadedSheet,
+ report: &faunosteo_core::domain::report::Report,
+) -> Result<Vec<u8>, String> {
+ let envelope = old_envelope();
+ let input = ExportInput {
+ sheet_snapshot: serde_json::to_value(build_sheet_snapshot(sheet, report)).unwrap(),
+ report: report.clone(),
+ branding: envelope["branding"].clone(),
+ labels: envelope["labels"].clone(),
+ locale: from(envelope["locale"].clone()),
+ exported_at: "2026-10-25T12:00:00.000Z".into(),
+ };
+ export_pdf(input, &Rasters::default())
+ .map(|r| r.pdf)
+ .map_err(|e| format!("{e:?}"))
+}
+
+#[test]
+fn the_direct_export_on_an_unverified_v0_sheet_with_the_canonical_value_is_refused() {
+ let map = json_file(&format!("{DRAFT}/report-migration-map.json"));
+ let mut v0 = json_file(&format!("{DRAFT}/sheet-ref.json"));
+ v0.as_object_mut().unwrap().remove("fingerprint");
+ let sheet = sheet_with_ref(v0, map).unwrap();
+ assert!(!sheet.is_fingerprint_verified());
+ let snapshot = build_sheet_snapshot(&sheet, &old_report());
+ assert_eq!(snapshot.reference.document_sha256, canonical());
+ let refused = export_on(&sheet, &old_report()).unwrap_err();
+ assert!(refused.contains("SheetMismatch"), "{refused}");
+}
+
+#[test]
+fn a_mutated_document_or_reference_never_keeps_the_alias() {
+ let mut document = draft_sheet();
+ document.document.name.fr = "Fiche modifiée après chargement".into();
+ assert!(!document.recognises_historical_stamp(&document.reference.sheet_id.clone(), alias()));
+ assert!(export_on(&document, &old_report()).is_err());
+ let mut reference = draft_sheet();
+ reference.reference.document_sha256 = "f".repeat(64);
+ assert!(!reference.recognises_historical_stamp(&reference.reference.sheet_id.clone(), alias()));
+ assert!(export_on(&reference, &old_report()).is_err());
+ // Untouched, the same sheet grants it, and the direct export writes one stamp.
+ let sheet = draft_sheet();
+ assert!(sheet.recognises_historical_stamp(&sheet.reference.sheet_id, alias()));
+ let written = attachment(&export_on(&sheet, &old_report()).unwrap());
+ assert_eq!(written["sheetSnapshot"]["ref"]["documentSha256"], alias());
+}
+
+#[test]
+fn the_historical_value_on_another_sheet_id_is_not_recognised() {
+ let sheet = draft_sheet();
+ assert!(!sheet.recognises_historical_stamp("00000000-0000-0000-0000-000000000000", alias()));
+ let mut report = old_report();
+ report.sheet.sheet_id = "00000000-0000-0000-0000-000000000000".into();
+ assert_eq!(
+ build_sheet_snapshot(&sheet, &report)
+ .reference
+ .document_sha256,
+ canonical()
+ );
+ assert!(export_on(&sheet, &report).is_err());
+ let import_other = {
+ let mut envelope = old_envelope();
+ envelope["report"]["sheet"]["sheetId"] = json!("00000000-0000-0000-0000-000000000000");
+ import_archive(&sheet, &envelope.to_string()).unwrap()
+ };
+ assert!(import_other.rebase.rebased);
+}
+
+#[test]
+fn a_v1_block_whose_value_contradicts_the_content_is_refused_at_load() {
+ let mut document = json_file(&format!("{DRAFT}/document.json"));
+ document["name"]["fr"] = json!("Contenu modifié, tampon conservé");
+ let base = draft_sheet();
+ let assets: serde_json::Map<String, Value> = base
+ .assets
+ .iter()
+ .map(|(k, v)| (k.clone(), json!(v)))
+ .collect();
+ let data: Result<BundledSheetData, _> = serde_json::from_value(json!({
+ "status": "draft",
+ "ref": json_file(&format!("{DRAFT}/sheet-ref.json")),
+ "document": document,
+ "migrationMap": json_file(&format!("{DRAFT}/report-migration-map.json")),
+ "assets": assets,
+ "assetHashes": {},
+ }));
+ let refused = LoadedSheet::from_bundle(data.unwrap()).unwrap_err();
+ assert!(
+ format!("{refused:?}").contains("ContentMismatch"),
+ "{refused:?}"
+ );
+}
+
+#[test]
+fn an_explicit_null_block_is_refused_and_an_absent_one_is_v0() {
+ let map = json_file(&format!("{DRAFT}/report-migration-map.json"));
+ let mut null_block = json_file(&format!("{DRAFT}/sheet-ref.json"));
+ null_block["fingerprint"] = Value::Null;
+ let refused = sheet_with_ref(null_block, map.clone()).unwrap_err();
+ assert!(refused.starts_with("shape:"), "{refused}");
+ let mut malformed = json_file(&format!("{DRAFT}/sheet-ref.json"));
+ malformed["fingerprint"] = json!("sha256-rfc8785-validated-v1");
+ assert!(sheet_with_ref(malformed, map.clone()).is_err());
+ let absent = sheet_with_ref(json_file(&format!("{PRE_SWITCH}/sheet-ref.json")), map).unwrap();
+ assert!(!absent.is_fingerprint_verified());
+}
+
+#[test]
+fn a_v1_sheet_carrying_only_draft_warnings_loads() {
+ use faunosteo_core::domain::sheet::validate::{SheetIssueSeverity, validate_sheet_document};
+ let mut document = json_file(&format!("{DRAFT}/document.json"));
+ document["annotations"][0]["finding_zone_id"] = Value::Null;
+ let typed = from(document.clone());
+ let issues = validate_sheet_document(&typed);
+ assert!(!issues.is_empty());
+ assert!(
+ issues
+ .iter()
+ .all(|i| i.severity == SheetIssueSeverity::Warning),
+ "{issues:?}"
+ );
+ let value = document_fingerprint(&typed).unwrap();
+ let mut reference = json_file(&format!("{DRAFT}/sheet-ref.json"));
+ reference["document_sha256"] = json!(value);
+ reference["fingerprint"]["aliases"] = json!([]);
+ let base = draft_sheet();
+ let assets: serde_json::Map<String, Value> = base
+ .assets
+ .iter()
+ .map(|(k, v)| (k.clone(), json!(v)))
+ .collect();
+ let hashes: serde_json::Map<String, Value> = base
+ .asset_hashes
+ .iter()
+ .map(|(k, v)| (k.clone(), json!(v)))
+ .collect();
+ let sheet = loaded(
+ reference,
+ document,
+ json_file(&format!("{DRAFT}/report-migration-map.json")),
+ Value::Object(assets),
+ Value::Object(hashes),
+ );
+ assert!(sheet.is_fingerprint_verified());
+ // Another content: an old report on it is no alias, it rebases.
+ assert!(
+ import_archive(&sheet, &old_envelope().to_string())
+ .unwrap()
+ .rebase
+ .rebased
+ );
+}
diff --git a/crates/core/tests/sheet_fingerprint.rs b/crates/core/tests/sheet_fingerprint.rs
index 79a9e09..f298826 100644
index 79a9e09..3707e95 100644
--- a/crates/core/tests/sheet_fingerprint.rs
+++ b/crates/core/tests/sheet_fingerprint.rs
@@ -126,17 +126,16 @@ fn the_registry_holds_one_pair_bound_to_the_equine_sheet() {
@@ -2316,6 +2605,34 @@ index 79a9e09..f298826 100644
}
#[test]
@@ -268,3 +267,27 @@ fn v1_never_carries_the_historical_value_or_a_malformed_one() {
);
}
}
+
+fn nested(depth: usize) -> Value {
+ let mut value = Value::from(1);
+ for _ in 0..depth {
+ value = Value::Array(vec![value]);
+ }
+ value
+}
+
+#[test]
+fn nesting_is_bounded_with_a_controlled_error() {
+ use faunosteo_core::domain::sheet::fingerprint::{CanonicalError, MAX_CANONICAL_DEPTH};
+ assert_eq!(MAX_CANONICAL_DEPTH, 128);
+ assert!(canonical_json(&nested(MAX_CANONICAL_DEPTH)).is_ok());
+ assert_eq!(
+ canonical_json(&nested(MAX_CANONICAL_DEPTH + 1)),
+ Err(CanonicalError::TooDeep)
+ );
+ let mut object = Value::from(1);
+ for _ in 0..=MAX_CANONICAL_DEPTH {
+ object = serde_json::json!({ "k": object });
+ }
+ assert_eq!(canonical_json(&object), Err(CanonicalError::TooDeep));
+}
diff --git a/package.json b/package.json
index 6907a5a..02b42a7 100644
--- a/package.json
@@ -2573,6 +2890,27 @@ index e0593ef..2fcb5e5 100644
+ )
+ })
+})
diff --git a/scripts/import-equine.sh b/scripts/import-equine.sh
index 011f78d..861b227 100755
--- a/scripts/import-equine.sh
+++ b/scripts/import-equine.sh
@@ -1,12 +1,12 @@
#!/usr/bin/env bash
-# `pnpm r5:import-equine --check | --out <dir>`: the anatomical pipeline on the core (R5.2 to
-# R5.4), the `import-equine` binary of crates/core behind its `curation` feature, on the native
+# `pnpm import:equine --check | --out <dir>` (alias `pnpm r5:import-equine`): the official
+# writer of the seed since R5.6, the anatomical pipeline on the core (R5.2 to R5.6), the `import-equine` binary of crates/core behind its `curation` feature, on the native
# toolchain of the development machine (scripts/rust-env.sh). The first run compiles it
# (release profile); the next ones start at once. `--check` compares the produced folders with
# the committed seed and writes nothing; `--out <dir>` writes `<dir>/legacy-import` and
# `<dir>/draft` into an absent or empty folder (a relative path is typed from the folder pnpm
-# was run in, INIT_CWD). The TypeScript `pnpm import:equine` stays the writer of the seed until
-# the R5 switch.
+# was run in, INIT_CWD). The TypeScript generator stays reachable as `pnpm import:equine:legacy`
+# (pre-switch fingerprint convention) until R5.7.
set -euo pipefail
cd "$(dirname "$0")/.."
diff --git a/scripts/rust-check.sh b/scripts/rust-check.sh
index d5f8207..568c1bc 100755
--- a/scripts/rust-check.sh