@try-works/dsh-tool-mode 0.0.0-stage → 0.5.44

package/lib/prepared-assets.js

@@ -0,0 +1,471 @@
+/**
+ * The host's prepared-assets path (RES-02/03/05, the last in-repo slice):
+ * lock reading → preparation plan → approval-gated, digest-verified acquisition
+ * into an isolated content-addressed cache → the prepared-cold readiness flip →
+ * the PreparedAssetMapV1 the provider routes consume.
+ *
+ * The verified components this module finally gives callers to:
+ *
+ * - `planPreparation`/`DeploymentIdentity` (deployment-coordinator.ts) — the
+ *   pre-approval disclosure;
+ * - `acquireAsset` (asset-acquisition.ts) — digest+size verified, atomic,
+ *   resumable acquisition with tamper refusal;
+ * - `createHttpSource` (http-acquisition.ts) — the default ranged source.
+ *
+ * Honesty rules carried through:
+ *
+ * - a lock with no digests REFUSES (no guessed values);
+ * - an executable asset WITHOUT the explicit executable-preparation approval
+ *   refuses (RES-02);
+ * - a tampered final path is refused and never flips readiness;
+ * - the cache lives under the host's isolated state dir, never the repo or
+ *   HOME; a REAL network run is opt-in (the default source), and the suite
+ *   injects a local file source so it performs no network.
+ *
+ * @module @try-works/dsh-tool-mode/prepared-assets
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, linkSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, statfsSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { acquireAsset, sameDigest } from "./asset-acquisition.js";
+/**
+ * Parse a models.lock.json document.
+ *
+ * A lock with no digest on any asset REFUSES: a preparation built on guessed
+ * bytes would verify nothing (RES-03).
+ * @param bytes - the lock document.
+ * @returns the parsed lock.
+ */
+export function parseAssetLock(bytes) {
+    let document;
+    try {
+        document = JSON.parse(bytes);
+    }
+    catch (error) {
+        throw new Error(`the asset lock is unreadable: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (typeof document !== 'object' || document === null)
+        throw new Error('the asset lock is not a document');
+    const root = document;
+    const assetSets = root['assetSets'];
+    if (typeof assetSets !== 'object' || assetSets === null)
+        throw new Error('the asset lock declares no assetSets');
+    const sets = {};
+    for (const [setId, rawSet] of Object.entries(assetSets)) {
+        const set = rawSet;
+        const revision = typeof set['pinning'] === 'object' && set['pinning'] !== null
+            ? set['pinning']['revision']
+            : undefined;
+        const license = typeof set['license'] === 'object' && set['license'] !== null
+            ? set['license']
+            : {};
+        const rawGroups = set['groups'];
+        if (!Array.isArray(rawGroups))
+            throw new Error(`asset set ${setId} declares no groups`);
+        const groups = rawGroups.map((rawGroup, groupIndex) => {
+            const group = rawGroup;
+            const rawAssets = group['assets'];
+            if (!Array.isArray(rawAssets))
+                throw new Error(`asset set ${setId} group ${groupIndex} declares no assets`);
+            const assets = rawAssets.map((rawAsset, assetIndex) => {
+                const asset = rawAsset;
+                const digest = typeof asset['digest'] === 'string' ? asset['digest'] : '';
+                const bytes = typeof asset['bytes'] === 'number' ? asset['bytes'] : NaN;
+                const id = typeof asset['id'] === 'string' ? asset['id'] : '';
+                const file = typeof asset['file'] === 'string' ? asset['file'] : '';
+                const source = typeof asset['source'] === 'string' ? asset['source'] : '';
+                if (digest.length === 0 || !Number.isFinite(bytes) || id.length === 0 || file.length === 0) {
+                    throw new Error(`asset set ${setId} group ${groupIndex} asset ${assetIndex} is incomplete; a lock without pinned digests and sizes refuses (RES-03)`);
+                }
+                return { id, file, bytes, source, digest, executable: asset['executable'] === true };
+            });
+            return { id: typeof group['id'] === 'string' ? group['id'] : `group-${groupIndex}`, assets };
+        });
+        sets[setId] = {
+            groups,
+            revision: typeof revision === 'string' ? revision : '',
+            license: {
+                name: typeof license['name'] === 'string' ? license['name'] : 'undeclared',
+                url: typeof license['url'] === 'string' ? license['url'] : '',
+            },
+        };
+    }
+    const lockRevision = Object.values(sets)[0]?.revision ?? '';
+    if (lockRevision.length === 0)
+        throw new Error('the asset lock pins no model revision; a preparation cannot be planned');
+    return { revision: lockRevision, license: Object.values(sets)[0]?.license ?? { name: 'undeclared', url: '' }, sets };
+}
+/** The identity the lock implies for one model deployment. */
+export function identityFor(extensionId, modelId, lock) {
+    return {
+        extensionId,
+        modelId,
+        modelRevision: lock.revision,
+        engineVersion: 'onnxruntime-node',
+        quantization: 'unquantized-fp32',
+        tokenizer: 'gemma',
+        preprocessingRecipe: 'pinned',
+    };
+}
+/** The flat PlannedAsset list for one asset set. */
+export function plannedAssets(lock, assetSetId) {
+    const set = lock.sets[assetSetId];
+    if (set === undefined)
+        throw new Error(`the lock declares no asset set "${assetSetId}"`);
+    return set.groups.flatMap(group => group.assets.map(asset => ({
+        assetId: `${group.id}/${asset.id}`,
+        bytes: asset.bytes,
+        source: asset.source,
+        digest: asset.digest,
+        executable: asset.executable,
+    })));
+}
+/** The group map for one asset set, keyed by group id. */
+export function lockGroups(lock, assetSetId) {
+    const set = lock.sets[assetSetId];
+    if (set === undefined)
+        throw new Error(`the lock declares no asset set "${assetSetId}"`);
+    return set.groups;
+}
+/**
+ * Whether one lock `source` is a resolvable http(s) download URL.
+ * @param source - the lock's source string.
+ * @returns whether a transfer can be planned for it.
+ */
+export function isFetchableAssetSource(source) {
+    /**
+     * A source is fetchable when it has a URI SCHEME at all: https/http, a `file:`
+     * deployment lock, or the injected-source test scheme (`fixture:`). A PROSE
+     * description ("the split export of the pinned checkpoint") has no scheme and
+     * cannot plan a transfer.
+     */
+    return /^[a-z][a-z0-9+.-]*:/i.test(source.trim());
+}
+/**
+ * The operator-facing reason an asset has no transferable location.
+ *
+ * A prose `source` (e.g. "the split export of the pinned checkpoint") is not a
+ * download URL; the bytes must be produced by the documented export and placed in
+ * the prepared-assets cache (file name = the pinned digest) before a transfer-free
+ * preparation can succeed.
+ * @param assetId - the lock asset id.
+ * @param source - the prose/non-URL source.
+ * @returns the exact refusal reason.
+ */
+export function assetSourceUnavailableReason(assetId, source) {
+    return `the asset lock declares no download URL for ${assetId}: its source is ${JSON.stringify(source)}; `
+        + 'the artifacts must be produced by the documented export and placed in the prepared-assets cache';
+}
+/**
+ * The first planned asset with neither an http(s) URL nor bytes already in the cache.
+ *
+ * A cache hit is a legitimate source: a later acquisition still verifies the blob
+ * against the pinned digest, so pre-seeded artifacts are verified rather than trusted.
+ * @param assets - the planned assets to check.
+ * @param cacheRoot - the content-addressed cache root (blob filename = digest).
+ * @returns the first unavailable asset, or undefined when every asset is reachable.
+ */
+export function firstUnavailableAssetSource(assets, cacheRoot) {
+    return assets.find(asset => !isFetchableAssetSource(asset.source) && !existsSync(join(cacheRoot, asset.digest)));
+}
+/** The filesystem store acquisition needs, over node:fs. */
+function fsStore() {
+    return {
+        write(path, bytes) {
+            mkdirSync(join(path, '..'), { recursive: true });
+            writeFileSync(path, bytes);
+        },
+        read(path) {
+            if (!existsSync(path))
+                return undefined;
+            return new Uint8Array(readFileSync(path));
+        },
+        sizeOf(path) {
+            if (!existsSync(path))
+                return 0;
+            return statSyncSize(path);
+        },
+        rename(from, to) {
+            renameSync(from, to);
+        },
+        remove(path) {
+            rmSync(path, { force: true });
+        },
+        exists(path) {
+            return existsSync(path);
+        },
+    };
+}
+/** Synchronous size (the store interface is sync). */
+function statSyncSize(path) {
+    try {
+        return statSync(path).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * The default free-space probe (TASK-131): `statfs` at the nearest existing
+ * ancestor of the path, so a cache root that does not exist yet probes the
+ * volume it will be created on.
+ * @param path - the cache root (which may not exist yet).
+ * @returns the available bytes (bavail × bsize), or 0 when unreadable.
+ */
+export function defaultFreeSpaceBytes(path) {
+    let current = path;
+    for (;;) {
+        try {
+            const stats = statfsSync(current);
+            return stats.bavail * stats.bsize;
+        }
+        catch {
+            const parent = dirname(current);
+            if (parent === current)
+                return 0;
+            current = parent;
+        }
+    }
+}
+/**
+ * Create the prepared-assets registry.
+ * @param options - the cache root and the default source.
+ * @returns the registry.
+ */
+export function createPreparedAssetRegistry(options) {
+    const cacheRoot = options.cacheRoot;
+    const freeSpaceProbe = options.freeSpaceBytes ?? defaultFreeSpaceBytes;
+    const held = new Map();
+    const ownersPath = join(cacheRoot, 'owners.json');
+    /**
+     * Ownership is PERSISTED, not merely computable (RES-03): a restart still knows
+     * which extension references which content-addressed digest, so a future purge
+     * can refuse to delete a blob another owner still needs.
+     */
+    function readOwners() {
+        if (!existsSync(ownersPath))
+            return {};
+        try {
+            const parsed = JSON.parse(readFileSync(ownersPath, 'utf8'));
+            const owners = {};
+            for (const [extensionId, digests] of Object.entries(parsed)) {
+                if (!Array.isArray(digests))
+                    continue;
+                owners[extensionId] = digests.filter((digest) => typeof digest === 'string');
+            }
+            return owners;
+        }
+        catch {
+            // A corrupt ownership index is not evidence of zero owners; it is evidence
+            // that no safe deletion decision can be made, so it reads as empty and the
+            // caller retains blobs (deletion is conservative).
+            return {};
+        }
+    }
+    function writeOwners(owners) {
+        mkdirSync(cacheRoot, { recursive: true });
+        const temporary = `${ownersPath}.${process.pid}.tmp`;
+        writeFileSync(temporary, JSON.stringify(owners, null, 2));
+        renameSync(temporary, ownersPath);
+    }
+    function recordOwnership(extensionId, groups) {
+        const owners = readOwners();
+        owners[extensionId] = [...new Set(groups.flatMap(group => group.files.map(file => file.digest)))];
+        writeOwners(owners);
+    }
+    function forgetOwnership(extensionId) {
+        const owners = readOwners();
+        if (!(extensionId in owners))
+            return;
+        delete owners[extensionId];
+        writeOwners(owners);
+    }
+    // The content-addressed blob pool, shared across extensions (RES-03: two
+    // owners share one set of bytes).
+    return {
+        cacheDirectory: cacheRoot,
+        plans() {
+            return new Map([...held.entries()].map(([extensionId, preparation]) => [extensionId, preparation.plan]));
+        },
+        assetMapFor(extensionId) {
+            const preparation = held.get(extensionId);
+            if (preparation === undefined)
+                return undefined;
+            /**
+             * TWO projections over one verified preparation, both truthful:
+             *
+             * - the GROUP id resolves to the group directory (embeddinggemma's selective
+             *   loading asks for `text-backbone` and reads `onnx/model.onnx` under it);
+             * - each ASSET id resolves to the individual materialized file (needle asks
+             *   for `needle-engine-win-x64` and needs the executable's path).
+             *
+             * The SDK documents the map as asset ids to local handles, so the per-asset
+             * entries are the canonical projection and the group entry is the directory
+             * convenience the first-party group consumers already rely on. An exact
+             * asset-id match wins over a group-id match; the ids are namespaced by the
+             * lock and a collision is not silently served as the other kind.
+             */
+            const groupHandles = new Map();
+            const assetHandles = new Map();
+            for (const group of preparation.groups) {
+                groupHandles.set(group.groupId, { path: group.path, digest: group.digests.join(',') });
+                for (const file of group.files) {
+                    assetHandles.set(file.assetId, { path: file.path, digest: file.digest });
+                }
+            }
+            return {
+                assetIds: [...groupHandles.keys(), ...assetHandles.keys()],
+                get(assetId) {
+                    return assetHandles.get(assetId) ?? groupHandles.get(assetId);
+                },
+            };
+        },
+        groupsFor(extensionId) {
+            return held.get(extensionId)?.groups ?? [];
+        },
+        purge(extensionId) {
+            const extensionRoot = join(cacheRoot, 'groups', extensionId.replaceAll('/', '__'));
+            const removed = existsSync(extensionRoot);
+            if (removed)
+                rmSync(extensionRoot, { recursive: true, force: true });
+            held.delete(extensionId);
+            forgetOwnership(extensionId);
+            return { removed };
+        },
+        /**
+         * RESTART RESTORE. `prepare` is the only thing that fills the in-process map,
+         * and it lives in one process: after a host restart the store still says
+         * `prepared-cold`, the extension activates, and every tool call then fails
+         * with "the text-backbone asset group was not prepared" because the map is
+         * empty. The group directories are on disk from the earlier verified prepare,
+         * so rebuilding the handles from them is a stat walk, not a transfer; a file
+         * that is absent or no longer the recorded size refuses instead of publishing
+         * a handle nobody verified.
+         */
+        restore(extensionId, plan, groups) {
+            const prepared = [];
+            for (const group of groups) {
+                const groupDir = join(cacheRoot, 'groups', plan.identity.extensionId.replaceAll('/', '__'), plan.identity.modelId, group.id);
+                const digests = [];
+                const files = [];
+                for (const asset of group.assets) {
+                    const filePath = join(groupDir, asset.file);
+                    if (!existsSync(filePath) || statSyncSize(filePath) !== asset.bytes) {
+                        return {
+                            ok: false,
+                            reason: `${group.id}/${asset.id} is not in the prepared cache at its recorded size (${filePath})`,
+                        };
+                    }
+                    digests.push(asset.digest);
+                    files.push({ assetId: asset.id, file: asset.file, path: filePath, digest: asset.digest });
+                }
+                prepared.push({ groupId: group.id, path: groupDir, digests, files });
+            }
+            held.set(extensionId, { plan, groups: prepared });
+            recordOwnership(extensionId, prepared);
+            return { ok: true, groups: prepared };
+        },
+        async prepare(extensionId, plan, groups, options) {
+            /**
+             * A lock whose assets carry PROSE sources (no URL) has no transferable
+             * location; refuse BEFORE any acquisition, naming the asset, instead of
+             * surfacing a URL-parse error from deep inside the transport. Artifacts
+             * already materialized in the content-addressed cache are a legitimate
+             * source (a later acquisition still verifies their digest).
+             */
+            const unavailable = firstUnavailableAssetSource(groups.flatMap(group => group.assets.map(asset => ({ assetId: `${group.id}/${asset.id}`, source: asset.source, digest: asset.digest }))), cacheRoot);
+            if (unavailable !== undefined) {
+                return { ok: false, reason: assetSourceUnavailableReason(unavailable.assetId, unavailable.source) };
+            }
+            /**
+             * TASK-131 (RC2): the disk-space preflight. Before anything transfers,
+             * compare the bytes that are actually MISSING from the content-addressed
+             * cache (a digest hit transfers nothing) against the free space at the
+             * cache root, and refuse with a named, actionable error quoting the
+             * numbers — never let a multi-GB transfer run into a mid-stream ENOSPC
+             * that surfaces as a bare transport failure.
+             */
+            const missingAssets = groups.flatMap(group => group.assets)
+                .filter(asset => !existsSync(join(cacheRoot, asset.digest)));
+            const missingBytes = missingAssets.reduce((sum, asset) => sum + asset.bytes, 0);
+            if (missingBytes > 0) {
+                const free = freeSpaceProbe(cacheRoot);
+                if (free < missingBytes) {
+                    return {
+                        ok: false,
+                        reason: `[extension-asset-space-insufficient] the asset cache root ${cacheRoot} needs ${missingBytes} bytes `
+                            + `for ${missingAssets.length} missing asset(s) but only ${free} bytes are free. `
+                            + 'Configure assetCacheRoot on a volume with at least that much free space, or free space, and retry.',
+                    };
+                }
+            }
+            if (!options.allowExecutable && plan.requiresExecutableApproval) {
+                return {
+                    ok: false,
+                    reason: 'the plan includes an EXECUTABLE asset, which requires the separate executable-preparation approval (RES-02); this call did not grant it',
+                };
+            }
+            const store = fsStore();
+            mkdirSync(cacheRoot, { recursive: true });
+            const prepared = [];
+            for (const group of groups) {
+                const groupDir = join(cacheRoot, 'groups', plan.identity.extensionId.replaceAll('/', '__'), plan.identity.modelId, group.id);
+                const digests = [];
+                const files = [];
+                for (const asset of group.assets) {
+                    const planned = {
+                        assetId: asset.id,
+                        bytes: asset.bytes,
+                        source: asset.source,
+                        digest: asset.digest,
+                        executable: asset.executable,
+                    };
+                    // NO in-memory blob shortcut: acquireAsset re-verifies the on-disk
+                    // bytes on every call (a cache HIT transfers zero bytes but still
+                    // checks the digest), so a blob tampered on disk is re-acquired
+                    // rather than trusted from a stale memory record — and two owners
+                    // still share the verified bytes.
+                    const result = await acquireAsset(planned, {
+                        store,
+                        source: options.source,
+                        root: cacheRoot,
+                        signal: options.signal,
+                    });
+                    if (!result.acquired) {
+                        return { ok: false, reason: `${group.id}/${asset.id}: ${result.reason}` };
+                    }
+                    const blob = { digest: result.digest, path: result.path };
+                    // Materialize the lock's per-asset FILE layout inside the group dir via
+                    // a hard link: the provider resolves `${groupDir}/onnx/model.onnx` etc.
+                    // The link shares the verified blob's bytes (same volume); the digest
+                    // was verified at acquisition and the blob path never changes.
+                    mkdirSync(join(groupDir, asset.file, '..'), { recursive: true });
+                    const linkTarget = join(groupDir, asset.file);
+                    if (!existsSync(linkTarget)) {
+                        try {
+                            linkSync(blob.path, linkTarget);
+                        }
+                        catch {
+                            // Hard links can fail across volumes; a copy is the fallback and
+                            // is equally verified because the blob's digest was checked.
+                            writeFileSync(linkTarget, readFileSync(blob.path));
+                        }
+                    }
+                    else if (!sameDigest(createHash('sha256').update(readFileSync(linkTarget)).digest('hex'), asset.digest)) {
+                        // A tampered FINAL path never poisons readiness: it is removed and
+                        // the verified blob re-linked.
+                        rmSync(linkTarget, { force: true });
+                        linkSync(blob.path, linkTarget);
+                    }
+                    digests.push(asset.digest);
+                    files.push({ assetId: asset.id, file: asset.file, path: linkTarget, digest: asset.digest });
+                }
+                prepared.push({ groupId: group.id, path: groupDir, digests, files });
+            }
+            held.set(extensionId, { plan, groups: prepared });
+            recordOwnership(extensionId, prepared);
+            return { ok: true, groups: prepared };
+        },
+    };
+}
+//# sourceMappingURL=prepared-assets.js.map

package/lib/provider-bridge.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Extension provider bridge.
+ *
+ * This is the ONLY route from a catalog entry to model code (BASE-09). The host
+ * no longer imports an adapter for any model: it resolves the extension that
+ * DECLARES the model, loads that extension through its public `./tool-mode`
+ * entry, and asks it for a provider. A first-party package and a third-party
+ * package take the same path, so there is no private built-in adapter route that
+ * only first-party code can use — which is precisely what BASE-09 forbids.
+ *
+ * The binding from a catalog model to an extension is DATA, held in the model's
+ * own catalog entry, not a switch on the model name. Adding a vendor therefore
+ * means publishing a package and adding a catalog row, with no host change.
+ *
+ * @module @try-works/dsh-tool-mode/provider-bridge
+ */
+import { type PreparedAssetMapV1, type ProviderInspectionV1 } from '@try-works/tool-mode-extension-sdk';
+import { type ToolGrant } from './authority.ts';
+import type { ManagedWorkerRegistry } from './managed-workers.ts';
+import type { ModelCatalogEntry } from './types.ts';
+import type { ModelAdapter } from './adapters/types.ts';
+/** How a model's provider is obtained. */
+export interface ProviderBinding {
+    /**
+     * The extension package that implements the model, resolved like any other
+     * dependency. A relative path is admitted so a first-party package can be used
+     * from a checkout before it is published.
+     */
+    readonly extension: string;
+    /** The `modelId` the extension declares for this model. */
+    readonly modelId: string;
+}
+/** Raised when a model cannot be served through its declared extension. */
+export declare class ProviderBridgeError extends Error {
+    readonly name = "ProviderBridgeError";
+}
+/**
+ * Loads extensions and adapts their providers to the host's adapter interface.
+ *
+ * One bridge per plugin activation, so an extension is imported and activated
+ * once no matter how many tools it serves.
+ */
+export declare class ProviderBridge {
+    #private;
+    constructor(options: {
+        readonly grant: ToolGrant;
+        readonly activationGeneration: number;
+        readonly installedPath?: (extensionId: string) => string | undefined;
+        readonly managed?: ManagedWorkerRegistry;
+        readonly log?: (message: string, fields?: Record<string, unknown>) => void;
+    });
+    /** The extensions currently activated, for diagnostics. */
+    get activatedExtensions(): readonly string[];
+    /**
+     * Inspect one extension-backed catalog entry through its provider.
+     *
+     * Inspection is the extension's read-only readiness path (EXT-18). It may import
+     * and activate the extension, but it does not load model assets or invoke the
+     * model; the provider itself must report only approved local state. This is used
+     * by publication and discovery so the host does not equate "the package
+     * resolves" with "the selected deployment is prepared".
+     * @param entry - the catalog entry to inspect.
+     * @param signal - cancellation for the read-only inspection.
+     * @returns the provider's inspection, or undefined for entries with no provider binding.
+     */
+    inspect(entry: ModelCatalogEntry, signal: AbortSignal): Promise<ProviderInspectionV1 | undefined>;
+    /**
+     * Inspect one extension INSTALLED IN THE STORE, keyed by its own manifest model id.
+     *
+     * The catalog-driven {@link inspect} cannot reach an extension that has no catalog
+     * row (EmbeddingGemma and Needle ship declared tools but are not catalogued), which
+     * left their deployments permanently `needs-preparation`. This route activates the
+     * extension through its public entry and inspects the provider the MANIFEST declares,
+     * so "prepared" can become a durable fact for store-installed packages too.
+     *
+     * Inspection remains read-only (EXT-18): no model assets are loaded.
+     * @param specifier - the installed extension package name or ABSOLUTE install path.
+     *   An absolute path runs the exact store copy the caller verified, rather than
+     *   whatever the package name resolves to in the host's own dependency graph.
+     * @param modelId - the model id the extension's manifest declares.
+     * @param signal - cancellation for the read-only inspection.
+     * @returns the provider's inspection, or undefined when the model is not declared.
+     * @throws ProviderBridgeError when the package cannot be resolved or the provider
+     *   refuses creation for this model id (the model's declaredness is the provider's
+     *   to assert, so an undeclared id surfaces as a throw rather than undefined).
+     */
+    inspectExtension(specifier: string, modelId: string, signal: AbortSignal, assets?: Readonly<PreparedAssetMapV1>): Promise<ProviderInspectionV1 | undefined>;
+    /**
+     * Build an adapter for one catalog entry.
+     *
+     * Returns undefined when the entry declares no provider binding, which is the
+     * correct outcome for a model reached through a command transport instead.
+     *
+     * The adapter is LAZY: it does not import or activate the extension until the
+     * first invocation. Two reasons, and the second is the important one:
+     * registering a tool must not run somebody else's package code (EXT-19 requires
+     * import and `create()` to stay lightweight), and a package that fails to load
+     * must fail the CALL it was needed for rather than the registration of every
+     * other tool in the catalog.
+     * @param entry - the catalog entry.
+     * @returns the adapter, or undefined when no extension implements this model.
+     */
+    adapterFor(entry: ModelCatalogEntry): ModelAdapter | undefined;
+    /** Release every activated extension. */
+    dispose(reason?: 'deactivate' | 'upgrade' | 'uninstall' | 'shutdown' | 'fault'): Promise<void>;
+}
+//# sourceMappingURL=provider-bridge.d.ts.map

package/lib/provider-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-bridge.d.ts","sourceRoot":"","sources":["../src/provider-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EASL,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EAC1B,MAAM,oCAAoC,CAAA;AAE3C,OAAO,EAA6B,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1E,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,sBAAsB,CAAA;AAGjE,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAA;AACnD,OAAO,KAAK,EAAgC,YAAY,EAAE,MAAM,qBAAqB,CAAA;AAErF,0CAA0C;AAC1C,MAAM,WAAW,eAAe;IAC9B;;;;OAIG;IACH,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;IAC1B,2DAA2D;IAC3D,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CACzB;AAeD,2EAA2E;AAC3E,qBAAa,mBAAoB,SAAQ,KAAK;IAC5C,SAAkB,IAAI,yBAAwB;CAC/C;AAED;;;;;GAKG;AACH,qBAAa,cAAc;;gBAuBb,OAAO,EAAE;QACnB,QAAQ,CAAC,KAAK,EAAE,SAAS,CAAA;QACzB,QAAQ,CAAC,oBAAoB,EAAE,MAAM,CAAA;QACrC,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;QACpE,QAAQ,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAA;QACxC,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;KAC3E;IAQD,2DAA2D;IAC3D,IAAI,mBAAmB,IAAI,SAAS,MAAM,EAAE,CAE3C;IAED;;;;;;;;;;;OAWG;IACG,OAAO,CAAC,KAAK,EAAE,iBAAiB,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IAsBvG;;;;;;;;;;;;;;;;;;;OAmBG;IACG,gBAAgB,CACpB,SAAS,EAAE,MAAM,EACjB,OAAO,EAAE,MAAM,EACf,MAAM,EAAE,WAAW,EACnB,MAAM,CAAC,EAAE,QAAQ,CAAC,kBAAkB,CAAC,GACpC,OAAO,CAAC,oBAAoB,GAAG,SAAS,CAAC;IA0B5C;;;;;;;;;;;;;;OAcG;IACH,UAAU,CAAC,KAAK,EAAE,iBAAiB,GAAG,YAAY,GAAG,SAAS;IAqF9D,yCAAyC;IACnC,OAAO,CAAC,MAAM,GAAE,YAAY,GAAG,SAAS,GAAG,WAAW,GAAG,UAAU,GAAG,OAAoB,GAAG,OAAO,CAAC,IAAI,CAAC;CA6HjH"}