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

package/lib/provider-bridge.js

@@ -0,0 +1,423 @@
+/**
+ * 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 { activateExtension, assertNoReservedMeta, EXTENSION_ENTRY, loadExtensionModule, } from '@try-works/tool-mode-extension-sdk';
+import { createInvocationAuthority } from "./authority.js";
+import { isAbsolute, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+/** Raised when a model cannot be served through its declared extension. */
+export class ProviderBridgeError extends Error {
+    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 class ProviderBridge {
+    #activated = new Map();
+    #grant;
+    #generation;
+    #log;
+    /**
+     * The managed-worker registry (EXT-20). Present ONLY when the operator opted in
+     * (`managedWorkers: true`): every executable route — catalog invocation and
+     * inspection — then goes through the worker, and the in-process import/activate
+     * path below is never taken for it. There is NO silent in-process fallback: a
+     * phase the protocol cannot serve is REFUSED with its reason.
+     */
+    #managed;
+    /**
+     * Resolve an extension ID to its ABSOLUTE installed path when the host knows it.
+     *
+     * A store install is not on the plugin package's module graph, so resolving it by
+     * package NAME throws and every store-only tongue/voz deployment records `failed`.
+     * The host supplies the store's verified install path instead; name resolution stays
+     * the fallback for packages that really are dependencies.
+     */
+    #installedPath;
+    constructor(options) {
+        this.#grant = options.grant;
+        this.#generation = options.activationGeneration;
+        this.#managed = options.managed;
+        this.#installedPath = options.installedPath;
+        this.#log = options.log ?? (() => { });
+    }
+    /** The extensions currently activated, for diagnostics. */
+    get activatedExtensions() {
+        return [...this.#activated.keys()];
+    }
+    /**
+     * 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.
+     */
+    async inspect(entry, signal) {
+        const binding = entry.provider;
+        if (binding === undefined)
+            return undefined;
+        if (this.#managed !== undefined) {
+            // EXT-20, managed mode: inspection runs ENTIRELY in the managed process
+            // through the verified SDK inspect API — the entry is never imported in-host.
+            // A store install is reached through its verified absolute path (see
+            // #installedPath); resolving the package name would fail off the plugin graph.
+            const resolved = await resolveExtensionPackage(this.#installedPath?.(binding.extension) ?? binding.extension, entry);
+            const worker = await this.#managed.adapterFor({
+                extensionId: resolved.manifestId,
+                entryPath: resolved.entryPath,
+                manifestPath: resolved.manifestPath,
+                generation: this.#generation,
+            });
+            return await worker.inspect(binding.modelId, { signal });
+        }
+        const activated = await this.#activate(binding.extension, entry);
+        const provider = await this.#providerFor(activated, binding);
+        return provider.inspect(signal);
+    }
+    /**
+     * 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).
+     */
+    async inspectExtension(specifier, modelId, signal, assets) {
+        if (this.#managed !== undefined) {
+            // Managed mode: the SAME worker-backed inspection as the catalog path —
+            // the entry is imported and created only in the child process.
+            const entry = { id: modelId, provider: { extension: specifier, modelId } };
+            return await this.inspect(entry, signal);
+        }
+        const entry = { id: modelId, provider: { extension: specifier, modelId } };
+        const activated = await this.#activate(specifier, entry);
+        const provider = await this.#providerFor(activated, { extension: specifier, modelId });
+        const first = await provider.inspect(signal);
+        /**
+         * A provider can only see the host's VERIFIED asset map through `load()`, and an
+         * extension whose inspect runs without it reports `needs-preparation` even when the
+         * bytes are prepared and verified (Needle: inspect resolves env/config/cache, not the
+         * host map). When inspect itself says it is unprepared and the host HAS a map for
+         * this deployment, hand the map over and re-inspect. This is a recovery path only:
+         * a provider that already reports callable readiness is never loaded here (EXT-18).
+         */
+        if (first?.readiness === 'needs-preparation' && assets !== undefined) {
+            await provider.load({ assets, signal });
+            return await provider.inspect(signal);
+        }
+        return first;
+    }
+    /**
+     * 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) {
+        const binding = entry.provider;
+        if (binding === undefined)
+            return undefined;
+        if (this.#managed !== undefined) {
+            /**
+             * EXT-20, MANAGED MODE: the catalog invocation runs OUT OF PROCESS. The
+             * bridge resolves the entry path by DISCOVERY ONLY (reading the manifest is
+             * not importing), binds the worker to the activation generation, and sends
+             * the pre-authorized input over the wire — the grant, the caller identity
+             * and the host environment never cross, and the HOST resolves the path
+             * authority before the wire because the child's resolver DENIES by design.
+             */
+            const registry = this.#managed;
+            return {
+                modelId: entry.id,
+                invoke: async (invocation) => {
+                    const resolved = await resolveExtensionPackage(this.#installedPath?.(binding.extension) ?? binding.extension, entry);
+                    const authority = invocation.authority ?? createInvocationAuthority(this.#grant, 'interactive');
+                    const input = {};
+                    for (const [key, value] of Object.entries(invocation.args)) {
+                        input[key] = value;
+                    }
+                    // SEC-06: the HOST's authority is the child's path broker — the verified
+                    // SDK protocol asks the host for EVERY path the provider touches, and an
+                    // unauthorized candidate is refused by the authority inside this callback
+                    // BEFORE the child ever opens the file. The broker is request-scoped and
+                    // carries no grant or identity beyond the resolution function.
+                    const resolvePath = (candidate) => authority.resolvePath(candidate);
+                    // EXT-20: the worker is keyed by the TRUE MANIFEST ID, never by the path
+                    // or the package specifier — and the manifest path rides along so the
+                    // registry can stage an owning-package layout for manifest-less store copies.
+                    const worker = await registry.adapterFor({
+                        extensionId: resolved.manifestId,
+                        entryPath: resolved.entryPath,
+                        manifestPath: resolved.manifestPath,
+                        generation: this.#generation,
+                    });
+                    // The CHILD's strict protocol maps IMPLEMENTATION ids to model ids through
+                    // the manifest, so the wire carries the manifest's implementation id for
+                    // this model — never the model id itself (a strict provider refuses a
+                    // model id passed as an implementation id).
+                    const implementationId = resolved.implementations
+                        .find(implementation => implementation.modelId === binding.modelId)?.id
+                        ?? binding.modelId;
+                    const payload = await worker.invoke({
+                        implementationId,
+                        input,
+                        signal: invocation.signal,
+                        resolvePath,
+                    });
+                    // The same reserved-root assertion as the in-process path (EXT-17).
+                    assertNoReservedMeta(payload, binding.modelId);
+                    return payload;
+                },
+                dispose: async () => {
+                    await registry.dispose(binding.extension);
+                },
+            };
+        }
+        return {
+            modelId: entry.id,
+            invoke: async (invocation) => {
+                const activated = await this.#activate(binding.extension, entry);
+                const provider = await this.#providerFor(activated, binding);
+                return this.#invoke(provider, binding, invocation);
+            },
+            // An arrow function, not a method: a method's `this` would be the adapter
+            // object literal rather than the bridge, so `#activated` would not resolve.
+            dispose: async () => {
+                // Provider-level disposal only when a provider was actually created:
+                // disposing a model that was never called must not activate its extension
+                // merely in order to shut it down.
+                const activated = this.#activated.get(binding.extension);
+                if (activated === undefined)
+                    return;
+                const provider = (await activated).providers.get(binding.modelId);
+                if (provider !== undefined)
+                    await (await provider).dispose();
+            },
+        };
+    }
+    /** Release every activated extension. */
+    async dispose(reason = 'shutdown') {
+        const extensions = [...this.#activated.values()];
+        this.#activated.clear();
+        for (const pending of extensions) {
+            try {
+                const activated = await pending;
+                for (const provider of activated.providers.values()) {
+                    await (await provider).dispose();
+                }
+                await activated.instance.dispose(reason);
+            }
+            catch (error) {
+                // One extension failing to stop must not prevent the others from being
+                // released, or a single bad package would leak every process it shares.
+                this.#log('extension disposal failed', { error: String(error) });
+            }
+        }
+    }
+    /** Activate an extension package once, and reuse it. */
+    async #activate(specifier, entry) {
+        const existing = this.#activated.get(specifier);
+        if (existing !== undefined)
+            return existing;
+        const pending = (async () => {
+            // EVERY route (catalog inspect, extension inspect, tool dispatch) loads the
+            // installed copy by PATH when the host knows it: a store install is off this
+            // module graph, so a name lookup is what made tongue/voz fail on every boot.
+            const loaded = await loadExtensionPackage(this.#installedPath?.(specifier) ?? specifier, entry);
+            const instance = await activateExtension(loaded, this.#contextFor(specifier));
+            return { instance, providers: new Map() };
+        })();
+        this.#activated.set(specifier, pending);
+        pending.catch(() => {
+            if (this.#activated.get(specifier) === pending)
+                this.#activated.delete(specifier);
+        });
+        return pending;
+    }
+    /** Create or reuse the provider for one model. */
+    async #providerFor(activated, binding) {
+        const existing = activated.providers.get(binding.modelId);
+        if (existing !== undefined)
+            return existing;
+        const pending = activated.instance.createProvider({
+            modelId: binding.modelId,
+            configuration: {},
+        });
+        activated.providers.set(binding.modelId, pending);
+        pending.catch(() => {
+            if (activated.providers.get(binding.modelId) === pending)
+                activated.providers.delete(binding.modelId);
+        });
+        return pending;
+    }
+    /** Run one invocation through the provider. */
+    async #invoke(provider, binding, invocation) {
+        const authority = invocation.authority ?? createInvocationAuthority(this.#grant, 'interactive');
+        /**
+         * The load is deliberately NOT coordinated here.
+         *
+         * An earlier version routed `provider.load()` through the DeploymentCoordinator at
+         * this point, and the suite caught the consequence: loading then happened BEFORE
+         * the implementation authorized its inputs, so a call with a denied path loaded
+         * ~349 MB of weights before refusing. SEC-06 wants the denial first, and the
+         * extension performs path resolution inside `invoke`, so the coordinator cannot be
+         * placed here without inverting that.
+         *
+         * The coordinator is therefore a tested, standalone component (RES-02/03/05) whose
+         * place is INSIDE an implementation's own load path, where it can sit after the
+         * checks that must precede a load. Wiring it here would have traded a security
+         * property for a resource optimisation.
+         */
+        const input = {};
+        for (const [key, value] of Object.entries(invocation.args)) {
+            input[key] = value;
+        }
+        const payload = await provider.invoke({
+            implementationId: binding.modelId,
+            input,
+            context: {
+                invocationId: `inv_${Date.now().toString(36)}_${Math.floor(Math.random() * 1e6).toString(36)}`,
+                signal: invocation.signal,
+                limits: authority.limits,
+                resolvePath: candidate => authority.resolvePath(candidate),
+            },
+        });
+        // The host authors the reserved root `meta` (EXT-17). An extension supplying one
+        // is asserting its own provenance, which it does not get to do.
+        assertNoReservedMeta(payload, binding.modelId);
+        return payload;
+    }
+    /** Build the context an extension receives, which carries no host internals. */
+    #contextFor(extensionId) {
+        const controller = new AbortController();
+        return {
+            extensionId,
+            extensionVersion: '0.0.0',
+            activationGeneration: this.#generation,
+            storage: {
+                // The host grants a directory it owns; the extension never receives a
+                // path into the operator's own filesystem.
+                directory: '',
+                async read() { return undefined; },
+                async write() { },
+            },
+            logger: {
+                log: (level, message, fields) => {
+                    this.#log(`${level}: ${message}`, fields);
+                },
+            },
+            signal: controller.signal,
+            configuration: {},
+        };
+    }
+}
+/**
+ * Resolve an extension package's entry path, manifest identity and manifest path BY
+ * DISCOVERY ONLY (EXT-20).
+ *
+ * This reads the package's metadata — the package.json and the manifest — and
+ * returns the absolute `./tool-mode` entry path, the manifest's TRUE id, and the
+ * manifest path WITHOUT importing the entry. Managed mode needs exactly this: the
+ * worker child imports the entry in its own process and derives its model mapping
+ * from the manifest, so the host must never load the module — and must key the
+ * worker by the manifest id, never by a path.
+ * @param specifier - the package name or absolute install path.
+ * @param entry - the catalog entry, for diagnostics.
+ * @returns the entry path, the manifest id and the manifest path.
+ * @throws ProviderBridgeError when the package cannot be resolved or has no entry.
+ */
+async function resolveExtensionPackage(specifier, entry) {
+    let packageJsonPath;
+    try {
+        // `import.meta.resolve` is the resolver the runtime itself uses, so the
+        // extension is found exactly as Node would find it at call time. An ABSOLUTE
+        // path resolves to the exact installed copy.
+        if (isAbsolute(specifier)) {
+            packageJsonPath = pathToFileURL(join(specifier, 'package.json')).href;
+        }
+        else {
+            packageJsonPath = import.meta.resolve(`${specifier}/package.json`);
+        }
+    }
+    catch (error) {
+        const origin = isAbsolute(specifier)
+            ? 'the installed package'
+            : `the dependency "${specifier}"`;
+        throw new ProviderBridgeError(`model "${entry.id}" cannot reach ${origin}, which could not be resolved: `
+            + `${error instanceof Error ? error.message : String(error)}. `
+            + (isAbsolute(specifier)
+                ? 'The store install path is unreadable; reinstall the package and retry.'
+                : 'Install it, or correct the catalog binding.'));
+    }
+    const { discoverExtension } = await import('@try-works/tool-mode-extension-sdk');
+    const discovery = discoverExtension(new URL('.', packageJsonPath).pathname.replace(/^\/([A-Za-z]:)/, '$1'));
+    if (discovery.entryPath === undefined) {
+        throw new ProviderBridgeError(`extension "${specifier}" declares no ${EXTENSION_ENTRY} entry, so it cannot provide model "${entry.id}"`);
+    }
+    return {
+        entryPath: discovery.entryPath,
+        manifestId: discovery.manifest.id,
+        manifestPath: discovery.manifestPath,
+        implementations: discovery.manifest.implementations
+            .filter((implementation) => typeof implementation.modelId === 'string')
+            .map(implementation => ({ id: implementation.id, modelId: implementation.modelId })),
+    };
+}
+/**
+ * Import an extension package's public entry.
+ *
+ * The specifier is resolved by Node like any other dependency, then the package's
+ * own discovery runs so the entry comes from its real `exports` map rather than
+ * from a host-side convention.
+ * @param specifier - the package name or path.
+ * @param entry - the catalog entry, for diagnostics.
+ * @returns the validated extension module.
+ * @throws ProviderBridgeError when the package cannot be resolved or has no entry.
+ */
+async function loadExtensionPackage(specifier, entry) {
+    const { entryPath } = await resolveExtensionPackage(specifier, entry);
+    return loadExtensionModule(entryPath);
+}
+//# sourceMappingURL=provider-bridge.js.map

package/lib/ptc-authority.d.ts

@@ -0,0 +1,154 @@
+/**
+ * The authorized tool bindings a PTC program may call (CODE-03, ARCH-01, SEC-03).
+ *
+ * The directive is specific about this, and about what NOT to do:
+ *
+ *   "ONE authorized-tool-pipeline function feeding both native PTC and external
+ *    `tool_mode_run` — intersect requested names with the grant and the visible tool set,
+ *    REJECT unknown/forbidden rather than omit."
+ *
+ * **Reject rather than omit** is the whole design. A program that asks for a tool it may
+ * not have must fail loudly: silently handing it a smaller namespace produces a program
+ * that runs, quietly does something other than what it says, and reports success. That is
+ * worse than a refusal, because the caller cannot tell the difference.
+ *
+ * The bindings themselves are built with a **null prototype**, so a program cannot reach
+ * `Object.prototype` through a binding name — `toString`, `constructor` and `__proto__`
+ * stop being reachable as if they were tools.
+ *
+ * @module @try-works/dsh-tool-mode/ptc-authority
+ */
+/**
+ * One binding a program may call.
+ *
+ * The shape is what a PTC runtime expects: a function that takes already-validated
+ * arguments and returns the tool's canonical value.
+ */
+export type ToolBinding = (args: Record<string, unknown>) => Promise<unknown>;
+/** What a program asked for. */
+export interface ProgramRequest {
+    /** The tool names the generated program declares it will call. */
+    readonly requested: readonly string[];
+}
+/** What the caller is permitted to reach. */
+export interface ProgramAuthority {
+    /**
+     * The tool names the caller's grant admits.
+     *
+     * This is the AUTHORIZATION half. A tool absent here is forbidden regardless of whether
+     * it is registered.
+     */
+    readonly granted: readonly string[];
+    /**
+     * The tool names actually registered right now.
+     *
+     * This is the AVAILABILITY half, and it is separate: a granted tool whose owning
+     * extension is deactivated is not available, while a registered tool the caller has no
+     * grant for is not permitted. Only the INTERSECTION is bindable.
+     */
+    readonly visible: readonly string[];
+    /**
+     * Tools whose canonical value is confidential (MCP-11). These are blocked before a
+     * binding can return their value, regardless of grant.
+     */
+    readonly confidential?: readonly string[];
+}
+/** Why one requested name was refused. */
+export interface BindingRejection {
+    readonly name: string;
+    readonly reason: 
+    /** No such tool is registered. */
+    'unknown'
+    /** Registered, but the caller's grant does not admit it. */
+     | 'forbidden'
+    /** Requested more than once, which makes the program ambiguous. */
+     | 'duplicate'
+    /** Not a usable identifier as a binding name. */
+     | 'invalid-name'
+    /** CODE-07: never bindable inside a program, regardless of grant. */
+     | 'excluded'
+    /** MCP-11: blocked by the operator confidentiality policy. */
+     | 'confidential';
+    /** What the caller can do about it, when anything. */
+    readonly remedy: string;
+}
+/** The outcome of authorizing a program's requested tools. */
+export type AuthorityDecision = {
+    readonly ok: true;
+    /** The bindings, with a null prototype. */
+    readonly bindings: Record<string, ToolBinding>;
+    /** The names that were bound, in request order. */
+    readonly bound: readonly string[];
+} | {
+    readonly ok: false;
+    /**
+     * EVERY rejection, not the first.
+     *
+     * A program asking for three tools it cannot have should learn all three in one
+     * round rather than being handed the next one each time.
+     */
+    readonly rejections: readonly BindingRejection[];
+};
+/**
+ * Generate TypeScript bindings for EXACTLY the names a program was authorized to call
+ * (CODE-03). The generated source is descriptive metadata, not executable code.
+ * @param names - the bound names, after the grant/visibility intersection.
+ * @returns a TypeScript interface declaration.
+ */
+export declare function generateProgramTypes(names: readonly string[]): string;
+/**
+ * Whether a name is usable as a binding.
+ *
+ * A generated program references bindings as identifiers, so a name that is not a plain
+ * identifier cannot be bound — and `__proto__` in particular must never become a key on
+ * the map, since assigning it would change the object's prototype rather than add a field.
+ * @param name - the candidate name.
+ * @returns whether it is usable.
+ */
+export declare function isBindableName(name: string): boolean;
+/**
+ * Tool names a program binding must NEVER expose, regardless of grant (CODE-07).
+ *
+ * `tool_mode_run` is the recursive composition door: a program could nest programs, which
+ * the requirement forbids in v1. The management surface (`model_tools` and the extension
+ * install/activation controls) is operator territory: EXT-32 excludes installer and
+ * administration bindings from Code Mode, and SEC-09 keeps installation approval separate
+ * from tool-use permission, so a program that could reach them would hold the management
+ * grant by proxy.
+ *
+ * EXPORTED so the planning surface (NDL-02) reuses the SAME names: a `tools_plan`
+ * proposal must never target the composition door or the management surface either, and a
+ * second, independently maintained copy of this list would drift the first time one of
+ * them was edited. One set, two consumers, both refused by name.
+ *
+ * SEALED AS A FROZEN ARRAY, deliberately not a frozen `Set`: freezing a `Set` does NOT
+ * prevent `add`/`delete` (those methods mutate internal slots without consulting
+ * extensibility), so a frozen Set would only LOOK immutable. A frozen array throws on
+ * every mutation in strict mode, so neither consumer — nor any code holding a
+ * reference — can add or remove a name at runtime and silently desynchronize the two
+ * surfaces that depend on it.
+ */
+export declare const EXCLUDED_BINDINGS: readonly string[];
+/**
+ * Build the bindings a program may call (CODE-03, SEC-03).
+ *
+ * Intersects the requested names with BOTH the grant and the visible set, and refuses the
+ * whole request if anything is unattainable — so a program never runs against a smaller
+ * namespace than it declared.
+ *
+ * @param request - what the program asked for.
+ * @param authority - what is granted and what is available.
+ * @param resolve - resolves one bound name to its implementation.
+ * @returns the bindings, or every rejection.
+ */
+export declare function authorizeProgramTools(request: ProgramRequest, authority: ProgramAuthority, resolve: (name: string) => ToolBinding | undefined): AuthorityDecision;
+/**
+ * Describe a refusal for a caller (CODE-03).
+ *
+ * Names every rejection and why, because a program author who is told only that the
+ * request failed cannot fix it.
+ * @param rejections - the refusals.
+ * @returns a readable summary.
+ */
+export declare function describeRejections(rejections: readonly BindingRejection[]): string;
+//# sourceMappingURL=ptc-authority.d.ts.map

package/lib/ptc-authority.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ptc-authority.d.ts","sourceRoot":"","sources":["../src/ptc-authority.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;AAE7E,gCAAgC;AAChC,MAAM,WAAW,cAAc;IAC7B,kEAAkE;IAClE,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAA;CACtC;AAED,6CAA6C;AAC7C,MAAM,WAAW,gBAAgB;IAC/B;;;;;OAKG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IACnC;;;;;;OAMG;IACH,QAAQ,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,CAAA;IACnC;;;OAGG;IACH,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CAC1C;AAED,0CAA0C;AAC1C,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,MAAM;IACb,kCAAkC;IAChC,SAAS;IACX,4DAA4D;OAC1D,WAAW;IACb,mEAAmE;OACjE,WAAW;IACb,iDAAiD;OAC/C,cAAc;IAChB,qEAAqE;OACnE,UAAU;IACZ,8DAA8D;OAC5D,cAAc,CAAA;IAClB,sDAAsD;IACtD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CACxB;AAED,8DAA8D;AAC9D,MAAM,MAAM,iBAAiB,GACzB;IACA,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;IACjB,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAA;IAC9C,mDAAmD;IACnD,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAA;CAClC,GACC;IACA,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAA;IAClB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,SAAS,gBAAgB,EAAE,CAAA;CACjD,CAAA;AAEH;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,CAUrE;AAED;;;;;;;;GAQG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAQpD;AAgCD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,eAAO,MAAM,iBAAiB,EAAE,SAAS,MAAM,EAA2H,CAAA;AAE1K;;;;;;;;;;;GAWG;AACH,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,cAAc,EACvB,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,WAAW,GAAG,SAAS,GACjD,iBAAiB,CAgHnB;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAGlF"}