@lumenkey/cli 0.3.0 → 0.4.0-rc.1

package/dist/studio/asset-integrity-queue.d.ts

@@ -0,0 +1,24 @@
+import { type AssetIntegrity } from './asset-integrity-hash.js';
+import type { StudioSaveAuthority } from './output-save-journal.js';
+import type { StudioAsset, StudioRoot } from './types.js';
+export interface AssetIntegrityQueue {
+    cached(assetIds: readonly string[]): Promise<Map<string, AssetIntegrity>>;
+    observe(asset: StudioAsset): Promise<AssetIntegrity>;
+    idle(): Promise<void>;
+    close(): Promise<void>;
+}
+/** Root-owned local observer. No network, repair, HTTP hooks or file mutation.
+ * Hashing runs outside the authority's short commit queue. A failed completion
+ * publication makes later reads fail closed, rather than advertising stale success. */
+export declare function createAssetIntegrityQueue(root: StudioRoot, authority: StudioSaveAuthority, options: {
+    maxBytes: number;
+    now?: () => number;
+    beforeHash?(asset: StudioAsset): void | Promise<void>;
+    afterHash?(asset: StudioAsset): void | Promise<void>;
+    onInspect?(): void;
+    hashOptions?: {
+        beforeRead?(): void | Promise<void>;
+        afterChunk?(): void | Promise<void>;
+    };
+}): AssetIntegrityQueue;
+//# sourceMappingURL=asset-integrity-queue.d.ts.map

package/dist/studio/asset-integrity-queue.js

@@ -0,0 +1,94 @@
+import { hashStudioAsset, inspectStudioAsset } from './asset-integrity-hash.js';
+import { StudioError } from './errors.js';
+const TTL = 300000;
+const cold = () => ({ file: 'NOT_CHECKED', checkedAt: null, integrityCheck: 'IDLE' });
+const projection = (value) => ({ file: value.file, checkedAt: value.checkedAt, integrityCheck: value.integrityCheck });
+/** Root-owned local observer. No network, repair, HTTP hooks or file mutation.
+ * Hashing runs outside the authority's short commit queue. A failed completion
+ * publication makes later reads fail closed, rather than advertising stale success. */
+export function createAssetIntegrityQueue(root, authority, options) {
+    const now = options.now ?? Date.now;
+    let tail = Promise.resolve(), closing = false, fatal;
+    const tasks = new Map();
+    const preparing = new Map();
+    const cache = new Map();
+    function healthy() { if (fatal)
+        throw fatal; }
+    async function observations() { healthy(); return (await authority.readIntegrity())?.integrityObservations ?? []; }
+    async function existing(assetId) { return (await observations()).find(o => o.assetId === assetId); }
+    async function run(asset, task, signature) {
+        try {
+            let result;
+            if (closing)
+                result = { file: 'UNKNOWN', checkedAt: null, errorCode: 'SAVE_FILE_READ_FAILED' };
+            else {
+                try {
+                    await options.beforeHash?.(asset);
+                    result = await hashStudioAsset(root, asset, { maxBytes: options.maxBytes, expectedSignature: signature, now, signal: task.controller.signal, ...options.hashOptions });
+                }
+                catch {
+                    result = { file: 'UNKNOWN', checkedAt: null, errorCode: 'SAVE_FILE_READ_FAILED' };
+                }
+                finally {
+                    await options.afterHash?.(asset);
+                }
+            }
+            const value = { file: result.file, checkedAt: result.file === 'VERIFIED' ? result.checkedAt : task.checkedAt, integrityCheck: 'IDLE', ...(result.signature ? { signature: result.signature } : {}), ...(result.errorCode ? { errorCode: result.errorCode } : {}) };
+            await authority.observeIntegrity(asset.assetId, task.revision, value, result);
+            // Negative completed observations must remain visible to follow-up GETs.
+            // A changed stat still invalidates this bounded cache immediately.
+            cache.set(asset.assetId, { signature: result.signature ?? signature, completedAt: now() });
+        }
+        catch {
+            fatal = new StudioError('SAVE_AUTHORITY_UNAVAILABLE', 503);
+        }
+        finally {
+            tasks.delete(asset.assetId);
+        }
+    }
+    async function prepare(asset) {
+        healthy();
+        if (closing)
+            throw new StudioError('STUDIO_STORAGE_CLOSED', 503);
+        const previous = await existing(asset.assetId);
+        if (tasks.has(asset.assetId))
+            return projection(previous ?? cold());
+        options.onInspect?.();
+        const stat = await inspectStudioAsset(root, asset);
+        if (!stat.signature) {
+            cache.delete(asset.assetId);
+            const value = { file: stat.file, checkedAt: previous?.checkedAt ?? null, integrityCheck: 'IDLE', ...(stat.errorCode ? { errorCode: stat.errorCode } : {}) };
+            const committed = await authority.observeIntegrity(asset.assetId, previous?.revision ?? 0, value);
+            return projection(committed);
+        }
+        const recent = cache.get(asset.assetId), age = recent ? now() - recent.completedAt : -1;
+        if (previous && previous.file !== 'NOT_CHECKED' && previous.integrityCheck === 'IDLE' && recent?.signature === stat.signature && age >= 0 && age < TTL)
+            return projection(previous);
+        const pending = await authority.observeIntegrity(asset.assetId, previous?.revision ?? 0, { file: 'NOT_CHECKED', checkedAt: previous?.checkedAt ?? null, integrityCheck: 'PENDING' });
+        const task = { revision: pending.revision, checkedAt: pending.checkedAt, controller: new AbortController() };
+        tasks.set(asset.assetId, task);
+        // This is the single-hash-per-root guard, independent of download/commit locks.
+        tail = tail.then(() => run(asset, task, stat.signature));
+        return projection(pending);
+    }
+    return {
+        cached: async (ids) => {
+            const all = await observations();
+            const byId = new Map(all.map(o => [o.assetId, o]));
+            return new Map(ids.map(id => [id, projection(byId.get(id) ?? cold())]));
+        },
+        observe: asset => {
+            const pending = preparing.get(asset.assetId);
+            if (pending)
+                return pending;
+            const next = prepare(asset);
+            preparing.set(asset.assetId, next);
+            void next.finally(() => preparing.delete(asset.assetId)).catch(() => { });
+            return next;
+        },
+        idle: async () => { await Promise.allSettled(preparing.values()); await tail; healthy(); },
+        close: async () => { closing = true; for (const task of tasks.values())
+            task.controller.abort(); await Promise.allSettled(preparing.values()); await tail; healthy(); },
+    };
+}
+//# sourceMappingURL=asset-integrity-queue.js.map

package/dist/studio/asset-store.d.ts

@@ -0,0 +1,52 @@
+import type { ReadStream } from 'node:fs';
+import type { StudioAsset, StudioRecoveryIssue } from './types.js';
+import { type StudioRunJournal } from './run-journal.js';
+import { type StudioSaveAuthority } from './output-save-journal.js';
+import { type StudioDraftStore } from './draft-store.js';
+import { type StudioCanvasStore } from './canvas-store.js';
+import { type DirectorCaptureStore } from './director-captures.js';
+import { createAssetIntegrityQueue, type AssetIntegrityQueue } from './asset-integrity-queue.js';
+import type { AssetIntegrity } from './asset-integrity-hash.js';
+export declare const DEFAULT_STUDIO_MAX_BYTES: number;
+export interface StudioSaveInput {
+    displayName: string;
+    contentType: string;
+    expectedByteLength?: number;
+    stream: AsyncIterable<Uint8Array>;
+}
+export type StudioAssetWithIntegrity = StudioAsset & {
+    integrity: AssetIntegrity;
+};
+export interface StudioAssetStore {
+    readonly maxBytes: number;
+    directorCaptures: DirectorCaptureStore;
+    canvases: StudioCanvasStore;
+    drafts: StudioDraftStore;
+    runs: StudioRunJournal;
+    saveAuthority: StudioSaveAuthority;
+    readonly integrity: AssetIntegrityQueue;
+    metadata(assetId: string): Promise<StudioAssetWithIntegrity>;
+    list(): Promise<{
+        revision: number;
+        assets: StudioAssetWithIntegrity[];
+        recoveryIssues: StudioRecoveryIssue[];
+    }>;
+    save(input: StudioSaveInput): Promise<StudioAsset>;
+    registerExistingManagedFile(asset: StudioAsset): Promise<StudioAsset>;
+    read(assetId: string): Promise<{
+        asset: StudioAsset;
+        stream: ReadStream;
+    }>;
+    close(): Promise<void>;
+}
+export declare function openStudioAssetStore(options: {
+    outputDir: string;
+    maxBytes?: number;
+    integrity?: Omit<Parameters<typeof createAssetIntegrityQueue>[2], 'maxBytes'>;
+    faults?: {
+        beforeCatalogCommit?(): void | Promise<void>;
+        beforeCaptureCanvas?(): void | Promise<void>;
+        afterCaptureCanvas?(): void | Promise<void>;
+    };
+}): Promise<StudioAssetStore>;
+//# sourceMappingURL=asset-store.d.ts.map

package/dist/studio/asset-store.js

@@ -0,0 +1,352 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { link, open, readdir, rename, unlink, lstat } from 'node:fs/promises';
+import path from 'node:path';
+import { assertStudioMediaType, displayNameSchema, mediaExtensions, validateStudioAssetId, validateStudioCatalog } from './media.js';
+import { assertRegularFile, assertStudioRoot, prepareStudioRoot, resolveStudioAssetPath } from './paths.js';
+import { acquireStudioWriter } from './writer-lock.js';
+import { hasFsCode, storageError, StudioError, isSaveAuthorityError } from './errors.js';
+import { createRunJournal } from './run-journal.js';
+import { createSaveAuthority } from './output-save-journal.js';
+import { createDraftStore } from './draft-store.js';
+import { createCanvasAuthority, serializeCanvasAuthority } from './canvas-store.js';
+import { assertDirectorCanvas } from './director-relations.js';
+import { createDirectorCaptureStore } from './director-captures.js';
+import { createAssetIntegrityQueue } from './asset-integrity-queue.js';
+export const DEFAULT_STUDIO_MAX_BYTES = 512 * 1024 * 1024;
+const MAX_CATALOG_BYTES = 32 * 1024 * 1024;
+export async function openStudioAssetStore(options) {
+    const maxBytes = options.maxBytes ?? DEFAULT_STUDIO_MAX_BYTES;
+    if (!Number.isSafeInteger(maxBytes) || maxBytes < 1 || maxBytes > DEFAULT_STUDIO_MAX_BYTES)
+        throw new StudioError('STUDIO_INPUT_INVALID');
+    const root = await prepareStudioRoot(options.outputDir);
+    const writer = await acquireStudioWriter(root);
+    const catalogPath = path.join(root.managedDir, 'catalog.json');
+    let catalog;
+    async function readCatalog() {
+        await assertStudioRoot(root);
+        let handle;
+        try {
+            await assertRegularFile(catalogPath);
+            handle = await open(catalogPath, 'r');
+        }
+        catch (error) {
+            if (hasFsCode(error, 'ENOENT'))
+                return undefined;
+            throw storageError(error);
+        }
+        try {
+            if ((await handle.stat()).size > MAX_CATALOG_BYTES)
+                throw new Error();
+            return validateStudioCatalog(JSON.parse(await handle.readFile('utf8')));
+        }
+        catch {
+            throw new StudioError('STUDIO_CATALOG_INVALID', 500);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    async function commit(next, initial = false) {
+        await assertStudioRoot(root);
+        validateStudioCatalog(next);
+        const text = JSON.stringify(next);
+        if (Buffer.byteLength(text) > MAX_CATALOG_BYTES)
+            throw new StudioError('STUDIO_CATALOG_INVALID', 500);
+        const temp = path.join(root.managedDir, `catalog.${randomUUID()}.tmp`);
+        const handle = await open(temp, 'wx', 0o600);
+        try {
+            await handle.writeFile(text);
+            await handle.sync();
+        }
+        finally {
+            await handle.close();
+        }
+        await options.faults?.beforeCatalogCommit?.();
+        await assertStudioRoot(root);
+        if (initial) {
+            await link(temp, catalogPath);
+            await unlink(temp);
+        }
+        else {
+            await assertRegularFile(catalogPath);
+            await rename(temp, catalogPath);
+        }
+    }
+    try {
+        const loaded = await readCatalog();
+        catalog = loaded ?? { schemaVersion: 1, revision: 0, assets: [] };
+        if (!loaded) {
+            // Do not turn a disappeared authority into an empty library.
+            const files = await readdir(root.assetsDir);
+            const managed = await readdir(root.managedDir);
+            if (files.length || managed.some(name => name.startsWith('catalog.')))
+                throw new StudioError('STUDIO_CATALOG_INVALID', 500);
+            await commit(catalog, true);
+        }
+    }
+    catch (error) {
+        await writer.release();
+        throw storageError(error);
+    }
+    let queue = Promise.resolve();
+    let closing = false;
+    let closed;
+    function commitSerial(action) {
+        const next = queue.then(action).catch(error => { throw storageError(error); });
+        queue = next.catch(() => { });
+        return next;
+    }
+    function ensureOpen() { if (closing)
+        throw new StudioError('STUDIO_STORAGE_CLOSED', 503); }
+    function serial(action) {
+        if (closing)
+            return Promise.reject(new StudioError('STUDIO_STORAGE_CLOSED', 503));
+        return commitSerial(action);
+    }
+    const saveAuthority = createSaveAuthority(root, commitSerial);
+    // Reconcile a surviving PENDING before exposing any cache or receipt. Never
+    // initialize a save journal just because an empty local library was opened.
+    try {
+        await saveAuthority.readIntegrity();
+    }
+    catch (error) {
+        if (!isSaveAuthorityError(error)) {
+            await writer.release();
+            throw error;
+        }
+    }
+    const integrity = createAssetIntegrityQueue(root, saveAuthority, { maxBytes, ...options.integrity });
+    const notChecked = () => ({ file: 'NOT_CHECKED', checkedAt: null, integrityCheck: 'IDLE' });
+    async function authority() {
+        const disk = await readCatalog();
+        if (!disk || JSON.stringify(disk) !== JSON.stringify(catalog))
+            throw new StudioError('STUDIO_CATALOG_INVALID', 500);
+    }
+    async function checkedAsset(asset) {
+        let handle;
+        try {
+            const file = await resolveStudioAssetPath(root, asset);
+            handle = await open(file, 'r');
+            if ((await handle.stat()).size !== asset.byteLength)
+                throw new Error();
+            const hash = createHash('sha256');
+            const buffer = Buffer.alloc(64 * 1024);
+            let position = 0;
+            while (position < asset.byteLength) {
+                const { bytesRead } = await handle.read(buffer, 0, Math.min(buffer.length, asset.byteLength - position), position);
+                if (!bytesRead)
+                    throw new Error();
+                hash.update(buffer.subarray(0, bytesRead));
+                position += bytesRead;
+            }
+            if (hash.digest('hex') !== asset.sha256)
+                throw new Error();
+            return handle;
+        }
+        catch (error) {
+            await handle?.close();
+            throw new StudioError('STUDIO_ASSET_CORRUPT', 409);
+        }
+    }
+    // Internal primitives are not queued: the public operation takes this root's
+    // one serial lease exactly once, including catalog -> canvas capture writes.
+    async function saveAsset(input, captureAsset) {
+        const name = displayNameSchema.safeParse(input.displayName);
+        if (!name.success || !Object.hasOwn(mediaExtensions, input.contentType))
+            throw new StudioError('STUDIO_INPUT_INVALID');
+        const expected = input.expectedByteLength;
+        if (expected !== undefined && (!Number.isSafeInteger(expected) || expected <= 0))
+            throw new StudioError('STUDIO_INPUT_INVALID');
+        if (expected !== undefined && expected > maxBytes)
+            throw new StudioError('STUDIO_MEDIA_TOO_LARGE', 413);
+        await authority();
+        const assetId = captureAsset?.assetId ?? randomUUID();
+        const temp = path.join(root.assetsDir, `${assetId}.tmp`);
+        const handle = await open(temp, 'wx', 0o600);
+        let byteLength = 0;
+        let prefix = Buffer.alloc(0);
+        const hash = createHash('sha256');
+        try {
+            for await (const chunk of input.stream) {
+                if (!(chunk instanceof Uint8Array))
+                    throw new StudioError('STUDIO_INPUT_INVALID');
+                byteLength += chunk.byteLength;
+                if (byteLength > maxBytes)
+                    throw new StudioError('STUDIO_MEDIA_TOO_LARGE', 413);
+                if (prefix.length < 4096)
+                    prefix = Buffer.concat([prefix, chunk.subarray(0, 4096 - prefix.length)]);
+                hash.update(chunk);
+                await handle.writeFile(chunk);
+            }
+            if (expected !== undefined && expected !== byteLength)
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            const mediaType = assertStudioMediaType(prefix, input.contentType);
+            await handle.sync();
+            const asset = { assetId, displayName: name.data, mediaType, relativePath: `assets/${assetId}.${mediaExtensions[mediaType]}`, byteLength, sha256: hash.digest('hex'), savedAt: captureAsset?.savedAt ?? new Date().toISOString(), ...(captureAsset?.directorCapture ? { directorCapture: captureAsset.directorCapture } : {}) };
+            if (captureAsset && (asset.sha256 !== captureAsset.sha256 || asset.byteLength !== captureAsset.byteLength))
+                throw new StudioError('STUDIO_CAPTURE_PNG_INVALID', 422);
+            await handle.close();
+            await assertStudioRoot(root);
+            // link is exclusive: unlike rename it cannot overwrite an existing result.
+            await link(temp, path.join(root.managedDir, asset.relativePath));
+            await unlink(temp);
+            await authority();
+            // Cache the same schema-canonical representation that readCatalog returns;
+            // adding optional provenance must not turn property order into corruption.
+            const next = validateStudioCatalog({ schemaVersion: 1, revision: catalog.revision + 1, assets: [...catalog.assets, asset] });
+            await commit(next);
+            catalog = next;
+            return structuredClone(asset);
+        }
+        finally {
+            await handle.close();
+        }
+    }
+    const canvasAuthority = createCanvasAuthority(root, async (ids, pendingAssets) => {
+        await authority();
+        if (ids.some(id => ![...catalog.assets, ...pendingAssets].some(asset => asset.assetId === id)))
+            throw new StudioError('STUDIO_ASSET_NOT_FOUND', 404);
+    }, async (next, previous, all, pendingAssets) => { await authority(); assertDirectorCanvas(next, previous, all, [...catalog.assets, ...pendingAssets]); });
+    return {
+        maxBytes,
+        canvases: serializeCanvasAuthority(canvasAuthority, serial),
+        directorCaptures: createDirectorCaptureStore({ canvas: canvasAuthority, maxBytes,
+            assets: async () => { await authority(); return structuredClone(catalog.assets); },
+            save: (asset, bytes) => saveAsset({ displayName: asset.displayName, contentType: asset.mediaType, expectedByteLength: asset.byteLength, stream: (async function* () { yield bytes; })() }, asset),
+            verify: async (asset) => { try {
+                const handle = await checkedAsset(asset);
+                await handle.close();
+                return 'READY';
+            }
+            catch {
+                try {
+                    await assertRegularFile(path.join(root.managedDir, asset.relativePath));
+                }
+                catch (error) {
+                    if (hasFsCode(error, 'ENOENT'))
+                        return 'MISSING';
+                }
+                return 'CORRUPT';
+            } },
+            faults: options.faults,
+        }, serial),
+        drafts: createDraftStore(root, serial),
+        runs: createRunJournal(root, serial),
+        saveAuthority: {
+            read: () => { ensureOpen(); return saveAuthority.read(); },
+            readIntegrity: () => { ensureOpen(); return saveAuthority.readIntegrity(); },
+            bind: digest => { ensureOpen(); return saveAuthority.bind(digest); },
+            accept: input => { ensureOpen(); return saveAuthority.accept(input); },
+            update: (...args) => { ensureOpen(); return saveAuthority.update(...args); },
+            advanceWorker: (...args) => { ensureOpen(); return saveAuthority.advanceWorker(...args); },
+            observeIntegrity: (...args) => { ensureOpen(); return saveAuthority.observeIntegrity(...args); },
+        },
+        integrity,
+        metadata: async (assetId) => {
+            const asset = await serial(async () => { validateStudioAssetId(assetId); await authority(); const found = catalog.assets.find(a => a.assetId === assetId); if (!found)
+                throw new StudioError('STUDIO_ASSET_NOT_FOUND', 404); return structuredClone(found); });
+            let fact;
+            try {
+                fact = await integrity.observe(asset);
+            }
+            catch (error) {
+                if (!isSaveAuthorityError(error))
+                    throw error;
+                fact = notChecked();
+            }
+            ensureOpen();
+            return { ...asset, integrity: fact };
+        },
+        list: async () => {
+            const snapshot = await serial(async () => {
+                await authority();
+                const recoveryIssues = [];
+                const registered = new Set(catalog.assets.map(a => path.basename(a.relativePath)));
+                for (const name of await readdir(root.assetsDir)) {
+                    if (!registered.has(name))
+                        recoveryIssues.push({ code: name.endsWith('.tmp') ? 'INCOMPLETE_FILE' : 'UNREGISTERED_ASSET', file: `assets/${name}` });
+                }
+                for (const name of await readdir(root.managedDir)) {
+                    if (/^catalog\..+\.tmp$/.test(name))
+                        recoveryIssues.push({ code: 'INCOMPLETE_FILE', file: name });
+                }
+                return { revision: catalog.revision, assets: structuredClone(catalog.assets), recoveryIssues };
+            });
+            let facts;
+            try {
+                facts = await integrity.cached(snapshot.assets.map(a => a.assetId));
+            }
+            catch (error) {
+                if (!isSaveAuthorityError(error))
+                    throw error;
+                facts = new Map(snapshot.assets.map(a => [a.assetId, notChecked()]));
+            }
+            ensureOpen();
+            const assets = snapshot.assets.map(asset => ({ ...asset, integrity: facts.get(asset.assetId) }));
+            for (const asset of assets) {
+                if (['MISSING', 'MODIFIED', 'UNSAFE', 'UNKNOWN'].includes(asset.integrity.file))
+                    snapshot.recoveryIssues.push({ code: asset.integrity.file === 'MISSING' ? 'ASSET_MISSING' : 'ASSET_CORRUPT', file: asset.relativePath });
+            }
+            return { ...snapshot, assets };
+        },
+        save: input => serial(() => saveAsset(input)),
+        // Internal only: the worker must prove ownership and persist its transport
+        // metadata before calling. Never accepts an arbitrary browser file path.
+        registerExistingManagedFile: input => serial(async () => {
+            const asset = validateStudioCatalog({ schemaVersion: 1, revision: 0, assets: [input] }).assets[0];
+            if (asset.directorCapture || asset.byteLength > Math.min(maxBytes, 128 * 1024 * 1024))
+                throw new StudioError('STUDIO_INPUT_INVALID');
+            await authority();
+            const file = await resolveStudioAssetPath(root, asset);
+            const handle = await open(file, 'r');
+            try {
+                const before = await handle.stat();
+                if (!before.isFile() || before.nlink !== 1 || before.size !== asset.byteLength)
+                    throw new StudioError('STUDIO_ASSET_CORRUPT', 409);
+                const prefix = Buffer.alloc(Math.min(4096, asset.byteLength));
+                await handle.read(prefix, 0, prefix.length, 0);
+                assertStudioMediaType(prefix, asset.mediaType);
+                await assertStudioRoot(root);
+                await assertRegularFile(file);
+                const after = await handle.stat();
+                const named = await lstat(file);
+                if (after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ino !== named.ino || after.dev !== named.dev || after.nlink !== 1)
+                    throw new StudioError('STUDIO_ASSET_CORRUPT', 409);
+                const existing = catalog.assets.find(a => a.assetId === asset.assetId);
+                if (existing) {
+                    if (JSON.stringify(existing) !== JSON.stringify(asset))
+                        throw new StudioError('STUDIO_CATALOG_INVALID', 409);
+                    return structuredClone(existing);
+                }
+                await authority();
+                const next = validateStudioCatalog({ ...catalog, revision: catalog.revision + 1, assets: [...catalog.assets, asset] });
+                await commit(next);
+                catalog = next;
+                return structuredClone(asset);
+            }
+            finally {
+                await handle.close();
+            }
+        }),
+        read: assetId => serial(async () => {
+            validateStudioAssetId(assetId);
+            await authority();
+            const asset = catalog.assets.find(a => a.assetId === assetId);
+            if (!asset)
+                throw new StudioError('STUDIO_ASSET_NOT_FOUND', 404);
+            const handle = await checkedAsset(asset);
+            return { asset: structuredClone(asset), stream: handle.createReadStream({ start: 0, autoClose: true }) };
+        }),
+        close() {
+            closing = true;
+            return closed ??= (async () => { try {
+                await integrity.close();
+            }
+            finally {
+                await queue;
+                await writer.release();
+            } })();
+        },
+    };
+}
+//# sourceMappingURL=asset-store.js.map