@neilberkman/sidereon 0.37.0 → 0.39.0

package/pkg-node/sidereon.d.ts

@@ -4212,7 +4212,13 @@ export class MmapTerrain {
     free(): void;
     [Symbol.dispose](): void;
     /**
-     * FNV-1a checksum of the full terrain store byte span.
+     * Internal byte bridge used by the generated Node path adapter.
+     */
+    private static fromBytesAttestedInternal(bytes: Uint8Array, claimed_checksum64: any): MmapTerrain;
+    /**
+     * FNV-1a checksum of the full terrain store byte span as a JavaScript
+     * `bigint`. An attested handle returns its caller-supplied claim without
+     * hashing.
      */
     checksum64(): bigint;
     /**
@@ -4243,6 +4249,15 @@ export class MmapTerrain {
      * Browser runtimes should use [`MmapTerrain.fromBytes`] with fetched bytes.
      */
     static fromPath(path: string): MmapTerrain;
+    /**
+     * 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.
+     */
+    static fromPathAttested(path: string, claimed_checksum64: bigint): MmapTerrain;
     /**
      * Parse terrain store bytes from an owned `Uint8Array` copy.
      */
@@ -4293,6 +4308,16 @@ export class MmapTerrain {
      * Canonical store bytes for this parsed terrain store.
      */
     toBytes(): Uint8Array;
+    /**
+     * Recompute and verify the store checksums.
+     *
+     * Success changes [`MmapTerrain.digestProvenance`] to `"verified"`.
+     */
+    verify(): void;
+    /**
+     * Checksum provenance: `"verified"` or `"attested"`.
+     */
+    readonly digestProvenance: "verified" | "attested";
     /**
      * File-level vertical datum for the store's orthometric posting payloads.
      */
@@ -5943,18 +5968,49 @@ export class PreciseInterpolantArtifact {
     private constructor();
     free(): void;
     [Symbol.dispose](): void;
+    /**
+     * Internal byte bridge used by the generated Node path adapter.
+     */
+    private static fromBytesAttestedInternal(bytes: Uint8Array, claimed_checksum64: any): PreciseInterpolantArtifact;
     /**
      * Evaluate one satellite state at a J2000-second epoch.
      */
     evaluate(satellite: string, j2000_seconds: number): Sp3State;
+    /**
+     * Read a precise-interpolant artifact from host I/O and open it in memory.
+     *
+     * Browser runtimes should use [`openPreciseInterpolantArtifact`] with
+     * fetched bytes.
+     */
+    static fromPath(path: string): PreciseInterpolantArtifact;
+    /**
+     * 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.
+     */
+    static fromPathAttested(path: string, claimed_checksum64: bigint): PreciseInterpolantArtifact;
+    /**
+     * Recompute and verify the file-level and per-satellite checksums.
+     *
+     * Success changes [`PreciseInterpolantArtifact.digestProvenance`] to
+     * `"verified"`.
+     */
+    verify(): void;
     /**
      * Number of bytes retained by this artifact handle.
      */
     readonly byteLength: number;
     /**
-     * File-level artifact checksum.
+     * File-level artifact checksum as a JavaScript `bigint`. An attested
+     * handle returns its caller-supplied claim without hashing.
      */
     readonly checksum64: bigint;
+    /**
+     * Checksum provenance: `"verified"` or `"attested"`.
+     */
+    readonly digestProvenance: "verified" | "attested";
     /**
      * Satellite tokens present in the artifact, ascending.
      */
@@ -6001,6 +6057,10 @@ export enum PreciseInterpolantArtifactError {
      * A satellite payload checksum did not match its index record.
      */
     SatelliteChecksum = 7,
+    /**
+     * A caller claim did not match the checksum declared by the header.
+     */
+    AttestedChecksumMismatch = 8,
 }
 
 /**
@@ -8460,6 +8520,10 @@ export enum TerrainStoreError {
      * A tile payload checksum did not match its index record.
      */
     Checksum = 5,
+    /**
+     * A caller-attested full-store checksum did not match the bytes opened.
+     */
+    AttestedChecksumMismatch = 6,
 }
 
 /**

package/pkg-node/sidereon.js

@@ -9288,13 +9288,46 @@ 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.
@@ -9374,6 +9407,26 @@ 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
@@ -9502,6 +9555,17 @@ 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}
@@ -14081,6 +14145,21 @@ 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}
@@ -14090,13 +14169,30 @@ 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
@@ -14112,6 +14208,42 @@ 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[]}
@@ -14138,13 +14270,25 @@ 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;
 exports.PreciseInterpolantArtifact = PreciseInterpolantArtifact;
 
 /**
  * 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}
  */
 const PreciseInterpolantArtifactError = Object.freeze({
     /**
@@ -14179,6 +14323,10 @@ 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",
 });
 exports.PreciseInterpolantArtifactError = PreciseInterpolantArtifactError;
 
@@ -20378,7 +20526,7 @@ exports.TerrainGeoidModel = TerrainGeoidModel;
 
 /**
  * Terrain store conversion, serialization, and parsing error variants.
- * @enum {0 | 1 | 2 | 3 | 4 | 5}
+ * @enum {0 | 1 | 2 | 3 | 4 | 5 | 6}
  */
 const TerrainStoreError = Object.freeze({
     /**
@@ -20405,6 +20553,10 @@ 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",
 });
 exports.TerrainStoreError = TerrainStoreError;
 
@@ -32575,3 +32727,49 @@ const wasmModule = new WebAssembly.Module(wasmBytes);
 let wasmInstance = new WebAssembly.Instance(wasmModule, __wbg_get_imports());
 let wasm = wasmInstance.exports;
 wasm.__wbindgen_start();
+
+/* sidereon Node path-open adapters */
+const __sidereonMaxU64 = 0xffff_ffff_ffff_ffffn;
+const __mmapTerrainFromBytesAttested = MmapTerrain.__fromBytesAttested;
+const __preciseInterpolantFromBytesAttested = PreciseInterpolantArtifact.__fromBytesAttested;
+
+function __sidereonClaimedChecksum64(value) {
+    if (typeof value !== 'bigint') {
+        throw new TypeError('claimedChecksum64 must be a bigint');
+    }
+    if (value < 0n || value > __sidereonMaxU64) {
+        throw new RangeError('claimedChecksum64 must be between 0n and 18446744073709551615n');
+    }
+    return value;
+}
+
+function __sidereonReadArtifactPath(path) {
+    try {
+        return require('fs').readFileSync(path);
+    } catch (cause) {
+        const reason = cause instanceof Error ? cause.message : String(cause);
+        const message = `${path} failed: ${reason}`;
+        const error = new Error(message);
+        error.name = 'Io';
+        error.kind = 'Io';
+        error.detail = { name: 'Io', message, path: String(path) };
+        throw error;
+    }
+}
+
+MmapTerrain.fromPath = function(path) {
+    return MmapTerrain.fromBytes(__sidereonReadArtifactPath(path));
+};
+MmapTerrain.fromPathAttested = function(path, claimedChecksum64) {
+    const claim = __sidereonClaimedChecksum64(claimedChecksum64);
+    return __mmapTerrainFromBytesAttested(__sidereonReadArtifactPath(path), claim);
+};
+PreciseInterpolantArtifact.fromPath = function(path) {
+    return openPreciseInterpolantArtifact(__sidereonReadArtifactPath(path));
+};
+PreciseInterpolantArtifact.fromPathAttested = function(path, claimedChecksum64) {
+    const claim = __sidereonClaimedChecksum64(claimedChecksum64);
+    return __preciseInterpolantFromBytesAttested(__sidereonReadArtifactPath(path), claim);
+};
+delete MmapTerrain.__fromBytesAttested;
+delete PreciseInterpolantArtifact.__fromBytesAttested;