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

package/dist/browserTransfer.js

@@ -0,0 +1,102 @@
+import { BundleError, MAX_BROWSER_STORAGE_BYTES, bundleDigest, validateBundleManifest } from './bundle.js';
+import { verifyBrowserPreset, verifyPreparedBrowserPreset } from './browserPreset.js';
+import { mergePresetDefaults } from './resolve.js';
+/** Every encoded response stays well below Native Messaging's one MiB host limit. */
+export const PRESET_TRANSFER_CHUNK_BYTES = 128 * 1024;
+export const MAX_PRESET_TRANSFER_HEADER_BYTES = 16 * 1024 * 1024;
+function object(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        throw new BundleError('BUNDLE_INVALID', 'Invalid preset transfer response');
+    return value;
+}
+function hash(value) { return typeof value === 'string' && /^[a-f0-9]{64}$/.test(value); }
+export async function readPresetTransferResource(sha256, byteLength, options) {
+    if (!hash(sha256) || !Number.isSafeInteger(byteLength) || byteLength < 0 || byteLength > MAX_BROWSER_STORAGE_BYTES)
+        throw new BundleError('BUNDLE_QUOTA', 'Invalid preset resource digest or size');
+    const bytes = new Uint8Array(byteLength);
+    for (let offset = 0; offset < byteLength; offset += PRESET_TRANSFER_CHUNK_BYTES) {
+        options.signal?.throwIfAborted();
+        const count = Math.min(PRESET_TRANSFER_CHUNK_BYTES, byteLength - offset);
+        const response = object(await options.read(offset));
+        if (typeof response.data !== 'string' || response.data.length !== Math.ceil(count / 3) * 4 || !/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test(response.data))
+            throw new BundleError('BUNDLE_INTEGRITY', 'Invalid preset resource chunk');
+        const decoded = atob(response.data);
+        if (decoded.length !== count)
+            throw new BundleError('BUNDLE_INTEGRITY', 'Truncated preset resource chunk');
+        for (let i = 0; i < count; i++)
+            bytes[offset + i] = decoded.charCodeAt(i);
+    }
+    if (await bundleDigest(bytes) !== sha256)
+        throw new BundleError('BUNDLE_INTEGRITY', 'Preset transfer resource digest does not match');
+    return bytes;
+}
+/** Receives the captured browser projection, excluding Node-only packages and executing no factories. */
+export async function receiveBrowserPreset(installationRevision, options) {
+    if (!hash(installationRevision))
+        throw new BundleError('BUNDLE_INVALID', 'Expected an installation revision');
+    options.signal?.throwIfAborted();
+    const opened = object(await options.transport({ operation: 'open', installationRevision }));
+    if (typeof opened.session !== 'string' || !/^[a-zA-Z0-9-]{1,80}$/.test(opened.session))
+        throw new BundleError('BUNDLE_INVALID', 'Invalid preset transfer session');
+    const session = opened.session;
+    let released = false;
+    const release = async () => { if (!released) {
+        released = true;
+        await options.transport({ operation: 'release', session });
+    } };
+    const confirm = async () => {
+        options.signal?.throwIfAborted();
+        const response = object(await options.transport({ operation: 'confirm', session }));
+        if (response.installationRevision !== installationRevision)
+            throw new BundleError('BUNDLE_CONFLICT', 'The selected installation changed during browser transfer');
+    };
+    const read = (sha256, byteLength) => readPresetTransferResource(sha256, byteLength, { signal: options.signal, read: offset => options.transport({ operation: 'read', session, sha256, offset }) });
+    try {
+        if (!hash(opened.sha256) || !Number.isSafeInteger(opened.byteLength) || opened.byteLength < 1 || opened.byteLength > MAX_PRESET_TRANSFER_HEADER_BYTES)
+            throw new BundleError('BUNDLE_QUOTA', 'Invalid preset transfer header or size');
+        const metadataBytes = await read(opened.sha256, opened.byteLength);
+        const value = object(JSON.parse(new TextDecoder('utf-8', { fatal: true }).decode(metadataBytes)));
+        if (Object.keys(value).some(key => !['schemaVersion', 'installationRevision', 'snapshot', 'bundles', 'overrides'].includes(key)) || value.schemaVersion !== 1 || value.installationRevision !== installationRevision || !Array.isArray(value.bundles) || value.bundles.length > 64)
+            throw new BundleError('BUNDLE_INVALID', 'Invalid browser transfer metadata');
+        const graph = await verifyBrowserPreset(value.snapshot, options.mearlApiVersion);
+        const overrides = mergePresetDefaults({}, value.overrides);
+        if (new TextEncoder().encode(JSON.stringify(overrides)).byteLength > 262144)
+            throw new BundleError('BUNDLE_QUOTA', 'User overrides exceed 256 KiB');
+        let total = 0;
+        const descriptors = value.bundles.map(entry => {
+            const bundle = object(entry);
+            if (Object.keys(bundle).some(key => !['source', 'revision', 'manifest'].includes(key)) || typeof bundle.source !== 'string' || !hash(bundle.revision))
+                throw new BundleError('BUNDLE_INVALID', 'Invalid browser package descriptor');
+            const manifest = validateBundleManifest(bundle.manifest, options.mearlApiVersion);
+            total += Object.values(manifest.resources).reduce((sum, resource) => sum + resource.byteLength, 0);
+            if (total > MAX_BROWSER_STORAGE_BYTES)
+                throw new BundleError('BUNDLE_QUOTA', 'Browser transfer resources exceed 64 MiB');
+            return { source: bundle.source, revision: bundle.revision, manifest };
+        });
+        if (descriptors.length !== Object.keys(graph.snapshot.bundleRevisions).length || new Set(descriptors.map(bundle => bundle.manifest.id)).size !== descriptors.length || descriptors.some(bundle => graph.snapshot.bundleRevisions[bundle.manifest.id] !== bundle.revision))
+            throw new BundleError('BUNDLE_INTEGRITY', 'Browser transfer requires every exact package');
+        const resources = new Map();
+        const bundles = [];
+        for (const bundle of descriptors) {
+            const entries = {};
+            for (const [name, entry] of Object.entries(bundle.manifest.resources)) {
+                const bytes = resources.get(entry.sha256) ?? await read(entry.sha256, entry.byteLength);
+                if (bytes.byteLength !== entry.byteLength)
+                    throw new BundleError('BUNDLE_INTEGRITY', 'Resource digest has inconsistent lengths');
+                resources.set(entry.sha256, bytes);
+                entries[name] = bytes;
+            }
+            bundles.push({ ...bundle, resources: entries });
+        }
+        const prepared = await verifyPreparedBrowserPreset({ snapshot: graph.snapshot, bundles }, options.mearlApiVersion);
+        await confirm();
+        return { prepared, installation: { revision: installationRevision, browserRevision: prepared.snapshot.revision, overrides }, confirm, release };
+    }
+    catch (error) {
+        try {
+            await release();
+        }
+        catch { /* The transport may have closed with the failed transfer. */ }
+        throw error;
+    }
+}

package/dist/browserTransport.d.ts

@@ -0,0 +1,8 @@
+import type { BrowserViewTransport } from './browserViews.js';
+/** WebSocket permissions use their HTTP counterpart; native sockets reject redirects. */
+export declare function browserTransportUrl(input: unknown, kind: BrowserViewTransport['kind']): {
+    url: string;
+    permissionUrl: string;
+};
+/** Native SSE redirects remain inside the intersecting domain and Chrome host policies. */
+export declare function browserTransportPolicies(domains: string[], chromeOrigins: string[], allowAllDomains: boolean, kind: BrowserViewTransport['kind']): string[];

package/dist/browserTransport.js

@@ -0,0 +1,64 @@
+import { BundleError } from './bundle.js';
+/** WebSocket permissions use their HTTP counterpart; native sockets reject redirects. */
+export function browserTransportUrl(input, kind) {
+    if (typeof input !== 'string' || input.length > 16384)
+        throw new BundleError('BUNDLE_INVALID', 'Expected a browser transport URL');
+    const url = new URL(input);
+    const protocols = kind === 'websocket' ? ['ws:', 'wss:'] : kind === 'eventSource' ? ['http:', 'https:'] : [];
+    if (!protocols.includes(url.protocol) || url.username || url.password || url.hash)
+        throw new BundleError('BUNDLE_INVALID', 'Invalid browser transport URL');
+    const permission = new URL(url);
+    if (permission.protocol === 'ws:')
+        permission.protocol = 'http:';
+    if (permission.protocol === 'wss:')
+        permission.protocol = 'https:';
+    return { url: url.href, permissionUrl: permission.href };
+}
+function rules(origins, domainOnly) {
+    return origins.flatMap(origin => {
+        if (origin === '<all_urls>' && !domainOnly)
+            return [{ scheme: '*', host: '*' }];
+        const match = /^(\*|https?):\/\/(\*|(?:\*\.)?[a-zA-Z0-9.-]+|\[[a-fA-F0-9:]+\])\/\*$/.exec(origin);
+        return !match || domainOnly && (match[1] !== '*' || match[2] === '*') ? [] : [{ scheme: match[1], host: match[2].toLowerCase() }];
+    });
+}
+function intersection(a, b) {
+    const covers = (outer, inner) => outer === '*' || outer === inner || outer.startsWith('*.') && (inner.replace(/^\*\./, '') === outer.slice(2) || inner.replace(/^\*\./, '').endsWith('.' + outer.slice(2)));
+    return covers(a, b) ? b : covers(b, a) ? a : undefined;
+}
+function sources(origins, domainOnly, kind) {
+    const values = new Set();
+    const add = (scheme, host) => {
+        for (const name of host.startsWith('*.') ? [host.slice(2), host] : [host])
+            values.add(name === '*' ? `${scheme}:` : `${scheme}://${name}:*`);
+    };
+    const accepted = rules(origins, domainOnly);
+    for (const { scheme, host } of accepted) {
+        if (domainOnly || kind === 'websocket') {
+            for (const name of scheme === '*' ? ['http', 'https', 'ws', 'wss'] : scheme === 'https' ? ['https', 'wss'] : ['http', 'ws'])
+                add(name, host);
+        }
+        else if (scheme === '*' || scheme === 'https') {
+            add('https', host);
+        }
+    }
+    if (!domainOnly && kind === 'eventSource') {
+        // CSP http sources also permit https. Only their shared grant scope can be represented.
+        const http = accepted.filter(rule => rule.scheme !== 'https');
+        const https = accepted.filter(rule => rule.scheme !== 'http');
+        for (const a of http)
+            for (const b of https) {
+                const host = intersection(a.host, b.host);
+                if (host)
+                    add('http', host);
+            }
+    }
+    return [...values].join(' ') || "'none'";
+}
+/** Native SSE redirects remain inside the intersecting domain and Chrome host policies. */
+export function browserTransportPolicies(domains, chromeOrigins, allowAllDomains, kind) {
+    return [
+        `connect-src ${allowAllDomains ? 'http: https: ws: wss:' : sources(domains, true, kind)}`,
+        `connect-src ${sources(chromeOrigins, false, kind)}`,
+    ];
+}

package/dist/browserViews.d.ts

@@ -0,0 +1,44 @@
+import { type PreparedBundle } from './bundle.js';
+import type { JsonObject, JsonValue } from './types.js';
+import { type BrowserUiText } from './requestUi.js';
+export type BrowserViewSlot = 'requestImport' | 'requestCases' | 'captureLauncher' | 'captureController';
+export interface BrowserViewAction {
+    hook: string;
+    setting?: string;
+    disabledResult?: JsonValue;
+}
+export interface BrowserViewTransport {
+    kind: 'websocket' | 'eventSource';
+    setting: string;
+}
+export interface BrowserViewDefinition {
+    schemaVersion: 1;
+    entry: string;
+    actions: Record<string, BrowserViewAction>;
+    preferences?: Record<string, {
+        legacyKey?: string;
+        area?: 'local' | 'session';
+    }>;
+    transports?: Record<string, BrowserViewTransport>;
+    logins?: Record<string, {
+        url: string;
+        title: BrowserUiText;
+        size?: 'default' | 'fullscreen';
+    }>;
+}
+export interface SelectedBrowserView {
+    bundleId: string;
+    revision: string;
+    slot: BrowserViewSlot;
+    definition: BrowserViewDefinition;
+    html: string;
+}
+export interface BrowserViewBootstrap {
+    locale: string;
+    context: JsonObject;
+    preferences: JsonObject;
+}
+/** Views occupy existing host positions; their code stays in an opaque sandbox. */
+export declare function validateBrowserView(input: unknown): BrowserViewDefinition;
+export declare function selectBrowserView(bundles: PreparedBundle[], slot: BrowserViewSlot, apiVersion: string): SelectedBrowserView | undefined;
+export declare function buildBrowserViewPage(html: string): string;

package/dist/browserViews.js

@@ -0,0 +1,204 @@
+import { BundleError, MAX_REQUEST_UI_BYTES, readBundleJson, readBundleText, validateBundleManifest } from './bundle.js';
+import { clonePresetDefaults, isJsonObject } from './manifest.js';
+import { browserUiHttpUrl, validateBrowserUiText } from './requestUi.js';
+const identifier = /^[a-z][a-zA-Z0-9_.-]{0,79}$/;
+function invalid(message) { throw new BundleError('BUNDLE_INVALID', message); }
+function fields(value, keys) {
+    if (!isJsonObject(value) || Object.keys(value).some(key => !keys.includes(key)))
+        invalid('Invalid browser view structure');
+}
+function entries(value, limit) {
+    if (!isJsonObject(value) || Object.keys(value).length > limit || Object.keys(value).some(key => !identifier.test(key)))
+        invalid('Invalid browser view entries');
+    return Object.entries(value);
+}
+/** Views occupy existing host positions; their code stays in an opaque sandbox. */
+export function validateBrowserView(input) {
+    const value = clonePresetDefaults(input);
+    fields(value, ['schemaVersion', 'entry', 'actions', 'preferences', 'logins', 'transports']);
+    if (value.schemaVersion !== 1 || typeof value.entry !== 'string' || !/^[a-zA-Z0-9_][a-zA-Z0-9_./-]{0,255}$/.test(value.entry) || value.entry.split('/').some(part => !part || part === '.' || part === '..'))
+        invalid('Invalid browser view entry');
+    for (const [, action] of entries(value.actions, 32)) {
+        fields(action, ['hook', 'setting', 'disabledResult']);
+        if (typeof action.hook !== 'string' || !/^[a-z][a-zA-Z0-9_.-]{0,127}$/.test(action.hook))
+            invalid('Invalid browser view hook');
+        if (action.setting !== undefined && (typeof action.setting !== 'string' || !/^[a-z][a-zA-Z0-9_-]{0,72}Enabled$/.test(action.setting) || ['agentEnabled', 'sseMonitoringEnabled', 'agentFloatingButtonEnabled'].includes(action.setting)))
+            invalid('Invalid browser view setting');
+        if ((action.setting === undefined) !== (action.disabledResult === undefined))
+            invalid('A guarded view action requires its disabled result');
+    }
+    if (value.preferences !== undefined) {
+        const aliases = new Set();
+        for (const [, preference] of entries(value.preferences, 32)) {
+            fields(preference, ['legacyKey', 'area']);
+            if (preference.area !== undefined && preference.area !== 'local' && preference.area !== 'session')
+                invalid('Invalid browser view preference area');
+            if (preference.legacyKey !== undefined) {
+                if (typeof preference.legacyKey !== 'string' || !/^[a-z][a-zA-Z0-9:_.-]{0,127}$/.test(preference.legacyKey) || aliases.has(preference.legacyKey))
+                    invalid('Invalid browser view preference alias');
+                aliases.add(preference.legacyKey);
+            }
+        }
+    }
+    if (value.transports !== undefined) {
+        for (const [, transport] of entries(value.transports, 16)) {
+            fields(transport, ['kind', 'setting']);
+            if (transport.kind !== 'websocket' && transport.kind !== 'eventSource')
+                invalid('Invalid browser view transport');
+            if (typeof transport.setting !== 'string' || !/^[a-z][a-zA-Z0-9_-]{0,72}Enabled$/.test(transport.setting) || ['agentEnabled', 'sseMonitoringEnabled', 'agentFloatingButtonEnabled'].includes(transport.setting))
+                invalid('Invalid browser view transport setting');
+        }
+    }
+    if (value.logins !== undefined) {
+        for (const [, login] of entries(value.logins, 16)) {
+            fields(login, ['url', 'title', 'size']);
+            login.url = browserUiHttpUrl(login.url);
+            validateBrowserUiText(login.title);
+            if (login.size !== undefined && !['default', 'fullscreen'].includes(login.size))
+                invalid('Invalid browser view login size');
+        }
+    }
+    if (new TextEncoder().encode(JSON.stringify(value)).byteLength > MAX_REQUEST_UI_BYTES)
+        throw new BundleError('BUNDLE_QUOTA', 'Browser view definition exceeds 64 KiB');
+    return value;
+}
+export function selectBrowserView(bundles, slot, apiVersion) {
+    if (slot !== 'requestImport' && slot !== 'requestCases' && slot !== 'captureLauncher' && slot !== 'captureController')
+        invalid('Unsupported browser view position');
+    let selected;
+    for (const bundle of bundles) {
+        const manifest = validateBundleManifest(bundle.manifest, apiVersion);
+        const resource = manifest.contributions?.browserViews?.[slot];
+        if (!resource)
+            continue;
+        if (selected)
+            invalid('Browser view position has multiple providers');
+        const definition = validateBrowserView(readBundleJson(bundle, resource));
+        const bindings = manifest.contributions?.browserRuntimes?.extension?.bindings ?? {};
+        if (Object.values(definition.actions).some(action => !Object.hasOwn(bindings, action.hook)))
+            invalid('View actions must belong to their own browser runtime');
+        if (!Object.hasOwn(manifest.resources, definition.entry))
+            invalid('Browser view entry must be a declared resource');
+        const html = readBundleText(bundle, definition.entry);
+        if (!html.trim())
+            invalid('Browser view entry must not be empty');
+        selected = { bundleId: manifest.id, revision: bundle.revision, slot, definition, html };
+    }
+    return selected;
+}
+/** Serialized before the view bundle; only its parent receives this private port. */
+function installBrowserViewBridge() {
+    let connected = false;
+    let closed = false;
+    let serial = 0;
+    let port;
+    let resolveReady;
+    let rejectReady;
+    const ready = new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; });
+    void ready.catch(() => { });
+    const pending = new Map();
+    const listeners = new Set();
+    const eventListeners = new Set();
+    const handlers = new Map();
+    const call = async (method, input = {}) => {
+        await ready;
+        if (!connected)
+            throw new Error('Browser view is closed');
+        const value = JSON.parse(JSON.stringify(input));
+        const id = ++serial;
+        return new Promise((resolve, reject) => {
+            pending.set(id, { resolve, reject });
+            try {
+                port.postMessage({ type: 'view-call', id, method, input: value });
+            }
+            catch (error) {
+                pending.delete(id);
+                reject(error);
+            }
+        });
+    };
+    Object.defineProperty(window, 'mearlView', { value: Object.freeze({
+            ready: () => ready,
+            call,
+            handle: (method, handler) => {
+                if (typeof method !== 'string' || !/^[a-z][a-zA-Z0-9_.-]{0,79}$/.test(method) || typeof handler !== 'function' || handlers.has(method))
+                    throw new Error('Invalid or duplicate browser view command');
+                handlers.set(method, handler);
+                return () => { if (handlers.get(method) === handler)
+                    handlers.delete(method); };
+            },
+            onEvent: (listener) => { eventListeners.add(listener); return () => eventListeners.delete(listener); },
+            onContext: (listener) => { listeners.add(listener); return () => listeners.delete(listener); },
+        }) });
+    window.addEventListener('message', event => {
+        if (event.source !== window.parent || event.data?.type !== 'mearl-plugin-connect' || !event.ports[0] || connected || closed)
+            return;
+        connected = true;
+        port = event.ports[0];
+        port.onmessage = event => {
+            const value = event.data;
+            if (value?.type === 'view-command' && Number.isSafeInteger(value.id) && value.id > 0) {
+                const handler = handlers.get(value.method);
+                void Promise.resolve().then(() => {
+                    if (!handler)
+                        throw new Error('Unknown browser view command');
+                    return handler(value.input);
+                }).then(result => {
+                    if (connected)
+                        port.postMessage({ type: 'view-command-result', id: value.id, success: true, value: result });
+                }, error => {
+                    if (connected)
+                        port.postMessage({ type: 'view-command-result', id: value.id, success: false, error: error instanceof Error ? error.message : String(error) });
+                });
+                return;
+            }
+            if (value?.type === 'view-init') {
+                resolveReady(value.bootstrap);
+                return;
+            }
+            if (value?.type === 'view-event') {
+                for (const listener of eventListeners)
+                    listener(value.event);
+                return;
+            }
+            if (value?.type === 'view-context') {
+                for (const listener of listeners)
+                    listener(value.context);
+                return;
+            }
+            if (value?.type === 'view-key' && value.key === 'Escape') {
+                document.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true, cancelable: true }));
+                return;
+            }
+            if (value?.type === 'view-close') {
+                connected = false;
+                closed = true;
+                rejectReady(new Error('Browser view is closed'));
+                for (const request of pending.values())
+                    request.reject(new Error('Browser view is closed'));
+                pending.clear();
+                port.close();
+                return;
+            }
+            if (value?.type !== 'view-result' || !Number.isSafeInteger(value.id))
+                return;
+            const request = pending.get(value.id);
+            if (!request)
+                return;
+            pending.delete(value.id);
+            if (value.success === true)
+                request.resolve(value.value);
+            else
+                request.reject(new Error(typeof value.error === 'string' ? value.error : 'Browser view request failed'));
+        };
+        port.start();
+        port.postMessage({ type: 'view-ready' });
+    });
+    window.parent.postMessage({ type: 'mearl-plugin-ready' }, '*');
+}
+export function buildBrowserViewPage(html) {
+    if (typeof html !== 'string' || !html.trim())
+        invalid('Browser view entry must not be empty');
+    const policy = "default-src 'none'; script-src 'unsafe-inline' 'unsafe-eval'; style-src 'unsafe-inline'; img-src data: blob:; font-src data:; connect-src 'none'; frame-src 'none'; object-src 'none'; base-uri 'none'; form-action 'none'";
+    return `<!doctype html><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="${policy}"><script>(${installBrowserViewBridge.toString()})();</script>${html}`;
+}

package/dist/bundle.d.ts

@@ -0,0 +1,59 @@
+export declare const MAX_BUNDLE_BYTES: number;
+export declare const MAX_BUNDLE_MANIFEST_BYTES: number;
+export declare const MAX_BROWSER_STORAGE_BYTES: number;
+export declare const MAX_PAGE_RUNTIME_BYTES: number;
+export declare const MAX_REQUEST_UI_BYTES: number;
+export declare class BundleError extends Error {
+    readonly code: 'BUNDLE_INVALID' | 'BUNDLE_INTEGRITY' | 'BUNDLE_INCOMPATIBLE' | 'BUNDLE_CONFLICT' | 'BUNDLE_QUOTA';
+    constructor(code: 'BUNDLE_INVALID' | 'BUNDLE_INTEGRITY' | 'BUNDLE_INCOMPATIBLE' | 'BUNDLE_CONFLICT' | 'BUNDLE_QUOTA', message: string);
+}
+export interface BundleManifest {
+    schemaVersion: 1;
+    id: string;
+    version: string;
+    requires?: {
+        mearlApi: string;
+    };
+    resources: Record<string, {
+        sha256: string;
+        byteLength: number;
+    }>;
+    contributions?: {
+        appProfiles: string[];
+        pageRuntimes?: Record<string, string>;
+        nodeRuntimes?: Record<string, CapabilityRuntimeDeclaration>;
+        browserRuntimes?: Record<string, CapabilityRuntimeDeclaration>;
+        requestUi?: string;
+        browserViews?: Record<string, string>;
+    };
+}
+export interface CapabilityRuntimeDeclaration {
+    entry: string;
+    bindings: Record<string, string>;
+}
+export interface PreparedBundle {
+    source: string;
+    revision: string;
+    manifest: BundleManifest;
+    resources: Record<string, Uint8Array>;
+}
+export interface BundleLoadOptions {
+    maxBytes: number;
+    signal?: AbortSignal;
+}
+export type BundleLoader = (source: string, options: BundleLoadOptions) => Promise<Uint8Array>;
+export interface PrepareBundleOptions {
+    load: BundleLoader;
+    mearlApiVersion: string;
+    expectedId: string;
+    version?: string;
+    signal?: AbortSignal;
+}
+export declare function bundleSourceUrl(source: string): string;
+export declare function validateBundleManifest(value: unknown, mearlApiVersion: string): BundleManifest;
+export declare function bundleDigest(bytes: Uint8Array): Promise<string>;
+export declare function readBundleJson(bundle: PreparedBundle, name: string): unknown;
+export declare function readBundleText(bundle: PreparedBundle, name: string): string;
+export declare function prepareBundle(source: string, options: PrepareBundleOptions): Promise<PreparedBundle>;
+/** Revalidates persisted snapshots without network access and returns independent resource buffers. */
+export declare function verifyBundle(bundle: PreparedBundle, mearlApiVersion: string): Promise<PreparedBundle>;