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