@honua/app-platform 0.1.11-beta.0 → 0.1.13

package/offline/memory-store.d.ts

@@ -0,0 +1,17 @@
+import { type OfflineRegionCacheAdmin, type OfflineRegionCacheInventory, type OfflineRegionResourceRead, type OfflineRegionStore, type OfflineRegionWriteTransaction } from "./types.js";
+export interface MemoryOfflineRegionStoreOptions {
+    /** Injectable clock so tests can observe deterministic access timestamps. */
+    readonly now?: () => Date;
+}
+export declare class MemoryOfflineRegionStore implements OfflineRegionStore, OfflineRegionCacheAdmin {
+    #private;
+    constructor(options?: MemoryOfflineRegionStoreOptions);
+    inventory(): Promise<OfflineRegionCacheInventory>;
+    readResource(regionId: string, resourceId: string): Promise<OfflineRegionResourceRead | undefined>;
+    removeRegion(regionId: string): Promise<boolean>;
+    setRegionPinned(regionId: string, pinned: boolean): Promise<boolean>;
+    pruneExpired(now?: Date): Promise<readonly string[]>;
+    beginWrite(regionId: string): Promise<OfflineRegionWriteTransaction>;
+}
+export declare function createMemoryOfflineRegionStore(options?: MemoryOfflineRegionStoreOptions): MemoryOfflineRegionStore;
+//# sourceMappingURL=memory-store.d.ts.map

package/offline/memory-store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory-store.d.ts","sourceRoot":"","sources":["../../../src/offline/memory-store.ts"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,uBAAuB,EAC5B,KAAK,2BAA2B,EAGhC,KAAK,yBAAyB,EAC9B,KAAK,kBAAkB,EAEvB,KAAK,6BAA6B,EACnC,MAAM,YAAY,CAAC;AA0BpB,MAAM,WAAW,+BAA+B;IAC9C,6EAA6E;IAC7E,QAAQ,CAAC,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B;AAED,qBAAa,wBAAyB,YAAW,kBAAkB,EAAE,uBAAuB;;gBAOvE,OAAO,GAAE,+BAAoC;IAInD,SAAS,IAAI,OAAO,CAAC,2BAA2B,CAAC;IAejD,YAAY,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,yBAAyB,GAAG,SAAS,CAAC;IAqBlG,YAAY,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAOhD,eAAe,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC;IAUpE,YAAY,CAAC,GAAG,GAAE,IAAkB,GAAG,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC;IAajE,UAAU,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,6BAA6B,CAAC;CAiGlF;AAED,wBAAgB,8BAA8B,CAC5C,OAAO,GAAE,+BAAoC,GAC5C,wBAAwB,CAE1B"}

package/offline/memory-store.js

@@ -0,0 +1,183 @@
+import { assertCredentialFreeManifest, credentialScreenMessage, screenPersistedString } from "./credential-screen.js";
+import { compareCodeUnits } from "./digest.js";
+import { HonuaOfflineRegionError, } from "./types.js";
+export class MemoryOfflineRegionStore {
+    #regions = new Map();
+    #staging = new Map();
+    #now;
+    #revision = "0";
+    #sequence = 0;
+    constructor(options = {}) {
+        this.#now = options.now ?? (() => new Date());
+    }
+    async inventory() {
+        const regions = [];
+        for (const [id, record] of this.#regions) {
+            regions.push({
+                id,
+                logicalByteLength: record.logicalByteLength,
+                lastAccessedAt: record.lastAccessedAt,
+                ...(record.expiresAt ? { expiresAt: record.expiresAt } : {}),
+                ...(record.pinned ? { pinned: true } : {}),
+            });
+        }
+        regions.sort((left, right) => compareCodeUnits(left.id, right.id));
+        return { revision: this.#revision, regions };
+    }
+    async readResource(regionId, resourceId) {
+        requireId(regionId, "regionId");
+        requireId(resourceId, "resourceId");
+        const record = this.#regions.get(regionId);
+        if (!record)
+            return undefined;
+        const resource = record.manifest.resources.find((candidate) => candidate.id === resourceId);
+        if (!resource)
+            return undefined;
+        const bytes = record.resources.get(resourceId);
+        if (!bytes)
+            return undefined;
+        if (bytes.byteLength !== resource.byteLength) {
+            throw new HonuaOfflineRegionError("integrity-mismatch", `Offline resource ${resourceId} failed its stored byte-length check.`, { resourceId });
+        }
+        record.lastAccessedAt = this.#now().toISOString();
+        this.#advance();
+        return { regionId, manifest: record.manifest, resource, bytes: Uint8Array.from(bytes) };
+    }
+    async removeRegion(regionId) {
+        requireId(regionId, "regionId");
+        if (!this.#regions.delete(regionId))
+            return false;
+        this.#advance();
+        return true;
+    }
+    async setRegionPinned(regionId, pinned) {
+        requireId(regionId, "regionId");
+        if (typeof pinned !== "boolean")
+            throw new TypeError("pinned must be a boolean.");
+        const record = this.#regions.get(regionId);
+        if (!record || Boolean(record.pinned) === pinned)
+            return false;
+        record.pinned = pinned || undefined;
+        this.#advance();
+        return true;
+    }
+    async pruneExpired(now = this.#now()) {
+        if (!(now instanceof Date) || !Number.isFinite(now.getTime()))
+            throw new TypeError("now must be a valid Date.");
+        const cutoff = now.getTime();
+        const expired = [...this.#regions.entries()]
+            .filter(([, record]) => record.expiresAt !== undefined && Date.parse(record.expiresAt) <= cutoff)
+            .map(([id]) => id)
+            .sort(compareCodeUnits);
+        if (expired.length === 0)
+            return expired;
+        for (const id of expired)
+            this.#regions.delete(id);
+        this.#advance();
+        return expired;
+    }
+    async beginWrite(regionId) {
+        requireId(regionId, "regionId");
+        assertCredentialFreeIdentity(regionId, "regionId");
+        const evictions = [];
+        const staged = this.#staging.get(regionId) ?? new Map();
+        this.#staging.set(regionId, staged);
+        return {
+            evict: async (id) => {
+                if (!evictions.includes(id))
+                    evictions.push(id);
+            },
+            readStaged: async (resource) => {
+                const bytes = staged.get(resource.id);
+                if (!bytes || bytes.byteLength !== resource.byteLength)
+                    return undefined;
+                return Uint8Array.from(bytes);
+            },
+            discardStaged: async (resource) => {
+                staged.delete(resource.id);
+            },
+            write: async (resource, bytes) => {
+                assertCredentialFreeIdentity(resource.id, "resource.id");
+                const copy = Uint8Array.from(bytes);
+                if (copy.byteLength !== resource.byteLength) {
+                    throw new HonuaOfflineRegionError("integrity-mismatch", `Resource ${resource.id} byte length does not match its descriptor.`, { resourceId: resource.id });
+                }
+                staged.set(resource.id, copy);
+            },
+            commit: async (manifest, receipt, guard) => {
+                // `commit` is public, so the credential-free manifest invariant is
+                // re-enforced here rather than trusted from the coordinator.
+                assertCredentialFreeManifest(manifest);
+                if (this.#revision !== guard.expectedInventoryRevision)
+                    return "inventory-changed";
+                const existing = this.#regions.get(manifest.id);
+                const evicted = new Set(evictions);
+                let logicalBytesAfter = manifest.totalLogicalBytes;
+                for (const [id, record] of this.#regions) {
+                    if (id === manifest.id || evicted.has(id))
+                        continue;
+                    logicalBytesAfter += record.logicalByteLength;
+                }
+                if (logicalBytesAfter > guard.logicalQuotaBytes ||
+                    logicalBytesAfter !== guard.admission.logicalBytesAfter ||
+                    guard.admission.requiredLogicalBytes !== manifest.totalLogicalBytes ||
+                    guard.admission.replacementLogicalBytes !== (existing?.logicalByteLength ?? 0) ||
+                    !sameIds(guard.admission.evictRegionIds, evictions)) {
+                    throw new HonuaOfflineRegionError("store-failed", "Memory store rejected inconsistent offline-region admission.");
+                }
+                const expected = new Set(manifest.resources.map((resource) => resource.id));
+                for (const resource of manifest.resources) {
+                    const bytes = staged.get(resource.id);
+                    if (!bytes || bytes.byteLength !== resource.byteLength) {
+                        throw new HonuaOfflineRegionError("store-failed", "Memory store requires every manifest resource to be written before commit.", { resourceId: resource.id });
+                    }
+                }
+                for (const id of staged.keys()) {
+                    if (!expected.has(id)) {
+                        throw new HonuaOfflineRegionError("store-failed", "Memory store found an unexpected staged resource.", {
+                            resourceId: id,
+                        });
+                    }
+                }
+                for (const id of evictions)
+                    this.#regions.delete(id);
+                this.#regions.set(manifest.id, {
+                    manifest,
+                    receipt,
+                    logicalByteLength: manifest.totalLogicalBytes,
+                    lastAccessedAt: receipt.completedAt,
+                    ...(manifest.expiresAt ? { expiresAt: manifest.expiresAt } : {}),
+                    ...(existing?.pinned ? { pinned: true } : {}),
+                    resources: new Map(staged),
+                });
+                this.#staging.delete(manifest.id);
+                this.#advance();
+                return "committed";
+            },
+            rollback: async (options) => {
+                if (!options?.preserveStaged)
+                    this.#staging.delete(regionId);
+                evictions.length = 0;
+            },
+        };
+    }
+    #advance() {
+        this.#sequence += 1;
+        this.#revision = `${this.#sequence}`;
+    }
+}
+export function createMemoryOfflineRegionStore(options = {}) {
+    return new MemoryOfflineRegionStore(options);
+}
+function requireId(value, name) {
+    if (typeof value !== "string" || value.length === 0)
+        throw new TypeError(`${name} must be non-empty.`);
+}
+function assertCredentialFreeIdentity(value, path) {
+    const reason = screenPersistedString(value, "identity");
+    if (reason)
+        throw new HonuaOfflineRegionError("invalid-manifest", credentialScreenMessage(path, reason), { path });
+}
+function sameIds(left, right) {
+    return left.length === right.length && left.every((id, index) => id === right[index]);
+}

package/offline/quota.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Real browser storage-quota interrogation for offline-region admission.
+ *
+ * `logicalQuotaBytes` is an honest accounting of declared payload lengths, but
+ * it has no relationship to the space a browser will actually grant. This module
+ * closes that gap in the only way the platform supports: it reads
+ * `navigator.storage.estimate()` through an injectable interface, derives a
+ * conservative logical budget with an explicit reserve, and reports an explicit
+ * `unavailable` result rather than inventing a number when the platform cannot
+ * estimate.
+ *
+ * The estimate is deliberately imprecise and origin-scoped, and the accounting
+ * unit stays logical payload bytes: physical occupancy, deduplication, and index
+ * overhead are outside the contract and are exactly why a reserve exists. The
+ * derived budget is advisory, never a guarantee, so a device can still refuse a
+ * write that the budget admitted — which is why storage-pressure failures are
+ * classified here too.
+ *
+ * Nothing in this module performs network I/O, mutates the store, or reads or
+ * returns a credential, origin secret, or request URL. Persistence is never
+ * requested implicitly: `requestOfflinePersistentStorage()` is the only path to
+ * `navigator.storage.persist()` and it exists solely because the caller asked.
+ */
+/** Stable discriminator and version for storage-budget probe results. */
+export declare const HONUA_OFFLINE_STORAGE_BUDGET_KIND: "honua.offline-storage-budget";
+export declare const HONUA_OFFLINE_STORAGE_BUDGET_VERSION: "1.0";
+/** Stable discriminator and version for explicit persistence-request results. */
+export declare const HONUA_OFFLINE_STORAGE_PERSISTENCE_KIND: "honua.offline-storage-persistence";
+export declare const HONUA_OFFLINE_STORAGE_PERSISTENCE_VERSION: "1.0";
+/** Fraction of the remaining estimate held back from the derived logical budget. */
+export declare const DEFAULT_OFFLINE_STORAGE_HEADROOM_RATIO = 0.2;
+/** Floor for the reserve, so a large-quota origin still keeps real headroom. */
+export declare const DEFAULT_OFFLINE_STORAGE_MIN_RESERVE_BYTES: number;
+/**
+ * Whether the origin's storage survives eviction pressure. `unknown` is a real
+ * answer: a platform without `StorageManager.persisted()` has not told us.
+ */
+export type OfflineStoragePersistence = "persisted" | "best-effort" | "unknown";
+/** Why no budget could be derived. Never accompanied by a fabricated number. */
+export type OfflineStorageBudgetUnavailableReason = "storage-manager-unavailable" | "estimate-unsupported" | "estimate-failed" | "estimate-incomplete";
+/**
+ * Injectable subset of the platform `StorageManager`.
+ *
+ * Every member is optional so a partial host implementation is describable
+ * rather than assumed; the probe degrades to an explicit `unavailable` result
+ * instead of throwing. A real `navigator.storage` satisfies this structurally.
+ */
+export interface OfflineStorageManagerLike {
+    estimate?: () => Promise<{
+        readonly quota?: number;
+        readonly usage?: number;
+    } | undefined>;
+    persisted?: () => Promise<boolean>;
+    persist?: () => Promise<boolean>;
+}
+/** A derived, advisory logical budget backed by a real platform estimate. */
+export interface OfflineStorageBudgetAvailableV1 {
+    readonly kind: typeof HONUA_OFFLINE_STORAGE_BUDGET_KIND;
+    readonly version: typeof HONUA_OFFLINE_STORAGE_BUDGET_VERSION;
+    readonly status: "available";
+    readonly observedAt: string;
+    /** Platform-reported origin quota. Imprecise and subject to change. */
+    readonly quotaBytes: number;
+    readonly usageBytes: number;
+    /** `max(0, quota - usage)`; the hard upper bound on any derived budget. */
+    readonly remainingBytes: number;
+    readonly reserveBytes: number;
+    readonly headroomRatio: number;
+    /** Pass to `logicalQuotaBytes`. Never exceeds `remainingBytes`. */
+    readonly logicalBudgetBytes: number;
+    readonly persistence: OfflineStoragePersistence;
+}
+/** An explicit refusal to estimate. Carries no budget of any kind. */
+export interface OfflineStorageBudgetUnavailableV1 {
+    readonly kind: typeof HONUA_OFFLINE_STORAGE_BUDGET_KIND;
+    readonly version: typeof HONUA_OFFLINE_STORAGE_BUDGET_VERSION;
+    readonly status: "unavailable";
+    readonly observedAt: string;
+    readonly reason: OfflineStorageBudgetUnavailableReason;
+    readonly persistence: OfflineStoragePersistence;
+}
+export type OfflineStorageBudgetV1 = OfflineStorageBudgetAvailableV1 | OfflineStorageBudgetUnavailableV1;
+export interface ProbeOfflineStorageBudgetOptions {
+    /** Defaults to `navigator.storage`. Inject for tests and non-browser hosts. */
+    readonly storage?: OfflineStorageManagerLike;
+    /** Fraction of remaining space held in reserve. `0` to `1`; defaults to `0.2`. */
+    readonly headroomRatio?: number;
+    /** Reserve floor in bytes; defaults to 16 MiB. Clamped by remaining space. */
+    readonly minimumReserveBytes?: number;
+    /** Explicit clock input so a persisted probe result stays reproducible. */
+    readonly now?: Date;
+}
+export type OfflineStoragePersistenceRequestStatus = "granted" | "denied" | "unavailable";
+export type OfflineStoragePersistenceUnavailableReason = "storage-manager-unavailable" | "persist-unsupported" | "persist-failed";
+/** Result of an explicit, caller-initiated persistence request. */
+export interface OfflineStoragePersistenceRequestV1 {
+    readonly kind: typeof HONUA_OFFLINE_STORAGE_PERSISTENCE_KIND;
+    readonly version: typeof HONUA_OFFLINE_STORAGE_PERSISTENCE_VERSION;
+    readonly status: OfflineStoragePersistenceRequestStatus;
+    readonly persistence: OfflineStoragePersistence;
+    readonly reason?: OfflineStoragePersistenceUnavailableReason;
+}
+export interface RequestOfflinePersistentStorageOptions {
+    /** Defaults to `navigator.storage`. Inject for tests and non-browser hosts. */
+    readonly storage?: OfflineStorageManagerLike;
+}
+/**
+ * Read the origin's real storage estimate and derive a conservative logical
+ * budget, or report explicitly that the platform cannot estimate.
+ *
+ * Performs no network I/O, writes nothing, and never calls
+ * `StorageManager.persist()`. `persisted()` is read when the platform offers it
+ * because persisted state changes the eviction risk of every cached region; a
+ * platform that does not offer it yields `persistence: "unknown"` rather than an
+ * assumption.
+ *
+ * Derivation is deterministic integer arithmetic over the reported values:
+ *
+ * ```text
+ * remaining = max(0, quota - usage)
+ * reserve   = min(remaining, max(minimumReserveBytes, floor(remaining * headroomRatio)))
+ * budget    = remaining - reserve
+ * ```
+ *
+ * so the budget can never exceed the platform-reported remaining quota, and a
+ * nearly full origin yields `0` instead of a number that cannot be honoured.
+ */
+export declare function probeOfflineStorageBudget(options?: ProbeOfflineStorageBudgetOptions): Promise<OfflineStorageBudgetV1>;
+/**
+ * Ask the browser to make this origin's storage persistent.
+ *
+ * This is the only call site of `StorageManager.persist()` in the SDK and it
+ * runs only because an application called it. It is never invoked by
+ * `downloadOfflineRegion`, by the probe, or by any store adapter: the request
+ * can show a permission prompt, and a download is not consent to ask.
+ */
+export declare function requestOfflinePersistentStorage(options?: RequestOfflinePersistentStorageOptions): Promise<OfflineStoragePersistenceRequestV1>;
+/**
+ * Report whether a thrown value is, or wraps, a platform storage-pressure
+ * failure — the device refusing a write for lack of space.
+ *
+ * Recognizes the `QuotaExceededError` `DOMException` every engine raises, the
+ * Firefox `NS_ERROR_DOM_QUOTA_REACHED` name, and the legacy numeric
+ * `DOMException` codes, then walks a bounded `cause` and `AggregateError` graph
+ * so a store adapter that wrapped the failure is still classified correctly.
+ * Bounded and cycle-safe: it inspects at most 32 nodes and visits none twice.
+ *
+ * Exported because a host-supplied `OfflineRegionStore` must classify the same
+ * condition the same way; without a shared predicate an adapter's wrapper would
+ * silently downgrade a full device to an internal store failure.
+ */
+export declare function isStorageQuotaPressureError(error: unknown): boolean;
+/**
+ * Validate and take ownership of a caller-supplied budget envelope.
+ *
+ * Internal to the offline area: the diagnostic accepts a budget produced by
+ * `probeOfflineStorageBudget()`, and a public entry point cannot assume it was
+ * not hand-built.
+ */
+export declare function captureOfflineStorageBudget(value: unknown, path: string): OfflineStorageBudgetV1;
+//# sourceMappingURL=quota.d.ts.map

package/offline/quota.d.ts.map

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