arcane-os 0.69.0 → 0.70.0

package/browser-runtime/ai/dbopfs-model-parts.mjs

@@ -0,0 +1,344 @@
+import Is from '../dependencies/strong-type/index.js';
+
+const is = new Is(false);
+const owners = new WeakMap();
+// Physical OPFS framing only; every input chunk is written in full. This is
+// neither a model limit nor public progress, and avoids a file per network read.
+const PART_FRAME = 8 * 1024 * 1024;
+
+export function withDbopfsModelLock(dbopfs, tableName, name, operation, {signal} = {}) {
+    let tables = owners.get(dbopfs);
+    if (!tables) owners.set(dbopfs, tables = new Map());
+    let entries = tables.get(tableName);
+    if (!entries) tables.set(tableName, entries = new Map());
+    const preceding = entries.get(name) ?? Promise.resolve();
+    let acquired = false;
+    function runOwnedOperation() {
+        throwIfModelAborted(signal);
+        acquired = true;
+        return operation();
+    }
+    async function acquireStorageOwner() {
+        throwIfModelAborted(signal);
+        if (dbopfs.readyPromise) await dbopfs.readyPromise;
+        throwIfModelAborted(signal);
+        const locks = dbopfs.lockManager ?? globalThis.navigator?.locks;
+        if (!is.function(locks?.request)) return runOwnedOperation();
+        const lockName = `arcane-model-storage:${JSON.stringify([dbopfs.storagePath ?? '', tableName, name])}`;
+        return locks.request(lockName, signal ? {mode: 'exclusive', signal} : {mode: 'exclusive'}, runOwnedOperation);
+    }
+    const current = preceding.then(acquireStorageOwner, acquireStorageOwner);
+    entries.set(name, current);
+    function releaseOwner() {
+        if (entries.get(name) === current) entries.delete(name);
+        if (entries.size === 0) tables.delete(tableName);
+    }
+    current.then(releaseOwner, releaseOwner);
+    if (!signal) return current;
+    // A cancelled waiter can leave promptly, while its inert queue link stays
+    // behind the preceding owner. Once acquired, durable cleanup must settle.
+    return new Promise(function observeStorageWait(resolve, reject) {
+        function cancelWait() {
+            if (!acquired) {
+                try {
+                    throwIfModelAborted(signal);
+                } catch (error) {
+                    reject(error);
+                }
+            }
+        }
+        signal.addEventListener('abort', cancelWait, {once: true});
+        if (signal.aborted) cancelWait();
+        current.then(function ownedOperationFinished(value) {
+            signal.removeEventListener('abort', cancelWait);
+            resolve(value);
+        }, function ownedOperationFailed(error) {
+            signal.removeEventListener('abort', cancelWait);
+            reject(error);
+        });
+    });
+}
+
+export function throwIfModelAborted(signal) {
+    if (signal?.aborted) {
+        throw signal.reason ?? new DOMException('The model resource operation was cancelled.', 'AbortError');
+    }
+}
+
+function missingFile(error) {
+    return error?.name === 'NotFoundError' || error?.code === 'ENOENT';
+}
+
+/** Own the reader until its cancellation and pending read have settled. */
+export async function* readModelChunks(body, signal) {
+    throwIfModelAborted(signal);
+    if (body === null || body === undefined) return;
+    if (is.function(body.stream)) body = body.stream();
+    if (!is.function(body.getReader)) {
+        if (body instanceof ArrayBuffer || ArrayBuffer.isView(body) || is.string(body)) {
+            body = new Blob([body]).stream();
+        } else {
+            for await (const chunk of body) {
+                throwIfModelAborted(signal);
+                yield chunk;
+            }
+            throwIfModelAborted(signal);
+            return;
+        }
+    }
+    const reader = body.getReader();
+    let ended = false;
+    let cancellation;
+    function cancelReader() {
+        cancellation ??= Promise.resolve(reader.cancel(signal?.reason));
+        // Observe immediately; cleanup below retains and reports any failure.
+        cancellation.catch(function observeCancellation() {});
+    }
+    signal?.addEventListener('abort', cancelReader, {once: true});
+    try {
+        if (signal?.aborted) cancelReader();
+        while (true) {
+            throwIfModelAborted(signal);
+            const {value, done} = await reader.read();
+            throwIfModelAborted(signal);
+            if (done) {
+                ended = true;
+                return;
+            }
+            yield value;
+        }
+    } finally {
+        signal?.removeEventListener('abort', cancelReader);
+        try {
+            if (!ended) cancelReader();
+            await cancellation;
+        } finally {
+            reader.releaseLock();
+        }
+    }
+}
+
+/** Shared private storage for complete resources and resumable closed parts. */
+export function createDbopfsModelPartStore({dbopfs, tableName}) {
+    let directoryPromise;
+    async function directory() {
+        if (dbopfs.readyPromise) await dbopfs.readyPromise;
+        directoryPromise ??= Promise.resolve(dbopfs.getTableHandle(tableName));
+        return directoryPromise;
+    }
+    async function file(name) {
+        try {
+            const handle = await (await directory()).getFileHandle(name, {create: false});
+            return await handle.getFile();
+        } catch (error) {
+            if (missingFile(error)) return null;
+            throw error;
+        }
+    }
+    async function removeFile(name) {
+        try {
+            await (await directory()).removeEntry(name);
+            return true;
+        } catch (error) {
+            if (missingFile(error)) return false;
+            throw error;
+        }
+    }
+    function manifestName(name) {
+        return `${name}.arcane-parts.json`;
+    }
+    async function readState(name) {
+        const record = await file(manifestName(name));
+        return record ? JSON.parse(await record.text()) : null;
+    }
+    async function saveState(name, record) {
+        const target = manifestName(name);
+        const existing = await file(target);
+        let writer;
+        try {
+            const handle = await (await directory()).getFileHandle(target, {create: true});
+            writer = await handle.createWritable();
+            await writer.write(JSON.stringify(record));
+            await writer.close();
+        } catch (error) {
+            const failures = [error];
+            try {
+                await writer?.abort(error);
+            } catch (cleanupError) {
+                failures.push(cleanupError);
+            }
+            if (!existing) {
+                try {
+                    await removeFile(target);
+                } catch (cleanupError) {
+                    failures.push(cleanupError);
+                }
+            }
+            if (failures.length > 1) throw new AggregateError(failures, 'Unable to settle the model part index.');
+            throw error;
+        }
+    }
+    async function assemble(record, signal) {
+        const parts = [];
+        for (const name of record.parts) {
+            throwIfModelAborted(signal);
+            const part = await file(name);
+            if (!part) return null;
+            parts.push(part);
+        }
+        throwIfModelAborted(signal);
+        return new Blob(parts);
+    }
+    async function clear(name, signal) {
+        throwIfModelAborted(signal);
+        const record = await readState(name);
+        if (!record) return false;
+        for (const part of record.parts) {
+            throwIfModelAborted(signal);
+            await removeFile(part);
+        }
+        await removeFile(manifestName(name));
+        return true;
+    }
+    function locked(name, operation, signal) {
+        return withDbopfsModelLock(dbopfs, tableName, `parts:${name}`, operation, {signal});
+    }
+    function state(name, {signal} = {}) {
+        return locked(name, async function readModelPartState() {
+            throwIfModelAborted(signal);
+            return readState(name);
+        }, signal);
+    }
+    function read(name, {signal} = {}) {
+        return locked(name, async function readCompleteModelParts() {
+            throwIfModelAborted(signal);
+            const record = await readState(name);
+            return record?.complete ? assemble(record, signal) : null;
+        }, signal);
+    }
+    function readPartial(name, {signal} = {}) {
+        return locked(name, async function readClosedModelParts() {
+            throwIfModelAborted(signal);
+            const record = await readState(name);
+            return record ? assemble(record, signal) : null;
+        }, signal);
+    }
+    function remove(name, {signal} = {}) {
+        return locked(name, async function removeModelParts() {
+            return clear(name, signal);
+        }, signal);
+    }
+    function write(name, body, {signal, onProgress, append = false} = {}) {
+        return locked(name, async function writeModelParts() {
+            throwIfModelAborted(signal);
+            let record = append ? await readState(name) : null;
+            if (!record) {
+                await clear(name, signal);
+                record = {parts: [], complete: false};
+            } else {
+                record.complete = false;
+            }
+            await saveState(name, record);
+            let writer = null;
+            let openName;
+            let framed = 0;
+            function report(complete = false) {
+                onProgress?.({phase: 'download', completed: record.parts.length,
+                    total: complete ? record.parts.length : null, unit: 'shards'});
+            }
+            async function closePart() {
+                await writer.close();
+                writer = null;
+                record.parts.push(openName);
+                await saveState(name, record);
+                framed = 0;
+                report();
+            }
+            try {
+                report();
+                for await (const value of readModelChunks(body, signal)) {
+                    let chunk;
+                    if (is.string(value)) chunk = new TextEncoder().encode(value);
+                    else if (value instanceof ArrayBuffer) chunk = new Uint8Array(value);
+                    else if (ArrayBuffer.isView(value)) {
+                        chunk = new Uint8Array(value.buffer, value.byteOffset, value.byteLength);
+                    } else {
+                        throw new TypeError('Model stream chunks must be strings, ArrayBuffers or typed arrays.');
+                    }
+                    let offset = 0;
+                    while (offset < chunk.byteLength) {
+                        throwIfModelAborted(signal);
+                        if (!writer) {
+                            openName = `${name}.arcane-part-${record.parts.length}`;
+                            const handle = await (await directory()).getFileHandle(openName, {create: true});
+                            writer = await handle.createWritable();
+                        }
+                        const end = Math.min(chunk.byteLength, offset + PART_FRAME - framed);
+                        await writer.write(chunk.subarray(offset, end));
+                        framed += end - offset;
+                        offset = end;
+                        if (framed === PART_FRAME) await closePart();
+                    }
+                }
+                throwIfModelAborted(signal);
+                if (writer) await closePart();
+                throwIfModelAborted(signal);
+                record.complete = true;
+                await saveState(name, record);
+                report(true);
+                return await assemble(record, signal);
+            } catch (error) {
+                if (writer) {
+                    const failures = [error];
+                    try {
+                        await writer.abort(error);
+                    } catch (cleanupError) {
+                        failures.push(cleanupError);
+                    }
+                    try {
+                        await removeFile(openName);
+                    } catch (cleanupError) {
+                        failures.push(cleanupError);
+                    }
+                    if (failures.length > 1) {
+                        throw new AggregateError(failures, 'Unable to settle the interrupted model part.');
+                    }
+                }
+                throw error;
+            }
+        }, signal);
+    }
+    // The HTTP Range owner already selected one physical part and owns its
+    // protocol framing. Keep its established filename and complete-file reads.
+    function writePart(name, body, {signal} = {}) {
+        return locked(name, async function writeNamedModelPart() {
+            throwIfModelAborted(signal);
+            const handle = await (await directory()).getFileHandle(name, {create: true});
+            const writer = await handle.createWritable();
+            let closed = false;
+            try {
+                for await (const chunk of readModelChunks(body, signal)) await writer.write(chunk);
+                throwIfModelAborted(signal);
+                await writer.close();
+                closed = true;
+                return await handle.getFile();
+            } catch (error) {
+                if (closed) throw error;
+                const failures = [error];
+                try {
+                    await writer.abort(error);
+                } catch (cleanupError) {
+                    failures.push(cleanupError);
+                }
+                try {
+                    await removeFile(name);
+                } catch (cleanupError) {
+                    failures.push(cleanupError);
+                }
+                if (failures.length > 1) throw new AggregateError(failures, 'Unable to settle the model range part.');
+                throw error;
+            }
+        }, signal);
+    }
+    return {read, write, remove, state, readPartial, writePart};
+}

package/browser-runtime/ai/dbopfs-model-resources.mjs

@@ -0,0 +1,190 @@
+import {createDbopfsModelPartStore, readModelChunks, throwIfModelAborted, withDbopfsModelLock} from './dbopfs-model-parts.mjs';
+
+const INDEX_NAME = 'arcane-model-resources.json';
+
+/** URL/request semantics identify resources; OPFS names are ordinary index IDs. */
+export function createDbopfsResourceStore({dbopfs, tableName, fetchImpl = globalThis.fetch?.bind(globalThis)}) {
+    const parts = createDbopfsModelPartStore({dbopfs, tableName});
+    // Credential-bearing request selection stays transient. Its durable entry
+    // has an ordinary index name and response metadata, never request headers.
+    const privateEntries = new Map();
+    let directoryPromise;
+    async function directory() {
+        if (dbopfs.readyPromise) await dbopfs.readyPromise;
+        directoryPromise ??= Promise.resolve(dbopfs.getTableHandle(tableName));
+        return directoryPromise;
+    }
+    async function readIndex() {
+        try {
+            const handle = await (await directory()).getFileHandle(INDEX_NAME, {create: false});
+            return JSON.parse(await (await handle.getFile()).text());
+        } catch (error) {
+            if (error?.name === 'NotFoundError' || error?.code === 'ENOENT') return {entries: []};
+            throw error;
+        }
+    }
+    async function writeIndex(index) {
+        const table = await directory();
+        let existing;
+        try {
+            existing = await table.getFileHandle(INDEX_NAME, {create: false});
+        } catch (error) {
+            if (error?.name !== 'NotFoundError' && error?.code !== 'ENOENT') throw error;
+        }
+        let writer;
+        try {
+            const handle = existing ?? await table.getFileHandle(INDEX_NAME, {create: true});
+            writer = await handle.createWritable();
+            await writer.write(JSON.stringify(index));
+            await writer.close();
+        } catch (error) {
+            const failures = [error];
+            try {
+                await writer?.abort(error);
+            } catch (cleanupError) {
+                failures.push(cleanupError);
+            }
+            if (!existing) {
+                try {
+                    await table.removeEntry(INDEX_NAME);
+                } catch (cleanupError) {
+                    if (cleanupError?.name !== 'NotFoundError' && cleanupError?.code !== 'ENOENT') failures.push(cleanupError);
+                }
+            }
+            if (failures.length > 1) throw new AggregateError(failures, 'Unable to settle the model resource index.');
+            throw error;
+        }
+    }
+    function entryFor(key, metadata, privateRequest, signal) {
+        return withDbopfsModelLock(dbopfs, tableName, 'resource-index', async function updateResourceIndex() {
+            const index = await readIndex();
+            let entry = index.entries.find(function sameResource(candidate) {
+                return privateRequest ? candidate.name === privateEntries.get(key) : candidate.key === key;
+            });
+            let changed = false;
+            if (!entry) {
+                entry = {name: `arcane-resource-${index.entries.length}`};
+                if (!privateRequest) entry.key = key;
+                index.entries.push(entry);
+                changed = true;
+            }
+            if (metadata !== undefined) {
+                entry.metadata = metadata;
+                changed = true;
+            }
+            if (changed) await writeIndex(index);
+            if (privateRequest) privateEntries.set(key, entry.name);
+            return entry;
+        }, {signal});
+    }
+    async function fetchResource(input, {onProgress, ...options} = {}) {
+        const request = new Request(input, options);
+        const signal = request.signal;
+        const key = JSON.stringify([request.method, request.url, request.credentials, [...request.headers]]);
+        const privateRequest = request.headers.has('authorization') || request.headers.has('cookie');
+        function reportResourceProgress(progress) {
+            onProgress?.({...progress, url: request.url});
+        }
+        throwIfModelAborted(signal);
+        const selected = await entryFor(key, undefined, privateRequest, signal);
+        return withDbopfsModelLock(dbopfs, tableName, `resource:${selected.name}`, async function fetchStoredResource() {
+            throwIfModelAborted(signal);
+            const entry = await entryFor(key, undefined, privateRequest, signal);
+            const reusable = request.method === 'GET' && !request.headers.has('range')
+                && !['reload', 'no-cache', 'no-store'].includes(request.cache);
+            if (reusable && entry.metadata?.status === 200) {
+                const file = await parts.read(entry.name, {signal});
+                if (file) {
+                    const state = await parts.state(entry.name, {signal});
+                    onProgress?.({phase: 'download', completed: state.parts.length,
+                        total: state.parts.length, unit: 'shards', cached: true, url: request.url});
+                    return {...entry.metadata, file};
+                }
+            }
+            let response;
+            let append = false;
+            let metadata;
+            let remaining;
+            // Offset/Content-Range exist only at the HTTP resume boundary, never
+            // in resource identity, model admission, or application progress.
+            const previousHeaders = new Headers(entry.metadata?.headers);
+            const encoding = previousHeaders.get('content-encoding');
+            const partial = reusable && entry.metadata?.status === 200
+                && (!encoding || encoding === 'identity')
+                ? await parts.readPartial(entry.name, {signal}) : null;
+            try {
+                if (partial?.size) {
+                    const headers = new Headers(request.headers);
+                    headers.set('Range', `bytes=${partial.size}-`);
+                    const validator = previousHeaders.get('etag') ?? previousHeaders.get('last-modified');
+                    if (validator) headers.set('If-Range', validator);
+                    response = await fetchImpl(new Request(request, {headers}));
+                    const range = /^bytes (\d+)-(\d+)\/(\d+)$/u.exec(response.headers.get('content-range') ?? '');
+                    if (response.status === 206 && range && Number(range[1]) === partial.size
+                        && Number(range[2]) >= Number(range[1])
+                        && Number(range[2]) + 1 === Number(range[3])) {
+                        append = true;
+                        remaining = Number(range[2]) - Number(range[1]) + 1;
+                        // The completed response is the original full resource,
+                        // not the resumed transport fragment delivered as a 206.
+                        metadata = {...entry.metadata};
+                    } else if (response.status === 206 || response.status === 416) {
+                        await response.body?.cancel();
+                        response = undefined;
+                    }
+                }
+                response ??= await fetchImpl(request);
+                throwIfModelAborted(signal);
+                metadata ??= {
+                    status: response.status,
+                    statusText: response.statusText,
+                    headers: [...response.headers],
+                    url: response.url || request.url,
+                    redirected: response.redirected
+                };
+                if (!response.ok) {
+                    // A transient server error must not erase a resumable model.
+                    // Keep its complete response separate and preserve its status.
+                    const file = await parts.write(`${entry.name}.response`, response.body, {
+                        signal, onProgress: reportResourceProgress
+                    });
+                    return {...metadata, file};
+                }
+                if (!append) await parts.remove(entry.name, {signal});
+                await entryFor(key, metadata, privateRequest, signal);
+                let body = response.body;
+                if (append) {
+                    const responseBody = body;
+                    async function* resumedResponse() {
+                        let received = 0;
+                        for await (const chunk of readModelChunks(responseBody, signal)) {
+                            received += chunk.byteLength;
+                            if (received > remaining) throw new Error('The model server exceeded its HTTP Content-Range.');
+                            yield chunk;
+                        }
+                        if (received !== remaining) throw new Error('The model server ended before its HTTP Content-Range.');
+                    }
+                    body = resumedResponse();
+                }
+                const file = await parts.write(entry.name, body, {
+                    signal,
+                    append,
+                    onProgress: reportResourceProgress
+                });
+                return {...metadata, file};
+            } catch (error) {
+                if (response?.body && !response.body.locked) {
+                    try {
+                        await response.body.cancel(error);
+                    } catch (cleanupError) {
+                        if (cleanupError !== error) {
+                            throw new AggregateError([error, cleanupError], 'Unable to settle the model resource response.');
+                        }
+                    }
+                }
+                throw error;
+            }
+        }, {signal});
+    }
+    return {fetchResource};
+}

package/browser-runtime/ai/decision-runtime.mjs

@@ -195,13 +195,29 @@ export function decodeDecisionOutputs(rows, outputs) {
     return {decisions, outputs};
 }
 
-export async function loadDecisionRuntime(configuration, report) {
+export async function loadDecisionRuntime(configuration, report, resourceFetch = null) {
     const {family, model: repository, revision = 'main', device = 'webgpu',
         dtype = family === 'laya' ? 'fp16' : 'fp32', runtime} = configuration;
     report(
         {phase: 'loading-runtime'}
     );
     const namespace = await import(runtime.moduleUrl);
+    if (resourceFetch) {
+        // Dedicated Worker environment: all actual tokenizer/config/graph and
+        // external-data requests use the selected SDK store. A cache hook alone
+        // can be caught and ignored by the upstream loader.
+        namespace.env.fetch = function fetchDecisionResource(input, options) {
+            return resourceFetch(input, {
+                ...options,
+                onProgress: function reportDecisionResource(progress) {
+                    report(progress);
+                }
+            });
+        };
+        namespace.env.useBrowserCache = false;
+        namespace.env.useCustomCache = false;
+        namespace.env.useFSCache = false;
+    }
     if (runtime.wasmPaths !== undefined) {
         namespace.env.backends.onnx.wasm.wasmPaths = runtime.wasmPaths;
     }

package/browser-runtime/ai/decision-worker.mjs

@@ -1,8 +1,17 @@
 import Is from '../dependencies/strong-type/index.js';
 import {loadDecisionRuntime} from './decision-runtime.mjs';
+import {createModelResourceClient} from './model-resource-bridge.mjs';
 
 const is = new Is(false);
 let engine;
+const nativeFetch = globalThis.fetch.bind(globalThis);
+const resources = createModelResourceClient(
+    {
+        send: function sendModelResource(message) {
+            globalThis.postMessage(message);
+        }
+    }
+);
 
 function errorRecord(error, seen = new Map()) {
     if (!is.error(error)) return error;
@@ -26,16 +35,27 @@ function errorRecord(error, seen = new Map()) {
 }
 
 async function handleDecisionOperation(event) {
+    if (resources.receive(event.data)) return;
     const {id, op, payload} = event.data;
     try {
         if (op === 'load') {
+            if (event.data.storedResources) {
+                // Cover native ONNX support-file fetches as well as env.fetch.
+                // Native module imports remain the browser module loader's job.
+                globalThis.fetch = function fetchDecisionSupport(input, options) {
+                    const url = new URL(is.string(input) ? input : input.url ?? input.href, globalThis.location.href);
+                    if (url.protocol === 'blob:' || url.protocol === 'data:') return nativeFetch(input, options);
+                    return resources.fetch(input, options);
+                };
+            }
             engine = await loadDecisionRuntime(
                 payload,
                 function reportDecisionProgress(progress) {
                     globalThis.postMessage(
                         {id, progress}
                     );
-                }
+                },
+                event.data.storedResources ? resources.fetch : null
             );
             globalThis.postMessage(
                 {id, result: {loaded: true}}