@honua/app-platform 0.2.3 → 0.2.4

package/control-plane/dataset-import/client.d.ts

@@ -0,0 +1,32 @@
+export { DatasetImportTaskApiError } from "./errors.js";
+import type { CreateDatasetImportTask, DatasetImportAuthorityDescriptor, DatasetImportAuthorityRenewal, DatasetImportTask, DatasetImportTaskReference, RenewDatasetImportAuthority } from "./types.js";
+export interface DatasetImportTaskClientOptions {
+    /** Deployment origin, optionally with its reverse-proxy path prefix. */
+    readonly baseUrl: string;
+    readonly workspaceId: string;
+    readonly targetId: string;
+    /** Framework-retained turn, never a moving current-view value. Omit for human actions. */
+    readonly originatingTurnId?: string;
+    readonly fetch?: typeof globalThis.fetch;
+    /** Reads fresh authentication for each request; credentials are never persisted here. */
+    readonly headers?: () => HeadersInit | Promise<HeadersInit>;
+}
+/**
+ * Canonical task/authority APIs only. Never dispatches an import, retries a POST,
+ * invents an authority revision, or treats preparation as an accepted job.
+ * Persist original intent/renewal IDs before calling mutation methods. On lost
+ * replies use readIntent or replay the SAME renewal ID, never mint a replacement.
+ */
+export declare class DatasetImportTaskClient {
+    private readonly workspaceId;
+    private readonly targetId;
+    private readonly transport;
+    constructor(options: DatasetImportTaskClientOptions);
+    createTask(request: CreateDatasetImportTask, signal?: AbortSignal): Promise<DatasetImportTask>;
+    readIntent(intentId: string, signal?: AbortSignal): Promise<DatasetImportTask | null>;
+    readTask(reference: DatasetImportTaskReference, signal?: AbortSignal): Promise<DatasetImportTask | null>;
+    readAuthority(reference: DatasetImportTaskReference, signal?: AbortSignal): Promise<DatasetImportAuthorityDescriptor | null>;
+    renewAuthority(reference: DatasetImportTaskReference, request: RenewDatasetImportAuthority, signal?: AbortSignal): Promise<DatasetImportAuthorityRenewal>;
+    private assertTask;
+}
+//# sourceMappingURL=client.d.ts.map

package/control-plane/dataset-import/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../../../src/control-plane/dataset-import/client.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,yBAAyB,EAAE,MAAM,aAAa,CAAC;AACxD,OAAO,KAAK,EACV,uBAAuB,EACvB,gCAAgC,EAChC,6BAA6B,EAC7B,iBAAiB,EACjB,0BAA0B,EAC1B,2BAA2B,EAC5B,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,8BAA8B;IAC7C,wEAAwE;IACxE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,0FAA0F;IAC1F,QAAQ,CAAC,iBAAiB,CAAC,EAAE,MAAM,CAAC;IACpC,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,UAAU,CAAC,KAAK,CAAC;IACzC,yFAAyF;IACzF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,WAAW,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;CAC7D;AAED;;;;;GAKG;AACH,qBAAa,uBAAuB;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAS;IAClC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkC;gBAEhD,OAAO,EAAE,8BAA8B;IAM7C,UAAU,CAAC,OAAO,EAAE,uBAAuB,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,iBAAiB,CAAC;IAQ9F,UAAU,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAarF,QAAQ,CAAC,SAAS,EAAE,0BAA0B,EAAE,MAAM,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAWxG,aAAa,CACjB,SAAS,EAAE,0BAA0B,EACrC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,gCAAgC,GAAG,IAAI,CAAC;IA+B7C,cAAc,CAClB,SAAS,EAAE,0BAA0B,EACrC,OAAO,EAAE,2BAA2B,EACpC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,6BAA6B,CAAC;IA6BzC,OAAO,CAAC,UAAU;CASnB"}

package/control-plane/dataset-import/client.js

@@ -0,0 +1,112 @@
+import { DatasetImportWorkspaceTransport, validId } from "./transport.js";
+export { DatasetImportTaskApiError } from "./errors.js";
+/**
+ * Canonical task/authority APIs only. Never dispatches an import, retries a POST,
+ * invents an authority revision, or treats preparation as an accepted job.
+ * Persist original intent/renewal IDs before calling mutation methods. On lost
+ * replies use readIntent or replay the SAME renewal ID, never mint a replacement.
+ */
+export class DatasetImportTaskClient {
+    workspaceId;
+    targetId;
+    transport;
+    constructor(options) {
+        this.transport = new DatasetImportWorkspaceTransport(options);
+        this.workspaceId = options.workspaceId;
+        this.targetId = options.targetId;
+    }
+    async createTask(request, signal) {
+        // Serialize before the first await so later form edits cannot change the request.
+        const body = JSON.stringify(request);
+        const task = await this.transport.request("/dataset-import-tasks", "POST", body, signal);
+        this.assertTask(task);
+        return task;
+    }
+    async readIntent(intentId, signal) {
+        validId(intentId);
+        const task = await this.transport.request(`/dataset-import-task-intents/${encodeURIComponent(intentId)}`, "GET", undefined, signal, true);
+        if (task !== null)
+            this.assertTask(task);
+        return task;
+    }
+    async readTask(reference, signal) {
+        const pinned = pin(reference);
+        const task = await this.transport.request(path(pinned), "GET", undefined, signal, true);
+        if (task !== null) {
+            this.assertTask(task);
+            if (task.taskId !== pinned.taskId || task.revision !== pinned.revision || task.contentHash !== pinned.contentHash)
+                throw new Error("Import task response changed the immutable task binding.");
+        }
+        return task;
+    }
+    async readAuthority(reference, signal) {
+        const pinned = pin(reference);
+        const descriptor = await this.transport.request(`${path(pinned)}/authority?contentHash=${pinned.contentHash}`, "GET", undefined, signal, true);
+        if (descriptor !== null &&
+            (descriptor.taskId !== pinned.taskId ||
+                descriptor.taskRevision !== pinned.revision ||
+                descriptor.taskContentHash !== pinned.contentHash ||
+                !Number.isSafeInteger(descriptor.authorityRevision) ||
+                descriptor.authorityRevision < 1 ||
+                !validDigest(descriptor.authorityFingerprint) ||
+                !validDigest(descriptor.policyContextFingerprint) ||
+                !validDigest(descriptor.originalTurnHash) ||
+                typeof descriptor.executorActorId !== "string" ||
+                descriptor.executorActorId.length < 1 ||
+                typeof descriptor.originatingTurnId !== "string" ||
+                descriptor.originatingTurnId.length < 1 ||
+                !Number.isFinite(Date.parse(descriptor.uploadAdmissionDeadline)) ||
+                (descriptor.preparedOperationId != null &&
+                    (descriptor.preparedOperationId.length !== 32 || !/^[a-f0-9]{32}$/.test(descriptor.preparedOperationId)))))
+            throw new Error("Import authority response changed the immutable task binding.");
+        return descriptor;
+    }
+    async renewAuthority(reference, request, signal) {
+        const pinned = pin(reference);
+        validId(request.renewalId);
+        if (request.taskContentHash !== pinned.contentHash ||
+            !Number.isSafeInteger(request.expectedAuthorityRevision) ||
+            request.expectedAuthorityRevision < 1)
+            throw new TypeError("An exact task hash and positive authority revision are required.");
+        const body = JSON.stringify(request);
+        const renewalId = request.renewalId;
+        const previousRevision = request.expectedAuthorityRevision;
+        const receipt = await this.transport.request(`${path(pinned)}/authority-renewals`, "POST", body, signal);
+        if (receipt.renewalId !== renewalId ||
+            receipt.previousAuthorityRevision !== previousRevision ||
+            receipt.authorityRevision !== previousRevision + 1 ||
+            !validDigest(receipt.authorityFingerprint) ||
+            !Number.isFinite(Date.parse(receipt.renewedAt)))
+            throw new Error("Import renewal response changed the original renewal binding.");
+        return receipt;
+    }
+    assertTask(task) {
+        if (!task || task.workspaceId !== this.workspaceId || task.targetId !== this.targetId)
+            throw new Error("Import task response changed workspace or deployment target.");
+        pin({
+            taskId: task.taskId,
+            revision: task.revision,
+            contentHash: task.contentHash,
+        });
+    }
+}
+function pin(reference) {
+    validId(reference.taskId);
+    if (!Number.isSafeInteger(reference.revision) ||
+        reference.revision < 1 ||
+        typeof reference.contentHash !== "string" ||
+        reference.contentHash.length !== 64 ||
+        !/^[a-f0-9]{64}$/.test(reference.contentHash))
+        throw new TypeError("A positive revision and lowercase whole SHA-256 task hash are required.");
+    return {
+        taskId: reference.taskId,
+        revision: reference.revision,
+        contentHash: reference.contentHash,
+    };
+}
+function path(reference) {
+    return `/dataset-import-tasks/${encodeURIComponent(reference.taskId)}/versions/${reference.revision}`;
+}
+function validDigest(value) {
+    return typeof value === "string" && value.length === 64 && /^[a-f0-9]{64}$/.test(value);
+}

package/control-plane/dataset-import/errors.d.ts

@@ -0,0 +1,5 @@
+export declare class DatasetImportTaskApiError extends Error {
+    readonly status: number;
+    constructor(status: number);
+}
+//# sourceMappingURL=errors.d.ts.map

package/control-plane/dataset-import/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../../../src/control-plane/dataset-import/errors.ts"],"names":[],"mappings":"AAAA,qBAAa,yBAA0B,SAAQ,KAAK;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM;gBAAd,MAAM,EAAE,MAAM;CAIpC"}

package/control-plane/dataset-import/errors.js

@@ -0,0 +1,8 @@
+export class DatasetImportTaskApiError extends Error {
+    status;
+    constructor(status) {
+        super(`Dataset import request failed (${status}).`);
+        this.status = status;
+        this.name = "DatasetImportTaskApiError";
+    }
+}

package/control-plane/dataset-import/file-hash.d.ts

@@ -0,0 +1,14 @@
+/** Whole-file SHA-256 with bounded reads; no upload or task is created by hashing. */
+export interface DatasetImportFileHashOptions {
+    readonly signal?: AbortSignal;
+    /** Defaults to 1 MiB; bounded to 64 KiB–8 MiB. */
+    readonly chunkBytes?: number;
+    readonly onProgress?: (hashedBytes: number, totalBytes: number) => void;
+}
+/**
+ * Hash every byte before creating a resumable intent, including when resuming a
+ * reselected file. Names, timestamps and accepted-prefix hashes are insufficient.
+ * Reads slices sequentially so browser memory does not grow with file size.
+ */
+export declare function hashDatasetImportFile(file: Blob, options?: DatasetImportFileHashOptions): Promise<string>;
+//# sourceMappingURL=file-hash.d.ts.map

package/control-plane/dataset-import/file-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-hash.d.ts","sourceRoot":"","sources":["../../../../src/control-plane/dataset-import/file-hash.ts"],"names":[],"mappings":"AAAA,sFAAsF;AACtF,MAAM,WAAW,4BAA4B;IAC3C,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAC9B,kDAAkD;IAClD,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,IAAI,CAAC;CACzE;AAED;;;;GAIG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,GAAE,4BAAiC,GAAG,OAAO,CAAC,MAAM,CAAC,CAoDnH"}

package/control-plane/dataset-import/file-hash.js

@@ -0,0 +1,117 @@
+/**
+ * Hash every byte before creating a resumable intent, including when resuming a
+ * reselected file. Names, timestamps and accepted-prefix hashes are insufficient.
+ * Reads slices sequentially so browser memory does not grow with file size.
+ */
+export async function hashDatasetImportFile(file, options = {}) {
+    const chunkBytes = options.chunkBytes ?? 1024 * 1024;
+    if (!Number.isSafeInteger(chunkBytes) || chunkBytes < 65536 || chunkBytes > 8 * 1024 * 1024)
+        throw new RangeError("chunkBytes must be an integer between 64 KiB and 8 MiB.");
+    if (!Number.isSafeInteger(file.size) || file.size < 0)
+        throw new RangeError("File size must be a nonnegative safe integer.");
+    const state = new Uint32Array([
+        0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+    ]);
+    const words = new Uint32Array(64);
+    const block = new Uint8Array(64);
+    let buffered = 0;
+    const consume = (bytes) => {
+        let offset = 0;
+        while (offset < bytes.length) {
+            if (buffered === 0 && bytes.length - offset >= 64) {
+                compress(state, words, bytes.subarray(offset, offset + 64));
+                offset += 64;
+                continue;
+            }
+            const count = Math.min(64 - buffered, bytes.length - offset);
+            block.set(bytes.subarray(offset, offset + count), buffered);
+            offset += count;
+            buffered += count;
+            if (buffered === 64) {
+                compress(state, words, block);
+                buffered = 0;
+            }
+        }
+    };
+    options.signal?.throwIfAborted();
+    options.onProgress?.(0, file.size);
+    for (let offset = 0; offset < file.size; offset += chunkBytes) {
+        options.signal?.throwIfAborted();
+        const expected = Math.min(chunkBytes, file.size - offset);
+        const slice = file.slice(offset, offset + expected);
+        if (slice.size !== expected)
+            throw new Error("File slice length changed during hashing.");
+        const bytes = new Uint8Array(await slice.arrayBuffer());
+        options.signal?.throwIfAborted();
+        if (bytes.length !== expected)
+            throw new Error("File read was truncated or exceeded its declared length.");
+        consume(bytes);
+        options.onProgress?.(offset + bytes.length, file.size);
+    }
+    options.signal?.throwIfAborted();
+    // SHA-256 encodes the full 64-bit bit length, including files over 512 MiB.
+    const padding = new Uint8Array(buffered < 56 ? 64 - buffered : 128 - buffered);
+    padding[0] = 0x80;
+    const length = new DataView(padding.buffer);
+    length.setUint32(padding.length - 8, Math.floor(file.size / 0x20000000), false);
+    length.setUint32(padding.length - 4, (file.size % 0x20000000) * 8, false);
+    consume(padding);
+    return Array.from(state, (word) => word.toString(16).padStart(8, "0")).join("");
+}
+function compress(state, words, block) {
+    const view = new DataView(block.buffer, block.byteOffset, block.byteLength);
+    for (let index = 0; index < 16; index++)
+        words[index] = view.getUint32(index * 4, false);
+    for (let index = 16; index < 64; index++) {
+        const before15 = words[index - 15] ?? 0;
+        const before2 = words[index - 2] ?? 0;
+        const s0 = rotateRight(before15, 7) ^ rotateRight(before15, 18) ^ (before15 >>> 3);
+        const s1 = rotateRight(before2, 17) ^ rotateRight(before2, 19) ^ (before2 >>> 10);
+        words[index] = ((words[index - 16] ?? 0) + s0 + (words[index - 7] ?? 0) + s1) >>> 0;
+    }
+    let a = state[0] ?? 0;
+    let b = state[1] ?? 0;
+    let c = state[2] ?? 0;
+    let d = state[3] ?? 0;
+    let e = state[4] ?? 0;
+    let f = state[5] ?? 0;
+    let g = state[6] ?? 0;
+    let h = state[7] ?? 0;
+    for (let index = 0; index < 64; index++) {
+        const upper1 = rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25);
+        const choose = (e & f) ^ (~e & g);
+        const temp1 = (h + upper1 + choose + (SHA256_CONSTANTS[index] ?? 0) + (words[index] ?? 0)) >>> 0;
+        const upper0 = rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22);
+        const majority = (a & b) ^ (a & c) ^ (b & c);
+        const temp2 = (upper0 + majority) >>> 0;
+        h = g;
+        g = f;
+        f = e;
+        e = (d + temp1) >>> 0;
+        d = c;
+        c = b;
+        b = a;
+        a = (temp1 + temp2) >>> 0;
+    }
+    state[0] = ((state[0] ?? 0) + a) >>> 0;
+    state[1] = ((state[1] ?? 0) + b) >>> 0;
+    state[2] = ((state[2] ?? 0) + c) >>> 0;
+    state[3] = ((state[3] ?? 0) + d) >>> 0;
+    state[4] = ((state[4] ?? 0) + e) >>> 0;
+    state[5] = ((state[5] ?? 0) + f) >>> 0;
+    state[6] = ((state[6] ?? 0) + g) >>> 0;
+    state[7] = ((state[7] ?? 0) + h) >>> 0;
+}
+function rotateRight(value, amount) {
+    return (value >>> amount) | (value << (32 - amount));
+}
+const SHA256_CONSTANTS = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98,
+    0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786,
+    0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8,
+    0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,
+    0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819,
+    0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a,
+    0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7,
+    0xc67178f2,
+]);

package/control-plane/dataset-import/index.d.ts

@@ -0,0 +1,10 @@
+export { hashDatasetImportFile } from "./file-hash.js";
+export type { DatasetImportFileHashOptions } from "./file-hash.js";
+export type { CreateDatasetImportTask, DatasetImportArtifactSource, DatasetImportAuthorityDescriptor, DatasetImportAuthorityRenewal, DatasetImportDestination, DatasetImportSource, DatasetImportTask, DatasetImportTaskOptions, DatasetImportTaskReference, RenewDatasetImportAuthority, } from "./types.js";
+export { DatasetImportTaskApiError, DatasetImportTaskClient, } from "./client.js";
+export type { DatasetImportTaskClientOptions } from "./client.js";
+export { DatasetImportUploadClient } from "./upload-client.js";
+export type { DatasetImportSourceRetentionReceipt, DatasetImportUploadCapabilities, DatasetImportUploadReceipt, } from "./types.js";
+export { DatasetImportSubmissionClient } from "./submission-client.js";
+export type { DatasetImportJobReceipt, DatasetImportOutputReceipt, DatasetImportSubmissionReceipt, SubmitDatasetImport, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/control-plane/dataset-import/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/control-plane/dataset-import/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,gBAAgB,CAAC;AACvD,YAAY,EAAE,4BAA4B,EAAE,MAAM,gBAAgB,CAAC;AACnE,YAAY,EACV,uBAAuB,EACvB,2BAA2B,EAC3B,gCAAgC,EAChC,6BAA6B,EAC7B,wBAAwB,EACxB,mBAAmB,EACnB,iBAAiB,EACjB,wBAAwB,EACxB,0BAA0B,EAC1B,2BAA2B,GAC5B,MAAM,YAAY,CAAC;AACpB,OAAO,EACL,yBAAyB,EACzB,uBAAuB,GACxB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAClE,OAAO,EAAE,yBAAyB,EAAE,MAAM,oBAAoB,CAAC;AAC/D,YAAY,EACV,mCAAmC,EACnC,+BAA+B,EAC/B,0BAA0B,GAC3B,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,6BAA6B,EAAE,MAAM,wBAAwB,CAAC;AACvE,YAAY,EACV,uBAAuB,EACvB,0BAA0B,EAC1B,8BAA8B,EAC9B,mBAAmB,GACpB,MAAM,YAAY,CAAC"}

package/control-plane/dataset-import/index.js

@@ -0,0 +1,4 @@
+export { hashDatasetImportFile } from "./file-hash.js";
+export { DatasetImportTaskApiError, DatasetImportTaskClient, } from "./client.js";
+export { DatasetImportUploadClient } from "./upload-client.js";
+export { DatasetImportSubmissionClient } from "./submission-client.js";

package/control-plane/dataset-import/submission-client.d.ts

@@ -0,0 +1,18 @@
+import type { DatasetImportTaskClientOptions } from "./client.js";
+import type { DatasetImportAuthorityDescriptor, DatasetImportSubmissionReceipt, DatasetImportTaskReference } from "./types.js";
+/**
+ * Shared canonical submission/status transport. Human POST prepares the original
+ * task and awaits its actual agent; only an authenticated executor can dispatch.
+ * Persist the task and reviewed authority BEFORE POST. After an unknown reply,
+ * read/reconcile the SAME task; GET never dispatches and there is no POST retry.
+ * Explicit original POST replay is a deliberate caller action, never automatic.
+ */
+export declare class DatasetImportSubmissionClient {
+    private readonly transport;
+    constructor(options: DatasetImportTaskClientOptions);
+    read(reference: DatasetImportTaskReference, signal?: AbortSignal): Promise<DatasetImportSubmissionReceipt | null>;
+    /** Snapshot and validate the original known receipt before the authentication await. */
+    reconcile(reference: DatasetImportTaskReference, original: DatasetImportSubmissionReceipt, signal?: AbortSignal): Promise<DatasetImportSubmissionReceipt | null>;
+    submit(reference: DatasetImportTaskReference, reviewed: DatasetImportAuthorityDescriptor, signal?: AbortSignal): Promise<DatasetImportSubmissionReceipt>;
+}
+//# sourceMappingURL=submission-client.d.ts.map

package/control-plane/dataset-import/submission-client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"submission-client.d.ts","sourceRoot":"","sources":["../../../../src/control-plane/dataset-import/submission-client.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAElE,OAAO,KAAK,EACV,gCAAgC,EAEhC,8BAA8B,EAC9B,0BAA0B,EAC3B,MAAM,YAAY,CAAC;AAEpB;;;;;;GAMG;AACH,qBAAa,6BAA6B;IACxC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAkC;gBAChD,OAAO,EAAE,8BAA8B;IAI7C,IAAI,CACR,SAAS,EAAE,0BAA0B,EACrC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,8BAA8B,GAAG,IAAI,CAAC;IAajD,wFAAwF;IAClF,SAAS,CACb,SAAS,EAAE,0BAA0B,EACrC,QAAQ,EAAE,8BAA8B,EACxC,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,8BAA8B,GAAG,IAAI,CAAC;IA4B3C,MAAM,CACV,SAAS,EAAE,0BAA0B,EACrC,QAAQ,EAAE,gCAAgC,EAC1C,MAAM,CAAC,EAAE,WAAW,GACnB,OAAO,CAAC,8BAA8B,CAAC;CAwC3C"}

package/control-plane/dataset-import/submission-client.js

@@ -0,0 +1,197 @@
+import { DatasetImportWorkspaceTransport, validId } from "./transport.js";
+/**
+ * Shared canonical submission/status transport. Human POST prepares the original
+ * task and awaits its actual agent; only an authenticated executor can dispatch.
+ * Persist the task and reviewed authority BEFORE POST. After an unknown reply,
+ * read/reconcile the SAME task; GET never dispatches and there is no POST retry.
+ * Explicit original POST replay is a deliberate caller action, never automatic.
+ */
+export class DatasetImportSubmissionClient {
+    transport;
+    constructor(options) {
+        this.transport = new DatasetImportWorkspaceTransport(options);
+    }
+    async read(reference, signal) {
+        const pinned = pin(reference);
+        const value = await this.transport.request(`${path(pinned)}?contentHash=${pinned.contentHash}`, "GET", undefined, signal, true);
+        if (value !== null)
+            validate(value, pinned);
+        return value;
+    }
+    /** Snapshot and validate the original known receipt before the authentication await. */
+    async reconcile(reference, original, signal) {
+        const pinned = pin(reference);
+        const before = structuredClone(original);
+        validate(before, pinned);
+        const value = await this.read(pinned, signal);
+        if (value !== null) {
+            if (before.state !== "not-prepared")
+                requireOriginal(before, value);
+            if (before.state === "accepted") {
+                if (value.state !== "accepted" ||
+                    value.job.jobId !== before.job.jobId ||
+                    value.job.leaseId !== before.job.leaseId ||
+                    value.job.createdAt !== before.job.createdAt)
+                    fail();
+                if (terminal(before.job.status) &&
+                    (value.job.status !== before.job.status ||
+                        outputKey(value.job.output) !== outputKey(before.job.output) ||
+                        value.job.completedAt !== before.job.completedAt ||
+                        value.job.errorCode !== before.job.errorCode))
+                    fail();
+            }
+        }
+        return value;
+    }
+    async submit(reference, reviewed, signal) {
+        const pinned = pin(reference);
+        if (!reviewed ||
+            reviewed.taskId !== pinned.taskId ||
+            reviewed.taskRevision !== pinned.revision ||
+            reviewed.taskContentHash !== pinned.contentHash ||
+            !positive(reviewed.authorityRevision) ||
+            !digest(reviewed.authorityFingerprint) ||
+            !digest(reviewed.policyContextFingerprint) ||
+            !date(reviewed.uploadAdmissionDeadline) ||
+            (reviewed.preparedOperationId != null && !operation(reviewed.preparedOperationId)))
+            throw new TypeError("An exact reviewed task authority and original admission deadline are required.");
+        const expected = {
+            authorityRevision: reviewed.authorityRevision,
+            authorityFingerprint: reviewed.authorityFingerprint,
+            policyContextFingerprint: reviewed.policyContextFingerprint,
+            acceptBefore: reviewed.uploadAdmissionDeadline,
+            operationId: reviewed.preparedOperationId,
+        };
+        const body = JSON.stringify({
+            taskContentHash: pinned.contentHash,
+            authorityRevision: expected.authorityRevision,
+            authorityFingerprint: expected.authorityFingerprint,
+            policyContextFingerprint: expected.policyContextFingerprint,
+        });
+        const value = await this.transport.request(path(pinned), "POST", body, signal);
+        validate(value, pinned);
+        if (value.state === "not-prepared" ||
+            value.authorityRevision !== expected.authorityRevision ||
+            value.authorityFingerprint !== expected.authorityFingerprint ||
+            value.policyContextFingerprint !== expected.policyContextFingerprint ||
+            Date.parse(value.acceptBefore) !== Date.parse(expected.acceptBefore) ||
+            (expected.operationId != null && value.operationId !== expected.operationId))
+            fail();
+        return value;
+    }
+}
+function pin(reference) {
+    if (!reference)
+        throw new TypeError("An immutable task reference is required.");
+    validId(reference.taskId);
+    if (!positive(reference.revision) || !digest(reference.contentHash))
+        throw new TypeError("An immutable task reference is required.");
+    return { taskId: reference.taskId, revision: reference.revision, contentHash: reference.contentHash };
+}
+function path(reference) {
+    return `/dataset-import-tasks/${encodeURIComponent(reference.taskId)}/versions/${reference.revision}/submission`;
+}
+function digest(value) {
+    return typeof value === "string" && value.length === 64 && /^[a-f0-9]{64}$/.test(value);
+}
+function operation(value) {
+    return typeof value === "string" && value.length === 32 && /^[a-f0-9]{32}$/.test(value);
+}
+function positive(value) {
+    return Number.isSafeInteger(value) && value > 0;
+}
+function date(value) {
+    return typeof value === "string" && Number.isFinite(Date.parse(value));
+}
+function text(value) {
+    return (typeof value === "string" &&
+        value.length > 0 &&
+        value.length <= 256 &&
+        value.trim() === value &&
+        !Array.from(value).some((character) => {
+            const code = character.charCodeAt(0);
+            return code <= 31 || (code >= 127 && code <= 159);
+        }));
+}
+function outputKey(output) {
+    return output == null
+        ? "null"
+        : JSON.stringify([output.schema, output.physicalTableName, output.featureCount, output.detectedSrid ?? null]);
+}
+function terminal(value) {
+    return ["succeeded", "failed", "cancelled"].includes(value);
+}
+function fail() {
+    throw new Error("Submission response changed the original task, authority, operation or accepted job receipt.");
+}
+function requireOriginal(before, value) {
+    if (value.state === "not-prepared" ||
+        value.operationId !== before.operationId ||
+        value.authorityRevision !== before.authorityRevision ||
+        value.authorityFingerprint !== before.authorityFingerprint ||
+        value.policyContextFingerprint !== before.policyContextFingerprint ||
+        value.acceptBefore !== before.acceptBefore)
+        fail();
+}
+function validate(value, reference) {
+    if (!value ||
+        value.taskId !== reference.taskId ||
+        value.taskRevision !== reference.revision ||
+        value.taskContentHash !== reference.contentHash ||
+        !["not-prepared", "prepared", "accepted"].includes(value.state))
+        fail();
+    if (value.state === "not-prepared") {
+        if ([
+            value.operationId,
+            value.authorityRevision,
+            value.authorityFingerprint,
+            value.policyContextFingerprint,
+            value.acceptBefore,
+            value.job,
+        ].some((item) => item != null))
+            fail();
+        return;
+    }
+    if (!operation(value.operationId) ||
+        !positive(value.authorityRevision) ||
+        !digest(value.authorityFingerprint) ||
+        !digest(value.policyContextFingerprint) ||
+        !date(value.acceptBefore))
+        fail();
+    if (value.state === "prepared") {
+        if (value.job != null)
+            fail();
+        return;
+    }
+    const job = value.job;
+    if (!job ||
+        job.jobId !== value.operationId ||
+        !text(job.leaseId) ||
+        !["queued", "provisioning", "running", "succeeded", "failed", "cancelled"].includes(job.status) ||
+        !date(job.createdAt) ||
+        !date(job.updatedAt) ||
+        Date.parse(job.updatedAt) < Date.parse(job.createdAt) ||
+        (job.completedAt != null && (!date(job.completedAt) || !terminal(job.status))) ||
+        (job.percentComplete != null &&
+            (!Number.isFinite(job.percentComplete) || job.percentComplete < 0 || job.percentComplete > 100)) ||
+        (job.errorCode != null && (job.status !== "failed" || job.errorCode !== "import-failed")))
+        fail();
+    if (job.outcomePending !== undefined &&
+        (typeof job.outcomePending !== "boolean" || (job.outcomePending && terminal(job.status))))
+        fail();
+    const output = job.output;
+    if (job.status === "succeeded" && output == null)
+        fail();
+    if (output != null &&
+        (job.status !== "succeeded" ||
+            !text(output.schema) ||
+            !text(output.physicalTableName) ||
+            !Number.isSafeInteger(output.featureCount) ||
+            output.featureCount < 0 ||
+            output.featureCount > 2147483647 ||
+            (output.detectedSrid != null &&
+                (!Number.isInteger(output.detectedSrid) ||
+                    output.detectedSrid < -2147483648 ||
+                    output.detectedSrid > 2147483647))))
+        fail();
+}

package/control-plane/dataset-import/transport.d.ts

@@ -0,0 +1,14 @@
+import type { DatasetImportTaskClientOptions } from "./client.js";
+/** Internal common transport: fixed deployment/workspace/turn, fresh authentication only. */
+export declare class DatasetImportWorkspaceTransport {
+    private readonly base;
+    private readonly workspaceId;
+    private readonly originatingTurnId?;
+    private readonly fetcher;
+    private readonly headers?;
+    constructor(options: DatasetImportTaskClientOptions);
+    request<T>(suffix: string, method: "GET" | "POST" | "PUT" | "DELETE", body: BodyInit | undefined, signal?: AbortSignal, allowMissing?: false, contentType?: string): Promise<T>;
+    request<T>(suffix: string, method: "GET" | "POST" | "PUT" | "DELETE", body: BodyInit | undefined, signal: AbortSignal | undefined, allowMissing: true, contentType?: string): Promise<T | null>;
+}
+export declare function validId(value: string): void;
+//# sourceMappingURL=transport.d.ts.map

package/control-plane/dataset-import/transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../../src/control-plane/dataset-import/transport.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,8BAA8B,EAAE,MAAM,aAAa,CAAC;AAGlE,6FAA6F;AAC7F,qBAAa,+BAA+B;IAC1C,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAS;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAS;IACrC,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAS;IAC5C,OAAO,CAAC,QAAQ,CAAC,OAAO,CAA0B;IAClD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAC,CAA4C;gBAEzD,OAAO,EAAE,8BAA8B;IAe7C,OAAO,CAAC,CAAC,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,EACzC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,MAAM,CAAC,EAAE,WAAW,EACpB,YAAY,CAAC,EAAE,KAAK,EACpB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,CAAC,CAAC;IACP,OAAO,CAAC,CAAC,EACb,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,KAAK,GAAG,MAAM,GAAG,KAAK,GAAG,QAAQ,EACzC,IAAI,EAAE,QAAQ,GAAG,SAAS,EAC1B,MAAM,EAAE,WAAW,GAAG,SAAS,EAC/B,YAAY,EAAE,IAAI,EAClB,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,CAAC,GAAG,IAAI,CAAC;CAuBrB;AAED,wBAAgB,OAAO,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAY3C"}

package/control-plane/dataset-import/transport.js

@@ -0,0 +1,53 @@
+import { DatasetImportTaskApiError } from "./errors.js";
+/** Internal common transport: fixed deployment/workspace/turn, fresh authentication only. */
+export class DatasetImportWorkspaceTransport {
+    base;
+    workspaceId;
+    originatingTurnId;
+    fetcher;
+    headers;
+    constructor(options) {
+        const base = new URL(options.baseUrl);
+        if (!/^https?:$/.test(base.protocol) || base.username || base.password || base.search || base.hash)
+            throw new TypeError("A deployment HTTP(S) URL without credentials, query or fragment is required.");
+        validId(options.workspaceId);
+        validId(options.targetId);
+        if (options.originatingTurnId !== undefined)
+            validId(options.originatingTurnId);
+        this.base = `${base.href.replace(/\/$/, "")}/api/v1/agent/workspaces/${encodeURIComponent(options.workspaceId)}`;
+        this.workspaceId = options.workspaceId;
+        this.originatingTurnId = options.originatingTurnId;
+        // Native browser fetch rejects a transport instance as its receiver.
+        this.fetcher = options.fetch ?? globalThis.fetch.bind(globalThis);
+        this.headers = options.headers;
+    }
+    async request(suffix, method, body, signal, allowMissing = false, contentType = "application/json") {
+        const headers = new Headers(await this.headers?.());
+        headers.set("Accept", "application/json");
+        headers.delete("X-Honua-Workspace");
+        headers.delete("X-Honua-Turn");
+        if (this.originatingTurnId !== undefined) {
+            headers.set("X-Honua-Workspace", this.workspaceId);
+            headers.set("X-Honua-Turn", this.originatingTurnId);
+        }
+        if (body !== undefined)
+            headers.set("Content-Type", contentType);
+        const response = await this.fetcher(`${this.base}${suffix}`, { method, headers, body, signal, redirect: "error" });
+        if (allowMissing && response.status === 404)
+            return null;
+        if (!response.ok)
+            throw new DatasetImportTaskApiError(response.status);
+        return (await response.json());
+    }
+}
+export function validId(value) {
+    if (typeof value !== "string" ||
+        value.length < 1 ||
+        value.length > 256 ||
+        value.trim() !== value ||
+        Array.from(value).some((character) => {
+            const code = character.charCodeAt(0);
+            return code <= 31 || (code >= 127 && code <= 159);
+        }))
+        throw new TypeError("A bounded canonical identity is required.");
+}