From 8e77e376338fcc2648006af896786dfb0a0cee8c Mon Sep 17 00:00:00 2001 From: bchanot Date: Sun, 25 Oct 2026 01:28:09 +0200 Subject: [PATCH] chore(docs): R5.6 switch patch with the M1 correction (inactive) --- .claude/tasks/plans/r5-6-switch.patch | 582 ++++++++++++++++++++------ 1 file changed, 460 insertions(+), 122 deletions(-) diff --git a/.claude/tasks/plans/r5-6-switch.patch b/.claude/tasks/plans/r5-6-switch.patch index 99263d8c..0ab16723 100644 --- a/.claude/tasks/plans/r5-6-switch.patch +++ b/.claude/tasks/plans/r5-6-switch.patch @@ -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 # 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 # 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 /{legacy-import,draft} into an empty folder; never deletes (scripts/import-equine.sh, first run compiles) + pnpm assets:upload [--check] # 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 `.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, } fn seed_json Deserialize<'de>>(name: &str) -> Result { -@@ -58,6 +60,7 @@ fn load_sheet() -> Result { +@@ -58,6 +63,7 @@ fn load_sheet() -> Result { 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 { - 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 { ++/// 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 { + 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, out: &mut String) -> Option<()> { ++fn write_object( ++ map: &serde_json::Map, ++ depth: usize, ++ out: &mut String, ++) -> Result<(), CanonicalError> { + let mut entries: Vec<(Vec, &String, &Value)> = map + .iter() + .map(|(key, item)| (key.encode_utf16().collect(), key, item)) +@@ -161,10 +186,10 @@ fn write_object(map: &serde_json::Map, 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 { ++ // 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, +} + ++/// `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, 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, 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, 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 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 { +@@ -346,13 +347,33 @@ fn archive_line(outcome: &ArchiveReadOutcome) -> Vec { 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 { - 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, 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 = base ++ .assets ++ .iter() ++ .map(|(k, v)| (k.clone(), json!(v))) ++ .collect(); ++ let data: Result = 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 = base ++ .assets ++ .iter() ++ .map(|(k, v)| (k.clone(), json!(v))) ++ .collect(); ++ let hashes: serde_json::Map = 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 `: 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 ` (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 ` writes `/legacy-import` and + # `/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