@totemsdk/spatial-proof 0.1.0 → 1.0.1

package/dist/cjs/geometry.d.ts

@@ -0,0 +1,91 @@
+/**
+ * Pure TypeScript geometry helpers for @totemsdk/spatial-proof.
+ *
+ * COORDINATE ORDER: [lon, lat] in decimal degrees (GeoJSON / EPSG:4326).
+ * All functions are deterministic and dependency-free. Where a calculation is
+ * approximate (e.g. planar distance scaling near the poles), the result is
+ * clearly labelled in the calling relation's uncertainty notes.
+ *
+ * No network, no storage, no GDAL, no PostGIS, no map rendering.
+ */
+import type { BoundingBox, Coordinate, GeoGeometry, GeoLineStringGeometry, GeoMultiPolygonGeometry, GeoPolygonGeometry, SpatialObject, SpatialValidationResult } from './types.js';
+/**
+ * Validate a single [lon, lat] coordinate.
+ * Returns an error if the coordinate is out of range or not finite.
+ */
+export declare function validateCoordinate(coord: Coordinate): SpatialValidationResult;
+/**
+ * Ring closure: the first and last points must be equal. When a ring is not
+ * closed, it is rejected (see normalizePolygonRing for the deterministic
+ * normalizer).
+ */
+export declare function isRingClosed(ring: Coordinate[]): boolean;
+/**
+ * Deterministic normalizer: if the ring is not closed, append a copy of the
+ * first point. Idempotent for already-closed rings. The returned array is a
+ * fresh copy — the input is never mutated.
+ */
+export declare function normalizePolygonRing(ring: Coordinate[]): Coordinate[];
+/**
+ * Deterministic normalizer for a whole polygon: closes every ring.
+ */
+export declare function normalizePolygon(polygon: GeoPolygonGeometry): GeoPolygonGeometry;
+/**
+ * Validate a single geometry.
+ *
+ * Rules:
+ *   - Point: 1 valid coordinate
+ *   - LineString: at least 2 valid coordinates
+ *   - Polygon: at least 4 points per ring; rings must be closed
+ *   - MultiPolygon: at least 1 polygon, each valid
+ */
+export declare function validateGeometry(geometry: GeoGeometry): SpatialValidationResult;
+/**
+ * Validate a spatial object. CRS defaults to EPSG:4326; any other CRS
+ * produces a warning (all geometry math here assumes WGS84 lon/lat).
+ */
+export declare function validateSpatialObject(obj: SpatialObject): SpatialValidationResult;
+/**
+ * Compute the axis-aligned bounding box of any geometry. Handles Point,
+ * LineString, Polygon, and MultiPolygon (multi-dimensional flattening).
+ */
+export declare function getBoundingBox(geometry: GeoGeometry): BoundingBox;
+/**
+ * True when two bounding boxes share any area or edge.
+ */
+export declare function bboxIntersects(a: BoundingBox, b: BoundingBox): boolean;
+/**
+ * True when box `a` fully covers box `b`.
+ */
+export declare function bboxCovers(a: BoundingBox, b: BoundingBox): boolean;
+/**
+ * Great-circle distance between two [lon, lat] points using the Haversine
+ * formula. Approximate (spherical Earth, R = 6371 km).
+ */
+export declare function distanceMeters(a: Coordinate, b: Coordinate): number;
+/**
+ * Perpendicular distance from a point to a line segment defined by [a, b].
+ * Uses an equirectangular local approximation scaled to meters — accurate for
+ * short segments, approximate over large distances or near the poles.
+ */
+export declare function distancePointToSegmentMeters(point: Coordinate, a: Coordinate, b: Coordinate): number;
+/**
+ * Minimum distance from a point to a LineString.
+ * Approximate: equirectangular scaling applied per segment.
+ */
+export declare function distancePointToLineStringMeters(point: Coordinate, line: GeoLineStringGeometry): number;
+/**
+ * Ray-casting point-in-polygon test over the outer ring of a Polygon.
+ * Uses a normalized (closed) copy of the ring. Approximate on the lon/lat
+ * plane — fine for typical geofences; not geodesic.
+ */
+export declare function pointInPolygon(point: Coordinate, polygon: GeoPolygonGeometry): boolean;
+/**
+ * Point-in-MultiPolygon: true when the point is inside any of the polygons.
+ */
+export declare function pointInMultiPolygon(point: Coordinate, multi: GeoMultiPolygonGeometry): boolean;
+/**
+ * True when a point is within `thresholdM` meters of any boundary ring of a
+ * Polygon (outer ring and holes). Uses the equirectangular approximation.
+ */
+export declare function isPointNearBoundary(point: Coordinate, polygon: GeoPolygonGeometry, thresholdM: number): boolean;

package/dist/cjs/geometry.js

@@ -0,0 +1,334 @@
+"use strict";
+/**
+ * Pure TypeScript geometry helpers for @totemsdk/spatial-proof.
+ *
+ * COORDINATE ORDER: [lon, lat] in decimal degrees (GeoJSON / EPSG:4326).
+ * All functions are deterministic and dependency-free. Where a calculation is
+ * approximate (e.g. planar distance scaling near the poles), the result is
+ * clearly labelled in the calling relation's uncertainty notes.
+ *
+ * No network, no storage, no GDAL, no PostGIS, no map rendering.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateCoordinate = validateCoordinate;
+exports.isRingClosed = isRingClosed;
+exports.normalizePolygonRing = normalizePolygonRing;
+exports.normalizePolygon = normalizePolygon;
+exports.validateGeometry = validateGeometry;
+exports.validateSpatialObject = validateSpatialObject;
+exports.getBoundingBox = getBoundingBox;
+exports.bboxIntersects = bboxIntersects;
+exports.bboxCovers = bboxCovers;
+exports.distanceMeters = distanceMeters;
+exports.distancePointToSegmentMeters = distancePointToSegmentMeters;
+exports.distancePointToLineStringMeters = distancePointToLineStringMeters;
+exports.pointInPolygon = pointInPolygon;
+exports.pointInMultiPolygon = pointInMultiPolygon;
+exports.isPointNearBoundary = isPointNearBoundary;
+const EARTH_RADIUS_M = 6371000;
+function toRadians(deg) {
+    return (deg * Math.PI) / 180;
+}
+/** Meters per degree of latitude (equirectangular approximation). */
+function metersPerDegreeLat() {
+    return (Math.PI / 180) * EARTH_RADIUS_M;
+}
+/**
+ * Meters per degree of longitude at a given latitude (equirectangular
+ * approximation). Approximate and only valid for small distances.
+ */
+function metersPerDegreeLon(latDeg) {
+    return Math.cos(toRadians(latDeg)) * metersPerDegreeLat();
+}
+// ── Validation ───────────────────────────────────────────────────────────────
+function ok() {
+    return { valid: true, errors: [], warnings: [] };
+}
+/**
+ * Validate a single [lon, lat] coordinate.
+ * Returns an error if the coordinate is out of range or not finite.
+ */
+function validateCoordinate(coord) {
+    const errors = [];
+    const warnings = [];
+    if (!Array.isArray(coord) || coord.length !== 2) {
+        errors.push('coordinate must be a [lon, lat] pair');
+        return { valid: false, errors, warnings };
+    }
+    const [lon, lat] = coord;
+    if (!Number.isFinite(lon)) {
+        errors.push('longitude must be finite');
+    }
+    else if (lon < -180 || lon > 180) {
+        errors.push('longitude must be between -180 and 180');
+    }
+    if (!Number.isFinite(lat)) {
+        errors.push('latitude must be finite');
+    }
+    else if (lat < -90 || lat > 90) {
+        errors.push('latitude must be between -90 and 90');
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Ring closure: the first and last points must be equal. When a ring is not
+ * closed, it is rejected (see normalizePolygonRing for the deterministic
+ * normalizer).
+ */
+function isRingClosed(ring) {
+    if (ring.length < 2)
+        return false;
+    const first = ring[0];
+    const last = ring[ring.length - 1];
+    return first[0] === last[0] && first[1] === last[1];
+}
+/**
+ * Deterministic normalizer: if the ring is not closed, append a copy of the
+ * first point. Idempotent for already-closed rings. The returned array is a
+ * fresh copy — the input is never mutated.
+ */
+function normalizePolygonRing(ring) {
+    if (isRingClosed(ring))
+        return [...ring];
+    return [...ring.map((c) => [c[0], c[1]]), [ring[0][0], ring[0][1]]];
+}
+/**
+ * Deterministic normalizer for a whole polygon: closes every ring.
+ */
+function normalizePolygon(polygon) {
+    return {
+        type: 'Polygon',
+        coordinates: polygon.coordinates.map(normalizePolygonRing),
+    };
+}
+/**
+ * Validate a single geometry.
+ *
+ * Rules:
+ *   - Point: 1 valid coordinate
+ *   - LineString: at least 2 valid coordinates
+ *   - Polygon: at least 4 points per ring; rings must be closed
+ *   - MultiPolygon: at least 1 polygon, each valid
+ */
+function validateGeometry(geometry) {
+    const errors = [];
+    const warnings = [];
+    switch (geometry.type) {
+        case 'Point': {
+            const point = validateCoordinate(geometry.coordinates);
+            errors.push(...point.errors);
+            warnings.push(...point.warnings);
+            break;
+        }
+        case 'LineString': {
+            const coords = geometry.coordinates;
+            if (coords.length < 2) {
+                errors.push('LineString must have at least 2 points');
+            }
+            for (const c of coords) {
+                const point = validateCoordinate(c);
+                errors.push(...point.errors);
+            }
+            break;
+        }
+        case 'Polygon': {
+            const rings = geometry.coordinates;
+            if (rings.length === 0) {
+                errors.push('Polygon must have at least 1 ring');
+            }
+            for (const ring of rings) {
+                if (ring.length < 4) {
+                    errors.push('Polygon ring must have at least 4 points including closing point');
+                }
+                if (!isRingClosed(ring)) {
+                    errors.push('Polygon ring must be closed (first point must equal last point)');
+                }
+                for (const c of ring) {
+                    const point = validateCoordinate(c);
+                    errors.push(...point.errors);
+                }
+            }
+            break;
+        }
+        case 'MultiPolygon': {
+            const polys = geometry.coordinates;
+            if (polys.length === 0) {
+                errors.push('MultiPolygon must contain at least 1 polygon');
+            }
+            for (const poly of polys) {
+                const sub = validateGeometry({ type: 'Polygon', coordinates: poly });
+                errors.push(...sub.errors);
+                warnings.push(...sub.warnings);
+            }
+            break;
+        }
+        default:
+            errors.push('unknown geometry type: ' + geometry.type);
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+/**
+ * Validate a spatial object. CRS defaults to EPSG:4326; any other CRS
+ * produces a warning (all geometry math here assumes WGS84 lon/lat).
+ */
+function validateSpatialObject(obj) {
+    const errors = [];
+    const warnings = [];
+    if (typeof obj.spatialId !== 'string' || obj.spatialId.length === 0) {
+        errors.push('spatialId is required');
+    }
+    if (typeof obj.kind !== 'string' || obj.kind.length === 0) {
+        errors.push('kind is required');
+    }
+    const geo = validateGeometry(obj.geometry);
+    errors.push(...geo.errors);
+    warnings.push(...geo.warnings);
+    const crs = obj.crs ?? 'EPSG:4326';
+    if (crs !== 'EPSG:4326') {
+        warnings.push(`CRS is ${crs}; geometry math assumes WGS84 (EPSG:4326) [lon, lat]`);
+    }
+    return { valid: errors.length === 0, errors, warnings };
+}
+// ── Bounding boxes ───────────────────────────────────────────────────────────
+/**
+ * Compute the axis-aligned bounding box of any geometry. Handles Point,
+ * LineString, Polygon, and MultiPolygon (multi-dimensional flattening).
+ */
+function getBoundingBox(geometry) {
+    const coords = [];
+    const collect = (c) => { coords.push(c); };
+    switch (geometry.type) {
+        case 'Point':
+            collect(geometry.coordinates);
+            break;
+        case 'LineString':
+            geometry.coordinates.forEach(collect);
+            break;
+        case 'Polygon':
+            geometry.coordinates.forEach((ring) => ring.forEach(collect));
+            break;
+        case 'MultiPolygon':
+            geometry.coordinates.forEach((poly) => poly.forEach((ring) => ring.forEach(collect)));
+            break;
+    }
+    let minLon = Infinity;
+    let minLat = Infinity;
+    let maxLon = -Infinity;
+    let maxLat = -Infinity;
+    for (const [lon, lat] of coords) {
+        if (lon < minLon)
+            minLon = lon;
+        if (lon > maxLon)
+            maxLon = lon;
+        if (lat < minLat)
+            minLat = lat;
+        if (lat > maxLat)
+            maxLat = lat;
+    }
+    return { minLon, minLat, maxLon, maxLat };
+}
+/**
+ * True when two bounding boxes share any area or edge.
+ */
+function bboxIntersects(a, b) {
+    return !(a.maxLon < b.minLon || b.maxLon < a.minLon || a.maxLat < b.minLat || b.maxLat < a.minLat);
+}
+/**
+ * True when box `a` fully covers box `b`.
+ */
+function bboxCovers(a, b) {
+    return a.minLon <= b.minLon && a.maxLon >= b.maxLon && a.minLat <= b.minLat && a.maxLat >= b.maxLat;
+}
+// ── Distance ─────────────────────────────────────────────────────────────────
+/**
+ * Great-circle distance between two [lon, lat] points using the Haversine
+ * formula. Approximate (spherical Earth, R = 6371 km).
+ */
+function distanceMeters(a, b) {
+    const dLat = toRadians(b[1] - a[1]);
+    const dLon = toRadians(b[0] - a[0]);
+    const lat1 = toRadians(a[1]);
+    const lat2 = toRadians(b[1]);
+    const h = Math.sin(dLat / 2) ** 2 +
+        Math.cos(lat1) * Math.cos(lat2) * Math.sin(dLon / 2) ** 2;
+    return 2 * EARTH_RADIUS_M * Math.asin(Math.min(1, Math.sqrt(h)));
+}
+/**
+ * Perpendicular distance from a point to a line segment defined by [a, b].
+ * Uses an equirectangular local approximation scaled to meters — accurate for
+ * short segments, approximate over large distances or near the poles.
+ */
+function distancePointToSegmentMeters(point, a, b) {
+    const refLat = (point[1] + a[1] + b[1]) / 3;
+    const mPerLon = metersPerDegreeLon(refLat);
+    const mPerLat = metersPerDegreeLat();
+    const px = point[0] * mPerLon;
+    const py = point[1] * mPerLat;
+    const ax = a[0] * mPerLon;
+    const ay = a[1] * mPerLat;
+    const bx = b[0] * mPerLon;
+    const by = b[1] * mPerLat;
+    const dx = bx - ax;
+    const dy = by - ay;
+    if (dx === 0 && dy === 0) {
+        return Math.hypot(px - ax, py - ay);
+    }
+    const t = Math.max(0, Math.min(1, ((px - ax) * dx + (py - ay) * dy) / (dx * dx + dy * dy)));
+    const cx = ax + t * dx;
+    const cy = ay + t * dy;
+    return Math.hypot(px - cx, py - cy);
+}
+/**
+ * Minimum distance from a point to a LineString.
+ * Approximate: equirectangular scaling applied per segment.
+ */
+function distancePointToLineStringMeters(point, line) {
+    let min = Infinity;
+    for (let i = 1; i < line.coordinates.length; i++) {
+        const d = distancePointToSegmentMeters(point, line.coordinates[i - 1], line.coordinates[i]);
+        if (d < min)
+            min = d;
+    }
+    return min === Infinity ? 0 : min;
+}
+// ── Point-in-polygon ─────────────────────────────────────────────────────────
+/**
+ * Ray-casting point-in-polygon test over the outer ring of a Polygon.
+ * Uses a normalized (closed) copy of the ring. Approximate on the lon/lat
+ * plane — fine for typical geofences; not geodesic.
+ */
+function pointInPolygon(point, polygon) {
+    const ring = normalizePolygonRing(polygon.coordinates[0]);
+    let inside = false;
+    for (let i = 0, j = ring.length - 1; i < ring.length; j = i++) {
+        const [xi, yi] = ring[i];
+        const [xj, yj] = ring[j];
+        const intersect = yi > point[1] !== yj > point[1] &&
+            point[0] < ((xj - xi) * (point[1] - yi)) / (yj - yi) + xi;
+        if (intersect)
+            inside = !inside;
+    }
+    return inside;
+}
+/**
+ * Point-in-MultiPolygon: true when the point is inside any of the polygons.
+ */
+function pointInMultiPolygon(point, multi) {
+    return multi.coordinates.some((poly) => pointInPolygon(point, { type: 'Polygon', coordinates: poly }));
+}
+// ── Boundary distance ────────────────────────────────────────────────────────
+/**
+ * True when a point is within `thresholdM` meters of any boundary ring of a
+ * Polygon (outer ring and holes). Uses the equirectangular approximation.
+ */
+function isPointNearBoundary(point, polygon, thresholdM) {
+    for (const rawRing of polygon.coordinates) {
+        const ring = normalizePolygonRing(rawRing);
+        for (let i = 1; i < ring.length; i++) {
+            const d = distancePointToSegmentMeters(point, ring[i - 1], ring[i]);
+            if (d <= thresholdM)
+                return true;
+        }
+    }
+    return false;
+}

package/dist/cjs/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @module @totemsdk/spatial-proof
+ *
+ * Generic geospatial relationship proof primitives for Totem Edge.
+ *
+ * Answers "how does this proof, device, asset, observation, raster, image,
+ * route, or event relate to a known spatial object?" — inside a site boundary,
+ * covering a polygon, near a boundary, on a route, overlapping a zone, etc.
+ *
+ * This is a pure schema/calculation/proof package:
+ *
+ *   geometry + subject + relation + computation metadata
+ *   → deterministic spatial relation claim
+ *   → evidence hash
+ *   → Totem proof envelope
+ *   → proofgraph linkage
+ *
+ * No network, no storage, no map rendering, no GDAL, no PostGIS, no external
+ * API. All geometry math is deterministic; where a calculation is approximate
+ * (e.g. bounding-box-only relations) the uncertainty is explicit in the output.
+ *
+ * COORDINATE ORDER: [lon, lat] (GeoJSON / EPSG:4326).
+ */
+export type { Coordinate, GeoGeometry, GeoPointGeometry, GeoLineStringGeometry, GeoPolygonGeometry, GeoMultiPolygonGeometry, BoundingBox, SpatialObjectKind, SpatialObject, SpatialRelationType, EngineInfo, SpatialRelationClaimInputs, SpatialRelationClaimResult, SpatialRelationClaim, SpatialValidationResult, EvaluateSpatialRelationParams, CreateSpatialProofParams, SpatialProofVerifyResult, } from './types.js';
+export { canonicalJson, toHex } from './canonical.js';
+export { computeGeometryHash, computeSpatialObjectId, computeSpatialRelationId, hashSpatialObject, hashSpatialRelationClaim, } from './canonical.js';
+export { validateCoordinate, validateGeometry, validateSpatialObject, getBoundingBox, bboxIntersects, bboxCovers, distanceMeters, distancePointToSegmentMeters, distancePointToLineStringMeters, pointInPolygon, pointInMultiPolygon, isPointNearBoundary, isRingClosed, normalizePolygonRing, normalizePolygon, } from './geometry.js';
+export { evaluateSpatialRelation } from './relations.js';
+export { spatialRelationFromLocationClaim, validateSpatialRelationClaim, } from './claim.js';
+export { spatialObjectToEvidenceRef, spatialRelationToEvidenceRef, spatialClaimEvidenceRefs, createUnsignedSpatialProof, signSpatialProof, verifySpatialProof, } from './proof.js';
+export { spatialObjectToProofGraphNode, spatialRelationToProofGraphNode, spatialRelationToGraphEdges, addSpatialRelationToGraph, } from './proofgraph.js';

package/dist/cjs/index.js

@@ -0,0 +1,68 @@
+"use strict";
+/**
+ * @module @totemsdk/spatial-proof
+ *
+ * Generic geospatial relationship proof primitives for Totem Edge.
+ *
+ * Answers "how does this proof, device, asset, observation, raster, image,
+ * route, or event relate to a known spatial object?" — inside a site boundary,
+ * covering a polygon, near a boundary, on a route, overlapping a zone, etc.
+ *
+ * This is a pure schema/calculation/proof package:
+ *
+ *   geometry + subject + relation + computation metadata
+ *   → deterministic spatial relation claim
+ *   → evidence hash
+ *   → Totem proof envelope
+ *   → proofgraph linkage
+ *
+ * No network, no storage, no map rendering, no GDAL, no PostGIS, no external
+ * API. All geometry math is deterministic; where a calculation is approximate
+ * (e.g. bounding-box-only relations) the uncertainty is explicit in the output.
+ *
+ * COORDINATE ORDER: [lon, lat] (GeoJSON / EPSG:4326).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addSpatialRelationToGraph = exports.spatialRelationToGraphEdges = exports.spatialRelationToProofGraphNode = exports.spatialObjectToProofGraphNode = exports.verifySpatialProof = exports.signSpatialProof = exports.createUnsignedSpatialProof = exports.spatialClaimEvidenceRefs = exports.spatialRelationToEvidenceRef = exports.spatialObjectToEvidenceRef = exports.validateSpatialRelationClaim = exports.spatialRelationFromLocationClaim = exports.evaluateSpatialRelation = exports.normalizePolygon = exports.normalizePolygonRing = exports.isRingClosed = exports.isPointNearBoundary = exports.pointInMultiPolygon = exports.pointInPolygon = exports.distancePointToLineStringMeters = exports.distancePointToSegmentMeters = exports.distanceMeters = exports.bboxCovers = exports.bboxIntersects = exports.getBoundingBox = exports.validateSpatialObject = exports.validateGeometry = exports.validateCoordinate = exports.hashSpatialRelationClaim = exports.hashSpatialObject = exports.computeSpatialRelationId = exports.computeSpatialObjectId = exports.computeGeometryHash = exports.toHex = exports.canonicalJson = void 0;
+var canonical_js_1 = require("./canonical.js");
+Object.defineProperty(exports, "canonicalJson", { enumerable: true, get: function () { return canonical_js_1.canonicalJson; } });
+Object.defineProperty(exports, "toHex", { enumerable: true, get: function () { return canonical_js_1.toHex; } });
+var canonical_js_2 = require("./canonical.js");
+Object.defineProperty(exports, "computeGeometryHash", { enumerable: true, get: function () { return canonical_js_2.computeGeometryHash; } });
+Object.defineProperty(exports, "computeSpatialObjectId", { enumerable: true, get: function () { return canonical_js_2.computeSpatialObjectId; } });
+Object.defineProperty(exports, "computeSpatialRelationId", { enumerable: true, get: function () { return canonical_js_2.computeSpatialRelationId; } });
+Object.defineProperty(exports, "hashSpatialObject", { enumerable: true, get: function () { return canonical_js_2.hashSpatialObject; } });
+Object.defineProperty(exports, "hashSpatialRelationClaim", { enumerable: true, get: function () { return canonical_js_2.hashSpatialRelationClaim; } });
+var geometry_js_1 = require("./geometry.js");
+Object.defineProperty(exports, "validateCoordinate", { enumerable: true, get: function () { return geometry_js_1.validateCoordinate; } });
+Object.defineProperty(exports, "validateGeometry", { enumerable: true, get: function () { return geometry_js_1.validateGeometry; } });
+Object.defineProperty(exports, "validateSpatialObject", { enumerable: true, get: function () { return geometry_js_1.validateSpatialObject; } });
+Object.defineProperty(exports, "getBoundingBox", { enumerable: true, get: function () { return geometry_js_1.getBoundingBox; } });
+Object.defineProperty(exports, "bboxIntersects", { enumerable: true, get: function () { return geometry_js_1.bboxIntersects; } });
+Object.defineProperty(exports, "bboxCovers", { enumerable: true, get: function () { return geometry_js_1.bboxCovers; } });
+Object.defineProperty(exports, "distanceMeters", { enumerable: true, get: function () { return geometry_js_1.distanceMeters; } });
+Object.defineProperty(exports, "distancePointToSegmentMeters", { enumerable: true, get: function () { return geometry_js_1.distancePointToSegmentMeters; } });
+Object.defineProperty(exports, "distancePointToLineStringMeters", { enumerable: true, get: function () { return geometry_js_1.distancePointToLineStringMeters; } });
+Object.defineProperty(exports, "pointInPolygon", { enumerable: true, get: function () { return geometry_js_1.pointInPolygon; } });
+Object.defineProperty(exports, "pointInMultiPolygon", { enumerable: true, get: function () { return geometry_js_1.pointInMultiPolygon; } });
+Object.defineProperty(exports, "isPointNearBoundary", { enumerable: true, get: function () { return geometry_js_1.isPointNearBoundary; } });
+Object.defineProperty(exports, "isRingClosed", { enumerable: true, get: function () { return geometry_js_1.isRingClosed; } });
+Object.defineProperty(exports, "normalizePolygonRing", { enumerable: true, get: function () { return geometry_js_1.normalizePolygonRing; } });
+Object.defineProperty(exports, "normalizePolygon", { enumerable: true, get: function () { return geometry_js_1.normalizePolygon; } });
+var relations_js_1 = require("./relations.js");
+Object.defineProperty(exports, "evaluateSpatialRelation", { enumerable: true, get: function () { return relations_js_1.evaluateSpatialRelation; } });
+var claim_js_1 = require("./claim.js");
+Object.defineProperty(exports, "spatialRelationFromLocationClaim", { enumerable: true, get: function () { return claim_js_1.spatialRelationFromLocationClaim; } });
+Object.defineProperty(exports, "validateSpatialRelationClaim", { enumerable: true, get: function () { return claim_js_1.validateSpatialRelationClaim; } });
+var proof_js_1 = require("./proof.js");
+Object.defineProperty(exports, "spatialObjectToEvidenceRef", { enumerable: true, get: function () { return proof_js_1.spatialObjectToEvidenceRef; } });
+Object.defineProperty(exports, "spatialRelationToEvidenceRef", { enumerable: true, get: function () { return proof_js_1.spatialRelationToEvidenceRef; } });
+Object.defineProperty(exports, "spatialClaimEvidenceRefs", { enumerable: true, get: function () { return proof_js_1.spatialClaimEvidenceRefs; } });
+Object.defineProperty(exports, "createUnsignedSpatialProof", { enumerable: true, get: function () { return proof_js_1.createUnsignedSpatialProof; } });
+Object.defineProperty(exports, "signSpatialProof", { enumerable: true, get: function () { return proof_js_1.signSpatialProof; } });
+Object.defineProperty(exports, "verifySpatialProof", { enumerable: true, get: function () { return proof_js_1.verifySpatialProof; } });
+var proofgraph_js_1 = require("./proofgraph.js");
+Object.defineProperty(exports, "spatialObjectToProofGraphNode", { enumerable: true, get: function () { return proofgraph_js_1.spatialObjectToProofGraphNode; } });
+Object.defineProperty(exports, "spatialRelationToProofGraphNode", { enumerable: true, get: function () { return proofgraph_js_1.spatialRelationToProofGraphNode; } });
+Object.defineProperty(exports, "spatialRelationToGraphEdges", { enumerable: true, get: function () { return proofgraph_js_1.spatialRelationToGraphEdges; } });
+Object.defineProperty(exports, "addSpatialRelationToGraph", { enumerable: true, get: function () { return proofgraph_js_1.addSpatialRelationToGraph; } });

package/dist/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/dist/cjs/proof.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Proof envelope integration for @totemsdk/spatial-proof.
+ *
+ * Bridges spatial objects and spatial relation claims into @totemsdk/proof
+ * evidence refs and signed proof envelopes. Signing/verification delegate to
+ * @totemsdk/proof. Anchoring is deliberately NOT required for verification.
+ */
+import type { EvidenceRef, UnsignedProof, SignedProof } from '@totemsdk/proof';
+import type { CreateSpatialProofParams, GeoGeometry, SpatialObject, SpatialProofVerifyResult, SpatialRelationClaim } from './types.js';
+/**
+ * Convert a SpatialObject into an EvidenceRef for inclusion in a proof.
+ */
+export declare function spatialObjectToEvidenceRef(obj: SpatialObject): EvidenceRef;
+/**
+ * Convert a SpatialRelationClaim into an EvidenceRef for inclusion in a proof.
+ */
+export declare function spatialRelationToEvidenceRef(claim: SpatialRelationClaim): EvidenceRef;
+/**
+ * Build the evidence ref list for a spatial proof.
+ *
+ * Always includes the relation claim hash and spatial object hash. Optionally
+ * adds the subject geometry hash, subject proof ID, location claim ID, and
+ * raster manifest ID when present on the claim.
+ */
+export declare function spatialClaimEvidenceRefs(claim: SpatialRelationClaim, obj: SpatialObject, subjectGeometry?: GeoGeometry): EvidenceRef[];
+/**
+ * Create an unsigned attestation proof for a spatial relation claim.
+ *
+ * The proof claims: "this subject relates to this spatial object in this way
+ * at this time, computed by this engine." It does NOT claim the relation is
+ * geodetically exact — approximation notes travel inside the claim result.
+ */
+export declare function createUnsignedSpatialProof(params: CreateSpatialProofParams): UnsignedProof;
+/**
+ * Sign an unsigned spatial 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.
+ */
+export declare function signSpatialProof(unsigned: UnsignedProof, seed: Uint8Array, keyIndex: number): SignedProof;
+/**
+ * Verify a signed spatial proof end to end.
+ *
+ * Checks:
+ *   1. the underlying @totemsdk/proof verification (signature, proofId, expiry)
+ *   2. payload contains a structurally valid SpatialRelationClaim
+ *   3. the relation's claimId matches a recomputation from its fields
+ *   4. the relation evidence hash matches the payload claim
+ *   5. the spatial-object evidence hash matches the payload claim inputs
+ *   6. any subject geometry evidence hash is present when claimed
+ *
+ * Anchoring is not required.
+ */
+export declare function verifySpatialProof(signed: SignedProof): SpatialProofVerifyResult;