@honua/app-platform 0.1.12 → 0.1.13

package/offline/edit-replay.d.ts

@@ -0,0 +1,116 @@
+import type { ReplicaConflictPolicy } from "../replica-sync/types.js";
+import { type OfflineEditQueue, type OfflineEditQueuePartition, type OfflineFeatureEdit } from "./edit-queue.js";
+import { type OfflineReplaySyncConflictBinding, type OfflineReplaySyncConflictProjectionV1 } from "./replay-conflict.js";
+export declare const HONUA_OFFLINE_EDIT_REPLAY_VERSION: "1.0";
+export interface OfflineEditReplayIdentity {
+    readonly editId: `sha256:${string}`;
+    readonly requestFingerprint: `sha256:${string}`;
+    readonly idempotencyKey: string;
+}
+export interface OfflineEditReplayRequest extends OfflineEditReplayIdentity {
+    readonly version: typeof HONUA_OFFLINE_EDIT_REPLAY_VERSION;
+    readonly sourceId: string;
+    readonly edit: OfflineFeatureEdit;
+}
+export interface OfflineEditAppliedAcknowledgement extends OfflineEditReplayIdentity {
+    readonly kind: "applied";
+    readonly serverOperationId: string;
+    readonly serverGeneration?: string;
+}
+export interface OfflineEditRetryableAcknowledgement extends OfflineEditReplayIdentity {
+    readonly kind: "retryable";
+    readonly retryAt: string;
+    readonly reasonCode: string;
+}
+export interface OfflineEditConflictedAcknowledgement extends OfflineEditReplayIdentity {
+    readonly kind: "conflicted";
+    readonly conflictId: string;
+    readonly serverGeneration?: string;
+}
+export type OfflineEditReplayAcknowledgement = OfflineEditAppliedAcknowledgement | OfflineEditRetryableAcknowledgement | OfflineEditConflictedAcknowledgement;
+export interface OfflineEditReplayTransportContext {
+    readonly signal?: AbortSignal;
+}
+/**
+ * Application-owned binding to a server mutation transport. Returned values
+ * are treated as untrusted and validated before queue state changes.
+ */
+export type OfflineEditReplayTransport = (request: OfflineEditReplayRequest, context: OfflineEditReplayTransportContext) => unknown | Promise<unknown>;
+export interface ReplayOfflineEditPassOptions extends OfflineEditQueuePartition {
+    readonly workerId: string;
+    /** Required, between 1 and 100 inclusive. */
+    readonly limit: number;
+    /** Required, positive, and no more than 24 hours. */
+    readonly leaseDurationMs: number;
+    readonly signal?: AbortSignal;
+    /**
+     * Replica identity for conflict projection. Supply it to have every
+     * conflicted acknowledgement projected onto the shipped sync-conflict
+     * contracts as {@link OfflineEditReplayItemReceipt.syncConflict}; omit it and
+     * the pass behaves exactly as before. The SDK cannot derive a replica from a
+     * queue partition, so an absent binding means no projection rather than a
+     * guessed one.
+     */
+    readonly replica?: OfflineReplaySyncConflictBinding;
+    /**
+     * The replica's reconciliation policy, declared explicitly.
+     *
+     * Declaring it is how an application finds out that the SDK cannot carry the
+     * policy out: `client-wins` and `last-writer-wins` need a server to decide the
+     * outcome, so the pass refuses before it claims anything, naming the policy
+     * (`HonuaOfflineConflictAdjudicationError`). `manual` retains conflicts for
+     * review — which is also what an omitted policy does — and `server-wins`
+     * closes each conflict against the local edit and abandons it. See
+     * `OFFLINE_REPLAY_CONFLICT_POLICIES` and `docs/offline-regions.md`.
+     */
+    readonly conflictPolicy?: ReplicaConflictPolicy;
+}
+/** What a declared policy did to one conflicted edit. */
+export type OfflineEditReplayConflictPolicyOutcome = 
+/** The edit is still `conflicted` and awaiting review. */
+"retained-for-review"
+/** The conflict was closed against the local edit, which is now `cancelled`. */
+ | "discarded-local-edit"
+/**
+ * The conflict is durably recorded but the policy transition did not land —
+ * a concurrent writer moved the record first. The conflict stays open, and
+ * the pass says so instead of implying the policy was applied.
+ */
+ | "not-applied";
+export interface OfflineEditReplayConflictPolicyReceiptV1 {
+    readonly policy: ReplicaConflictPolicy;
+    readonly outcome: OfflineEditReplayConflictPolicyOutcome;
+}
+export type OfflineEditReplayUnacknowledgedReason = "cancelled" | "identity-mismatch" | "invalid-acknowledgement" | "missing-lease" | "repeated-claim" | "transition-rejected" | "transport-threw";
+export interface OfflineEditReplayItemReceipt {
+    readonly editId: `sha256:${string}`;
+    readonly outcome: "applied" | "retryable" | "conflicted" | "unacknowledged";
+    readonly reasonCode?: OfflineEditReplayUnacknowledgedReason;
+    /**
+     * Present only for a `conflicted` outcome when the pass was given a replica
+     * binding. It carries either the projected sync conflict or a typed refusal —
+     * never a partially guessed contract object. When a policy closed the
+     * conflict, the projection is of the resolved record, so its `status` and
+     * `localResolution` describe what the policy actually did.
+     */
+    readonly syncConflict?: OfflineReplaySyncConflictProjectionV1;
+    /**
+     * Present only for a `conflicted` outcome when the pass declared a conflict
+     * policy. A refused policy never reaches a receipt: the pass throws first.
+     */
+    readonly conflictPolicy?: OfflineEditReplayConflictPolicyReceiptV1;
+}
+export interface OfflineEditReplayPassReceipt {
+    readonly version: typeof HONUA_OFFLINE_EDIT_REPLAY_VERSION;
+    readonly claimedCount: number;
+    readonly invokedCount: number;
+    readonly appliedCount: number;
+    readonly retryableCount: number;
+    readonly conflictedCount: number;
+    readonly unacknowledgedCount: number;
+    readonly stoppedReason?: "cancelled";
+    readonly outcomes: readonly OfflineEditReplayItemReceipt[];
+}
+/** Claim and replay one bounded, deterministic queue pass. */
+export declare function replayOfflineEditPass(queue: OfflineEditQueue, transport: OfflineEditReplayTransport, options: ReplayOfflineEditPassOptions): Promise<OfflineEditReplayPassReceipt>;
+//# sourceMappingURL=edit-replay.d.ts.map

package/offline/edit-replay.d.ts.map

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

package/offline/edit-replay.js

@@ -0,0 +1,392 @@
+import { requireHonourableOfflineReplayConflictPolicy, } from "./conflict-resolution.js";
+import { HonuaOfflineEditQueueError, MAX_OFFLINE_EDIT_LEASE_DURATION_MS, } from "./edit-queue.js";
+import { normalizeOfflineReplaySyncConflictBinding, projectOfflineReplaySyncConflict, } from "./replay-conflict.js";
+export const HONUA_OFFLINE_EDIT_REPLAY_VERSION = "1.0";
+const DIGEST_PATTERN = /^sha256:[a-f0-9]{64}$/;
+const MAX_STRING_BYTES = 1024;
+const encoder = new TextEncoder();
+const OPTION_KEYS = new Set([
+    "authorizationScopeDigest",
+    "sourceId",
+    "workerId",
+    "limit",
+    "leaseDurationMs",
+    "signal",
+    "replica",
+    "conflictPolicy",
+]);
+const COMMON_ACKNOWLEDGEMENT_KEYS = ["kind", "editId", "requestFingerprint", "idempotencyKey"];
+const APPLIED_ACKNOWLEDGEMENT_KEYS = new Set([...COMMON_ACKNOWLEDGEMENT_KEYS, "serverOperationId", "serverGeneration"]);
+const RETRYABLE_ACKNOWLEDGEMENT_KEYS = new Set([...COMMON_ACKNOWLEDGEMENT_KEYS, "retryAt", "reasonCode"]);
+const CONFLICTED_ACKNOWLEDGEMENT_KEYS = new Set([...COMMON_ACKNOWLEDGEMENT_KEYS, "conflictId", "serverGeneration"]);
+class AcknowledgementError extends Error {
+    code;
+    constructor(code) {
+        super(code);
+        this.code = code;
+        this.name = "AcknowledgementError";
+    }
+}
+/** Claim and replay one bounded, deterministic queue pass. */
+export async function replayOfflineEditPass(queue, transport, options) {
+    if (!queue || typeof queue.claimReady !== "function") {
+        invalid("queue must implement OfflineEditQueue.", "queue");
+    }
+    if (typeof transport !== "function")
+        invalid("transport must be a function.", "transport");
+    const normalized = captureOptions(options);
+    if (normalized.signal?.aborted)
+        return createReceipt([], 0, "cancelled");
+    const outcomes = [];
+    const invokedEditIds = new Set();
+    let invokedCount = 0;
+    let stoppedReason;
+    while (outcomes.length < normalized.limit) {
+        if (normalized.signal?.aborted) {
+            stoppedReason = "cancelled";
+            break;
+        }
+        const [queued] = (await queue.claimReady({
+            authorizationScopeDigest: normalized.authorizationScopeDigest,
+            sourceId: normalized.sourceId,
+            workerId: normalized.workerId,
+            limit: 1,
+            leaseDurationMs: normalized.leaseDurationMs,
+        })).slice(0, 1);
+        if (!queued)
+            break;
+        if (normalized.signal?.aborted) {
+            outcomes.push(unacknowledged(queued.id, "cancelled"));
+            stoppedReason = "cancelled";
+            break;
+        }
+        if (invokedEditIds.has(queued.id)) {
+            outcomes.push(unacknowledged(queued.id, "repeated-claim"));
+            break;
+        }
+        const leaseToken = queued.lease?.token;
+        if (!leaseToken) {
+            outcomes.push(unacknowledged(queued.id, "missing-lease"));
+            break;
+        }
+        let rawAcknowledgement;
+        invokedCount += 1;
+        invokedEditIds.add(queued.id);
+        try {
+            rawAcknowledgement = await transport(replayRequest(queued), transportContext(normalized.signal));
+        }
+        catch {
+            const cancelled = normalized.signal?.aborted === true;
+            outcomes.push(unacknowledged(queued.id, cancelled ? "cancelled" : "transport-threw"));
+            if (cancelled)
+                stoppedReason = "cancelled";
+            break;
+        }
+        let acknowledgement;
+        try {
+            acknowledgement = captureAcknowledgement(rawAcknowledgement, queued);
+        }
+        catch (error) {
+            outcomes.push(unacknowledged(queued.id, error instanceof AcknowledgementError ? error.code : "invalid-acknowledgement"));
+            break;
+        }
+        let conflicted;
+        try {
+            if (acknowledgement.kind === "applied") {
+                await queue.markApplied(queued.id, leaseToken, {
+                    serverOperationId: acknowledgement.serverOperationId,
+                    ...(acknowledgement.serverGeneration === undefined
+                        ? {}
+                        : { serverGeneration: acknowledgement.serverGeneration }),
+                });
+            }
+            else if (acknowledgement.kind === "retryable") {
+                await queue.markRetry(queued.id, leaseToken, {
+                    retryAt: acknowledgement.retryAt,
+                    reasonCode: acknowledgement.reasonCode,
+                });
+            }
+            else {
+                conflicted = await queue.markConflicted(queued.id, leaseToken, {
+                    conflictId: acknowledgement.conflictId,
+                    ...(acknowledgement.serverGeneration === undefined
+                        ? {}
+                        : { serverGeneration: acknowledgement.serverGeneration }),
+                });
+            }
+        }
+        catch {
+            outcomes.push(unacknowledged(queued.id, "transition-rejected"));
+            break;
+        }
+        // Both run outside the transition guard on purpose: the durable conflict
+        // write has already succeeded, so neither a policy that cannot land nor a
+        // projection refusal may be reported as a rejected transition.
+        const policy = conflicted === undefined ? undefined : await applyConflictPolicy(queue, normalized, conflicted);
+        const resolved = policy?.record ?? conflicted;
+        const syncConflict = resolved === undefined || normalized.replica === undefined
+            ? undefined
+            : projectOfflineReplaySyncConflict({ edit: resolved, replica: normalized.replica });
+        outcomes.push(deepFreeze({
+            editId: queued.id,
+            outcome: acknowledgement.kind,
+            ...(syncConflict === undefined ? {} : { syncConflict }),
+            ...(policy === undefined ? {} : { conflictPolicy: policy.receipt }),
+        }));
+    }
+    return createReceipt(outcomes, invokedCount, stoppedReason);
+}
+/**
+ * Carry out the declared policy on one freshly conflicted edit.
+ *
+ * `manual` — and an omitted policy, which behaves the same way — decides
+ * nothing, so there is nothing to do beyond saying so. `server-wins` closes the
+ * conflict against the local edit through the queue's own reviewed-resolution
+ * transition, so a policy-driven closure and a reviewer-driven one leave
+ * identical durable state and identical audit history.
+ */
+async function applyConflictPolicy(queue, options, conflicted) {
+    const policy = options.policy;
+    if (policy === undefined)
+        return undefined;
+    if (policy.action !== "discard-local-edit" || policy.choice === undefined || !conflicted.conflict) {
+        return { receipt: Object.freeze({ policy: policy.policy, outcome: "retained-for-review" }) };
+    }
+    try {
+        const record = await queue.resolveConflict(conflicted.id, { authorizationScopeDigest: options.authorizationScopeDigest, sourceId: options.sourceId }, { conflictId: conflicted.conflict.conflictId, choice: policy.choice });
+        return { receipt: Object.freeze({ policy: policy.policy, outcome: "discarded-local-edit" }), record };
+    }
+    catch {
+        // The conflict is durably recorded; the policy simply did not land, and the
+        // receipt says that rather than implying the local edit was abandoned.
+        return { receipt: Object.freeze({ policy: policy.policy, outcome: "not-applied" }) };
+    }
+}
+function captureOptions(value) {
+    const record = optionRecord(value);
+    for (const key of Object.keys(record)) {
+        if (!OPTION_KEYS.has(key))
+            invalid(`options.${key} is not allowed.`, `options.${key}`);
+    }
+    const authorizationScopeDigest = optionDigest(record.authorizationScopeDigest, "options.authorizationScopeDigest");
+    const sourceId = optionString(record.sourceId, "options.sourceId");
+    const workerId = optionString(record.workerId, "options.workerId");
+    const limit = boundedInteger(record.limit, "options.limit", 100);
+    const leaseDurationMs = boundedInteger(record.leaseDurationMs, "options.leaseDurationMs", MAX_OFFLINE_EDIT_LEASE_DURATION_MS);
+    const signal = record.signal;
+    if (signal !== undefined && !isAbortSignal(signal)) {
+        invalid("options.signal must be an AbortSignal.", "options.signal");
+    }
+    const replica = record.replica === undefined
+        ? undefined
+        : normalizeOfflineReplaySyncConflictBinding(record.replica, "options.replica");
+    // Refused before the first claim: a pass either honours the policy it was
+    // given for every conflict it meets, or it does nothing at all.
+    const policy = record.conflictPolicy === undefined
+        ? undefined
+        : requireHonourableOfflineReplayConflictPolicy(record.conflictPolicy, "options.conflictPolicy");
+    return {
+        authorizationScopeDigest,
+        sourceId,
+        workerId,
+        limit,
+        leaseDurationMs,
+        ...(signal === undefined ? {} : { signal }),
+        ...(replica === undefined ? {} : { replica }),
+        ...(policy === undefined ? {} : { policy }),
+    };
+}
+function replayRequest(queued) {
+    return deepFreeze({
+        version: HONUA_OFFLINE_EDIT_REPLAY_VERSION,
+        editId: queued.id,
+        requestFingerprint: queued.requestFingerprint,
+        idempotencyKey: queued.idempotencyKey,
+        sourceId: queued.sourceId,
+        edit: queued.edit,
+    });
+}
+function transportContext(signal) {
+    return Object.freeze(signal === undefined ? {} : { signal });
+}
+function captureAcknowledgement(value, queued) {
+    const record = dataRecord(value, "acknowledgement");
+    const kind = record.kind;
+    if (kind === "applied") {
+        allowedKeys(record, APPLIED_ACKNOWLEDGEMENT_KEYS, "acknowledgement");
+        const identity = acknowledgementIdentity(record, queued);
+        return deepFreeze({
+            kind,
+            ...identity,
+            serverOperationId: normalizedString(record.serverOperationId, "acknowledgement.serverOperationId"),
+            ...(record.serverGeneration === undefined
+                ? {}
+                : { serverGeneration: normalizedString(record.serverGeneration, "acknowledgement.serverGeneration") }),
+        });
+    }
+    if (kind === "retryable") {
+        allowedKeys(record, RETRYABLE_ACKNOWLEDGEMENT_KEYS, "acknowledgement");
+        const identity = acknowledgementIdentity(record, queued);
+        return deepFreeze({
+            kind,
+            ...identity,
+            retryAt: normalizedTimestamp(record.retryAt, "acknowledgement.retryAt"),
+            reasonCode: normalizedString(record.reasonCode, "acknowledgement.reasonCode"),
+        });
+    }
+    if (kind === "conflicted") {
+        allowedKeys(record, CONFLICTED_ACKNOWLEDGEMENT_KEYS, "acknowledgement");
+        const identity = acknowledgementIdentity(record, queued);
+        return deepFreeze({
+            kind,
+            ...identity,
+            conflictId: normalizedString(record.conflictId, "acknowledgement.conflictId"),
+            ...(record.serverGeneration === undefined
+                ? {}
+                : { serverGeneration: normalizedString(record.serverGeneration, "acknowledgement.serverGeneration") }),
+        });
+    }
+    throw new AcknowledgementError("invalid-acknowledgement");
+}
+function acknowledgementIdentity(record, queued) {
+    const identity = {
+        editId: digest(record.editId, "acknowledgement.editId"),
+        requestFingerprint: digest(record.requestFingerprint, "acknowledgement.requestFingerprint"),
+        idempotencyKey: normalizedString(record.idempotencyKey, "acknowledgement.idempotencyKey"),
+    };
+    if (identity.editId !== queued.id ||
+        identity.requestFingerprint !== queued.requestFingerprint ||
+        identity.idempotencyKey !== queued.idempotencyKey) {
+        throw new AcknowledgementError("identity-mismatch");
+    }
+    return identity;
+}
+function createReceipt(outcomes, invokedCount, stoppedReason) {
+    return deepFreeze({
+        version: HONUA_OFFLINE_EDIT_REPLAY_VERSION,
+        claimedCount: outcomes.length,
+        invokedCount,
+        appliedCount: outcomes.filter((outcome) => outcome.outcome === "applied").length,
+        retryableCount: outcomes.filter((outcome) => outcome.outcome === "retryable").length,
+        conflictedCount: outcomes.filter((outcome) => outcome.outcome === "conflicted").length,
+        unacknowledgedCount: outcomes.filter((outcome) => outcome.outcome === "unacknowledged").length,
+        ...(stoppedReason === undefined ? {} : { stoppedReason }),
+        outcomes: [...outcomes],
+    });
+}
+function unacknowledged(editId, reasonCode) {
+    return deepFreeze({ editId, outcome: "unacknowledged", reasonCode });
+}
+function dataRecord(value, path) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        acknowledgementInvalid(`${path} must be a plain data object.`);
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        acknowledgementInvalid(`${path} must use a safe prototype.`);
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+        acknowledgementInvalid(`${path} cannot contain symbol keys.`);
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const record = Object.create(null);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+        if (!("value" in descriptor))
+            acknowledgementInvalid(`${path}.${key} must be a data property.`);
+        record[key] = descriptor.value;
+    }
+    return record;
+}
+function optionRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        invalid("options must be a plain data object.", "options");
+    }
+    const prototype = Object.getPrototypeOf(value);
+    if (prototype !== Object.prototype && prototype !== null) {
+        invalid("options must use a safe prototype.", "options");
+    }
+    if (Object.getOwnPropertySymbols(value).length > 0) {
+        invalid("options cannot contain symbol keys.", "options");
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    const record = Object.create(null);
+    for (const [key, descriptor] of Object.entries(descriptors)) {
+        if (!("value" in descriptor))
+            invalid(`options.${key} must be a data property.`, `options.${key}`);
+        record[key] = descriptor.value;
+    }
+    return record;
+}
+function allowedKeys(record, allowed, path) {
+    for (const key of Object.keys(record)) {
+        if (!allowed.has(key))
+            acknowledgementInvalid(`${path}.${key} is not allowed.`);
+    }
+}
+function normalizedString(value, path) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > MAX_STRING_BYTES ||
+        value.trim() !== value ||
+        encoder.encode(value).byteLength > MAX_STRING_BYTES) {
+        acknowledgementInvalid(`${path} must be a normalized non-empty string of at most 1024 UTF-8 bytes.`);
+    }
+    return value;
+}
+function optionString(value, path) {
+    if (typeof value !== "string" ||
+        value.length === 0 ||
+        value.length > MAX_STRING_BYTES ||
+        value.trim() !== value ||
+        encoder.encode(value).byteLength > MAX_STRING_BYTES) {
+        invalid(`${path} must be a normalized non-empty string of at most 1024 UTF-8 bytes.`, path);
+    }
+    return value;
+}
+function optionDigest(value, path) {
+    const result = optionString(value, path);
+    if (!DIGEST_PATTERN.test(result))
+        invalid(`${path} must be a lowercase SHA-256 digest.`, path);
+    return result;
+}
+function digest(value, path) {
+    const result = normalizedString(value, path);
+    if (!DIGEST_PATTERN.test(result))
+        acknowledgementInvalid(`${path} must be a lowercase SHA-256 digest.`);
+    return result;
+}
+function normalizedTimestamp(value, path) {
+    const result = normalizedString(value, path);
+    const time = Date.parse(result);
+    if (!Number.isFinite(time) || new Date(time).toISOString() !== result) {
+        acknowledgementInvalid(`${path} must be a normalized ISO timestamp.`);
+    }
+    return result;
+}
+function boundedInteger(value, path, maximum) {
+    if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
+        invalid(`${path} must be a positive safe integer no greater than ${maximum}.`, path);
+    }
+    return value;
+}
+function isAbortSignal(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        typeof value.aborted === "boolean" &&
+        typeof value.addEventListener === "function");
+}
+function acknowledgementInvalid(message) {
+    void message;
+    throw new AcknowledgementError("invalid-acknowledgement");
+}
+function invalid(message, path) {
+    throw new HonuaOfflineEditQueueError("invalid-edit", message, { path });
+}
+function deepFreeze(value) {
+    if (typeof value !== "object" || value === null || Object.isFrozen(value))
+        return value;
+    Object.freeze(value);
+    for (const child of Object.values(value))
+        deepFreeze(child);
+    return value;
+}

package/offline/fetch-handler.d.ts

@@ -0,0 +1,12 @@
+import type { OfflineRegionFetchHandler, OfflineRegionFetchHandlerOptions } from "./types.js";
+/**
+ * Creates a storage-backed fetch handler for service workers and fetch-event
+ * integrations. The host owns URL matching; the SDK only turns a matched,
+ * credential-free resource identity into a response.
+ *
+ * A miss, unsupported method, or expired region returns `undefined`, allowing
+ * the host to continue its normal network fallback. Storage failures are
+ * propagated so a host can distinguish them from an ordinary cache miss.
+ */
+export declare function createOfflineRegionFetchHandler(options: OfflineRegionFetchHandlerOptions): OfflineRegionFetchHandler;
+//# sourceMappingURL=fetch-handler.d.ts.map

package/offline/fetch-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fetch-handler.d.ts","sourceRoot":"","sources":["../../../src/offline/fetch-handler.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,yBAAyB,EACzB,gCAAgC,EAEjC,MAAM,YAAY,CAAC;AAEpB;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAAC,OAAO,EAAE,gCAAgC,GAAG,yBAAyB,CAmBpH"}

package/offline/fetch-handler.js

@@ -0,0 +1,65 @@
+/**
+ * Creates a storage-backed fetch handler for service workers and fetch-event
+ * integrations. The host owns URL matching; the SDK only turns a matched,
+ * credential-free resource identity into a response.
+ *
+ * A miss, unsupported method, or expired region returns `undefined`, allowing
+ * the host to continue its normal network fallback. Storage failures are
+ * propagated so a host can distinguish them from an ordinary cache miss.
+ */
+export function createOfflineRegionFetchHandler(options) {
+    if (!options.store)
+        throw new TypeError("An offline region store is required.");
+    if (typeof options.regionId !== "string" || options.regionId.length === 0)
+        throw new TypeError("regionId must be non-empty.");
+    if (typeof options.match !== "function")
+        throw new TypeError("A request matcher is required.");
+    const now = options.now ?? (() => new Date());
+    return async (request) => {
+        if (!(request instanceof Request))
+            throw new TypeError("request must be a Request.");
+        if (request.method !== "GET" && request.method !== "HEAD")
+            return undefined;
+        const resourceId = await options.match(request);
+        if (resourceId === undefined)
+            return undefined;
+        if (typeof resourceId !== "string" || resourceId.length === 0)
+            throw new TypeError("The request matcher returned an invalid resource ID.");
+        const read = await options.store.readResource(options.regionId, resourceId);
+        if (!read || isExpired(read, now()))
+            return undefined;
+        return toResponse(read, request.method === "HEAD");
+    };
+}
+function toResponse(read, head) {
+    const headers = new Headers({
+        "content-length": String(read.bytes.byteLength),
+        "x-honua-offline-region": read.regionId,
+        "x-honua-offline-state": read.manifest.source.observation.state,
+        "x-honua-offline-observed-at": read.manifest.source.observation.observedAt,
+    });
+    setHeaderIfValid(headers, "x-honua-offline-source-version", read.resource.sourceVersion);
+    setHeaderIfValid(headers, "x-honua-offline-schema-version", read.resource.schemaVersion);
+    setHeaderIfValid(headers, "x-honua-offline-plan-version", read.resource.planVersion);
+    if (read.resource.contentType)
+        headers.set("content-type", read.resource.contentType);
+    if (read.manifest.expiresAt)
+        headers.set("x-honua-offline-expires-at", read.manifest.expiresAt);
+    return new Response(head ? null : Uint8Array.from(read.bytes), { status: 200, headers });
+}
+function setHeaderIfValid(headers, name, value) {
+    if ([...value].every((character) => {
+        const codePoint = character.codePointAt(0) ?? 0;
+        return codePoint >= 0x20 && codePoint <= 0xff && codePoint !== 0x7f;
+    })) {
+        headers.set(name, value);
+    }
+}
+function isExpired(read, now) {
+    if (!(now instanceof Date) || !Number.isFinite(now.getTime()))
+        throw new TypeError("now must be a valid Date.");
+    if (!read.manifest.expiresAt)
+        return false;
+    const expiresAt = Date.parse(read.manifest.expiresAt);
+    return !Number.isFinite(expiresAt) || now.getTime() >= expiresAt;
+}

package/offline/index.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Storage-neutral contracts for bounded, downloadable offline regions.
+ *
+ * This experimental entrypoint provides an IndexedDB adapter for browser
+ * persistence and a storage-backed fetch handler for service-worker or fetch
+ * integrations. Applications inject request matching, resource loading, and
+ * network policy; the SDK owns deterministic manifest identity, credential
+ * projection, cache diagnostics, quota admission against the origin's real
+ * storage estimate, integrity checks, cancellation, progress semantics, durable
+ * edit-queue state, and the composed local-first status that names one honest
+ * state across cached reads and undelivered writes. Applications still own
+ * connectivity policy, persistence requests, and edit replay transport binding.
+ *
+ * @experimental
+ */
+export { createOfflineRegionDiagnostic, createOfflineRegionManifest, downloadOfflineRegion, planOfflineRegionAdmission, verifyOfflineRegionManifest, } from "./region.js";
+export { canonicalizeOfflineRegionQuery, compareOfflineRegionBounds, isWgs84LonLatCrs, normalizeOfflineRegionTileKey, OFFLINE_REGION_DEFAULT_TILE_MATRIX_SET, OFFLINE_REGION_MAX_TILE_ZOOM, OFFLINE_REGION_PROTOCOL, offlineRegionAssetSelector, offlineRegionAuthorizationScopeDigest, offlineRegionMetadataSelector, offlineRegionQueryFingerprint, offlineRegionResourceId, offlineRegionTileEnvelope, offlineRegionTileSelector, } from "./selection.js";
+export type { OfflineRegionBoundsRelation, OfflineRegionCanonicalQueryV1, OfflineRegionQueryScopeV1, OfflineRegionResourceSelector, OfflineRegionSelectionIdentityV1, OfflineRegionTileSelectorOptions, } from "./selection.js";
+export { createOfflineRegionFeatureBatch, createOfflineRegionSnapshotLoader, decodeOfflineRegionFeatureBatch, DEFAULT_OFFLINE_REGION_SNAPSHOT_MAX_CONTENTS, encodeOfflineRegionFeatureBatch, HONUA_OFFLINE_FEATURE_BATCH_KIND, HONUA_OFFLINE_FEATURE_BATCH_VERSION, HONUA_OFFLINE_REGION_SNAPSHOT_KIND, HONUA_OFFLINE_REGION_SNAPSHOT_VERSION, planOfflineRegionSnapshot, } from "./snapshot.js";
+export type { OfflineRegionFeatureBatchV1, OfflineRegionSnapshotContentV1, OfflineRegionSnapshotEntryV1, OfflineRegionSnapshotSelectionV1, OfflineRegionSnapshotV1, } from "./snapshot.js";
+export { createOfflineRegionQueryPlanCache, DEFAULT_OFFLINE_REGION_READ_STALE_AFTER_MS, HONUA_OFFLINE_REGION_READ_KIND, HONUA_OFFLINE_REGION_READ_VERSION, } from "./read-gate.js";
+export type { OfflineRegionReadCacheDecisionV1, OfflineRegionReadFreshness, OfflineRegionReadGateOptions, OfflineRegionReadProvenanceV1, OfflineRegionStoreReadOptions, } from "./read-gate.js";
+export { readOfflineRegionQuery } from "./read.js";
+export type { OfflineRegionQueryReadV1, ReadOfflineRegionQueryOptions } from "./read.js";
+export { readOfflineRegionAsset, readOfflineRegionMetadata, readOfflineRegionResource, readOfflineRegionTile, resolveOfflineRegionResourceId, } from "./read-resource.js";
+export type { OfflineRegionMetadataReadV1, OfflineRegionResourceReadV1, OfflineRegionTileReadV1, ReadOfflineRegionAssetOptions, ReadOfflineRegionMetadataOptions, ReadOfflineRegionResourceOptions, ReadOfflineRegionTileOptions, } from "./read-resource.js";
+export { buildOfflineRegionTileUrlTemplate, createOfflineRegionTileProtocol, OFFLINE_REGION_TILE_SCHEME, parseOfflineRegionTileUrl, registerOfflineRegionTileProtocol, } from "./tile-protocol.js";
+export type { CreateOfflineRegionTileProtocolOptions, OfflineRegionProtocolHandler, OfflineRegionProtocolRegistrar, OfflineRegionProtocolRequest, OfflineRegionProtocolResponse, OfflineRegionTileAddressV1, } from "./tile-protocol.js";
+export { createMemoryOfflineRegionStore, MemoryOfflineRegionStore } from "./memory-store.js";
+export type { MemoryOfflineRegionStoreOptions } from "./memory-store.js";
+export { HONUA_OFFLINE_REGION_STORE_CONFORMANCE_KIND, HONUA_OFFLINE_REGION_STORE_CONFORMANCE_VERSION, OFFLINE_REGION_STORE_CONFORMANCE_CASES, runOfflineRegionStoreConformance, } from "./store-conformance.js";
+export type { OfflineRegionStoreConformanceCaseResultV1, OfflineRegionStoreConformanceOptions, OfflineRegionStoreConformanceReportV1, } from "./store-conformance.js";
+export { applyOfflineRegionSchemaMigration, createIndexedDbOfflineRegionStore, HONUA_OFFLINE_REGION_SCHEMA_VERSION, HONUA_OFFLINE_REGION_STORE_RECOVERY_KIND, HONUA_OFFLINE_REGION_STORE_RECOVERY_VERSION, IndexedDbOfflineRegionStore, OFFLINE_REGION_SCHEMA_MIGRATIONS, planOfflineRegionSchemaMigration, readableOfflineRegionSchemaVersions, } from "./indexeddb.js";
+export type { OfflineRegionSchemaMigrationPlanV1, OfflineRegionSchemaMigrationRefusal, OfflineRegionSchemaMigrationV1, OfflineRegionStoreRecoveryV1, } from "./indexeddb.js";
+export { DEFAULT_OFFLINE_STORAGE_HEADROOM_RATIO, DEFAULT_OFFLINE_STORAGE_MIN_RESERVE_BYTES, HONUA_OFFLINE_STORAGE_BUDGET_KIND, HONUA_OFFLINE_STORAGE_BUDGET_VERSION, HONUA_OFFLINE_STORAGE_PERSISTENCE_KIND, HONUA_OFFLINE_STORAGE_PERSISTENCE_VERSION, isStorageQuotaPressureError, probeOfflineStorageBudget, requestOfflinePersistentStorage, } from "./quota.js";
+export type { OfflineStorageBudgetAvailableV1, OfflineStorageBudgetUnavailableReason, OfflineStorageBudgetUnavailableV1, OfflineStorageBudgetV1, OfflineStorageManagerLike, OfflineStoragePersistence, OfflineStoragePersistenceRequestStatus, OfflineStoragePersistenceRequestV1, OfflineStoragePersistenceUnavailableReason, ProbeOfflineStorageBudgetOptions, RequestOfflinePersistentStorageOptions, } from "./quota.js";
+export { createOfflineRegionFetchHandler } from "./fetch-handler.js";
+export { createIndexedDbOfflineEditQueue, createMemoryOfflineEditQueue, IndexedDbOfflineEditQueue, MemoryOfflineEditQueue, } from "./edit-queue.js";
+export { HONUA_OFFLINE_EDIT_REPLAY_VERSION, replayOfflineEditPass } from "./edit-replay.js";
+export { classifyOfflineReplayConflictPolicy, HONUA_OFFLINE_CONFLICT_RESOLUTION_KIND, HONUA_OFFLINE_CONFLICT_RESOLUTION_VERSION, HonuaOfflineConflictAdjudicationError, isHonuaOfflineConflictAdjudicationError, OFFLINE_REPLAY_CONFLICT_POLICIES, recordOfflineConflictResolution, } from "./conflict-resolution.js";
+export type { OfflineConflictAdjudicationCode, OfflineConflictResolutionReceiptV1, OfflineReplayConflictPolicyAction, OfflineReplayConflictPolicyDisposition, OfflineReplayConflictPolicyReason, OfflineReplayConflictPolicyRuleV1, RecordOfflineConflictResolutionOptions, } from "./conflict-resolution.js";
+export { HONUA_OFFLINE_REPLAY_SYNC_CONFLICT_KIND, HONUA_OFFLINE_REPLAY_SYNC_CONFLICT_VERSION, OFFLINE_REPLAY_SYNC_CONFLICT_FIELD_MAP, projectOfflineReplaySyncConflict, } from "./replay-conflict.js";
+export type { OfflineReplayLocalConflictResolutionV1, OfflineReplayProjectedSyncConflict, OfflineReplaySyncConflictBinding, OfflineReplaySyncConflictFieldDisposition, OfflineReplaySyncConflictFieldMappingV1, OfflineReplaySyncConflictProjectedV1, OfflineReplaySyncConflictProjectionV1, OfflineReplaySyncConflictRefusalReason, OfflineReplaySyncConflictRefusedV1, OfflineReplaySyncConflictUnavailableMember, OfflineReplaySyncConflictUnavailableReason, OfflineReplaySyncConflictUnavailableV1, ProjectOfflineReplaySyncConflictInput, } from "./replay-conflict.js";
+export { createLocalFirstStatus, DEFAULT_LOCAL_FIRST_MAX_EDITS, DEFAULT_LOCAL_FIRST_MAX_LISTED_EDIT_IDS, DEFAULT_LOCAL_FIRST_MAX_REGIONS, HONUA_LOCAL_FIRST_STATUS_KIND, HONUA_LOCAL_FIRST_STATUS_VERSION, } from "./status.js";
+export type { CreateLocalFirstStatusOptions, LocalFirstCompleteness, LocalFirstConnectivity, LocalFirstFreshness, LocalFirstReadAvailability, LocalFirstReads, LocalFirstRegionSummary, LocalFirstState, LocalFirstStateReason, LocalFirstStatusLimits, LocalFirstStatusV1, LocalFirstWriteCoverage, LocalFirstWrites, LocalFirstWriteState, } from "./status.js";
+export { DEFAULT_OFFLINE_EDIT_QUEUE_MAX_AUDIT_EVENTS, DEFAULT_OFFLINE_EDIT_QUEUE_MAX_DEPENDENCIES, DEFAULT_OFFLINE_EDIT_QUEUE_MAX_EDITS, DEFAULT_OFFLINE_EDIT_QUEUE_MAX_PAYLOAD_BYTES, DEFAULT_OFFLINE_EDIT_QUEUE_MAX_RECOVERY_BYTES, DEFAULT_OFFLINE_EDIT_QUEUE_MAX_RECOVERY_RECORDS, HONUA_OFFLINE_EDIT_QUEUE_RECOVERY_KIND, HONUA_OFFLINE_EDIT_QUEUE_RECOVERY_VERSION, HONUA_OFFLINE_EDIT_QUEUE_VERSION, HonuaOfflineEditQueueError, inspectStoredOfflineEdit, inspectStoredOfflineEditMetadata, inspectStoredOfflineEditTombstone, MAX_OFFLINE_EDIT_LEASE_DURATION_MS, planOfflineEditQueueRecovery, } from "./edit-queue.js";
+export type { CancelOfflineEditInput, ClaimOfflineEditsOptions, EnqueueOfflineEditInput, IndexedDbOfflineEditQueueOptions, ListOfflineEditsOptions, MarkOfflineEditAppliedInput, MarkOfflineEditConflictedInput, MarkOfflineEditRetryInput, OfflineEditAppliedOutcome, OfflineEditAuditEvent, OfflineEditAuditEventKind, OfflineEditCancellationOutcome, OfflineEditConflictOutcome, OfflineEditConflictResolutionAcknowledgement, OfflineEditConflictResolutionChoice, OfflineEditConflictResolutionDisposition, OfflineEditConflictResolutionOutcome, OfflineEditEnqueueResult, OfflineEditJsonValue, OfflineEditLease, OfflineEditOperation, OfflineEditQueue, OfflineEditQueueDiscardReason, OfflineEditQueueErrorCode, OfflineEditQueueInspection, OfflineEditQueueMetadata, OfflineEditQueueOptions, OfflineEditQueuePartition, OfflineEditQueueRecoveryLimits, OfflineEditQueueRecoveryPlanV1, OfflineEditQueueRecoveryRowsV1, OfflineEditQueueRecoveryV1, OfflineEditQueueRepairReason, OfflineEditQueueStateCounts, OfflineEditQueueStoredRecord, OfflineEditQueueTombstone, OfflineEditRetry, OfflineFeatureEdit, OfflineQueuedEdit, OfflineQueuedEditState, PruneTerminalOfflineEditsOptions, ResolveOfflineEditConflictInput, } from "./edit-queue.js";
+export type { OfflineEditAppliedAcknowledgement, OfflineEditConflictedAcknowledgement, OfflineEditReplayAcknowledgement, OfflineEditReplayConflictPolicyOutcome, OfflineEditReplayConflictPolicyReceiptV1, OfflineEditReplayIdentity, OfflineEditReplayItemReceipt, OfflineEditReplayPassReceipt, OfflineEditReplayRequest, OfflineEditReplayTransport, OfflineEditReplayTransportContext, OfflineEditReplayUnacknowledgedReason, OfflineEditRetryableAcknowledgement, ReplayOfflineEditPassOptions, } from "./edit-replay.js";
+export type { IndexedDbOfflineRegionStoreOptions } from "./indexeddb.js";
+export { DEFAULT_OFFLINE_REGION_MAX_ATTRIBUTIONS, DEFAULT_OFFLINE_REGION_MAX_LOGICAL_BYTES, DEFAULT_OFFLINE_REGION_MAX_METADATA_ENTRIES, DEFAULT_OFFLINE_REGION_MAX_RESOURCES, DEFAULT_OFFLINE_REGION_MAX_STRING_BYTES, HONUA_OFFLINE_REGION_DIAGNOSTIC_KIND, HONUA_OFFLINE_REGION_DIAGNOSTIC_VERSION, HONUA_OFFLINE_REGION_KIND, HONUA_OFFLINE_REGION_VERSION, HonuaOfflineRegionError, } from "./types.js";
+export type { CreateOfflineRegionDiagnosticOptions, CreateOfflineRegionManifestInput, OfflineRegionAdmissionPlan, OfflineRegionBounds, OfflineRegionCacheAdmin, OfflineRegionCacheInventory, OfflineRegionCommitGuard, OfflineRegionDownloadOptions, OfflineRegionDownloadProgress, OfflineRegionDownloadReceipt, OfflineRegionDiagnosticAdmission, OfflineRegionDiagnosticV1, OfflineRegionErrorCode, OfflineRegionFetchHandler, OfflineRegionFetchHandlerOptions, OfflineRegionLimits, OfflineRegionManifestV1, OfflineRegionObservation, OfflineRegionResourceInput, OfflineRegionResourceMatcher, OfflineRegionResourceRead, OfflineRegionResourceKind, OfflineRegionResourceLoader, OfflineRegionResourceV1, OfflineRegionStore, OfflineRegionStoredRegion, OfflineRegionValidator, OfflineRegionWriteTransaction, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map