@mearl/preset 0.0.0-stage → 3.0.0-beta.1

package/dist/bundleStore.js

@@ -0,0 +1,478 @@
+import { BundleError, MAX_BUNDLE_BYTES, MAX_BROWSER_STORAGE_BYTES, MAX_PAGE_RUNTIME_BYTES, bundleDigest, verifyBundle } from './bundle.js';
+import { verifyBrowserPreset, verifyPreparedBrowserPreset } from './browserPreset.js';
+import { mergePresetDefaults } from './resolve.js';
+function installationMetadata(value) {
+    if (!value || Object.keys(value).some(key => !['revision', 'browserRevision', 'overrides'].includes(key)) || !/^[a-f0-9]{64}$/.test(value.revision) || !/^[a-f0-9]{64}$/.test(value.browserRevision))
+        throw new BundleError('BUNDLE_INVALID', 'Invalid browser installation identity');
+    const overrides = mergePresetDefaults({}, value.overrides);
+    if (new TextEncoder().encode(JSON.stringify(overrides)).byteLength > 262144)
+        throw new BundleError('BUNDLE_QUOTA', 'Browser user overrides exceed 256 KiB');
+    return { revision: value.revision, browserRevision: value.browserRevision, overrides };
+}
+const STORE = 'bundles';
+const PRESET = 'preset';
+const RUNTIMES = 'pageRuntimes';
+const PINS = 'pageRuntimePins';
+function captureRevisions(input) {
+    if (input === undefined)
+        return;
+    const entries = Object.entries(input);
+    if (entries.length > 64 || entries.some(([id, revision]) => !/^[a-z][a-z0-9-]{0,79}$/.test(id) || typeof revision !== 'string'))
+        throw new BundleError('BUNDLE_INVALID', 'Invalid expected browser bundle selection');
+    return Object.fromEntries(entries);
+}
+function checkRevisions(records, expected) {
+    if (expected && (records.length !== Object.keys(expected).length || records.some(record => !Object.hasOwn(expected, record.id) || expected[record.id] !== record.revision)))
+        throw new BundleError('BUNDLE_CONFLICT', 'Browser bundles changed while contributions were being validated');
+}
+function runtimePaths(bundle) {
+    return [...new Set([
+            ...Object.values(bundle?.manifest?.contributions?.pageRuntimes ?? {}),
+            ...Object.values(bundle?.manifest?.contributions?.browserRuntimes ?? {}).map(runtime => runtime?.entry),
+        ].filter((name) => typeof name === 'string'))];
+}
+function referencedRuntimes(records, runtimes, pins) {
+    const referenced = new Set(pins.map(pin => pin.sha256));
+    for (const record of records)
+        for (const name of runtimePaths(record.bundle)) {
+            const digest = record.bundle?.manifest?.resources?.[name]?.sha256;
+            if (digest)
+                referenced.add(digest);
+        }
+    return runtimes.filter(runtime => referenced.has(runtime.sha256));
+}
+function runtimeResources(bundles) {
+    const result = new Map();
+    for (const bundle of bundles)
+        for (const name of runtimePaths(bundle)) {
+            const resource = bundle?.manifest?.resources?.[name], bytes = bundle?.resources?.[name];
+            if (resource && typeof resource.sha256 === 'string' && /^[a-f0-9]{64}$/.test(resource.sha256) && bytes instanceof Uint8Array && bytes.byteLength === resource.byteLength)
+                result.set(resource.sha256, { sha256: resource.sha256, bytes });
+        }
+    return [...result.values()];
+}
+function checkStorageBudget(records, runtimes) {
+    if (records.some(record => !Number.isSafeInteger(record.byteLength) || record.byteLength < 0 || record.byteLength > MAX_BUNDLE_BYTES) ||
+        runtimes.some(runtime => !(runtime.bytes instanceof Uint8Array) || runtime.bytes.byteLength > MAX_BUNDLE_BYTES)) {
+        throw new BundleError('BUNDLE_INTEGRITY', 'Stored resource size is invalid');
+    }
+    const retained = runtimes.reduce((sum, runtime) => sum + runtime.bytes.byteLength, 0);
+    const total = records.reduce((sum, record) => sum + record.byteLength, retained);
+    if (records.length > 64 || !Number.isSafeInteger(total) || total > MAX_BROWSER_STORAGE_BYTES)
+        throw new BundleError('BUNDLE_QUOTA', 'Installed and retained resources exceed the browser storage budget');
+}
+export class BrowserBundleStore {
+    options;
+    database;
+    constructor(options) {
+        this.options = options;
+    }
+    open() {
+        if (this.database)
+            return this.database;
+        this.database = new Promise((resolve, reject) => {
+            const request = (this.options.indexedDB ?? indexedDB).open(this.options.databaseName ?? 'mearl-capability-bundles', 4);
+            request.onupgradeneeded = () => {
+                if (!request.result.objectStoreNames.contains(STORE))
+                    request.result.createObjectStore(STORE, { keyPath: 'id' });
+                if (!request.result.objectStoreNames.contains(PRESET))
+                    request.result.createObjectStore(PRESET);
+                if (!request.result.objectStoreNames.contains(RUNTIMES))
+                    request.result.createObjectStore(RUNTIMES, { keyPath: 'sha256' });
+                if (!request.result.objectStoreNames.contains(PINS))
+                    request.result.createObjectStore(PINS, { keyPath: 'owner' });
+            };
+            request.onerror = () => reject(request.error);
+            request.onsuccess = () => {
+                const database = request.result;
+                database.onversionchange = () => { database.close(); this.database = undefined; };
+                resolve(database);
+            };
+        }).catch(error => { this.database = undefined; throw error; });
+        return this.database;
+    }
+    async close() {
+        const current = this.database;
+        this.database = undefined;
+        if (current)
+            (await current).close();
+    }
+    async records() {
+        const database = await this.open();
+        return new Promise((resolve, reject) => {
+            const transaction = database.transaction([STORE, PRESET], 'readonly');
+            const request = transaction.objectStore(STORE).getAll();
+            const active = transaction.objectStore(PRESET).get('active');
+            const installation = transaction.objectStore(PRESET).get('installation');
+            const token = transaction.objectStore(PRESET).get('installationToken');
+            transaction.oncomplete = () => resolve({ records: request.result, active: active.result, installation: installation.result, installationToken: token.result ?? null });
+            transaction.onabort = transaction.onerror = () => reject(transaction.error ?? new Error('Bundle read failed'));
+        });
+    }
+    async get(id) {
+        const database = await this.open();
+        const record = await new Promise((resolve, reject) => {
+            const transaction = database.transaction(STORE, 'readonly');
+            const request = transaction.objectStore(STORE).get(id);
+            transaction.oncomplete = () => resolve(request.result);
+            transaction.onabort = transaction.onerror = () => reject(transaction.error ?? new Error('Bundle read failed'));
+        });
+        return record ? this.verified(record) : undefined;
+    }
+    async verified(record) {
+        if (record.id !== record.bundle?.manifest?.id || record.revision !== record.bundle?.revision) {
+            throw new BundleError('BUNDLE_INTEGRITY', 'Stored bundle identity does not match');
+        }
+        const bundle = await verifyBundle(record.bundle, this.options.mearlApiVersion);
+        if (Object.values(bundle.resources).reduce((sum, bytes) => sum + bytes.byteLength, 0) !== record.byteLength) {
+            throw new BundleError('BUNDLE_INTEGRITY', 'Stored resource size does not match');
+        }
+        return bundle;
+    }
+    async list() {
+        const bundles = [];
+        const errors = [];
+        const { records, active, installation: storedInstallation, installationToken } = await this.records();
+        for (const record of records) {
+            try {
+                bundles.push(await this.verified(record));
+            }
+            catch (error) {
+                errors.push({ id: record.id, error: error instanceof Error ? error.message : 'Invalid stored bundle' });
+            }
+        }
+        let activation;
+        let activationError;
+        let installation;
+        let installationError;
+        if (active) {
+            try {
+                activation = await verifyBrowserPreset(active, this.options.mearlApiVersion);
+            }
+            catch (error) {
+                activation = undefined;
+                activationError = error instanceof Error ? error.message : 'Invalid active preset';
+            }
+            if (activation) {
+                for (const [id, revision] of Object.entries(activation.snapshot.bundleRevisions)) {
+                    if (!bundles.some(bundle => bundle.manifest.id === id && bundle.revision === revision) && !errors.some(error => error.id === id)) {
+                        errors.push({ id, error: 'BUNDLE_INTEGRITY: An active preset package is missing or corrupt' });
+                    }
+                }
+            }
+        }
+        if (storedInstallation !== undefined) {
+            try {
+                installation = installationMetadata(storedInstallation);
+                if (!activation || installation.browserRevision !== activation.snapshot.revision)
+                    throw new BundleError('BUNDLE_INTEGRITY', 'Browser installation does not match its active preset');
+            }
+            catch (error) {
+                installation = undefined;
+                installationError = error instanceof Error ? error.message : 'Invalid browser installation';
+            }
+        }
+        return { bundles, errors, activation, activationError, installation, installationError, installationToken, activeRevision: active?.revision ?? null,
+            revisions: Object.fromEntries(records.map(record => [record.id, record.revision])) };
+    }
+    async activePreset() {
+        const database = await this.open();
+        const active = await new Promise((resolve, reject) => {
+            const transaction = database.transaction(PRESET, 'readonly');
+            const request = transaction.objectStore(PRESET).get('active');
+            transaction.oncomplete = () => resolve(request.result);
+            transaction.onabort = transaction.onerror = () => reject(transaction.error ?? new Error('Preset read failed'));
+        });
+        return active ? verifyBrowserPreset(active, this.options.mearlApiVersion) : undefined;
+    }
+    /** Verified browser modules remain addressable while a bound document retains them. */
+    async browserRuntimeBytes(sha256) {
+        if (!/^[a-f0-9]{64}$/.test(sha256))
+            throw new BundleError('BUNDLE_INVALID', 'Invalid browser runtime digest');
+        const database = await this.open();
+        const record = await new Promise((resolve, reject) => {
+            const transaction = database.transaction(RUNTIMES, 'readonly');
+            const request = transaction.objectStore(RUNTIMES).get(sha256);
+            transaction.oncomplete = () => resolve(request.result);
+            transaction.onabort = transaction.onerror = () => reject(transaction.error ?? new Error('Browser runtime read failed'));
+        });
+        if (!(record?.bytes instanceof Uint8Array) || record.sha256 !== sha256 || record.bytes.byteLength > MAX_BUNDLE_BYTES || await bundleDigest(record.bytes) !== sha256) {
+            throw new BundleError('BUNDLE_INTEGRITY', 'Pinned browser runtime is missing or corrupt');
+        }
+        return Uint8Array.from(record.bytes);
+    }
+    /** Content-addressed code survives package updates so pinned documents can still navigate. */
+    async pageRuntimeSource(sha256) {
+        const bytes = await this.browserRuntimeBytes(sha256);
+        if (bytes.byteLength > MAX_PAGE_RUNTIME_BYTES)
+            throw new BundleError('BUNDLE_INTEGRITY', 'Page runtime exceeds its size limit');
+        try {
+            return new TextDecoder('utf-8', { fatal: true }).decode(bytes);
+        }
+        catch {
+            throw new BundleError('BUNDLE_INTEGRITY', 'Page runtime is not UTF-8');
+        }
+    }
+    async pinPageRuntimes(patch) {
+        await this.updateRuntimePins(patch, false);
+    }
+    /** Hosts rebuild these references from their authoritative session state after restart. */
+    async synchronizePageRuntimePins(pins) {
+        await this.updateRuntimePins(pins, true);
+    }
+    async updateRuntimePins(input, replace) {
+        const patch = Object.entries(input).map(([owner, sha256]) => {
+            if (!/^[a-zA-Z0-9:._-]{1,200}$/.test(owner) || sha256 !== null && !/^[a-f0-9]{64}$/.test(sha256))
+                throw new BundleError('BUNDLE_INVALID', 'Invalid page runtime reference');
+            return { owner, sha256 };
+        });
+        const database = await this.open();
+        await new Promise((resolve, reject) => {
+            const transaction = database.transaction([STORE, RUNTIMES, PINS], 'readwrite');
+            const runtimeStore = transaction.objectStore(RUNTIMES);
+            const pinStore = transaction.objectStore(PINS);
+            const records = transaction.objectStore(STORE).getAll();
+            const resources = runtimeStore.getAll();
+            const request = pinStore.getAll();
+            let failure;
+            request.onsuccess = () => {
+                const cached = new Map(resources.result.map(resource => [resource.sha256, resource]));
+                const missing = new Set(patch.flatMap(({ sha256 }) => sha256 && !cached.has(sha256) ? [sha256] : []));
+                let added = false;
+                for (const runtime of runtimeResources(records.result.map(record => record.bundle))) {
+                    if (missing.has(runtime.sha256)) {
+                        cached.set(runtime.sha256, runtime);
+                        runtimeStore.put(runtime);
+                        added = true;
+                    }
+                }
+                const available = [...cached.values()];
+                if (added) {
+                    try {
+                        checkStorageBudget(records.result, available);
+                    }
+                    catch (error) {
+                        failure = error;
+                        transaction.abort();
+                        return;
+                    }
+                }
+                const pins = new Map(replace ? [] : request.result.map((pin) => [pin.owner, pin]));
+                for (const { owner, sha256 } of patch) {
+                    if (sha256 === null) {
+                        pins.delete(owner);
+                        continue;
+                    }
+                    if (!replace && !cached.has(sha256)) {
+                        failure = new BundleError('BUNDLE_INTEGRITY', 'Cannot retain a missing page runtime');
+                        transaction.abort();
+                        return;
+                    }
+                    pins.set(owner, { owner, sha256 });
+                }
+                pinStore.clear();
+                for (const pin of pins.values())
+                    pinStore.put(pin);
+                const retained = new Set(referencedRuntimes(records.result, available, [...pins.values()]).map(runtime => runtime.sha256));
+                for (const runtime of available)
+                    if (!retained.has(runtime.sha256))
+                        runtimeStore.delete(runtime.sha256);
+            };
+            transaction.oncomplete = () => resolve();
+            transaction.onabort = transaction.onerror = () => reject(failure ?? transaction.error ?? new Error('Page runtime reference update failed'));
+        });
+    }
+    /** Pins the verified selection while reading its package from the same IndexedDB snapshot. */
+    async profileBinding(name) {
+        const activation = await this.activePreset();
+        const target = activation?.preset.appProfiles[name];
+        if (!activation || !target)
+            return undefined;
+        const id = target.split('/')[0];
+        const database = await this.open();
+        const record = await new Promise((resolve, reject) => {
+            const transaction = database.transaction([PRESET, STORE], 'readonly');
+            const current = transaction.objectStore(PRESET).get('active');
+            const bundle = transaction.objectStore(STORE).get(id);
+            transaction.oncomplete = () => {
+                if (current.result?.revision !== activation.snapshot.revision) {
+                    reject(new BundleError('BUNDLE_CONFLICT', 'The selected preset changed during profile lookup'));
+                }
+                else {
+                    resolve(bundle.result);
+                }
+            };
+            transaction.onabort = transaction.onerror = () => reject(transaction.error ?? new Error('Preset binding read failed'));
+        });
+        if (!record || record.revision !== activation.snapshot.bundleRevisions[id])
+            throw new BundleError('BUNDLE_INTEGRITY', 'The selected app provider is missing');
+        return { target, bundle: await this.verified(record) };
+    }
+    /** Packages and the exact preset graph become visible together, after host contribution checks. */
+    async activatePreset(input, replacements, expectedRevision, association, expectedBundleRevisions) {
+        const selection = captureRevisions(expectedBundleRevisions);
+        const accepted = association?.installation && { installation: installationMetadata(association.installation), expected: association.expectedInstallationToken };
+        if (association && association.expectedInstallationToken !== null && !/^[a-f0-9]{64}$/.test(association.expectedInstallationToken) || accepted && accepted.installation.browserRevision !== input.revision)
+            throw new BundleError('BUNDLE_INVALID', 'Invalid browser installation selection');
+        if (replacements.length > 64 || replacements.reduce((total, item) => total + Object.values(item.bundle.resources).reduce((sum, bytes) => sum + bytes.byteLength, 0), 0) > MAX_BROWSER_STORAGE_BYTES) {
+            throw new BundleError('BUNDLE_QUOTA', 'Preset packages exceed the browser storage budget');
+        }
+        const expected = replacements.map(item => item.expectedRevision);
+        const { snapshot, bundles } = await verifyPreparedBrowserPreset({ snapshot: input, bundles: replacements.map(item => item.bundle) }, this.options.mearlApiVersion);
+        const next = bundles.map((bundle, index) => ({ bundle, expectedRevision: expected[index] }));
+        const token = accepted ? await bundleDigest(crypto.getRandomValues(new Uint8Array(32))) : null;
+        const database = await this.open();
+        await new Promise((resolve, reject) => {
+            const transaction = database.transaction([STORE, PRESET, RUNTIMES, PINS], 'readwrite');
+            const store = transaction.objectStore(STORE);
+            const presets = transaction.objectStore(PRESET);
+            const records = store.getAll();
+            const runtimeStore = transaction.objectStore(RUNTIMES);
+            const retained = runtimeStore.getAll();
+            const pins = transaction.objectStore(PINS).getAll();
+            const installation = presets.get('installationToken');
+            const active = presets.get('active');
+            let failure;
+            active.onsuccess = () => {
+                try {
+                    checkRevisions(records.result, selection);
+                }
+                catch (error) {
+                    failure = error;
+                    transaction.abort();
+                    return;
+                }
+                if ((active.result?.revision ?? null) !== expectedRevision || association && (installation.result ?? null) !== association.expectedInstallationToken || next.some(item => (records.result.find(record => record.id === item.bundle.manifest.id)?.revision ?? null) !== item.expectedRevision)) {
+                    failure = new BundleError('BUNDLE_CONFLICT', 'Preset or packages changed while activation was being prepared');
+                    transaction.abort();
+                    return;
+                }
+                const replacing = new Set(next.map(item => item.bundle.manifest.id));
+                const previousManaged = new Set(Object.keys(active.result?.bundleRevisions ?? {}));
+                if (accepted && next.some(item => !previousManaged.has(item.bundle.manifest.id) && records.result.some(record => record.id === item.bundle.manifest.id))) {
+                    failure = new BundleError('BUNDLE_CONFLICT', 'A preset package conflicts with an independently installed browser package');
+                    transaction.abort();
+                    return;
+                }
+                const result = records.result.filter(record => !replacing.has(record.id) && !previousManaged.has(record.id));
+                for (const { bundle } of next)
+                    result.push({ id: bundle.manifest.id, revision: bundle.revision, byteLength: Object.values(bundle.resources).reduce((sum, bytes) => sum + bytes.byteLength, 0), bundle });
+                const resources = runtimeResources(next.map(item => item.bundle));
+                const cache = new Map(retained.result.map(runtime => [runtime.sha256, runtime]));
+                for (const runtime of resources)
+                    cache.set(runtime.sha256, runtime);
+                const keeping = referencedRuntimes(result, [...cache.values()], pins.result);
+                try {
+                    checkStorageBudget(result, keeping);
+                }
+                catch (error) {
+                    failure = error;
+                    transaction.abort();
+                    return;
+                }
+                for (const record of result)
+                    if (replacing.has(record.id))
+                        store.put(record);
+                for (const id of previousManaged)
+                    if (!replacing.has(id))
+                        store.delete(id);
+                for (const runtime of resources)
+                    runtimeStore.put(runtime);
+                const keep = new Set(keeping.map(runtime => runtime.sha256));
+                for (const runtime of retained.result)
+                    if (!keep.has(runtime.sha256))
+                        runtimeStore.delete(runtime.sha256);
+                presets.put(snapshot, 'active');
+                if (accepted) {
+                    presets.put(accepted.installation, 'installation');
+                    presets.put(token, 'installationToken');
+                }
+                else {
+                    presets.delete('installation');
+                    presets.delete('installationToken');
+                }
+            };
+            transaction.oncomplete = () => resolve();
+            transaction.onabort = transaction.onerror = () => reject(failure ?? transaction.error ?? new Error('Preset activation failed'));
+        });
+    }
+    /** Verifies all resources before a compare-and-swap transaction replaces the active snapshot. */
+    async install(bundle, expectedRevision, expectedBundleRevisions) {
+        const selection = captureRevisions(expectedBundleRevisions);
+        const verified = await verifyBundle(bundle, this.options.mearlApiVersion);
+        const byteLength = Object.values(verified.resources).reduce((sum, bytes) => sum + bytes.byteLength, 0);
+        await this.change(verified.manifest.id, expectedRevision, {
+            id: verified.manifest.id, revision: verified.revision, byteLength, bundle: verified,
+        }, selection);
+    }
+    async remove(id, expectedRevision) {
+        await this.change(id, expectedRevision);
+    }
+    async change(id, expectedRevision, next, selection) {
+        const database = await this.open();
+        await new Promise((resolve, reject) => {
+            const transaction = database.transaction([STORE, PRESET, RUNTIMES, PINS], 'readwrite');
+            const store = transaction.objectStore(STORE);
+            const active = transaction.objectStore(PRESET).get('active');
+            const runtimeStore = transaction.objectStore(RUNTIMES);
+            const retained = runtimeStore.getAll();
+            const pins = transaction.objectStore(PINS).getAll();
+            let failure;
+            const request = store.getAll();
+            request.onsuccess = () => {
+                const records = request.result;
+                try {
+                    checkRevisions(records, selection);
+                }
+                catch (error) {
+                    failure = error;
+                    transaction.abort();
+                    return;
+                }
+                if (Object.hasOwn(active.result?.bundleRevisions ?? {}, id)) {
+                    failure = new BundleError('BUNDLE_CONFLICT', 'The package is managed by the active preset');
+                    transaction.abort();
+                    return;
+                }
+                const current = records.find(record => record.id === id);
+                if ((current?.revision ?? null) !== expectedRevision) {
+                    failure = new BundleError('BUNDLE_CONFLICT', 'Bundle changed while the operation was being prepared');
+                    transaction.abort();
+                    return;
+                }
+                if (next) {
+                    const others = records.filter(record => record.id !== id);
+                    const resources = runtimeResources([next.bundle]);
+                    const cache = new Map(retained.result.map(runtime => [runtime.sha256, runtime]));
+                    for (const runtime of resources)
+                        cache.set(runtime.sha256, runtime);
+                    const keeping = referencedRuntimes([...others, next], [...cache.values()], pins.result);
+                    try {
+                        checkStorageBudget([...others, next], keeping);
+                    }
+                    catch (error) {
+                        failure = error;
+                        transaction.abort();
+                        return;
+                    }
+                    store.put(next);
+                    for (const runtime of resources)
+                        runtimeStore.put(runtime);
+                    const keep = new Set(keeping.map(runtime => runtime.sha256));
+                    for (const runtime of retained.result)
+                        if (!keep.has(runtime.sha256))
+                            runtimeStore.delete(runtime.sha256);
+                }
+                else {
+                    store.delete(id);
+                    const keep = new Set(referencedRuntimes(records.filter(record => record.id !== id), retained.result, pins.result).map(runtime => runtime.sha256));
+                    for (const runtime of retained.result)
+                        if (!keep.has(runtime.sha256))
+                            runtimeStore.delete(runtime.sha256);
+                }
+            };
+            transaction.oncomplete = () => resolve();
+            transaction.onabort = transaction.onerror = () => reject(failure ?? transaction.error ?? new Error('Bundle transaction failed'));
+        });
+    }
+}

package/dist/bundles.d.ts

@@ -0,0 +1,22 @@
+export { BundleError, MAX_BUNDLE_BYTES, MAX_BUNDLE_MANIFEST_BYTES, MAX_BROWSER_STORAGE_BYTES, MAX_PAGE_RUNTIME_BYTES, MAX_REQUEST_UI_BYTES, bundleDigest, bundleSourceUrl, prepareBundle, readBundleJson, readBundleText, validateBundleManifest, verifyBundle, } from './bundle.js';
+export type { BundleManifest, PreparedBundle, BundleLoader, BundleLoadOptions, PrepareBundleOptions, CapabilityRuntimeDeclaration } from './bundle.js';
+export { createBundleFetchLoader } from './bundleFetch.js';
+export { BrowserBundleStore } from './bundleStore.js';
+export type { BrowserPresetInstallation } from './bundleStore.js';
+export { prepareBrowserPreset, presetRequiresBrowser, verifyBrowserPreset, verifyPreparedBrowserPreset } from './browserPreset.js';
+export type { BrowserPresetSnapshot, PreparedBrowserPreset } from './browserPreset.js';
+export { preparePreset, verifyPreset, verifyPreparedPreset } from './preset.js';
+export type { PresetSnapshot, PreparedPreset } from './preset.js';
+export type { PreparePresetOptions } from './prepare.js';
+export { installPageRuntimeHost, buildPageRuntimeRegistrationSource, buildPageRuntimeCallSource } from './pageRuntime.js';
+export type { PageRuntimeBinding, PageRuntimeConfig } from './pageRuntime.js';
+export { receiveBrowserPreset, readPresetTransferResource, PRESET_TRANSFER_CHUNK_BYTES, MAX_PRESET_TRANSFER_HEADER_BYTES } from './browserTransfer.js';
+export type { BrowserPresetTransferHeader, PresetTransferRequest, PresetTransferTransport } from './browserTransfer.js';
+export { prepareBrowserBundleSnapshot } from './nodeSnapshot.js';
+export { buildBrowserCapabilityPage, buildBrowserPureCapabilityPage } from './browserSandbox.js';
+export type { BrowserCapabilityHost, BrowserCapabilityInvocation, BrowserCapabilityRequest, BrowserCapabilityResponse } from './browserSandbox.js';
+export { validateBrowserRequestUi, selectBrowserRequestUi, browserUiText, browserRequestUiLink, browserRequestLoginError, validateBrowserRequestDetail } from './requestUi.js';
+export type { BrowserUiText, BrowserRequestUi, BrowserRequestDetail, SelectedBrowserRequestUi } from './requestUi.js';
+export { validateBrowserView, selectBrowserView, buildBrowserViewPage } from './browserViews.js';
+export type { BrowserViewSlot, BrowserViewDefinition, BrowserViewAction, BrowserViewTransport, SelectedBrowserView, BrowserViewBootstrap } from './browserViews.js';
+export { browserTransportUrl, browserTransportPolicies } from './browserTransport.js';

package/dist/bundles.js

@@ -0,0 +1,12 @@
+export { BundleError, MAX_BUNDLE_BYTES, MAX_BUNDLE_MANIFEST_BYTES, MAX_BROWSER_STORAGE_BYTES, MAX_PAGE_RUNTIME_BYTES, MAX_REQUEST_UI_BYTES, bundleDigest, bundleSourceUrl, prepareBundle, readBundleJson, readBundleText, validateBundleManifest, verifyBundle, } from './bundle.js';
+export { createBundleFetchLoader } from './bundleFetch.js';
+export { BrowserBundleStore } from './bundleStore.js';
+export { prepareBrowserPreset, presetRequiresBrowser, verifyBrowserPreset, verifyPreparedBrowserPreset } from './browserPreset.js';
+export { preparePreset, verifyPreset, verifyPreparedPreset } from './preset.js';
+export { installPageRuntimeHost, buildPageRuntimeRegistrationSource, buildPageRuntimeCallSource } from './pageRuntime.js';
+export { receiveBrowserPreset, readPresetTransferResource, PRESET_TRANSFER_CHUNK_BYTES, MAX_PRESET_TRANSFER_HEADER_BYTES } from './browserTransfer.js';
+export { prepareBrowserBundleSnapshot } from './nodeSnapshot.js';
+export { buildBrowserCapabilityPage, buildBrowserPureCapabilityPage } from './browserSandbox.js';
+export { validateBrowserRequestUi, selectBrowserRequestUi, browserUiText, browserRequestUiLink, browserRequestLoginError, validateBrowserRequestDetail } from './requestUi.js';
+export { validateBrowserView, selectBrowserView, buildBrowserViewPage } from './browserViews.js';
+export { browserTransportUrl, browserTransportPolicies } from './browserTransport.js';

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export { PresetError, validatePreset, clonePresetDefaults } from './manifest.js';
+export { mergePresetDefaults, resolvePreset } from './resolve.js';
+export type * from './types.js';
+export { prepareNodeBundleSnapshot, prepareNodeCapabilitySnapshot, verifyNodeCapabilitySnapshot, verifyNodeCapabilityActivation, validateNodeModuleConfig, resolvePresetModuleConfig, MAX_NODE_SELECTION_BYTES } from './nodeSnapshot.js';
+export type { NodeCapabilitySelection, NodeCapabilitySnapshot, NodeCapabilityActivation } from './nodeSnapshot.js';

package/dist/index.js

@@ -0,0 +1,3 @@
+export { PresetError, validatePreset, clonePresetDefaults } from './manifest.js';
+export { mergePresetDefaults, resolvePreset } from './resolve.js';
+export { prepareNodeBundleSnapshot, prepareNodeCapabilitySnapshot, verifyNodeCapabilitySnapshot, verifyNodeCapabilityActivation, validateNodeModuleConfig, resolvePresetModuleConfig, MAX_NODE_SELECTION_BYTES } from './nodeSnapshot.js';

package/dist/installation.d.ts

@@ -0,0 +1,24 @@
+export interface InstallationGuide {
+    url: string;
+    registry: string;
+}
+export interface InstallationPreset {
+    label: string;
+    source: string;
+    origins: string[];
+}
+export interface InstallationConfig {
+    schemaVersion: 1;
+    guide?: InstallationGuide;
+    presets?: Record<string, InstallationPreset>;
+    legacyPreset?: string;
+}
+/** One validated catalog is used by the website and extension; parameters cannot add install sources. */
+export declare function parseInstallationConfig(value: unknown, publicOrigin: string): InstallationConfig;
+/** Explicit host scopes retain their selected schemes; download sources remain HTTPS. */
+export declare function validateInstallationOrigin(value: unknown): string;
+/** Match both scheme and host against a catalog scope before loading a resource. */
+export declare function matchesInstallationOrigin(scope: string, target: URL): boolean;
+export declare const INSTALLATION_CONFIG_MAX_BYTES = 65536;
+export declare function readInstallationJson(response: Response, maxBytes: number): Promise<unknown>;
+export declare function loadInstallationConfig(url: string | URL, publicOrigin: string, signal?: AbortSignal): Promise<InstallationConfig>;