@totemsdk/raster-proof 0.1.0

package/dist/proof.js

@@ -0,0 +1,247 @@
+"use strict";
+/**
+ * Proof envelope integration for @totemsdk/raster-proof.
+ *
+ * Bridges raster manifests, window proofs and Merkle proofs into
+ * @totemsdk/proof evidence refs and signed proof envelopes. Signing and
+ * verification delegate to @totemsdk/proof. Anchoring is deliberately NOT
+ * required for verification.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rasterEvidenceRefs = rasterEvidenceRefs;
+exports.createUnsignedRasterProof = createUnsignedRasterProof;
+exports.signRasterProof = signRasterProof;
+exports.verifyRasterProof = verifyRasterProof;
+const proof_1 = require("@totemsdk/proof");
+const canonical_js_1 = require("./canonical.js");
+const manifest_js_1 = require("./manifest.js");
+const window_js_1 = require("./window.js");
+const provenance_js_1 = require("./provenance.js");
+const merkle_js_1 = require("./merkle.js");
+/**
+ * Build the evidence ref list for a raster proof:
+ *   - raster manifest hash
+ *   - content hash
+ *   - Merkle root when present
+ *   - window proof hash when present
+ *   - source raster IDs when derived
+ *   - spatial object ID when present
+ */
+function rasterEvidenceRefs(manifest, windowProof, spatialObjectId) {
+    const refs = [
+        (0, manifest_js_1.rasterManifestToEvidenceRef)(manifest),
+        { id: manifest.asset.contentHash, kind: 'raster-content', hash: manifest.asset.contentHash },
+    ];
+    if (manifest.asset.merkleRoot) {
+        refs.push({ id: manifest.rasterId + ':merkle', kind: 'raster-merkle-root', hash: manifest.asset.merkleRoot });
+    }
+    if (windowProof) {
+        refs.push((0, window_js_1.rasterWindowProofToEvidenceRef)(windowProof));
+    }
+    if (manifest.provenance?.derivedFrom) {
+        for (const src of manifest.provenance.derivedFrom) {
+            refs.push({ id: src, kind: 'raster-source', hash: src });
+        }
+    }
+    if (spatialObjectId) {
+        refs.push({ id: spatialObjectId, kind: 'spatial-object', hash: spatialObjectId });
+    }
+    return refs;
+}
+/**
+ * Create an unsigned attestation proof for a raster manifest.
+ *
+ * The proof claims: "this manifest describes this asset, produced by this
+ * source, at this time, with this content hash / Merkle root". It does NOT
+ * claim the visual interpretation is correct — interpretation is an
+ * operator / model / reviewer claim made elsewhere.
+ */
+function createUnsignedRasterProof(params) {
+    const { manifest, windowProof, merkleProofs, spatialObjectId } = params;
+    return (0, proof_1.createProof)({
+        kind: 'attestation',
+        subject: {
+            id: manifest.rasterId,
+            kind: 'raster-manifest',
+            metadata: {
+                sourceType: manifest.sourceType,
+                layerType: manifest.layerType,
+            },
+        },
+        issuer: params.issuer ?? manifest.deviceId ?? manifest.operatorId ?? manifest.rasterId,
+        issuedAt: params.issuedAt,
+        expiresAt: params.expiresAt,
+        evidence: rasterEvidenceRefs(manifest, windowProof, spatialObjectId),
+        payload: {
+            rasterManifest: manifest,
+            ...(windowProof ? { windowProof } : {}),
+            ...(merkleProofs && merkleProofs.length > 0 ? { merkleProofs } : {}),
+        },
+    });
+}
+/**
+ * Sign an unsigned raster proof with a WOTS key.
+ *
+ * The caller is responsible for reserving the WOTS key index (see
+ * @totemsdk/wots-lease) before calling — one-time key warning applies.
+ */
+function signRasterProof(unsigned, seed, keyIndex) {
+    return (0, proof_1.signProof)(unsigned, seed, keyIndex);
+}
+/**
+ * Verify a window proof payload against the manifest and any supplied Merkle
+ * proofs. Returns a failure reason string, or null when valid.
+ */
+function checkWindowProof(windowProof, manifest, merkleProofs) {
+    const { windowProofId: _wid, ...rest } = windowProof;
+    if ((0, canonical_js_1.computeRasterWindowProofId)(rest) !== windowProof.windowProofId) {
+        return 'windowProofId does not match recomputed value';
+    }
+    if (manifest.asset.merkleRoot && windowProof.merkleRoot !== manifest.asset.merkleRoot) {
+        return 'window proof merkleRoot does not match manifest asset.merkleRoot';
+    }
+    if (windowProof.rasterId !== manifest.rasterId) {
+        return 'window proof rasterId does not match manifest';
+    }
+    if (windowProof.chunkIndices.length === 0 || windowProof.chunkIndices.length !== windowProof.chunkHashes.length) {
+        return 'window proof chunkIndices must be non-empty and match chunkHashes length';
+    }
+    for (const proof of merkleProofs ?? []) {
+        if (!(0, merkle_js_1.verifyMerkleProof)(proof)) {
+            return 'a supplied merkle proof failed verification';
+        }
+        if (windowProof.merkleRoot && proof.root !== windowProof.merkleRoot) {
+            return 'a supplied merkle proof root does not match the window proof root';
+        }
+        if (!windowProof.chunkIndices.includes(proof.leafIndex)) {
+            return 'a supplied merkle proof leafIndex is not referenced by the window proof';
+        }
+    }
+    return null;
+}
+/**
+ * Verify a signed raster proof end to end.
+ *
+ * Checks:
+ *   1. the underlying @totemsdk/proof verification (signature, proofId, expiry)
+ *   2. payload contains a structurally valid RasterManifest
+ *   3. the manifest rasterId matches a recomputation from its fields
+ *   4. the manifest evidence hash matches the payload manifest
+ *   5. content hash and Merkle root evidence refs are present when declared
+ *   6. window proof (when supplied) has a recomputable ID, matches the
+ *      manifest's Merkle root, and any supplied Merkle proofs verify
+ *   7. provenance structure is valid for derived rasters
+ *
+ * Anchoring is not required. Source raster manifests are not supplied inside
+ * the proof, so derivation checks are structural only (full cross-source
+ * verification is @totemsdk/raster-proof's verifyRasterDerivation).
+ */
+function verifyRasterProof(signed) {
+    const base = (0, proof_1.verifyProof)(signed);
+    if (!base.valid) {
+        return {
+            valid: false,
+            reason: base.reason,
+            signerAddress: base.signerAddress,
+        };
+    }
+    const signerAddress = signed.signature.address;
+    const manifest = signed.payload?.['rasterManifest'];
+    if (!manifest || typeof manifest !== 'object') {
+        return { valid: false, reason: 'payload missing rasterManifest', signerAddress };
+    }
+    const validation = (0, manifest_js_1.validateRasterManifest)(manifest);
+    if (!validation.valid) {
+        return {
+            valid: false,
+            reason: 'payload rasterManifest invalid: ' + validation.errors.join('; '),
+            payloadValid: false,
+            rasterId: manifest.rasterId,
+            signerAddress,
+        };
+    }
+    const { rasterId: _rasterId, ...rest } = manifest;
+    if ((0, canonical_js_1.computeRasterManifestId)(rest) !== manifest.rasterId) {
+        return {
+            valid: false,
+            reason: 'rasterId does not match recomputed value',
+            rasterIdValid: false,
+            rasterId: manifest.rasterId,
+            signerAddress,
+        };
+    }
+    const manifestEvidence = signed.evidence?.find((e) => e.id === manifest.rasterId && e.kind === 'raster-manifest');
+    if (!manifestEvidence) {
+        return {
+            valid: false,
+            reason: 'evidence missing raster-manifest ref',
+            rasterId: manifest.rasterId,
+            signerAddress,
+        };
+    }
+    if (manifestEvidence.hash !== (0, canonical_js_1.hashRasterManifest)(manifest)) {
+        return {
+            valid: false,
+            reason: 'evidence hash does not match payload manifest',
+            manifestHashValid: false,
+            rasterId: manifest.rasterId,
+            signerAddress,
+        };
+    }
+    const contentEvidence = signed.evidence?.find((e) => e.kind === 'raster-content');
+    if (!contentEvidence || contentEvidence.hash !== manifest.asset.contentHash) {
+        return {
+            valid: false,
+            reason: 'evidence missing or mismatched raster-content hash',
+            rasterId: manifest.rasterId,
+            signerAddress,
+        };
+    }
+    if (manifest.asset.merkleRoot) {
+        const merkleEvidence = signed.evidence?.find((e) => e.kind === 'raster-merkle-root');
+        if (!merkleEvidence || merkleEvidence.hash !== manifest.asset.merkleRoot) {
+            return {
+                valid: false,
+                reason: 'evidence missing or mismatched raster-merkle-root',
+                rasterId: manifest.rasterId,
+                signerAddress,
+            };
+        }
+    }
+    const windowProof = signed.payload?.['windowProof'];
+    if (windowProof) {
+        const merkleProofs = signed.payload?.['merkleProofs'];
+        const err = checkWindowProof(windowProof, manifest, merkleProofs);
+        if (err) {
+            return {
+                valid: false,
+                reason: err,
+                windowProofValid: false,
+                rasterId: manifest.rasterId,
+                signerAddress,
+            };
+        }
+    }
+    if (manifest.sourceType === 'derived') {
+        const derivation = (0, provenance_js_1.structuralDerivationCheck)(manifest);
+        if (!derivation.valid) {
+            return {
+                valid: false,
+                reason: 'derivation structure invalid: ' + derivation.reasons?.join('; '),
+                derivationValid: false,
+                rasterId: manifest.rasterId,
+                signerAddress,
+            };
+        }
+    }
+    return {
+        valid: true,
+        signerAddress,
+        rasterId: manifest.rasterId,
+        payloadValid: true,
+        rasterIdValid: true,
+        manifestHashValid: true,
+        ...(windowProof ? { windowProofValid: true } : {}),
+        ...(manifest.sourceType === 'derived' ? { derivationValid: true } : {}),
+    };
+}

package/dist/proofgraph.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Proofgraph integration helpers for @totemsdk/raster-proof.
+ *
+ * Produces nodes and edges for @totemsdk/proofgraph without storage
+ * assumptions. Helpers never mutate a graph directly — callers combine the
+ * returned nodes/edges with addNode/addEdge.
+ *
+ * Note: @totemsdk/proofgraph has no native 'raster' node type, so raster
+ * manifests and window proofs map to the generic 'custom' node type (the
+ * same approach @totemsdk/location-proof and @totemsdk/spatial-proof use).
+ * If a dedicated 'raster' node type is ever wanted, propose it in
+ * @totemsdk/proofgraph (do not silently fork the vocabulary).
+ */
+import type { ProofGraph, ProofGraphNode, ProofGraphEdge } from '@totemsdk/proofgraph';
+import type { RasterManifest, RasterWindowProof } from './types.js';
+/**
+ * Build a ProofGraphNode for a raster manifest ('custom' type).
+ * Node ID is deterministic: "custom:<rasterId>".
+ */
+export declare function rasterManifestToProofGraphNode(manifest: RasterManifest): ProofGraphNode;
+/**
+ * Build a ProofGraphNode for a raster window proof ('custom' type).
+ * Node ID is deterministic: "custom:<windowProofId>".
+ */
+export declare function rasterWindowProofToProofGraphNode(windowProof: RasterWindowProof): ProofGraphNode;
+/**
+ * Build ProofGraphEdges for a raster manifest:
+ *   derived_from  raster → each source raster     (when provenance.derivedFrom)
+ *   references    raster → spatial object         (when spatial.spatialObjectId)
+ *   about         raster → device                 (when deviceId)
+ *   about         raster → subject(operator)      (when operatorId)
+ *   about         raster → subject(mission)       (when missionId)
+ *   references    window proof → raster           (see rasterWindowProofToGraphEdges)
+ *
+ * The "raster supports proof" edge is created by @totemsdk/proofgraph's
+ * addProof when the signed proof is added to the graph — this helper has no
+ * proof to link at construction time.
+ *
+ * Edge IDs are deterministic (content-derived in @totemsdk/proofgraph).
+ */
+export declare function rasterManifestToGraphEdges(manifest: RasterManifest): ProofGraphEdge[];
+/**
+ * Build ProofGraphEdges for a raster window proof:
+ *   derived_from  window proof → raster
+ */
+export declare function rasterWindowProofToGraphEdges(windowProof: RasterWindowProof): ProofGraphEdge[];
+/**
+ * Add a raster manifest as a 'custom' node to a proof graph (immutable —
+ * returns a new graph).
+ */
+export declare function addRasterManifestToGraph(graph: ProofGraph, manifest: RasterManifest): ProofGraph;

package/dist/proofgraph.js

@@ -0,0 +1,120 @@
+"use strict";
+/**
+ * Proofgraph integration helpers for @totemsdk/raster-proof.
+ *
+ * Produces nodes and edges for @totemsdk/proofgraph without storage
+ * assumptions. Helpers never mutate a graph directly — callers combine the
+ * returned nodes/edges with addNode/addEdge.
+ *
+ * Note: @totemsdk/proofgraph has no native 'raster' node type, so raster
+ * manifests and window proofs map to the generic 'custom' node type (the
+ * same approach @totemsdk/location-proof and @totemsdk/spatial-proof use).
+ * If a dedicated 'raster' node type is ever wanted, propose it in
+ * @totemsdk/proofgraph (do not silently fork the vocabulary).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rasterManifestToProofGraphNode = rasterManifestToProofGraphNode;
+exports.rasterWindowProofToProofGraphNode = rasterWindowProofToProofGraphNode;
+exports.rasterManifestToGraphEdges = rasterManifestToGraphEdges;
+exports.rasterWindowProofToGraphEdges = rasterWindowProofToGraphEdges;
+exports.addRasterManifestToGraph = addRasterManifestToGraph;
+const proofgraph_1 = require("@totemsdk/proofgraph");
+/**
+ * Build a ProofGraphNode for a raster manifest ('custom' type).
+ * Node ID is deterministic: "custom:<rasterId>".
+ */
+function rasterManifestToProofGraphNode(manifest) {
+    return {
+        id: (0, proofgraph_1.computeNodeId)('custom', manifest.rasterId),
+        type: 'custom',
+        refId: manifest.rasterId,
+        data: {
+            kind: 'raster-manifest',
+            sourceType: manifest.sourceType,
+            layerType: manifest.layerType,
+            contentHash: manifest.asset.contentHash,
+            ...(manifest.asset.merkleRoot ? { merkleRoot: manifest.asset.merkleRoot } : {}),
+            ...(manifest.spatial?.spatialObjectId ? { spatialObjectId: manifest.spatial.spatialObjectId } : {}),
+            ...(manifest.deviceId ? { deviceId: manifest.deviceId } : {}),
+        },
+        createdAt: manifest.createdAt,
+    };
+}
+/**
+ * Build a ProofGraphNode for a raster window proof ('custom' type).
+ * Node ID is deterministic: "custom:<windowProofId>".
+ */
+function rasterWindowProofToProofGraphNode(windowProof) {
+    return {
+        id: (0, proofgraph_1.computeNodeId)('custom', windowProof.windowProofId),
+        type: 'custom',
+        refId: windowProof.windowProofId,
+        data: {
+            kind: 'raster-window-proof',
+            rasterId: windowProof.rasterId,
+            merkleRoot: windowProof.merkleRoot,
+            chunkIndices: windowProof.chunkIndices,
+            hashes: windowProof.chunkHashes,
+        },
+        createdAt: windowProof.createdAt,
+    };
+}
+/**
+ * Build ProofGraphEdges for a raster manifest:
+ *   derived_from  raster → each source raster     (when provenance.derivedFrom)
+ *   references    raster → spatial object         (when spatial.spatialObjectId)
+ *   about         raster → device                 (when deviceId)
+ *   about         raster → subject(operator)      (when operatorId)
+ *   about         raster → subject(mission)       (when missionId)
+ *   references    window proof → raster           (see rasterWindowProofToGraphEdges)
+ *
+ * The "raster supports proof" edge is created by @totemsdk/proofgraph's
+ * addProof when the signed proof is added to the graph — this helper has no
+ * proof to link at construction time.
+ *
+ * Edge IDs are deterministic (content-derived in @totemsdk/proofgraph).
+ */
+function rasterManifestToGraphEdges(manifest) {
+    const edges = [];
+    for (const src of manifest.provenance?.derivedFrom ?? []) {
+        edges.push((0, proofgraph_1.buildEdge)('derived_from', manifest.rasterId, src, manifest.rasterId, {
+            kind: 'raster-source',
+        }));
+    }
+    if (manifest.spatial?.spatialObjectId) {
+        edges.push((0, proofgraph_1.buildEdge)('references', manifest.rasterId, manifest.spatial.spatialObjectId, manifest.rasterId, {
+            kind: 'spatial-object',
+        }));
+    }
+    if (manifest.deviceId) {
+        edges.push((0, proofgraph_1.buildEdge)('about', manifest.rasterId, manifest.deviceId, manifest.rasterId, { kind: 'device' }));
+    }
+    if (manifest.operatorId) {
+        edges.push((0, proofgraph_1.buildEdge)('about', manifest.rasterId, manifest.operatorId, manifest.rasterId, { kind: 'operator' }));
+    }
+    if (manifest.missionId) {
+        edges.push((0, proofgraph_1.buildEdge)('about', manifest.rasterId, manifest.missionId, manifest.rasterId, { kind: 'mission' }));
+    }
+    return edges;
+}
+/**
+ * Build ProofGraphEdges for a raster window proof:
+ *   derived_from  window proof → raster
+ */
+function rasterWindowProofToGraphEdges(windowProof) {
+    return [
+        (0, proofgraph_1.buildEdge)('derived_from', windowProof.windowProofId, windowProof.rasterId, windowProof.windowProofId, {
+            kind: 'raster-window-proof',
+        }),
+    ];
+}
+/**
+ * Add a raster manifest as a 'custom' node to a proof graph (immutable —
+ * returns a new graph).
+ */
+function addRasterManifestToGraph(graph, manifest) {
+    return (0, proofgraph_1.addNode)(graph, 'custom', manifest.rasterId, {
+        kind: 'raster-manifest',
+        ...manifest,
+    });
+}

package/dist/provenance.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Derived raster provenance for @totemsdk/raster-proof.
+ *
+ * createDerivedRasterManifest records a raster produced from other rasters
+ * (satellite scene → water mask, image set → orthomosaic, before/after →
+ * change mask, …). verifyRasterDerivation checks the DECLARED provenance
+ * structure — that every derivedFrom ID is supplied, parameters are present
+ * when a pipeline is named, and the manifest is honestly marked as derived.
+ *
+ * It does NOT verify that image processing was performed correctly. That is
+ * outside this package's scope.
+ */
+import type { CreateDerivedRasterManifestParams, RasterDerivationVerifyResult, RasterManifest } from './types.js';
+/**
+ * Create a derived raster manifest from source rasters. sourceType is forced
+ * to 'derived'; provenance.derivedFrom lists the source raster IDs.
+ */
+export declare function createDerivedRasterManifest(params: CreateDerivedRasterManifestParams): RasterManifest;
+/**
+ * Structural derivation check (no source manifests required). Used both by
+ * verifyRasterDerivation (with sources) and by proof verification (where the
+ * signer's source rasters are not inside the proof).
+ */
+export declare function structuralDerivationCheck(manifest: RasterManifest): Omit<RasterDerivationVerifyResult, 'sourceRasterIds' | 'missingSources'>;
+/**
+ * Verify the declared provenance structure of a derived raster manifest
+ * against the supplied source manifests.
+ */
+export declare function verifyRasterDerivation(manifest: RasterManifest, sourceManifests: RasterManifest[]): RasterDerivationVerifyResult;

package/dist/provenance.js

@@ -0,0 +1,95 @@
+"use strict";
+/**
+ * Derived raster provenance for @totemsdk/raster-proof.
+ *
+ * createDerivedRasterManifest records a raster produced from other rasters
+ * (satellite scene → water mask, image set → orthomosaic, before/after →
+ * change mask, …). verifyRasterDerivation checks the DECLARED provenance
+ * structure — that every derivedFrom ID is supplied, parameters are present
+ * when a pipeline is named, and the manifest is honestly marked as derived.
+ *
+ * It does NOT verify that image processing was performed correctly. That is
+ * outside this package's scope.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDerivedRasterManifest = createDerivedRasterManifest;
+exports.structuralDerivationCheck = structuralDerivationCheck;
+exports.verifyRasterDerivation = verifyRasterDerivation;
+const manifest_js_1 = require("./manifest.js");
+/**
+ * Create a derived raster manifest from source rasters. sourceType is forced
+ * to 'derived'; provenance.derivedFrom lists the source raster IDs.
+ */
+function createDerivedRasterManifest(params) {
+    const { sourceManifests, layerType, asset, pipelineId, pipelineVersion, parametersHash, modelId, uncertainty, operatorId, ...rest } = params;
+    if (sourceManifests.length === 0) {
+        throw new Error('a derived raster requires at least one source manifest');
+    }
+    if (pipelineId !== undefined && parametersHash === undefined) {
+        throw new Error('parametersHash is required when pipelineId is set');
+    }
+    return (0, manifest_js_1.createRasterManifest)({
+        sourceType: 'derived',
+        layerType,
+        asset,
+        provenance: {
+            derivedFrom: sourceManifests.map((m) => m.rasterId),
+            ...(pipelineId !== undefined ? { pipelineId } : {}),
+            ...(pipelineVersion !== undefined ? { pipelineVersion } : {}),
+            ...(parametersHash !== undefined ? { parametersHash } : {}),
+            ...(modelId !== undefined ? { modelId } : {}),
+            ...(uncertainty !== undefined && uncertainty.length > 0 ? { uncertainty } : {}),
+            ...(operatorId !== undefined ? { operatorId } : {}),
+        },
+        ...rest,
+    });
+}
+/**
+ * Structural derivation check (no source manifests required). Used both by
+ * verifyRasterDerivation (with sources) and by proof verification (where the
+ * signer's source rasters are not inside the proof).
+ */
+function structuralDerivationCheck(manifest) {
+    const reasons = [];
+    if (manifest.sourceType !== 'derived') {
+        reasons.push('manifest.sourceType must be "derived"');
+    }
+    if (!manifest.asset || typeof manifest.asset.contentHash !== 'string' || manifest.asset.contentHash.length === 0) {
+        reasons.push('derived raster must declare asset.contentHash');
+    }
+    const derivedFrom = manifest.provenance?.derivedFrom ?? [];
+    if (derivedFrom.length === 0) {
+        reasons.push('derived raster must declare provenance.derivedFrom');
+    }
+    if (manifest.provenance?.pipelineId !== undefined && manifest.provenance.parametersHash === undefined) {
+        reasons.push('parametersHash is required when pipelineId is present');
+    }
+    if (manifest.provenance?.uncertainty !== undefined) {
+        const bad = manifest.provenance.uncertainty.some((u) => typeof u !== 'string' || u.length === 0);
+        if (bad) {
+            reasons.push('provenance.uncertainty must be an array of non-empty strings');
+        }
+    }
+    return { valid: reasons.length === 0, ...(reasons.length > 0 ? { reasons } : {}) };
+}
+/**
+ * Verify the declared provenance structure of a derived raster manifest
+ * against the supplied source manifests.
+ */
+function verifyRasterDerivation(manifest, sourceManifests) {
+    const structural = structuralDerivationCheck(manifest);
+    const reasons = structural.reasons ?? [];
+    const derivedFrom = manifest.provenance?.derivedFrom ?? [];
+    const supplied = new Set(sourceManifests.map((m) => m.rasterId));
+    const missing = derivedFrom.filter((id) => !supplied.has(id));
+    if (missing.length > 0) {
+        reasons.push(`derivedFrom references missing source rasters: ${missing.join(', ')}`);
+    }
+    return {
+        valid: reasons.length === 0,
+        ...(reasons.length > 0 ? { reasons } : {}),
+        sourceRasterIds: derivedFrom,
+        ...(missing.length > 0 ? { missingSources: missing } : {}),
+        ...(manifest.provenance?.uncertainty !== undefined ? { uncertainty: manifest.provenance.uncertainty } : {}),
+    };
+}

package/dist/spatial.d.ts

@@ -0,0 +1,23 @@
+/**
+ * @totemsdk/spatial-proof integration for @totemsdk/raster-proof.
+ *
+ * Bridges a raster manifest's bounds into a @totemsdk/spatial-proof
+ * SpatialObject and evaluates spatial relations (covers, intersects,
+ * overlaps, covered_by, …) against site boundaries, zones, routes, scene
+ * footprints and inspection areas. All geometry math is delegated to
+ * @totemsdk/spatial-proof — nothing here is reimplemented.
+ */
+import type { SpatialObject, SpatialRelationClaim, SpatialRelationType } from '@totemsdk/spatial-proof';
+import type { CreateRasterSpatialRelationParams, RasterManifest } from './types.js';
+/**
+ * Convert a raster manifest into a spatial object footprint, or null when the
+ * manifest has no bounds (nothing to georeference).
+ */
+export declare function rasterFootprintToSpatialObject(manifest: RasterManifest): SpatialObject | null;
+/**
+ * Evaluate a spatial relation between a raster footprint and a spatial
+ * object, producing a deterministic SpatialRelationClaim via
+ * @totemsdk/spatial-proof. Requires the manifest to have bounds.
+ */
+export declare function createRasterSpatialRelation(params: CreateRasterSpatialRelationParams): SpatialRelationClaim;
+export type { SpatialRelationType };

package/dist/spatial.js

@@ -0,0 +1,77 @@
+"use strict";
+/**
+ * @totemsdk/spatial-proof integration for @totemsdk/raster-proof.
+ *
+ * Bridges a raster manifest's bounds into a @totemsdk/spatial-proof
+ * SpatialObject and evaluates spatial relations (covers, intersects,
+ * overlaps, covered_by, …) against site boundaries, zones, routes, scene
+ * footprints and inspection areas. All geometry math is delegated to
+ * @totemsdk/spatial-proof — nothing here is reimplemented.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rasterFootprintToSpatialObject = rasterFootprintToSpatialObject;
+exports.createRasterSpatialRelation = createRasterSpatialRelation;
+const spatial_proof_1 = require("@totemsdk/spatial-proof");
+/**
+ * Build a bbox Polygon (GeoJSON [lon, lat], closed ring) from manifest bounds.
+ */
+function footprintPolygon(bounds) {
+    const [minLon, minLat, maxLon, maxLat] = bounds;
+    return {
+        type: 'Polygon',
+        coordinates: [[
+                [minLon, minLat],
+                [maxLon, minLat],
+                [maxLon, maxLat],
+                [minLon, maxLat],
+                [minLon, minLat],
+            ]],
+    };
+}
+/**
+ * Convert a raster manifest into a spatial object footprint, or null when the
+ * manifest has no bounds (nothing to georeference).
+ */
+function rasterFootprintToSpatialObject(manifest) {
+    const bounds = manifest.spatial?.bounds;
+    if (!bounds || bounds.length !== 4) {
+        return null;
+    }
+    const geometry = footprintPolygon(bounds);
+    const body = {
+        kind: 'scene-footprint',
+        geometry,
+        ...(manifest.spatial?.crs !== undefined ? { crs: manifest.spatial.crs } : {}),
+        ...(manifest.spatial?.spatialObjectId !== undefined ? { spatialId: manifest.spatial.spatialObjectId } : {}),
+        ...(manifest.rasterId !== undefined ? { name: `raster ${manifest.rasterId}` } : {}),
+    };
+    const spatialObject = {
+        ...body,
+        spatialId: body.spatialId ?? (0, spatial_proof_1.computeSpatialObjectId)(body),
+    };
+    return spatialObject;
+}
+/**
+ * Evaluate a spatial relation between a raster footprint and a spatial
+ * object, producing a deterministic SpatialRelationClaim via
+ * @totemsdk/spatial-proof. Requires the manifest to have bounds.
+ */
+function createRasterSpatialRelation(params) {
+    const { manifest, spatialObject, relation, computedAt, maxDistanceM, subjectProofId, metadata } = params;
+    const bounds = manifest.spatial?.bounds;
+    if (!bounds || bounds.length !== 4) {
+        throw new Error('createRasterSpatialRelation requires manifest.spatial.bounds');
+    }
+    return (0, spatial_proof_1.evaluateSpatialRelation)({
+        subjectId: manifest.rasterId,
+        subjectKind: 'raster-manifest',
+        spatialObject,
+        relation,
+        subjectGeometry: footprintPolygon(bounds),
+        rasterManifestId: manifest.rasterId,
+        ...(computedAt !== undefined ? { computedAt } : {}),
+        ...(maxDistanceM !== undefined ? { maxDistanceM } : {}),
+        ...(subjectProofId !== undefined ? { subjectProofId } : {}),
+        ...(metadata !== undefined ? { metadata } : {}),
+    });
+}