@mearl/preset 3.0.0-beta.1 → 3.0.0-beta.10

package/dist/bundleStore.js

@@ -11,8 +11,8 @@ function installationMetadata(value) {
 }
 const STORE = 'bundles';
 const PRESET = 'preset';
-const RUNTIMES = 'pageRuntimes';
-const PINS = 'pageRuntimePins';
+const OBJECTS = 'objects';
+const PINS = 'resourcePins';
 function captureRevisions(input) {
     if (input === undefined)
         return;
@@ -25,39 +25,54 @@ 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 storedBundle(bundle) {
+    const { resources, ...metadata } = bundle;
+    return { id: bundle.manifest.id, revision: bundle.revision,
+        byteLength: Object.values(resources).reduce((sum, bytes) => sum + bytes.byteLength, 0), bundle: metadata };
 }
-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 bundleObjectHashes(records) {
+    const hashes = new Set();
+    for (const record of records) {
+        const resources = record?.bundle?.manifest?.resources;
+        if (!resources || typeof resources !== 'object' || Array.isArray(resources))
+            continue;
+        for (const resource of Object.values(resources))
+            if (resource && typeof resource.sha256 === 'string' && /^[a-f0-9]{64}$/.test(resource.sha256))
+                hashes.add(resource.sha256);
+    }
+    return hashes;
+}
+function referencedObjects(records, resources, pins) {
+    const referenced = bundleObjectHashes(records);
+    for (const pin of pins)
+        referenced.add(pin.sha256);
+    return resources.filter(resource => referenced.has(resource.sha256));
 }
-function runtimeResources(bundles) {
+function bundleObjects(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 });
-        }
+        for (const [name, resource] of Object.entries(bundle.manifest.resources))
+            result.set(resource.sha256, { sha256: resource.sha256, bytes: bundle.resources[name] });
     return [...result.values()];
 }
+/** Schedule object reads inside the metadata transaction, preserving one consistent snapshot. */
+function readObjects(records, store) {
+    const result = new Map();
+    const hashes = bundleObjectHashes(records);
+    for (const hash of hashes) {
+        const request = store.get(hash);
+        request.onsuccess = () => { if (request.result)
+            result.set(hash, request.result); };
+    }
+    return result;
+}
 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);
+    const total = 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');
 }
@@ -71,14 +86,14 @@ export class BrowserBundleStore {
         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);
+            const request = (this.options.indexedDB ?? indexedDB).open(this.options.databaseName ?? 'mearl-capabilities-v3', 1);
             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(OBJECTS))
+                    request.result.createObjectStore(OBJECTS, { keyPath: 'sha256' });
                 if (!request.result.objectStoreNames.contains(PINS))
                     request.result.createObjectStore(PINS, { keyPath: 'owner' });
             };
@@ -100,30 +115,41 @@ export class BrowserBundleStore {
     async records() {
         const database = await this.open();
         return new Promise((resolve, reject) => {
-            const transaction = database.transaction([STORE, PRESET], 'readonly');
+            const transaction = database.transaction([STORE, PRESET, OBJECTS], 'readonly');
             const request = transaction.objectStore(STORE).getAll();
+            let objects = new Map();
+            request.onsuccess = () => { objects = readObjects(request.result, transaction.objectStore(OBJECTS)); };
             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.oncomplete = () => resolve({ objects, 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();
+        let objects = new Map();
         const record = await new Promise((resolve, reject) => {
-            const transaction = database.transaction(STORE, 'readonly');
+            const transaction = database.transaction([STORE, OBJECTS], 'readonly');
             const request = transaction.objectStore(STORE).get(id);
+            request.onsuccess = () => { objects = readObjects(request.result ? [request.result] : [], transaction.objectStore(OBJECTS)); };
             transaction.oncomplete = () => resolve(request.result);
             transaction.onabort = transaction.onerror = () => reject(transaction.error ?? new Error('Bundle read failed'));
         });
-        return record ? this.verified(record) : undefined;
+        return record ? this.verified(record, objects) : undefined;
     }
-    async verified(record) {
+    async verified(record, objects) {
         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);
+        const resources = {};
+        for (const [name, metadata] of Object.entries(record.bundle.manifest.resources)) {
+            const object = objects.get(metadata.sha256);
+            if (!object || object.sha256 !== metadata.sha256)
+                throw new BundleError('BUNDLE_INTEGRITY', 'Stored resource integrity check failed: object is missing');
+            resources[name] = object.bytes;
+        }
+        const bundle = await verifyBundle({ ...record.bundle, resources }, 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');
         }
@@ -132,10 +158,10 @@ export class BrowserBundleStore {
     async list() {
         const bundles = [];
         const errors = [];
-        const { records, active, installation: storedInstallation, installationToken } = await this.records();
+        const { objects, records, active, installation: storedInstallation, installationToken } = await this.records();
         for (const record of records) {
             try {
-                bundles.push(await this.verified(record));
+                bundles.push(await this.verified(record, objects));
             }
             catch (error) {
                 errors.push({ id: record.id, error: error instanceof Error ? error.message : 'Invalid stored bundle' });
@@ -191,8 +217,8 @@ export class BrowserBundleStore {
             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);
+            const transaction = database.transaction(OBJECTS, 'readonly');
+            const request = transaction.objectStore(OBJECTS).get(sha256);
             transaction.oncomplete = () => resolve(request.result);
             transaction.onabort = transaction.onerror = () => reject(transaction.error ?? new Error('Browser runtime read failed'));
         });
@@ -228,8 +254,8 @@ export class BrowserBundleStore {
         });
         const database = await this.open();
         await new Promise((resolve, reject) => {
-            const transaction = database.transaction([STORE, RUNTIMES, PINS], 'readwrite');
-            const runtimeStore = transaction.objectStore(RUNTIMES);
+            const transaction = database.transaction([STORE, OBJECTS, PINS], 'readwrite');
+            const runtimeStore = transaction.objectStore(OBJECTS);
             const pinStore = transaction.objectStore(PINS);
             const records = transaction.objectStore(STORE).getAll();
             const resources = runtimeStore.getAll();
@@ -237,26 +263,7 @@ export class BrowserBundleStore {
             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) {
@@ -273,7 +280,7 @@ export class BrowserBundleStore {
                 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));
+                const retained = new Set(referencedObjects(records.result, available, [...pins.values()]).map(runtime => runtime.sha256));
                 for (const runtime of available)
                     if (!retained.has(runtime.sha256))
                         runtimeStore.delete(runtime.sha256);
@@ -290,10 +297,12 @@ export class BrowserBundleStore {
             return undefined;
         const id = target.split('/')[0];
         const database = await this.open();
+        let objects = new Map();
         const record = await new Promise((resolve, reject) => {
-            const transaction = database.transaction([PRESET, STORE], 'readonly');
+            const transaction = database.transaction([PRESET, STORE, OBJECTS], 'readonly');
             const current = transaction.objectStore(PRESET).get('active');
             const bundle = transaction.objectStore(STORE).get(id);
+            bundle.onsuccess = () => { objects = readObjects(bundle.result ? [bundle.result] : [], transaction.objectStore(OBJECTS)); };
             transaction.oncomplete = () => {
                 if (current.result?.revision !== activation.snapshot.revision) {
                     reject(new BundleError('BUNDLE_CONFLICT', 'The selected preset changed during profile lookup'));
@@ -306,7 +315,7 @@ export class BrowserBundleStore {
         });
         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) };
+        return { target, bundle: await this.verified(record, objects) };
     }
     /** Packages and the exact preset graph become visible together, after host contribution checks. */
     async activatePreset(input, replacements, expectedRevision, association, expectedBundleRevisions) {
@@ -323,11 +332,11 @@ export class BrowserBundleStore {
         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 transaction = database.transaction([STORE, PRESET, OBJECTS, PINS], 'readwrite');
             const store = transaction.objectStore(STORE);
             const presets = transaction.objectStore(PRESET);
             const records = store.getAll();
-            const runtimeStore = transaction.objectStore(RUNTIMES);
+            const runtimeStore = transaction.objectStore(OBJECTS);
             const retained = runtimeStore.getAll();
             const pins = transaction.objectStore(PINS).getAll();
             const installation = presets.get('installationToken');
@@ -356,12 +365,12 @@ export class BrowserBundleStore {
                 }
                 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));
+                    result.push(storedBundle(bundle));
+                const resources = bundleObjects(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);
+                const keeping = referencedObjects(result, [...cache.values()], pins.result);
                 try {
                     checkStorageBudget(result, keeping);
                 }
@@ -400,21 +409,18 @@ export class BrowserBundleStore {
     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);
+        await this.change(verified.manifest.id, expectedRevision, storedBundle(verified), selection, bundleObjects([verified]));
     }
     async remove(id, expectedRevision) {
         await this.change(id, expectedRevision);
     }
-    async change(id, expectedRevision, next, selection) {
+    async change(id, expectedRevision, next, selection, resources = []) {
         const database = await this.open();
         await new Promise((resolve, reject) => {
-            const transaction = database.transaction([STORE, PRESET, RUNTIMES, PINS], 'readwrite');
+            const transaction = database.transaction([STORE, PRESET, OBJECTS, PINS], 'readwrite');
             const store = transaction.objectStore(STORE);
             const active = transaction.objectStore(PRESET).get('active');
-            const runtimeStore = transaction.objectStore(RUNTIMES);
+            const runtimeStore = transaction.objectStore(OBJECTS);
             const retained = runtimeStore.getAll();
             const pins = transaction.objectStore(PINS).getAll();
             let failure;
@@ -442,11 +448,10 @@ export class BrowserBundleStore {
                 }
                 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);
+                    const keeping = referencedObjects([...others, next], [...cache.values()], pins.result);
                     try {
                         checkStorageBudget([...others, next], keeping);
                     }
@@ -465,7 +470,7 @@ export class BrowserBundleStore {
                 }
                 else {
                     store.delete(id);
-                    const keep = new Set(referencedRuntimes(records.filter(record => record.id !== id), retained.result, pins.result).map(runtime => runtime.sha256));
+                    const keep = new Set(referencedObjects(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);

package/dist/bundles.d.ts

@@ -1,5 +1,7 @@
 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 { selectExtensionContributions, validateExtensionContributions } from './extensionContributions.js';
+export type { ExtensionContributions } from './extensionContributions.js';
 export { createBundleFetchLoader } from './bundleFetch.js';
 export { BrowserBundleStore } from './bundleStore.js';
 export type { BrowserPresetInstallation } from './bundleStore.js';
@@ -12,7 +14,7 @@ export { installPageRuntimeHost, buildPageRuntimeRegistrationSource, buildPageRu
 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 { prepareBrowserBundleSnapshot } from './capabilitySnapshot.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';
@@ -20,3 +22,7 @@ export type { BrowserUiText, BrowserRequestUi, BrowserRequestDetail, SelectedBro
 export { validateBrowserView, selectBrowserView, buildBrowserViewPage } from './browserViews.js';
 export type { BrowserViewSlot, BrowserViewDefinition, BrowserViewAction, BrowserViewTransport, SelectedBrowserView, BrowserViewBootstrap } from './browserViews.js';
 export { browserTransportUrl, browserTransportPolicies } from './browserTransport.js';
+export { validateBrowserControl, selectBrowserControl } from './browserControls.js';
+export type { BrowserSegmentedControl, SelectedBrowserControl } from './browserControls.js';
+export { parseNetworkRoutePlan, encodeNetworkRoutePlan, decodeNetworkRoutePlan } from './networkRoutes.js';
+export type { NetworkHostRoute, NetworkRoutePlan } from './networkRoutes.js';

package/dist/bundles.js

@@ -1,12 +1,15 @@
 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 { selectExtensionContributions, validateExtensionContributions } from './extensionContributions.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 { prepareBrowserBundleSnapshot } from './capabilitySnapshot.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';
+export { validateBrowserControl, selectBrowserControl } from './browserControls.js';
+export { parseNetworkRoutePlan, encodeNetworkRoutePlan, decodeNetworkRoutePlan } from './networkRoutes.js';

package/dist/{nodeSnapshot.d.ts → capabilitySnapshot.d.ts}

@@ -1,5 +1,5 @@
 import type { JsonObject } from './types.js';
-export interface NodeCapabilitySelection {
+export interface CapabilitySelection {
     schemaVersion: 1;
     modules: Record<string, {
         sha256: string;
@@ -11,28 +11,28 @@ export interface NodeCapabilitySelection {
         handler: string;
     }>;
 }
-export interface NodeCapabilitySnapshot extends NodeCapabilitySelection {
+export interface CapabilitySnapshot extends CapabilitySelection {
     revision: string;
 }
-export interface NodeCapabilityActivation extends NodeCapabilitySnapshot {
+export interface CapabilityActivation extends CapabilitySnapshot {
     installationRevision?: string;
 }
-export declare const MAX_NODE_SELECTION_BYTES = 262144;
+export declare const MAX_CAPABILITY_SELECTION_BYTES = 262144;
 /** Explicit module configuration survives periods where a preset disables its module. */
-export declare function validateNodeModuleConfig(value: Record<string, JsonObject>): Record<string, JsonObject>;
+export declare function validateCapabilityConfig(value: Record<string, JsonObject>): Record<string, JsonObject>;
 /** Preset defaults are inherited; explicit host configuration stays a separate override. */
-export declare function resolvePresetModuleConfig(defaults: JsonObject, overrides?: Record<string, JsonObject>): Record<string, JsonObject>;
+export declare function resolveCapabilityConfig(defaults: JsonObject, overrides?: Record<string, JsonObject>): Record<string, JsonObject>;
 /** Exact content and bindings are selected together; filesystem and code loading belong to hosts. */
-export declare function prepareNodeCapabilitySnapshot(input: NodeCapabilitySelection): Promise<NodeCapabilitySnapshot>;
-export declare function verifyNodeCapabilitySnapshot(input: NodeCapabilitySnapshot): Promise<NodeCapabilitySnapshot>;
+export declare function prepareCapabilitySnapshot(input: CapabilitySelection): Promise<CapabilitySnapshot>;
+export declare function verifyCapabilitySnapshot(input: CapabilitySnapshot): Promise<CapabilitySnapshot>;
 /** The installer receipt and Node selection share one atomic filesystem pointer. */
-export declare function verifyNodeCapabilityActivation(input: NodeCapabilityActivation): Promise<NodeCapabilityActivation>;
+export declare function verifyCapabilityActivation(input: CapabilityActivation): Promise<CapabilityActivation>;
 export declare function prepareNodeBundleSnapshot(bundles: import('./bundle.js').PreparedBundle[], host: string, mearlApiVersion: string, config?: Record<string, JsonObject>): Promise<{
-    snapshot: NodeCapabilitySnapshot;
+    snapshot: CapabilitySnapshot;
     resources: Record<string, Uint8Array>;
 }>;
 /** Browser factories use the same exact module/configuration selection without a Node loader. */
 export declare function prepareBrowserBundleSnapshot(bundles: import('./bundle.js').PreparedBundle[], host: string, mearlApiVersion: string, config?: Record<string, JsonObject>): Promise<{
-    snapshot: NodeCapabilitySnapshot;
+    snapshot: CapabilitySnapshot;
     resources: Record<string, Uint8Array>;
 }>;

package/dist/{nodeSnapshot.js → capabilitySnapshot.js}

@@ -1,95 +1,95 @@
 import { BundleError, MAX_BROWSER_STORAGE_BYTES, MAX_BUNDLE_BYTES, bundleDigest, validateBundleManifest } from './bundle.js';
 import { clonePresetDefaults, isJsonObject } from './manifest.js';
 import { mergePresetDefaults } from './resolve.js';
-export const MAX_NODE_SELECTION_BYTES = 262_144;
+export const MAX_CAPABILITY_SELECTION_BYTES = 262_144;
 const identifier = /^[a-z][a-z0-9-]{0,79}$/;
 const hookName = /^[a-z][a-zA-Z0-9_.-]{0,127}$/;
 const digest = /^[a-f0-9]{64}$/;
 function invalid(message) { throw new BundleError('BUNDLE_INVALID', message); }
 function fields(value, allowed) {
     if (!isJsonObject(value) || Object.keys(value).some(key => !allowed.includes(key)))
-        invalid('Invalid Node capability selection structure');
+        invalid('Invalid Capability selection structure');
 }
 /** Explicit module configuration survives periods where a preset disables its module. */
-export function validateNodeModuleConfig(value) {
+export function validateCapabilityConfig(value) {
     const configs = clonePresetDefaults(value);
-    if (Object.keys(configs).length > 64 || new TextEncoder().encode(JSON.stringify(configs)).byteLength > MAX_NODE_SELECTION_BYTES)
-        throw new BundleError('BUNDLE_QUOTA', 'Node module configuration exceeds its limit');
+    if (Object.keys(configs).length > 64 || new TextEncoder().encode(JSON.stringify(configs)).byteLength > MAX_CAPABILITY_SELECTION_BYTES)
+        throw new BundleError('BUNDLE_QUOTA', 'Capability module configuration exceeds its limit');
     for (const [id, config] of Object.entries(configs))
         if (!identifier.test(id) || !isJsonObject(config))
-            invalid('Node module configuration must map IDs to JSON objects');
+            invalid('Capability module configuration must map IDs to JSON objects');
     return configs;
 }
 /** Preset defaults are inherited; explicit host configuration stays a separate override. */
-export function resolvePresetModuleConfig(defaults, overrides = {}) {
+export function resolveCapabilityConfig(defaults, overrides = {}) {
     const value = defaults.capabilities === undefined ? {} : defaults.capabilities;
     if (!isJsonObject(value))
         invalid('Capability defaults must map module IDs to configuration objects');
-    return validateNodeModuleConfig(mergePresetDefaults(validateNodeModuleConfig(value), validateNodeModuleConfig(overrides)));
+    return validateCapabilityConfig(mergePresetDefaults(validateCapabilityConfig(value), validateCapabilityConfig(overrides)));
 }
 /** Exact content and bindings are selected together; filesystem and code loading belong to hosts. */
-export async function prepareNodeCapabilitySnapshot(input) {
+export async function prepareCapabilitySnapshot(input) {
     const value = clonePresetDefaults(input);
     fields(value, ['schemaVersion', 'modules', 'bindings']);
     if (value.schemaVersion !== 1 || !isJsonObject(value.modules) || !isJsonObject(value.bindings))
-        invalid('Invalid Node capability selection');
+        invalid('Invalid Capability selection');
     if (Object.keys(value.modules).length > 64 || Object.keys(value.bindings).length > 256)
-        throw new BundleError('BUNDLE_QUOTA', 'Node capability selection exceeds the entry limit');
+        throw new BundleError('BUNDLE_QUOTA', 'Capability selection exceeds the entry limit');
     const modules = {};
     let total = 0;
     for (const id of Object.keys(value.modules).sort()) {
         if (!identifier.test(id))
-            invalid('Invalid Node module ID');
+            invalid('Invalid Capability module ID');
         const entry = value.modules[id];
         fields(entry, ['sha256', 'byteLength', 'config']);
         if (typeof entry.sha256 !== 'string' || !digest.test(entry.sha256) || typeof entry.byteLength !== 'number' || !Number.isSafeInteger(entry.byteLength) || entry.byteLength <= 0 || entry.byteLength > MAX_BUNDLE_BYTES)
-            invalid('Invalid Node module resource');
+            invalid('Invalid Capability module resource');
         if (entry.config !== undefined && !isJsonObject(entry.config))
-            invalid('Node module configuration must be a JSON object');
+            invalid('Capability module configuration must be a JSON object');
         total += entry.byteLength;
         if (total > MAX_BROWSER_STORAGE_BYTES)
-            throw new BundleError('BUNDLE_QUOTA', 'Node capability resources exceed 64 MiB');
+            throw new BundleError('BUNDLE_QUOTA', 'Capability resources exceed 64 MiB');
         modules[id] = { sha256: entry.sha256, byteLength: entry.byteLength, ...(entry.config === undefined ? {} : { config: clonePresetDefaults(entry.config) }) };
     }
     const bindings = {};
     for (const name of Object.keys(value.bindings).sort()) {
         if (!hookName.test(name))
-            invalid('Invalid Node hook name');
+            invalid('Invalid Capability hook name');
         const binding = value.bindings[name];
         fields(binding, ['module', 'handler']);
         if (typeof binding.module !== 'string' || !Object.hasOwn(modules, binding.module) || typeof binding.handler !== 'string' || !hookName.test(binding.handler))
-            invalid('Node hook must bind a declared module handler');
+            invalid('Capability hook must bind a declared module handler');
         bindings[name] = { module: binding.module, handler: binding.handler };
     }
     const selection = { schemaVersion: 1, modules, bindings };
-    if (new TextEncoder().encode(JSON.stringify(selection)).byteLength + 80 > MAX_NODE_SELECTION_BYTES)
-        throw new BundleError('BUNDLE_QUOTA', 'Node capability selection metadata exceeds 256 KiB');
+    if (new TextEncoder().encode(JSON.stringify(selection)).byteLength + 80 > MAX_CAPABILITY_SELECTION_BYTES)
+        throw new BundleError('BUNDLE_QUOTA', 'Capability selection metadata exceeds 256 KiB');
     return { ...selection, revision: await bundleDigest(new TextEncoder().encode(JSON.stringify(selection))) };
 }
-export async function verifyNodeCapabilitySnapshot(input) {
+export async function verifyCapabilitySnapshot(input) {
     const value = clonePresetDefaults(input);
     fields(value, ['schemaVersion', 'modules', 'bindings', 'revision']);
     if (typeof value.revision !== 'string' || !digest.test(value.revision))
-        invalid('Invalid Node capability revision');
+        invalid('Invalid Capability revision');
     const { revision, ...selection } = value;
-    const prepared = await prepareNodeCapabilitySnapshot(selection);
+    const prepared = await prepareCapabilitySnapshot(selection);
     if (prepared.revision !== revision)
-        throw new BundleError('BUNDLE_INTEGRITY', 'Node capability selection revision does not match');
+        throw new BundleError('BUNDLE_INTEGRITY', 'Capability selection revision does not match');
     return prepared;
 }
 /** The installer receipt and Node selection share one atomic filesystem pointer. */
-export async function verifyNodeCapabilityActivation(input) {
+export async function verifyCapabilityActivation(input) {
     const value = clonePresetDefaults(input);
     const { installationRevision, ...selection } = value;
     if (installationRevision !== undefined && (typeof installationRevision !== 'string' || !digest.test(installationRevision)))
         invalid('Invalid capability installation revision');
-    const snapshot = await verifyNodeCapabilitySnapshot(selection);
+    const snapshot = await verifyCapabilitySnapshot(selection);
     return { ...snapshot, ...(installationRevision === undefined ? {} : { installationRevision: installationRevision }) };
 }
 async function prepareRuntimeBundleSnapshot(bundles, kind, host, mearlApiVersion, config) {
     if (!identifier.test(host))
-        invalid('Invalid Node runtime host');
-    const configs = validateNodeModuleConfig(config);
+        invalid('Invalid capability runtime host');
+    const configs = validateCapabilityConfig(config);
     const modules = {};
     const bindings = {};
     const resources = {};
@@ -101,20 +101,21 @@ async function prepareRuntimeBundleSnapshot(bundles, kind, host, mearlApiVersion
         if (!runtime)
             continue;
         if (Object.hasOwn(modules, manifest.id))
-            invalid('Duplicate Node module ID');
+            invalid('Duplicate Capability module ID');
         const metadata = manifest.resources[runtime.entry];
         if (!Object.hasOwn(bundle.resources, runtime.entry))
-            invalid('Node module resource is missing');
+            invalid('Capability module resource is missing');
         total += metadata.byteLength;
         if (pending.length >= 64 || total > MAX_BROWSER_STORAGE_BYTES)
-            throw new BundleError('BUNDLE_QUOTA', 'Node capability resources exceed the selection limit');
+            throw new BundleError('BUNDLE_QUOTA', 'Capability resources exceed the selection limit');
         pending.push({ id: manifest.id, bytes: bundle.resources[runtime.entry], sha256: metadata.sha256 });
         if (pending[pending.length - 1].bytes.byteLength !== metadata.byteLength)
-            invalid('Node module length does not match');
-        modules[manifest.id] = { ...metadata, ...(configs[manifest.id] ? { config: clonePresetDefaults(configs[manifest.id]) } : {}) };
+            invalid('Capability module length does not match');
+        const effectiveConfig = mergePresetDefaults(manifest.defaults ?? {}, configs[manifest.id] ?? {});
+        modules[manifest.id] = { ...metadata, ...(Object.keys(effectiveConfig).length ? { config: effectiveConfig } : {}) };
         for (const [name, handler] of Object.entries(runtime.bindings)) {
             if (Object.hasOwn(bindings, name))
-                invalid('Node hook has multiple providers');
+                invalid('Capability hook has multiple providers');
             bindings[name] = { module: manifest.id, handler };
         }
     }
@@ -122,10 +123,10 @@ async function prepareRuntimeBundleSnapshot(bundles, kind, host, mearlApiVersion
     const captured = pending.map(resource => ({ ...resource, bytes: Uint8Array.from(resource.bytes) }));
     for (const resource of captured) {
         if (await bundleDigest(resource.bytes) !== resource.sha256)
-            throw new BundleError('BUNDLE_INTEGRITY', `Node module digest does not match: ${resource.id}`);
+            throw new BundleError('BUNDLE_INTEGRITY', `Capability module digest does not match: ${resource.id}`);
         resources[resource.sha256] = resource.bytes;
     }
-    return { snapshot: await prepareNodeCapabilitySnapshot({ schemaVersion: 1, modules, bindings }), resources };
+    return { snapshot: await prepareCapabilitySnapshot({ schemaVersion: 1, modules, bindings }), resources };
 }
 export function prepareNodeBundleSnapshot(bundles, host, mearlApiVersion, config = {}) {
     return prepareRuntimeBundleSnapshot(bundles, 'nodeRuntimes', host, mearlApiVersion, config);

package/dist/extensionContributions.d.ts

@@ -0,0 +1,29 @@
+import { type PreparedBundle } from './bundle.js';
+import { type BrowserUiText } from './requestUi.js';
+export interface ExtensionContributions {
+    schemaVersion: 1;
+    operations?: Record<string, {
+        hook: string;
+        setting?: string;
+    }>;
+    logins?: Record<string, {
+        url: string;
+        title: BrowserUiText;
+    }>;
+}
+export declare function validateExtensionContributions(input: unknown): ExtensionContributions;
+/** Definitions belong to packages; preset defaults cannot redirect their handlers. */
+export declare function selectExtensionContributions(bundles: PreparedBundle[]): {
+    operations: Record<string, {
+        hook: string;
+        setting?: string;
+    }>;
+    logins: Record<string, {
+        url: string;
+        title: BrowserUiText;
+    }>;
+    owners: Record<string, {
+        bundleId: string;
+        revision: string;
+    }>;
+};