@neilberkman/sidereon 0.38.0 → 0.39.1

package/pkg/sidereon.js

@@ -9180,13 +9180,46 @@ export class MmapTerrain {
         wasm.__wbg_mmapterrain_free(ptr, 0);
     }
     /**
-     * FNV-1a checksum of the full terrain store byte span.
+     * Internal byte bridge used by the generated Node path adapter.
+     * @param {Uint8Array} bytes
+     * @param {any} claimed_checksum64
+     * @returns {MmapTerrain}
+     */
+    static __fromBytesAttested(bytes, claimed_checksum64) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mmapterrain___fromBytesAttested(ptr0, len0, claimed_checksum64);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MmapTerrain.__wrap(ret[0]);
+    }
+    /**
+     * FNV-1a checksum of the full terrain store byte span as a JavaScript
+     * `bigint`. An attested handle returns its caller-supplied claim without
+     * hashing.
      * @returns {bigint}
      */
     checksum64() {
         const ret = wasm.mmapterrain_checksum64(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Checksum provenance: `"verified"` or `"attested"`.
+     * @returns {string}
+     */
+    get digestProvenance() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.mmapterrain_digestProvenance(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Ellipsoidal height `h = H + N` in metres at `(longitudeDeg, latitudeDeg)`
      * using the embedded EGM96 1-degree geoid grid.
@@ -9266,6 +9299,26 @@ export class MmapTerrain {
         }
         return MmapTerrain.__wrap(ret[0]);
     }
+    /**
+     * Read a terrain store file using a caller-attested full-store checksum.
+     *
+     * `claimedChecksum64` is an exact JavaScript `bigint` in the unsigned
+     * 64-bit range. The claim is returned by [`MmapTerrain.checksum64`] until
+     * [`MmapTerrain.verify`] succeeds. Browser runtimes should use an
+     * application-provided host-I/O bridge.
+     * @param {string} path
+     * @param {any} claimed_checksum64
+     * @returns {MmapTerrain}
+     */
+    static fromPathAttested(path, claimed_checksum64) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.mmapterrain_fromPathAttested(ptr0, len0, claimed_checksum64);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return MmapTerrain.__wrap(ret[0]);
+    }
     /**
      * Parse terrain store bytes from an owned `Uint8Array` copy.
      * @param {Uint8Array} bytes
@@ -9394,6 +9447,17 @@ export class MmapTerrain {
         wasm.__wbindgen_free(ret[0], ret[1] * 1, 1);
         return v1;
     }
+    /**
+     * Recompute and verify the store checksums.
+     *
+     * Success changes [`MmapTerrain.digestProvenance`] to `"verified"`.
+     */
+    verify() {
+        const ret = wasm.mmapterrain_verify(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
     /**
      * File-level vertical datum for the store's orthometric posting payloads.
      * @returns {VerticalDatum}
@@ -13928,6 +13992,21 @@ export class PreciseInterpolantArtifact {
         const ptr = this.__destroy_into_raw();
         wasm.__wbg_preciseinterpolantartifact_free(ptr, 0);
     }
+    /**
+     * Internal byte bridge used by the generated Node path adapter.
+     * @param {Uint8Array} bytes
+     * @param {any} claimed_checksum64
+     * @returns {PreciseInterpolantArtifact}
+     */
+    static __fromBytesAttested(bytes, claimed_checksum64) {
+        const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.preciseinterpolantartifact___fromBytesAttested(ptr0, len0, claimed_checksum64);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PreciseInterpolantArtifact.__wrap(ret[0]);
+    }
     /**
      * Number of bytes retained by this artifact handle.
      * @returns {number}
@@ -13937,13 +14016,30 @@ export class PreciseInterpolantArtifact {
         return ret >>> 0;
     }
     /**
-     * File-level artifact checksum.
+     * File-level artifact checksum as a JavaScript `bigint`. An attested
+     * handle returns its caller-supplied claim without hashing.
      * @returns {bigint}
      */
     get checksum64() {
         const ret = wasm.preciseinterpolantartifact_checksum64(this.__wbg_ptr);
         return BigInt.asUintN(64, ret);
     }
+    /**
+     * Checksum provenance: `"verified"` or `"attested"`.
+     * @returns {string}
+     */
+    get digestProvenance() {
+        let deferred1_0;
+        let deferred1_1;
+        try {
+            const ret = wasm.preciseinterpolantartifact_digestProvenance(this.__wbg_ptr);
+            deferred1_0 = ret[0];
+            deferred1_1 = ret[1];
+            return getStringFromWasm0(ret[0], ret[1]);
+        } finally {
+            wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
+        }
+    }
     /**
      * Evaluate one satellite state at a J2000-second epoch.
      * @param {string} satellite
@@ -13959,6 +14055,42 @@ export class PreciseInterpolantArtifact {
         }
         return Sp3State.__wrap(ret[0]);
     }
+    /**
+     * Read a precise-interpolant artifact from host I/O and open it in memory.
+     *
+     * Browser runtimes should use [`openPreciseInterpolantArtifact`] with
+     * fetched bytes.
+     * @param {string} path
+     * @returns {PreciseInterpolantArtifact}
+     */
+    static fromPath(path) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.preciseinterpolantartifact_fromPath(ptr0, len0);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PreciseInterpolantArtifact.__wrap(ret[0]);
+    }
+    /**
+     * Read a precise-interpolant artifact using a caller-attested checksum.
+     *
+     * `claimedChecksum64` is an exact JavaScript `bigint` in the unsigned
+     * 64-bit range. It must equal the checksum declared by the artifact
+     * header; a mismatch fails immediately without hashing the payload.
+     * @param {string} path
+     * @param {any} claimed_checksum64
+     * @returns {PreciseInterpolantArtifact}
+     */
+    static fromPathAttested(path, claimed_checksum64) {
+        const ptr0 = passStringToWasm0(path, wasm.__wbindgen_malloc, wasm.__wbindgen_realloc);
+        const len0 = WASM_VECTOR_LEN;
+        const ret = wasm.preciseinterpolantartifact_fromPathAttested(ptr0, len0, claimed_checksum64);
+        if (ret[2]) {
+            throw takeFromExternrefTable0(ret[1]);
+        }
+        return PreciseInterpolantArtifact.__wrap(ret[0]);
+    }
     /**
      * Satellite tokens present in the artifact, ascending.
      * @returns {string[]}
@@ -13985,12 +14117,24 @@ export class PreciseInterpolantArtifact {
             wasm.__wbindgen_free(deferred1_0, deferred1_1, 1);
         }
     }
+    /**
+     * Recompute and verify the file-level and per-satellite checksums.
+     *
+     * Success changes [`PreciseInterpolantArtifact.digestProvenance`] to
+     * `"verified"`.
+     */
+    verify() {
+        const ret = wasm.preciseinterpolantartifact_verify(this.__wbg_ptr);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
+    }
 }
 if (Symbol.dispose) PreciseInterpolantArtifact.prototype[Symbol.dispose] = PreciseInterpolantArtifact.prototype.free;
 
 /**
  * Error category for precise-interpolant artifact open or serialization.
- * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7}
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8}
  */
 export const PreciseInterpolantArtifactError = Object.freeze({
     /**
@@ -14025,6 +14169,10 @@ export const PreciseInterpolantArtifactError = Object.freeze({
      * A satellite payload checksum did not match its index record.
      */
     SatelliteChecksum: 7, "7": "SatelliteChecksum",
+    /**
+     * A caller claim did not match the checksum declared by the header.
+     */
+    AttestedChecksumMismatch: 8, "8": "AttestedChecksumMismatch",
 });
 
 /**
@@ -20150,7 +20298,7 @@ if (Symbol.dispose) TerrainGeoidModel.prototype[Symbol.dispose] = TerrainGeoidMo
 
 /**
  * Terrain store conversion, serialization, and parsing error variants.
- * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6}
  */
 export const TerrainStoreError = Object.freeze({
     /**
@@ -20177,6 +20325,10 @@ export const TerrainStoreError = Object.freeze({
      * A tile payload checksum did not match its index record.
      */
     Checksum: 5, "5": "Checksum",
+    /**
+     * A caller-attested full-store checksum did not match the bytes opened.
+     */
+    AttestedChecksumMismatch: 6, "6": "AttestedChecksumMismatch",
 });
 
 /**