Bound auxiliary artifact byte hashing

Signed-off-by: Nelson Spence <nelson@projectnavi.ai>

Author: Fieldnote-Echo

CHANGELOG.md

@@ -18,8 +18,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 - Added bounded parser/report defaults to `ordvec-manifest` verification for
   manifest JSON size, row-identity JSONL line length, row count,
-  duplicate-tracking memory, auxiliary artifact declaration count, report issue
-  count, and SQLite cached report size.
+  duplicate-tracking memory, auxiliary artifact declaration count and bytes,
+  report issue count, and SQLite cached report size.
 
 ### Added
 

docs/INDEX_PROVENANCE.md

@@ -68,8 +68,8 @@ The manifest verifier checks:
   whose `row_id` equals the zero-based line number and whose `db_id` is
   non-empty, NUL-free, and unique by default;
 - declared auxiliary artifacts, checking each caller-named sidecar's path,
-  SHA-256 digest, and byte length under the same default path policy as the
-  primary index artifact;
+  SHA-256 digest, byte length, and configured byte ceiling under the same
+  default path policy as the primary index artifact;
 - optional `calibration` profile references, checking profile identity,
   path/hash integrity, encoder identity, and ordinalization compatibility;
 - attestation **shape** only: predicate type, builder id when present, and at
@@ -81,8 +81,8 @@ secondary indexes, or stores that a caller intends to load together with the
 ordvec index. The verifier does not interpret those bytes; it only reports
 whether declared required members were verified, whether optional members were
 present or absent, and whether any declared member failed path, size, or digest
-checks. Callers should load sidecars only after the relevant declaration is
-verified.
+checks or exceeded the configured auxiliary artifact byte limit. Callers should
+load sidecars only after the relevant declaration is verified.
 
 When present, `calibration` binds an index artifact to a hashed ordinal profile
 used to interpret overlap, bucket, sign, or rank evidence under a calibrated

ordvec-manifest/README.md

@@ -38,6 +38,8 @@ Stable limit codes are part of the contract:
   (`row_identity_duplicate_tracking_limit_exceeded`);
 - auxiliary artifact declarations: 1,024
   (`auxiliary_artifact_count_limit_exceeded`);
+- auxiliary artifact bytes per declared file: 64 MiB
+  (`auxiliary_artifact_file_too_large`);
 - collected report issues: 1,024, after which a
   `verification_report_issue_limit_exceeded` issue is emitted;
 - SQLite cached report JSON: 4 MiB (`sqlite_cached_report_too_large`).
@@ -46,8 +48,9 @@ The CLI exposes matching override flags on `inspect`, `verify`, `create`,
 `sqlite verify`, and `sqlite activate`: `--max-manifest-bytes`,
 `--max-row-map-line-bytes`, `--max-row-map-rows`,
 `--max-row-map-tracked-id-bytes`, `--max-auxiliary-artifacts`,
-`--max-report-issues`, and `--max-cached-report-bytes`. Library callers can
-override the same ceilings via `VerifyOptions::limits`.
+`--max-auxiliary-artifact-bytes`, `--max-report-issues`, and
+`--max-cached-report-bytes`. Library callers can override the same ceilings via
+`VerifyOptions::limits`.
 
 Stable limit codes:
 
@@ -58,6 +61,7 @@ Stable limit codes:
 | row-identity JSONL rows | `row_identity_row_count_limit_exceeded` | `row_identity_row_count_limit_exceeded` |
 | row-identity duplicate-tracking `db_id` bytes | `row_identity_duplicate_tracking_limit_exceeded` | `row_identity_duplicate_tracking_limit_exceeded` |
 | auxiliary artifact declarations | `auxiliary_artifact_count_limit_exceeded` | n/a |
+| auxiliary artifact bytes per declared file | `auxiliary_artifact_file_too_large` | n/a |
 | collected verification report issues | `verification_report_issue_limit_exceeded` | n/a |
 | SQLite cached report JSON bytes | n/a | `sqlite_cached_report_too_large` |
 

ordvec-manifest/src/lib.rs

@@ -19,6 +19,7 @@ pub const DEFAULT_MAX_ROW_IDENTITY_JSONL_LINE_BYTES: usize = 64 * 1024;
 pub const DEFAULT_MAX_ROW_IDENTITY_ROWS: usize = 10_000_000;
 pub const DEFAULT_MAX_ROW_IDENTITY_TRACKED_DB_ID_BYTES: usize = 64 * 1024 * 1024;
 pub const DEFAULT_MAX_AUXILIARY_ARTIFACTS: usize = 1024;
+pub const DEFAULT_MAX_AUXILIARY_ARTIFACT_BYTES: u64 = 64 * 1024 * 1024;
 pub const DEFAULT_MAX_REPORT_ISSUES: usize = 1024;
 pub const DEFAULT_MAX_CACHED_REPORT_BYTES: u64 = 4 * 1024 * 1024;
 
@@ -1238,7 +1239,12 @@ fn verify_auxiliary_artifacts(
         match resolve_auxiliary_artifact_path(artifact, &document.base_dir, options, report) {
             AuxiliaryPathResolution::Resolved(resolved) => {
                 entry.canonical_path = Some(path_to_display(&resolved.canonical_path));
-                match sha256_file(&resolved.resolved_path) {
+                match sha256_file_bounded(
+                    &resolved.resolved_path,
+                    options.limits.max_auxiliary_artifact_bytes,
+                    "auxiliary_artifact_file_too_large",
+                    "auxiliary artifact",
+                ) {
                     Ok(hash) => {
                         entry.sha256 = Some(hash.sha256.clone());
                         entry.size_bytes = Some(hash.size_bytes);
@@ -1273,17 +1279,17 @@ fn verify_auxiliary_artifacts(
                         }
                     }
                     Err(err) => {
-                        mark_auxiliary_artifact_failed(
-                            &mut entry,
-                            "auxiliary_artifact_hash_failed",
-                        );
-                        report.error(
-                            "auxiliary_artifact_hash_failed",
+                        let code = err.code().unwrap_or("auxiliary_artifact_hash_failed");
+                        mark_auxiliary_artifact_failed(&mut entry, code);
+                        let message = if err.code().is_some() {
+                            err.to_string()
+                        } else {
                             format!(
                                 "failed to hash auxiliary artifact {:?}: {err}",
                                 artifact.name
-                            ),
-                        );
+                            )
+                        };
+                        report.error(code, message);
                     }
                 }
             }
@@ -1542,6 +1548,7 @@ pub struct ResourceLimits {
     pub max_row_identity_rows: usize,
     pub max_row_identity_tracked_db_id_bytes: usize,
     pub max_auxiliary_artifacts: usize,
+    pub max_auxiliary_artifact_bytes: u64,
     pub max_report_issues: usize,
     pub max_cached_report_bytes: u64,
 }
@@ -1554,6 +1561,7 @@ impl Default for ResourceLimits {
             max_row_identity_rows: DEFAULT_MAX_ROW_IDENTITY_ROWS,
             max_row_identity_tracked_db_id_bytes: DEFAULT_MAX_ROW_IDENTITY_TRACKED_DB_ID_BYTES,
             max_auxiliary_artifacts: DEFAULT_MAX_AUXILIARY_ARTIFACTS,
+            max_auxiliary_artifact_bytes: DEFAULT_MAX_AUXILIARY_ARTIFACT_BYTES,
             max_report_issues: DEFAULT_MAX_REPORT_ISSUES,
             max_cached_report_bytes: DEFAULT_MAX_CACHED_REPORT_BYTES,
         }

ordvec-manifest/src/main.rs

@@ -133,6 +133,8 @@ struct LimitArgs {
     #[arg(long)]
     max_auxiliary_artifacts: Option<usize>,
     #[arg(long)]
+    max_auxiliary_artifact_bytes: Option<u64>,
+    #[arg(long)]
     max_report_issues: Option<usize>,
     #[arg(long)]
     max_cached_report_bytes: Option<u64>,
@@ -156,6 +158,9 @@ impl LimitArgs {
         if let Some(value) = self.max_auxiliary_artifacts {
             limits.max_auxiliary_artifacts = value;
         }
+        if let Some(value) = self.max_auxiliary_artifact_bytes {
+            limits.max_auxiliary_artifact_bytes = value;
+        }
         if let Some(value) = self.max_report_issues {
             limits.max_report_issues = value;
         }

ordvec-manifest/tests/manifest.rs

@@ -1540,6 +1540,56 @@ fn auxiliary_artifact_count_limit_is_enforced_before_verification() {
     assert!(report.auxiliary_artifacts.is_empty());
 }
 
+#[test]
+fn auxiliary_artifact_byte_limit_is_enforced_before_hashing() {
+    let root = tempfile::tempdir().unwrap();
+    let (temp, mut manifest, _manifest_path) = identity_manifest(root.path());
+    let sidecar = temp.path().join("sidecar.bin");
+    fs::write(&sidecar, b"sidecar").unwrap();
+    let sidecar_hash = sha256_file(&sidecar).unwrap();
+    manifest.auxiliary_artifacts = vec![auxiliary_artifact(
+        "sidecar",
+        "sidecar.bin",
+        sidecar_hash.clone(),
+        true,
+    )];
+
+    let report = verify_manifest_with_base(
+        manifest.clone(),
+        temp.path(),
+        VerifyOptions {
+            limits: ResourceLimits {
+                max_auxiliary_artifact_bytes: sidecar_hash.size_bytes - 1,
+                ..ResourceLimits::default()
+            },
+            ..VerifyOptions::default()
+        },
+    );
+    assert!(error_codes(&report).contains(&"auxiliary_artifact_file_too_large"));
+    assert_eq!(report.auxiliary_artifacts[0].sha256, None);
+    assert_eq!(
+        report.auxiliary_artifacts[0].reason_code.as_deref(),
+        Some("auxiliary_artifact_file_too_large")
+    );
+
+    let report = verify_manifest_with_base(
+        manifest,
+        temp.path(),
+        VerifyOptions {
+            limits: ResourceLimits {
+                max_auxiliary_artifact_bytes: sidecar_hash.size_bytes,
+                ..ResourceLimits::default()
+            },
+            ..VerifyOptions::default()
+        },
+    );
+    assert!(report.ok, "{:?}", report.errors);
+    assert_eq!(
+        report.auxiliary_artifacts[0].sha256.as_deref(),
+        Some(sidecar_hash.sha256.as_str())
+    );
+}
+
 #[test]
 fn verification_report_deserializes_missing_auxiliary_artifacts_field() {
     let root = tempfile::tempdir().unwrap();