@honua/app-platform 0.1.12 → 0.1.13

package/columnar/index.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Dependency-free columnar batch and worker-transfer contracts exported by
+ * `@honua/sdk-js/query-planner` for large geospatial results.
+ *
+ * The Honua envelope includes a normative dependency-free GeoArrow 0.2 mapping
+ * without importing an Arrow implementation. Transfers expose exact
+ * backing-allocation and payload-copy metrics, deduplicate shared backing
+ * buffers, enforce conservative default ceilings, and use a one-owner lease
+ * with deterministic cancellation, acknowledgement, error, and disposal
+ * behavior.
+ *
+ * @experimental
+ */
+export { ColumnarBatchLease, createColumnarBatch, inspectColumnarBatch, leaseColumnarBatch } from "./transfer.js";
+export { fromApacheArrowRecordBatch, loadApacheArrow, toApacheArrowRecordBatch } from "./apache-arrow.js";
+export { createGeoArrowBatch, decodeGeoArrowBatch, inspectGeoArrowBatch } from "./geoarrow.js";
+export { DEFAULT_COLUMNAR_RESULT_MAX_FEATURES, columnarBatchToResult, columnarBatchToResultPages, resultToColumnarBatch, } from "./result.js";
+export type { ColumnarBatchToResultOptions, ColumnarBatchToResultPagesOptions, ColumnarGeoJsonGeometry, ColumnarGeoJsonGeometryType, ColumnarResult, ColumnarResultAttributeBinding, ColumnarResultDictionaryBinding, ColumnarResultFeatureIdBinding, ColumnarResultGeometryDescriptor, ColumnarResultProvenance, ColumnarResultTemporalBinding, ResultToColumnarBatchAttributeOptions, ResultToColumnarBatchGeometryOptions, ResultToColumnarBatchOptions, ResultToColumnarBatchResult, } from "./result.js";
+export { createGeoArrowReprojectOperation } from "./geoarrow-reproject.js";
+export type { CreateGeoArrowReprojectOperationOptions } from "./geoarrow-reproject.js";
+export { DEFAULT_GEOARROW_AGGREGATE_MAX_GROUPS, DEFAULT_GEOARROW_AGGREGATE_YIELD_ROWS, GEOARROW_AGGREGATE_ABORT_CHECK_ROWS, GEOARROW_AGGREGATE_MAX_GRID_CELL_INDEX, HONUA_GEOARROW_AGGREGATE_LAYOUT_VERSION, createGeoArrowAggregateOperation, readGeoArrowAggregateBatch, } from "./geoarrow-aggregate.js";
+export type { CreateGeoArrowAggregateOperationOptions, GeoArrowAggregateDictionaryGroupSpec, GeoArrowAggregateGridGroupSpec, GeoArrowAggregateGroupSpec, GeoArrowAggregateMetricKind, GeoArrowAggregateMetricSpec, GeoArrowAggregateNullKeyPolicy, GeoArrowAggregateNumericColumn, GeoArrowAggregateResult, GeoArrowAggregateRow, GeoArrowAggregateSource, GeoArrowAggregateTemporalGroupSpec, GeoArrowAggregateTruncationUnit, } from "./geoarrow-aggregate.js";
+export { COLUMNAR_PATCH_ABORT_CHECK_ROWS, COLUMNAR_PATCH_KIND, COLUMNAR_PATCH_VERSION, DEFAULT_COLUMNAR_PATCH_MAX_CAPACITY_UTILIZATION, DEFAULT_COLUMNAR_PATCH_MAX_OPERATIONS, DEFAULT_COLUMNAR_PATCH_MAX_TOMBSTONE_OVERLAY_BYTES, DEFAULT_COLUMNAR_PATCH_MAX_TOMBSTONE_RATIO, DEFAULT_COLUMNAR_PATCH_MAX_VERTEX_GROWTH_RATIO, HONUA_COLUMNAR_PATCH_LAYOUT_VERSION, HonuaColumnarPatchError, applyColumnarPatch, columnarPatchLiveMask, createColumnarPatch, createColumnarPatchOperation, createPatchableGeoArrowBatch, decodePatchedGeoArrowBatch, inspectColumnarPatchState, } from "./geoarrow-patch.js";
+export type { ApplyColumnarPatchOptions, ApplyColumnarPatchOutcomeV1, ColumnarPatchAppendV1, ColumnarPatchAppliedInPlaceV1, ColumnarPatchCapacityV1, ColumnarPatchCursorV1, ColumnarPatchDeleteV1, ColumnarPatchGeometry, ColumnarPatchMetricsV1, ColumnarPatchOperationV1, ColumnarPatchRebuildOptions, ColumnarPatchRebuildReason, ColumnarPatchRebuiltV1, ColumnarPatchRejectedV1, ColumnarPatchRejectionCode, ColumnarPatchReserveV1, ColumnarPatchStateV1, ColumnarPatchThresholds, ColumnarPatchUpdateV1, ColumnarPatchV1, CreateColumnarPatchInput, CreateColumnarPatchOperationOptions, CreatePatchableGeoArrowBatchOptions, CreatedPatchableGeoArrowBatch, DecodedPatchedGeoArrowBatch, PatchableGeoArrowBatchMetrics, } from "./geoarrow-patch.js";
+export { createGeoArrowFilterOperation, createGeoArrowProjectionOperation, createGeoArrowTransformOperation, } from "./operators.js";
+export { GEOARROW_ENVELOPE_MIGRATIONS, HONUA_GEOARROW_ENVELOPE_KIND, HONUA_GEOARROW_ENVELOPE_VERSION, deserializeGeoArrowBatch, planGeoArrowEnvelopeMigration, readableGeoArrowEnvelopeVersions, serializeGeoArrowBatch, } from "./geoarrow-serialization.js";
+export { DEFAULT_COLUMNAR_BATCH_CACHE_MAX_AGE_MS, DEFAULT_COLUMNAR_BATCH_CACHE_MAX_RECORDS, DEFAULT_COLUMNAR_BATCH_CACHE_QUOTA_BYTES, HONUA_COLUMNAR_BATCH_CACHE_FORMAT, MAX_COLUMNAR_BATCH_CACHE_MAX_AGE_MS, MAX_COLUMNAR_BATCH_CACHE_MAX_RECORDS, MAX_COLUMNAR_BATCH_CACHE_QUOTA_BYTES, columnarBatchCacheKey, columnarBatchCacheOrderingDigest, createColumnarBatchCache, createMemoryColumnarBatchCacheStorage, planColumnarBatchCacheAdmission, } from "./batch-cache.js";
+export type { ColumnarBatchCacheAdmissionV1, ColumnarBatchCacheDiagnosticV1, ColumnarBatchCacheEntryV1, ColumnarBatchCacheFreshnessV1, ColumnarBatchCacheHandle, ColumnarBatchCacheMissReason, ColumnarBatchCacheOptions, ColumnarBatchCacheReadOptions, ColumnarBatchCacheReadV1, ColumnarBatchCacheRecordV1, ColumnarBatchCacheRefusalReason, ColumnarBatchCacheStaleReason, ColumnarBatchCacheStorage, ColumnarBatchCacheWriteOptions, ColumnarBatchCacheWriteV1, } from "./batch-cache.js";
+export { columnarAuthorizationScopeDigest } from "./telemetry.js";
+export type { ColumnarTelemetry, ColumnarTelemetryIdentityV1, ColumnarTelemetryKind, ColumnarTelemetryOptions, ColumnarTelemetrySpan, ColumnarTelemetrySpanResult, } from "./telemetry.js";
+export { createIndexedDbColumnarBatchCacheStorage } from "./batch-cache-indexeddb.js";
+export type { IndexedDbColumnarBatchCacheStorageOptions } from "./batch-cache-indexeddb.js";
+export { COLUMNAR_BATCH_CACHE_CONFORMANCE_CASES, HONUA_COLUMNAR_BATCH_CACHE_CONFORMANCE_KIND, HONUA_COLUMNAR_BATCH_CACHE_CONFORMANCE_VERSION, columnarBatchCacheFixtureBatch, columnarBatchCacheFixtureIdentity, columnarBatchCacheLegacyEntry, runColumnarBatchCacheConformance, } from "./batch-cache-conformance.js";
+export type { ColumnarBatchCacheConformanceCaseResultV1, ColumnarBatchCacheConformanceOptions, ColumnarBatchCacheConformanceReportV1, } from "./batch-cache-conformance.js";
+export { GEOARROW_SPEC_VERSION, HONUA_GEOARROW_LAYOUT_VERSION, HonuaGeoArrowError, } from "./geoarrow-types.js";
+export type { GeoArrowEnvelopeMigrationPlanV1, GeoArrowEnvelopeMigrationRefusal, GeoArrowEnvelopeMigrationV1, } from "./geoarrow-types.js";
+export type { ApacheArrowAdapterMetrics, ApacheArrowAdapterOptions, ApacheArrowDataLike, ApacheArrowFieldLike, ApacheArrowModuleImporter, ApacheArrowModuleLike, ApacheArrowRecordBatchLike, ApacheArrowRecordBatchResult, ApacheArrowTypeLike, ApacheArrowVectorLike, CreateGeoArrowBatchInput, CreatedGeoArrowBatch, DecodedGeoArrowBatch, DecodedGeoArrowRow, GeoArrowBatchInspection, GeoArrowBatchSerializationResult, GeoArrowConversionLimits, GeoArrowSerializationMetrics, GeoArrowSerializationOptions, GeoArrowConversionMetrics, GeoArrowCoordinateLayout, GeoArrowCrs, GeoArrowCrsType, GeoArrowDictionaryBuffers, GeoArrowDictionaryColumnInput, GeoArrowDimensions, GeoArrowEdges, GeoArrowFeatureIdColumnInput, GeoArrowGeometryBuffers, GeoArrowGeometryColumnInput, GeoArrowGeometryKind, GeoArrowLineString, GeoArrowLineStringColumnInput, GeoArrowPoint, GeoArrowPointColumnInput, GeoArrowPolygon, GeoArrowPolygonColumnInput, GeoArrowPosition, GeoArrowTemporalBuffers, GeoArrowTemporalColumnInput, GeoArrowTimestampUnit, FromApacheArrowRecordBatchOptions, GeoArrowBatchFromApacheResult, HonuaGeoArrowErrorCode, LoadApacheArrowOptions, } from "./geoarrow-types.js";
+export type { CreateGeoArrowFilterOperationOptions, CreateGeoArrowProjectionOperationOptions, CreateGeoArrowTransformOperationOptions, GeoArrowProjectionColumn, GeoArrowRowPredicate, } from "./operators.js";
+export { COLUMNAR_WORKER_CANCEL_KIND, COLUMNAR_WORKER_ERROR_KIND, COLUMNAR_WORKER_PROGRESS_KIND, COLUMNAR_WORKER_PROTOCOL_VERSION, COLUMNAR_WORKER_REQUEST_KIND, COLUMNAR_WORKER_RESULT_KIND, HonuaColumnarWorkerError, createColumnarWorkerSession, startColumnarWorkerHost, } from "./worker.js";
+export type { ColumnarWorkerCancelV1, ColumnarWorkerErrorCode, ColumnarWorkerErrorV1, ColumnarWorkerExecutionProgress, ColumnarWorkerExecutionResult, ColumnarWorkerFactory, ColumnarWorkerFaultEvent, ColumnarWorkerHost, ColumnarWorkerMessageEvent, ColumnarWorkerOperation, ColumnarWorkerOperationContext, ColumnarWorkerProgressV1, ColumnarWorkerRequestV1, ColumnarWorkerResultV1, ColumnarWorkerSession, ColumnarWorkerSessionState, ColumnarWorkerStreamOrdering, ColumnarWorkerTransport, CreateColumnarWorkerSessionOptions, ExecuteColumnarWorkerOperationOptions, StartColumnarWorkerHostOptions, } from "./worker.js";
+export { COLUMNAR_BATCH_KIND, COLUMNAR_BATCH_VERSION, COLUMNAR_TRANSFER_KIND, DEFAULT_COLUMNAR_BATCH_MAX_BACKING_BYTES, DEFAULT_COLUMNAR_BATCH_MAX_BUFFER_VIEWS, DEFAULT_COLUMNAR_BATCH_MAX_METADATA_ENTRIES, DEFAULT_COLUMNAR_BATCH_MAX_ROWS, DEFAULT_COLUMNAR_BATCH_MAX_SCHEMA_NODES, DEFAULT_COLUMNAR_BATCH_MAX_STRING_BYTES, HonuaColumnarTransferError, } from "./types.js";
+export type { ColumnarBatchLeaseState, ColumnarBatchIdentityV1, ColumnarBatchLimits, ColumnarBatchMetrics, ColumnarBatchV1, ColumnarBufferRole, ColumnarBufferV1, ColumnarFieldV1, ColumnarFreshnessV1, ColumnarOrderingKeyV1, ColumnarOrderingV1, ColumnarSchemaV1, ColumnarTransferErrorCode, ColumnarTransferMessageV1, ColumnarTransferOptions, ColumnarTransferReceipt, ColumnarTransferTarget, ColumnarTypeV1, CreateColumnarBatchInput, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/columnar/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/columnar/index.ts"],"names":[],"mappings":"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"}

package/columnar/index.js

@@ -0,0 +1,29 @@
+/**
+ * Dependency-free columnar batch and worker-transfer contracts exported by
+ * `@honua/sdk-js/query-planner` for large geospatial results.
+ *
+ * The Honua envelope includes a normative dependency-free GeoArrow 0.2 mapping
+ * without importing an Arrow implementation. Transfers expose exact
+ * backing-allocation and payload-copy metrics, deduplicate shared backing
+ * buffers, enforce conservative default ceilings, and use a one-owner lease
+ * with deterministic cancellation, acknowledgement, error, and disposal
+ * behavior.
+ *
+ * @experimental
+ */
+export { ColumnarBatchLease, createColumnarBatch, inspectColumnarBatch, leaseColumnarBatch } from "./transfer.js";
+export { fromApacheArrowRecordBatch, loadApacheArrow, toApacheArrowRecordBatch } from "./apache-arrow.js";
+export { createGeoArrowBatch, decodeGeoArrowBatch, inspectGeoArrowBatch } from "./geoarrow.js";
+export { DEFAULT_COLUMNAR_RESULT_MAX_FEATURES, columnarBatchToResult, columnarBatchToResultPages, resultToColumnarBatch, } from "./result.js";
+export { createGeoArrowReprojectOperation } from "./geoarrow-reproject.js";
+export { DEFAULT_GEOARROW_AGGREGATE_MAX_GROUPS, DEFAULT_GEOARROW_AGGREGATE_YIELD_ROWS, GEOARROW_AGGREGATE_ABORT_CHECK_ROWS, GEOARROW_AGGREGATE_MAX_GRID_CELL_INDEX, HONUA_GEOARROW_AGGREGATE_LAYOUT_VERSION, createGeoArrowAggregateOperation, readGeoArrowAggregateBatch, } from "./geoarrow-aggregate.js";
+export { COLUMNAR_PATCH_ABORT_CHECK_ROWS, COLUMNAR_PATCH_KIND, COLUMNAR_PATCH_VERSION, DEFAULT_COLUMNAR_PATCH_MAX_CAPACITY_UTILIZATION, DEFAULT_COLUMNAR_PATCH_MAX_OPERATIONS, DEFAULT_COLUMNAR_PATCH_MAX_TOMBSTONE_OVERLAY_BYTES, DEFAULT_COLUMNAR_PATCH_MAX_TOMBSTONE_RATIO, DEFAULT_COLUMNAR_PATCH_MAX_VERTEX_GROWTH_RATIO, HONUA_COLUMNAR_PATCH_LAYOUT_VERSION, HonuaColumnarPatchError, applyColumnarPatch, columnarPatchLiveMask, createColumnarPatch, createColumnarPatchOperation, createPatchableGeoArrowBatch, decodePatchedGeoArrowBatch, inspectColumnarPatchState, } from "./geoarrow-patch.js";
+export { createGeoArrowFilterOperation, createGeoArrowProjectionOperation, createGeoArrowTransformOperation, } from "./operators.js";
+export { GEOARROW_ENVELOPE_MIGRATIONS, HONUA_GEOARROW_ENVELOPE_KIND, HONUA_GEOARROW_ENVELOPE_VERSION, deserializeGeoArrowBatch, planGeoArrowEnvelopeMigration, readableGeoArrowEnvelopeVersions, serializeGeoArrowBatch, } from "./geoarrow-serialization.js";
+export { DEFAULT_COLUMNAR_BATCH_CACHE_MAX_AGE_MS, DEFAULT_COLUMNAR_BATCH_CACHE_MAX_RECORDS, DEFAULT_COLUMNAR_BATCH_CACHE_QUOTA_BYTES, HONUA_COLUMNAR_BATCH_CACHE_FORMAT, MAX_COLUMNAR_BATCH_CACHE_MAX_AGE_MS, MAX_COLUMNAR_BATCH_CACHE_MAX_RECORDS, MAX_COLUMNAR_BATCH_CACHE_QUOTA_BYTES, columnarBatchCacheKey, columnarBatchCacheOrderingDigest, createColumnarBatchCache, createMemoryColumnarBatchCacheStorage, planColumnarBatchCacheAdmission, } from "./batch-cache.js";
+export { columnarAuthorizationScopeDigest } from "./telemetry.js";
+export { createIndexedDbColumnarBatchCacheStorage } from "./batch-cache-indexeddb.js";
+export { COLUMNAR_BATCH_CACHE_CONFORMANCE_CASES, HONUA_COLUMNAR_BATCH_CACHE_CONFORMANCE_KIND, HONUA_COLUMNAR_BATCH_CACHE_CONFORMANCE_VERSION, columnarBatchCacheFixtureBatch, columnarBatchCacheFixtureIdentity, columnarBatchCacheLegacyEntry, runColumnarBatchCacheConformance, } from "./batch-cache-conformance.js";
+export { GEOARROW_SPEC_VERSION, HONUA_GEOARROW_LAYOUT_VERSION, HonuaGeoArrowError, } from "./geoarrow-types.js";
+export { COLUMNAR_WORKER_CANCEL_KIND, COLUMNAR_WORKER_ERROR_KIND, COLUMNAR_WORKER_PROGRESS_KIND, COLUMNAR_WORKER_PROTOCOL_VERSION, COLUMNAR_WORKER_REQUEST_KIND, COLUMNAR_WORKER_RESULT_KIND, HonuaColumnarWorkerError, createColumnarWorkerSession, startColumnarWorkerHost, } from "./worker.js";
+export { COLUMNAR_BATCH_KIND, COLUMNAR_BATCH_VERSION, COLUMNAR_TRANSFER_KIND, DEFAULT_COLUMNAR_BATCH_MAX_BACKING_BYTES, DEFAULT_COLUMNAR_BATCH_MAX_BUFFER_VIEWS, DEFAULT_COLUMNAR_BATCH_MAX_METADATA_ENTRIES, DEFAULT_COLUMNAR_BATCH_MAX_ROWS, DEFAULT_COLUMNAR_BATCH_MAX_SCHEMA_NODES, DEFAULT_COLUMNAR_BATCH_MAX_STRING_BYTES, HonuaColumnarTransferError, } from "./types.js";

package/columnar/operators.d.ts

@@ -0,0 +1,70 @@
+import type { ColumnarBatchIdentityV1, DecodedGeoArrowRow, GeoArrowConversionLimits, GeoArrowCrs } from "./geoarrow-types.js";
+import type { ColumnarWorkerOperation } from "./worker.js";
+/** A worker-safe predicate over one decoded GeoArrow row. */
+export type GeoArrowRowPredicate = (row: DecodedGeoArrowRow, index: number) => boolean | Promise<boolean>;
+/** Options for the bounded GeoArrow row-filter worker operation. */
+export interface CreateGeoArrowFilterOperationOptions extends GeoArrowConversionLimits {
+    /** Stable id assigned to the filtered output batch. */
+    readonly id: string;
+    readonly predicate: GeoArrowRowPredicate;
+}
+export type GeoArrowProjectionColumn = "geometry" | "temporal" | "dictionary" | "featureId";
+/** Options for the bounded GeoArrow column-projection worker operation. */
+export interface CreateGeoArrowProjectionOperationOptions extends GeoArrowConversionLimits {
+    /** Stable id assigned to the projected output batch. */
+    readonly id: string;
+    /** Schema id for the projected field set. */
+    readonly schemaId: string;
+    /** Identity for the projected schema; callers must provide its schema version. */
+    readonly identity: ColumnarBatchIdentityV1;
+    /** Columns to retain. Geometry is always retained even when omitted. */
+    readonly columns?: readonly GeoArrowProjectionColumn[];
+}
+/** Options for a bounded XY affine transform of a GeoArrow batch. */
+export interface CreateGeoArrowTransformOperationOptions extends GeoArrowConversionLimits {
+    /** Stable id assigned to the transformed output batch. */
+    readonly id: string;
+    /** Schema id for the transformed coordinate field set. */
+    readonly schemaId: string;
+    /** Identity for the transformed schema and coordinate semantics. */
+    readonly identity: ColumnarBatchIdentityV1;
+    /** Multipliers applied to X and Y. Defaults to `[1, 1]`. */
+    readonly scale?: readonly [number, number];
+    /** Offsets added to X and Y after scaling. Defaults to `[0, 0]`. */
+    readonly translate?: readonly [number, number];
+    /** Optional replacement CRS; omitted means preserve the source CRS metadata. */
+    readonly outputCrs?: GeoArrowCrs;
+}
+/**
+ * Create a deterministic GeoArrow row filter for registration with
+ * `startColumnarWorkerHost`.
+ *
+ * The operation intentionally decodes only the normative GeoArrow row view and
+ * re-encodes the selected rows into a new bounded batch. It preserves geometry
+ * metadata, temporal values, dictionary values, feature ids, and source
+ * identity while omitting `rowOffset` because a filtered batch is not a
+ * contiguous source range.
+ */
+export declare function createGeoArrowFilterOperation(options: CreateGeoArrowFilterOperationOptions): ColumnarWorkerOperation;
+/**
+ * Create a deterministic GeoArrow column projection for registration with
+ * `startColumnarWorkerHost`.
+ *
+ * Geometry is mandatory in the normative batch. Optional temporal, dictionary,
+ * and feature-id columns are retained only when requested. A new schema id and
+ * identity are required because the projected field set is a distinct cache and
+ * authorization-visible result, even though row order and values are unchanged.
+ */
+export declare function createGeoArrowProjectionOperation(options: CreateGeoArrowProjectionOperationOptions): ColumnarWorkerOperation;
+/**
+ * Create a bounded XY affine transform for registration with
+ * `startColumnarWorkerHost`.
+ *
+ * The operation transforms every coordinate while preserving Z/M ordinates,
+ * row order, nulls, temporal values, dictionary values, feature ids, and
+ * batch identity fields supplied by the caller. A new id, schema id, and
+ * identity are required because coordinate semantics are part of the cache
+ * and authorization-visible result contract.
+ */
+export declare function createGeoArrowTransformOperation(options: CreateGeoArrowTransformOperationOptions): ColumnarWorkerOperation;
+//# sourceMappingURL=operators.d.ts.map

package/columnar/operators.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operators.d.ts","sourceRoot":"","sources":["../../../src/columnar/operators.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,uBAAuB,EACvB,kBAAkB,EAClB,wBAAwB,EACxB,WAAW,EAGZ,MAAM,qBAAqB,CAAC;AAG7B,OAAO,KAAK,EAAE,uBAAuB,EAAkC,MAAM,aAAa,CAAC;AAE3F,6DAA6D;AAC7D,MAAM,MAAM,oBAAoB,GAAG,CAAC,GAAG,EAAE,kBAAkB,EAAE,KAAK,EAAE,MAAM,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;AAE1G,oEAAoE;AACpE,MAAM,WAAW,oCAAqC,SAAQ,wBAAwB;IACpF,uDAAuD;IACvD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,SAAS,EAAE,oBAAoB,CAAC;CAC1C;AAED,MAAM,MAAM,wBAAwB,GAAG,UAAU,GAAG,UAAU,GAAG,YAAY,GAAG,WAAW,CAAC;AAE5F,2EAA2E;AAC3E,MAAM,WAAW,wCAAyC,SAAQ,wBAAwB;IACxF,wDAAwD;IACxD,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,kFAAkF;IAClF,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IAC3C,wEAAwE;IACxE,QAAQ,CAAC,OAAO,CAAC,EAAE,SAAS,wBAAwB,EAAE,CAAC;CACxD;AAED,qEAAqE;AACrE,MAAM,WAAW,uCAAwC,SAAQ,wBAAwB;IACvF,0DAA0D;IAC1D,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,0DAA0D;IAC1D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,oEAAoE;IACpE,QAAQ,CAAC,QAAQ,EAAE,uBAAuB,CAAC;IAC3C,4DAA4D;IAC5D,QAAQ,CAAC,KAAK,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC3C,oEAAoE;IACpE,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAC/C,gFAAgF;IAChF,QAAQ,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,EAAE,oCAAoC,GAAG,uBAAuB,CAuEpH;AAED;;;;;;;;GAQG;AACH,wBAAgB,iCAAiC,CAC/C,OAAO,EAAE,wCAAwC,GAChD,uBAAuB,CAqGzB;AAED;;;;;;;;;GASG;AACH,wBAAgB,gCAAgC,CAC9C,OAAO,EAAE,uCAAuC,GAC/C,uBAAuB,CAwFzB"}

package/columnar/operators.js

@@ -0,0 +1,307 @@
+import { createGeoArrowBatch, decodeGeoArrowBatch, inspectGeoArrowBatch } from "./geoarrow.js";
+/**
+ * Create a deterministic GeoArrow row filter for registration with
+ * `startColumnarWorkerHost`.
+ *
+ * The operation intentionally decodes only the normative GeoArrow row view and
+ * re-encodes the selected rows into a new bounded batch. It preserves geometry
+ * metadata, temporal values, dictionary values, feature ids, and source
+ * identity while omitting `rowOffset` because a filtered batch is not a
+ * contiguous source range.
+ */
+export function createGeoArrowFilterOperation(options) {
+    if (typeof options !== "object" || options === null) {
+        throw new TypeError("GeoArrow filter options must be an object");
+    }
+    if (typeof options.id !== "string" || options.id.trim() !== options.id || options.id.length === 0) {
+        throw new TypeError("GeoArrow filter id must be a non-empty trimmed string");
+    }
+    if (typeof options.predicate !== "function") {
+        throw new TypeError("GeoArrow filter predicate must be a function");
+    }
+    const limits = { ...options };
+    delete limits.id;
+    delete limits.predicate;
+    return async (batch, context) => {
+        const inspection = inspectGeoArrowBatch(batch, limits);
+        if (!batch.identity)
+            throw new TypeError("GeoArrow filter requires batch identity");
+        const decoded = decodeGeoArrowBatch(batch, limits);
+        const selected = [];
+        for (let index = 0; index < decoded.rows.length; index += 1) {
+            if (context.signal.aborted)
+                throw new DOMException("The operation was aborted", "AbortError");
+            const keep = await options.predicate(decoded.rows[index], index);
+            if (typeof keep !== "boolean")
+                throw new TypeError("GeoArrow filter predicate must return a boolean");
+            if (keep)
+                selected.push(decoded.rows[index]);
+            if (index === decoded.rows.length - 1 || index % 256 === 0) {
+                context.reportProgress(decoded.rows.length === 0 ? 1 : (index + 1) / decoded.rows.length, "filter");
+            }
+        }
+        const geometry = {
+            kind: inspection.geometry.kind,
+            field: inspection.geometry.field,
+            dimensions: inspection.geometry.dimensions,
+            coordinateLayout: inspection.geometry.coordinateLayout,
+            ...(inspection.geometry.crs === undefined ? {} : { crs: inspection.geometry.crs }),
+            ...(inspection.geometry.crsType === undefined ? {} : { crsType: inspection.geometry.crsType }),
+            edges: inspection.geometry.edges,
+            values: selected.map((row) => row.geometry),
+        };
+        const temporal = inspection.temporal
+            ? {
+                field: inspection.temporal.field,
+                unit: inspection.temporal.unit,
+                ...(inspection.temporal.timezone === undefined ? {} : { timezone: inspection.temporal.timezone }),
+                values: selected.map((row) => row.timestamp ?? null),
+            }
+            : undefined;
+        const dictionary = inspection.dictionary
+            ? {
+                field: inspection.dictionary.field,
+                ordered: inspection.dictionary.ordered,
+                values: selected.map((row) => row.dictionaryValue ?? null),
+            }
+            : undefined;
+        const featureIds = inspection.featureIds
+            ? { field: inspection.featureIds.field, values: selected.map((row) => row.featureId ?? 0) }
+            : undefined;
+        return createGeoArrowBatch({
+            id: options.id,
+            sequence: batch.sequence,
+            schemaId: batch.schema.id,
+            identity: batch.identity,
+            geometry,
+            ...(temporal === undefined ? {} : { temporal }),
+            ...(dictionary === undefined ? {} : { dictionary }),
+            ...(featureIds === undefined ? {} : { featureIds }),
+        }, limits).batch;
+    };
+}
+/**
+ * Create a deterministic GeoArrow column projection for registration with
+ * `startColumnarWorkerHost`.
+ *
+ * Geometry is mandatory in the normative batch. Optional temporal, dictionary,
+ * and feature-id columns are retained only when requested. A new schema id and
+ * identity are required because the projected field set is a distinct cache and
+ * authorization-visible result, even though row order and values are unchanged.
+ */
+export function createGeoArrowProjectionOperation(options) {
+    if (typeof options !== "object" || options === null) {
+        throw new TypeError("GeoArrow projection options must be an object");
+    }
+    if (typeof options.id !== "string" || options.id.trim() !== options.id || options.id.length === 0) {
+        throw new TypeError("GeoArrow projection id must be a non-empty trimmed string");
+    }
+    if (typeof options.schemaId !== "string" ||
+        options.schemaId.trim() !== options.schemaId ||
+        options.schemaId.length === 0) {
+        throw new TypeError("GeoArrow projection schemaId must be a non-empty trimmed string");
+    }
+    if (typeof options.identity !== "object" || options.identity === null) {
+        throw new TypeError("GeoArrow projection identity must be an object");
+    }
+    const columns = options.columns === undefined ? ["geometry"] : [...options.columns];
+    const allowed = new Set(["geometry", "temporal", "dictionary", "featureId"]);
+    if (columns.length !== new Set(columns).size || columns.some((column) => !allowed.has(column))) {
+        throw new TypeError("GeoArrow projection columns must be unique supported column names");
+    }
+    const limits = { ...options };
+    delete limits.id;
+    delete limits.schemaId;
+    delete limits.identity;
+    delete limits.columns;
+    const wants = new Set(columns);
+    return async (batch, context) => {
+        const inspection = inspectGeoArrowBatch(batch, limits);
+        if (wants.has("temporal") && inspection.temporal === undefined) {
+            throw new TypeError("GeoArrow projection requested a missing temporal column");
+        }
+        if (wants.has("dictionary") && inspection.dictionary === undefined) {
+            throw new TypeError("GeoArrow projection requested a missing dictionary column");
+        }
+        if (wants.has("featureId") && inspection.featureIds === undefined) {
+            throw new TypeError("GeoArrow projection requested a missing feature-id column");
+        }
+        const decoded = decodeGeoArrowBatch(batch, limits);
+        const geometryValues = [];
+        const temporalValues = [];
+        const dictionaryValues = [];
+        const featureIdValues = [];
+        for (let index = 0; index < decoded.rows.length; index += 1) {
+            if (context.signal.aborted)
+                throw new DOMException("The operation was aborted", "AbortError");
+            const row = decoded.rows[index];
+            geometryValues.push(row.geometry);
+            if (wants.has("temporal"))
+                temporalValues.push(row.timestamp ?? null);
+            if (wants.has("dictionary"))
+                dictionaryValues.push(row.dictionaryValue ?? null);
+            if (wants.has("featureId"))
+                featureIdValues.push(row.featureId);
+            if (index === decoded.rows.length - 1 || index % 256 === 0) {
+                context.reportProgress(decoded.rows.length === 0 ? 1 : (index + 1) / decoded.rows.length, "projection");
+            }
+        }
+        const geometry = {
+            kind: inspection.geometry.kind,
+            field: inspection.geometry.field,
+            dimensions: inspection.geometry.dimensions,
+            coordinateLayout: inspection.geometry.coordinateLayout,
+            ...(inspection.geometry.crs === undefined ? {} : { crs: inspection.geometry.crs }),
+            ...(inspection.geometry.crsType === undefined ? {} : { crsType: inspection.geometry.crsType }),
+            edges: inspection.geometry.edges,
+            values: geometryValues,
+        };
+        const temporal = wants.has("temporal")
+            ? (() => {
+                const temporalInspection = inspection.temporal;
+                if (temporalInspection === undefined) {
+                    throw new TypeError("GeoArrow projection requested a missing temporal column");
+                }
+                return {
+                    field: temporalInspection.field,
+                    unit: temporalInspection.unit,
+                    ...(temporalInspection.timezone === undefined ? {} : { timezone: temporalInspection.timezone }),
+                    values: temporalValues,
+                };
+            })()
+            : undefined;
+        const dictionary = wants.has("dictionary")
+            ? { field: inspection.dictionary.field, ordered: inspection.dictionary.ordered, values: dictionaryValues }
+            : undefined;
+        const featureIds = wants.has("featureId")
+            ? { field: inspection.featureIds.field, values: featureIdValues }
+            : undefined;
+        return createGeoArrowBatch({
+            id: options.id,
+            sequence: batch.sequence,
+            ...(batch.rowOffset === undefined ? {} : { rowOffset: batch.rowOffset }),
+            schemaId: options.schemaId,
+            identity: options.identity,
+            geometry,
+            ...(temporal === undefined ? {} : { temporal }),
+            ...(dictionary === undefined ? {} : { dictionary }),
+            ...(featureIds === undefined ? {} : { featureIds }),
+        }, limits).batch;
+    };
+}
+/**
+ * Create a bounded XY affine transform for registration with
+ * `startColumnarWorkerHost`.
+ *
+ * The operation transforms every coordinate while preserving Z/M ordinates,
+ * row order, nulls, temporal values, dictionary values, feature ids, and
+ * batch identity fields supplied by the caller. A new id, schema id, and
+ * identity are required because coordinate semantics are part of the cache
+ * and authorization-visible result contract.
+ */
+export function createGeoArrowTransformOperation(options) {
+    if (typeof options !== "object" || options === null) {
+        throw new TypeError("GeoArrow transform options must be an object");
+    }
+    if (typeof options.id !== "string" || options.id.trim() !== options.id || options.id.length === 0) {
+        throw new TypeError("GeoArrow transform id must be a non-empty trimmed string");
+    }
+    if (typeof options.schemaId !== "string" ||
+        options.schemaId.trim() !== options.schemaId ||
+        options.schemaId.length === 0) {
+        throw new TypeError("GeoArrow transform schemaId must be a non-empty trimmed string");
+    }
+    if (typeof options.identity !== "object" || options.identity === null) {
+        throw new TypeError("GeoArrow transform identity must be an object");
+    }
+    const scale = normalizeAffinePair(options.scale, [1, 1], "scale");
+    const translate = normalizeAffinePair(options.translate, [0, 0], "translate");
+    const limits = { ...options };
+    delete limits.id;
+    delete limits.schemaId;
+    delete limits.identity;
+    delete limits.scale;
+    delete limits.translate;
+    delete limits.outputCrs;
+    return async (batch, context) => {
+        const inspection = inspectGeoArrowBatch(batch, limits);
+        const decoded = decodeGeoArrowBatch(batch, limits);
+        const geometryValues = [];
+        for (let index = 0; index < decoded.rows.length; index += 1) {
+            if (context.signal.aborted)
+                throw new DOMException("The operation was aborted", "AbortError");
+            geometryValues.push(transformGeometry(decoded.rows[index].geometry, scale, translate));
+            if (index === decoded.rows.length - 1 || index % 256 === 0) {
+                context.reportProgress(decoded.rows.length === 0 ? 1 : (index + 1) / decoded.rows.length, "transform");
+            }
+        }
+        if (decoded.rows.length === 0)
+            context.reportProgress(1, "transform");
+        const geometry = {
+            kind: inspection.geometry.kind,
+            field: inspection.geometry.field,
+            dimensions: inspection.geometry.dimensions,
+            coordinateLayout: inspection.geometry.coordinateLayout,
+            ...(options.outputCrs === undefined
+                ? inspection.geometry.crs === undefined
+                    ? {}
+                    : { crs: inspection.geometry.crs }
+                : { crs: options.outputCrs }),
+            ...(options.outputCrs === undefined && inspection.geometry.crsType !== undefined
+                ? { crsType: inspection.geometry.crsType }
+                : {}),
+            edges: inspection.geometry.edges,
+            values: geometryValues,
+        };
+        const temporal = inspection.temporal
+            ? {
+                field: inspection.temporal.field,
+                unit: inspection.temporal.unit,
+                ...(inspection.temporal.timezone === undefined ? {} : { timezone: inspection.temporal.timezone }),
+                values: decoded.rows.map((row) => row.timestamp ?? null),
+            }
+            : undefined;
+        const dictionary = inspection.dictionary
+            ? {
+                field: inspection.dictionary.field,
+                ordered: inspection.dictionary.ordered,
+                values: decoded.rows.map((row) => row.dictionaryValue ?? null),
+            }
+            : undefined;
+        const featureIds = inspection.featureIds
+            ? { field: inspection.featureIds.field, values: decoded.rows.map((row) => row.featureId ?? 0) }
+            : undefined;
+        return createGeoArrowBatch({
+            id: options.id,
+            sequence: batch.sequence,
+            ...(batch.rowOffset === undefined ? {} : { rowOffset: batch.rowOffset }),
+            schemaId: options.schemaId,
+            identity: options.identity,
+            geometry,
+            ...(temporal === undefined ? {} : { temporal }),
+            ...(dictionary === undefined ? {} : { dictionary }),
+            ...(featureIds === undefined ? {} : { featureIds }),
+        }, limits).batch;
+    };
+}
+function normalizeAffinePair(value, fallback, name) {
+    const pair = value ?? fallback;
+    if (pair.length !== 2 || !Number.isFinite(pair[0]) || !Number.isFinite(pair[1])) {
+        throw new TypeError(`GeoArrow transform ${name} must contain exactly two finite numbers`);
+    }
+    return [pair[0], pair[1]];
+}
+function transformGeometry(geometry, scale, translate) {
+    if (geometry === null)
+        return null;
+    if (geometry.length === 0 || typeof geometry[0] === "number") {
+        return transformPosition(geometry, scale, translate);
+    }
+    if (typeof geometry[0][0] === "number") {
+        return geometry.map((position) => transformPosition(position, scale, translate));
+    }
+    return geometry.map((part) => part.map((position) => transformPosition(position, scale, translate)));
+}
+function transformPosition(position, scale, translate) {
+    return [position[0] * scale[0] + translate[0], position[1] * scale[1] + translate[1], ...position.slice(2)];
+}