@try-works/dsh-model-as-tool 0.1.0 → 0.1.2

package/lib/mcp/protocol.js

@@ -0,0 +1,387 @@
+/**
+ * The MCP 2026-07-28 wire core.
+ *
+ * The published `@modelcontextprotocol/sdk` (1.32.1) declares
+ * `LATEST_PROTOCOL_VERSION = 2025-11-25` and does not list `2026-07-28` among its
+ * supported revisions, so this is the "separately reviewed, schema-conformant
+ * adaptation" MCP-01 permits where SDK support is incomplete. It is written
+ * against the revision's own requirements rather than by changing a version string
+ * on legacy behaviour, which MCP-01 explicitly says does not satisfy the
+ * requirement.
+ *
+ * What makes this revision different, and what this module exists to enforce:
+ *
+ * - **No handshake.** `tools/list` and `tools/call` must work as the FIRST
+ *   application request. There is no `initialize`, no
+ *   `notifications/initialized`, no prior discovery call and no `Mcp-Session-Id`
+ *   (P26-01). So there is no session state here to get wrong.
+ * - **Per-request metadata.** Version and capabilities travel in `params._meta` on
+ *   EVERY request, and are never inferred from an earlier one (P26-02). That is
+ *   why `_meta` is parsed per request and not cached.
+ * - **Server identity in results.** Every result envelope carries `resultType`,
+ *   and the revision's guidance puts `serverInfo` in result metadata.
+ * - **Errors stay in their lanes** (P26-04): a malformed protocol request is a
+ *   JSON-RPC error, while an application tool failure is a tool-error RESULT. A
+ *   failure wrapped as a successful payload is the specific mistake this prevents.
+ *
+ * @module @try-works/dsh-model-as-tool/mcp/protocol
+ */
+/** The revision this server speaks. */
+export const PROTOCOL_VERSION = '2026-07-28';
+/**
+ * Revisions this server can also serve.
+ *
+ * Kept explicit and short. P26-03 requires an unsupported version to be answered
+ * with the supported list, so the list must be a fact rather than a guess.
+ */
+export const SUPPORTED_PROTOCOL_VERSIONS = [PROTOCOL_VERSION];
+/** The `_meta` keys the revision defines. */
+export const META_KEYS = {
+    protocolVersion: 'io.modelcontextprotocol/protocolVersion',
+    clientInfo: 'io.modelcontextprotocol/clientInfo',
+    clientCapabilities: 'io.modelcontextprotocol/clientCapabilities',
+    serverInfo: 'io.modelcontextprotocol/serverInfo',
+};
+/**
+ * Error codes.
+ *
+ * The reserved range belongs to the protocol. P26-03 is explicit that custom
+ * errors must not be allocated there, so this module declares only codes the
+ * revision defines and refuses to mint new ones in that band.
+ */
+export const ERROR_CODES = {
+    /** Standard JSON-RPC. */
+    parseError: -32700,
+    invalidRequest: -32600,
+    methodNotFound: -32601,
+    invalidParams: -32602,
+    internalError: -32603,
+    /** MCP-reserved. */
+    headerMismatch: -32020,
+    unsupportedClientCapability: -32021,
+    unsupportedProtocolVersion: -32022,
+};
+/** Raised for a request that must be answered with a JSON-RPC error. */
+export class WireError extends Error {
+    name = 'WireError';
+    code;
+    /** Structured detail, as the revision's schema defines for the code. */
+    data;
+    constructor(code, message, data) {
+        super(message);
+        this.code = code;
+        if (data !== undefined)
+            this.data = data;
+    }
+}
+/** Whether a numeric code lies in the range reserved for the protocol. */
+export function isReservedErrorCode(code) {
+    // JSON-RPC's own band plus MCP's -32000..-32099 allocation.
+    return (code >= -32768 && code <= -32000);
+}
+/**
+ * Parse `params._meta` from a request (P26-02).
+ *
+ * Missing required metadata is `invalid params`, not a defaulted value: inferring
+ * a version or a capability from a preceding request is exactly what P26-02
+ * forbids, and defaulting is inference with extra steps.
+ *
+ * The REQUIRED set is taken from the pinned revision schema's `RequestMetaObject`,
+ * which requires `clientCapabilities` and `protocolVersion` — and NOT `clientInfo`.
+ * Requiring `clientInfo` here would reject a request the schema admits, which is a
+ * conformance failure in the opposite direction from accepting too much.
+ *
+ * @param params - the request parameters.
+ * @returns the parsed metadata.
+ * @throws WireError `-32602` when a required key is absent or malformed.
+ */
+export function parseRequestMetadata(params) {
+    const meta = params?._meta;
+    if (typeof meta !== 'object' || meta === null || Array.isArray(meta)) {
+        throw new WireError(ERROR_CODES.invalidParams, 'params._meta is required on every modern request and must be an object');
+    }
+    const record = meta;
+    const protocolVersion = record[META_KEYS.protocolVersion];
+    if (typeof protocolVersion !== 'string' || protocolVersion.length === 0) {
+        throw new WireError(ERROR_CODES.invalidParams, `params._meta["${META_KEYS.protocolVersion}"] is required and must be a string`);
+    }
+    const capabilities = record[META_KEYS.clientCapabilities];
+    if (typeof capabilities !== 'object' || capabilities === null || Array.isArray(capabilities)) {
+        throw new WireError(ERROR_CODES.invalidParams, `params._meta["${META_KEYS.clientCapabilities}"] is required and must be an object`);
+    }
+    // Optional in the schema, so absent is admitted; present-but-malformed is not,
+    // because a client that sends half an Implementation has sent a broken one.
+    const clientInfo = record[META_KEYS.clientInfo];
+    let info = { name: 'unknown', version: 'unknown' };
+    if (clientInfo !== undefined) {
+        if (typeof clientInfo !== 'object' || clientInfo === null) {
+            throw new WireError(ERROR_CODES.invalidParams, `params._meta["${META_KEYS.clientInfo}"], when present, must be an object`);
+        }
+        const candidate = clientInfo;
+        if (typeof candidate.name !== 'string' || typeof candidate.version !== 'string') {
+            throw new WireError(ERROR_CODES.invalidParams, 'clientInfo needs a name and a version');
+        }
+        info = { name: candidate.name, version: candidate.version };
+    }
+    return {
+        protocolVersion,
+        // Self-reported and therefore for DIAGNOSTICS only: P26-02 is explicit that
+        // clientInfo is not authentication, so nothing here is ever used to authorize.
+        clientInfo: info,
+        clientCapabilities: capabilities,
+    };
+}
+/**
+ * Negotiate the protocol version for one request (P26-03).
+ *
+ * @param metadata - the request metadata.
+ * @returns the negotiated version.
+ * @throws WireError `-32022` carrying the official `supported` and `requested` data.
+ */
+export function negotiateVersion(metadata) {
+    if (!SUPPORTED_PROTOCOL_VERSIONS.includes(metadata.protocolVersion)) {
+        throw new WireError(ERROR_CODES.unsupportedProtocolVersion, `unsupported protocol version ${metadata.protocolVersion}`, 
+        // The revision defines this data shape; a bare message would leave the client
+        // unable to choose a version it can speak.
+        { supported: [...SUPPORTED_PROTOCOL_VERSIONS], requested: metadata.protocolVersion });
+    }
+    return metadata.protocolVersion;
+}
+/**
+ * The advertised-feature matrix (P26-12).
+ *
+ * P26-12 forbids advertising Tasks, sampling, resource subscriptions, prompts or
+ * UI extensions merely because an SDK exports their types. Declaring the matrix as
+ * data — with `implemented: false` where that is the truth — means the server
+ * cannot advertise a feature it does not have by accident.
+ */
+export const ADVERTISED_FEATURES = [
+    { feature: 'tools', implemented: true },
+    { feature: 'server/discover', implemented: true },
+    // Now implemented, for TOOL-catalog changes only. P26-12 forbids advertising a
+    // feature that is not implemented, and permits advertising one that is: the
+    // acknowledgement reports the supported subset, so the narrower reality is stated
+    // on the wire rather than implied here.
+    { feature: 'subscriptions/listen', implemented: true },
+    { feature: 'tasks', implemented: false },
+    { feature: 'sampling', implemented: false },
+    { feature: 'elicitation', implemented: false },
+    { feature: 'roots', implemented: false },
+    { feature: 'prompts', implemented: false },
+    { feature: 'resources/subscribe', implemented: false },
+    { feature: 'logging', implemented: false },
+];
+/**
+ * The capabilities object this server may advertise.
+ *
+ * Derived from {@link ADVERTISED_FEATURES} rather than written twice, so the
+ * matrix and the advertised capabilities cannot disagree.
+ * @returns the capability names that are genuinely implemented.
+ */
+export function implementedCapabilities() {
+    return ADVERTISED_FEATURES.filter(entry => entry.implemented).map(entry => entry.feature);
+}
+/**
+ * Whether a client's REQUIRED capability is one this server supports (P26-03).
+ *
+ * @param required - capability names the client declared as required.
+ * @returns the unsupported names, empty when all are supported.
+ */
+export function unsupportedRequiredCapabilities(required) {
+    const implemented = new Set(implementedCapabilities());
+    // `tools` is the only capability a client can require of this server today; any
+    // other requirement cannot be met, and P26-03 wants that answered with -32021
+    // rather than attempted.
+    return required.filter(name => !implemented.has(name));
+}
+/**
+ * The caching fields every cacheable result must carry (P26-14).
+ *
+ * Taken from the pinned schema's `CacheableResult`, which REQUIRES `cacheScope` and
+ * `ttlMs` on `DiscoverResult` and `ListToolsResult` alike. Tool Mode's
+ * authorization-filtered catalogs are private, so the default TTL is zero and the
+ * scope is private — a shared cache keyed on tool names would leak one caller's
+ * permitted set to another.
+ * @returns the caching fields.
+ */
+export function cacheableResultFields() {
+    return { cacheScope: 'private', ttlMs: 0 };
+}
+/**
+ * Build a successful result envelope (P26-04).
+ *
+ * Every modern result carries `resultType`, and `serverInfo` rides in result
+ * metadata per the revision's guidance — `ResultMetaObject` admits exactly that
+ * one key, which is what this writes.
+ * @param result - the method-specific fields.
+ * @param serverInfo - this server's identity.
+ * @returns the result object, including `resultType` and `_meta`.
+ */
+export function successResult(result, serverInfo) {
+    // The metadata is MERGED rather than replaced. A method-specific result may carry
+    // its own `_meta` members that the revision requires —
+    // `SubscriptionsListenResult` must contain
+    // `io.modelcontextprotocol/subscriptionId` — and overwriting the object dropped
+    // it, sending a result with a required field missing. A subscription test caught
+    // this; the pinned schema would have caught it too, and did not only because the
+    // fixture corpus has no subscription case yet.
+    const existing = typeof result._meta === 'object' && result._meta !== null
+        ? result._meta
+        : {};
+    return {
+        ...result,
+        resultType: 'complete',
+        _meta: {
+            ...existing,
+            [META_KEYS.serverInfo]: { name: serverInfo.name, version: serverInfo.version },
+        },
+    };
+}
+/**
+ * Build a tool-error RESULT (P26-04).
+ *
+ * The distinction this preserves is the whole point: an application failure is a
+ * successful protocol exchange carrying `isError`, while a malformed request is a
+ * JSON-RPC error. Wrapping a domain failure as protocol success, or an
+ * infrastructure failure as a successful domain payload, are both forbidden.
+ * @param message - a bounded, model-readable explanation.
+ * @returns the tool-error result.
+ */
+export function toolErrorResult(message) {
+    return {
+        // Truncated because a stack trace or an unbounded message would be neither
+        // model-readable nor safe to return.
+        isError: true,
+        content: [{ type: 'text', text: message.length > 2000 ? `${message.slice(0, 2000)}…` : message }],
+    };
+}
+/**
+ * Build a JSON-RPC error response.
+ *
+ * When the request id is UNKNOWN the `id` member is omitted rather than set to
+ * `null`. JSON-RPC 2.0 conventionally allows `id: null` for an undeterminable id,
+ * but the pinned revision schema types `RequestId` as `string | integer` and does
+ * not admit null — while `id` itself is optional. Omitting it is therefore the
+ * conformant way to say "unknown", and the independent probe caught this by
+ * rejecting a captured 401 whose id was null.
+ *
+ * @param id - the request id, or null when it could not be determined.
+ * @param error - the failure.
+ * @returns the response envelope.
+ */
+export function errorResponse(id, error) {
+    const data = 'data' in error ? error.data : undefined;
+    return {
+        jsonrpc: '2.0',
+        ...id === null ? {} : { id },
+        error: {
+            code: error.code,
+            message: error.message,
+            ...data === undefined ? {} : { data },
+        },
+    };
+}
+/**
+ * Decode the revision's Base64 sentinel encoding (P26-05).
+ *
+ * A header value may be encoded with the official `=?base64?…?=` sentinel, and it
+ * must be decoded BEFORE comparison. Comparing the encoded form would let a client
+ * present a value that decodes to something else entirely.
+ * @param value - the raw header value.
+ * @returns the decoded value.
+ */
+export function decodeHeaderValue(value) {
+    const match = /^=\?base64\?(.*)\?=$/s.exec(value);
+    if (match === null)
+        return value;
+    try {
+        return Buffer.from(match[1], 'base64').toString('utf8');
+    }
+    catch {
+        // A malformed sentinel is left as-is so the comparison against the body fails
+        // and reports a mismatch, rather than being silently accepted as something.
+        return value;
+    }
+}
+/**
+ * Check the required headers against the body (P26-05).
+ *
+ * Headers are checked against BODY FIELDS, so a request cannot claim one method in
+ * a header and another in its body. Every mismatch is `HeaderMismatch` (-32020),
+ * which the HTTP layer reports as 400.
+ * @param headers - the relevant request headers.
+ * @param body - the parsed request.
+ * @returns nothing when the headers agree.
+ * @throws WireError `-32020` naming the first disagreement.
+ */
+export function assertHeadersMatch(headers, body) {
+    const fail = (detail) => {
+        throw new WireError(ERROR_CODES.headerMismatch, detail);
+    };
+    const version = headers.protocolVersion === undefined ? undefined : decodeHeaderValue(headers.protocolVersion);
+    if (version === undefined) {
+        return fail('the MCP-Protocol-Version header is required');
+    }
+    const bodyVersion = body.params?._meta?.[META_KEYS.protocolVersion];
+    if (typeof bodyVersion === 'string' && version !== bodyVersion) {
+        return fail(`the MCP-Protocol-Version header (${version}) does not match the request body (${bodyVersion})`);
+    }
+    const method = headers.method === undefined ? undefined : decodeHeaderValue(headers.method);
+    if (method !== undefined && method !== body.method) {
+        return fail(`the Mcp-Method header (${method}) does not match the request method (${body.method})`);
+    }
+    // `Mcp-Name` is required only for a named call. Requiring it universally would
+    // reject a correct `tools/list`, which has no name.
+    if (body.method === 'tools/call') {
+        const name = headers.name === undefined ? undefined : decodeHeaderValue(headers.name);
+        if (name === undefined)
+            return fail('the Mcp-Name header is required for tools/call');
+        const bodyName = body.params?.name;
+        if (typeof bodyName === 'string' && name !== bodyName) {
+            return fail(`the Mcp-Name header (${name}) does not match the request name (${bodyName})`);
+        }
+    }
+}
+/**
+ * Parse a newline-delimited stdio frame (P26-08).
+ *
+ * Stdio carries protocol traffic on stdout and diagnostics on stderr, so a line
+ * that is not a JSON object is a protocol error rather than something to log and
+ * skip: silently dropping it would leave a client waiting for a response that
+ * never comes.
+ * @param line - one line of input.
+ * @returns the parsed request, or undefined for a blank line.
+ * @throws WireError `-32700` when the line is not a JSON object.
+ */
+export function parseStdioLine(line) {
+    const trimmed = line.trim();
+    if (trimmed.length === 0)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(trimmed);
+    }
+    catch {
+        throw new WireError(ERROR_CODES.parseError, 'the frame is not valid JSON');
+    }
+    if (typeof parsed !== 'object' || parsed === null || Array.isArray(parsed)) {
+        throw new WireError(ERROR_CODES.invalidRequest, 'the frame is not a JSON-RPC object');
+    }
+    const request = parsed;
+    if (request.jsonrpc !== '2.0' || typeof request.method !== 'string') {
+        throw new WireError(ERROR_CODES.invalidRequest, 'the frame is not a JSON-RPC 2.0 request');
+    }
+    return request;
+}
+/**
+ * Serialize one stdio frame.
+ * @param message - the response or notification.
+ * @returns the line, newline-terminated.
+ */
+export function serializeStdioFrame(message) {
+    // A newline inside the JSON would produce two frames and desynchronise the
+    // stream, so the compact form is used and embedded newlines are escaped by
+    // JSON.stringify itself.
+    return `${JSON.stringify(message)}\n`;
+}
+//# sourceMappingURL=protocol.js.map

package/lib/mcp/server.d.ts

@@ -0,0 +1,115 @@
+/**
+ * MCP method dispatch (MCP-05, MCP-06, MCP-08, MCP-09, MCP-13).
+ *
+ * The server is STATELESS by construction, which is what P26-01 requires: a
+ * `tools/list` or `tools/call` must be processable as the first application
+ * request. There is no session table here to require one, so the requirement is
+ * satisfied by the shape of the code rather than by remembering to skip a check.
+ *
+ * Dispatch resolves ONE authorized definition and calls it through the host's
+ * execution path (MCP-08), rather than reaching into a registry by name — the
+ * difference matters because the host's path applies the grant, the receipt and
+ * the result policy, while a direct lookup would bypass all three.
+ *
+ * @module @try-works/dsh-model-as-tool/mcp/server
+ */
+import { type HeaderInput, type WireRequest } from './protocol.ts';
+import type { SubscriptionRegistry } from './subscriptions.ts';
+/** One tool as the MCP surface describes it. */
+export interface McpToolDefinition {
+    /** The caller-facing name. */
+    readonly name: string;
+    /** A short human-readable title, when the contract declares one. */
+    readonly title?: string;
+    /** What the tool does, written for a model. */
+    readonly description: string;
+    /** The canonical input schema, JSON Schema 2020-12. */
+    readonly inputSchema: Readonly<Record<string, unknown>>;
+    /** The canonical OUTPUT schema (MCP-09). */
+    readonly outputSchema: Readonly<Record<string, unknown>>;
+    /** Whether this tool was imported from another MCP server. */
+    readonly importedFromMcp: boolean;
+}
+/** The outcome of invoking one tool. */
+export interface ToolInvocationOutcome {
+    /** The finalized, post-policy canonical value. */
+    readonly structured: unknown;
+    /** A bounded, model-readable rendering. */
+    readonly text: string;
+    /** Whether the tool itself failed. */
+    readonly isError?: boolean;
+}
+/** What dispatch needs from the host. */
+export interface McpHost {
+    /** This server's identity, reported in result metadata. */
+    readonly serverInfo: {
+        readonly name: string;
+        readonly version: string;
+    };
+    /**
+     * The tools this caller may see, in deterministic order (MCP-06).
+     * @returns the authorized definitions.
+     */
+    listTools(): readonly McpToolDefinition[];
+    /**
+     * Invoke one authorized tool through the host execution path (MCP-08).
+     * @param name - the tool name.
+     * @param args - the tool arguments.
+     * @param signal - the caller's abort signal.
+     * @returns the outcome.
+     */
+    callTool(name: string, args: Readonly<Record<string, unknown>>, signal: AbortSignal): Promise<ToolInvocationOutcome>;
+}
+/** One dispatched response. */
+export interface DispatchResult {
+    /** The response envelope to send, or undefined for a notification. */
+    readonly response?: Record<string, unknown>;
+    /** The HTTP status the transport should use. */
+    readonly httpStatus: number;
+    /**
+     * Notifications the transport must deliver after the response (P26-09).
+     *
+     * Carried on the result rather than written into the body, because a notification
+     * is a separate message: embedding one inside a result would produce a frame that
+     * is not a valid result and not a valid notification.
+     */
+    readonly followUp?: readonly Record<string, unknown>[];
+}
+/**
+ * Project a definition into the MCP tool shape.
+ *
+ * `outputSchema` is taken from the resolved definition rather than from DSH's
+ * model-facing `schemas()` projection, which intentionally omits `output`: a
+ * schema-only export built from that projection would be missing the very field
+ * MCP-09 requires.
+ * @param definition - the resolved definition.
+ * @returns the MCP tool descriptor.
+ */
+export declare function toMcpTool(definition: McpToolDefinition): Record<string, unknown>;
+/**
+ * Dispatch one request.
+ *
+ * Stateless: nothing is retained between calls, so a valid request works as the
+ * first one.
+ * @param request - the parsed request.
+ * @param host - the host surface.
+ * @param options - headers and the caller's abort signal.
+ * @returns the response and the HTTP status.
+ */
+export declare function dispatch(request: WireRequest, host: McpHost, options?: {
+    readonly headers?: HeaderInput;
+    readonly signal?: AbortSignal;
+    /** Whether the transport checks headers at all; stdio has none to check. */
+    readonly checkHeaders?: boolean;
+    /**
+     * The catalog subscription registry (P26-09).
+     *
+     * Optional so a host that offers no subscriptions does not have to construct one;
+     * subscriptions/listen then reports the method as unsupported rather than
+     * accepting a subscription it cannot serve.
+     */
+    readonly subscriptions?: SubscriptionRegistry;
+    /** The authenticated client, which a subscription is bound to. */
+    readonly clientId?: string;
+}): Promise<DispatchResult>;
+//# sourceMappingURL=server.d.ts.map

package/lib/mcp/server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAaL,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,eAAe,CAAA;AACtB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAE9D,gDAAgD;AAChD,MAAM,WAAW,iBAAiB;IAChC,8BAA8B;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,oEAAoE;IACpE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;IACvB,+CAA+C;IAC/C,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,uDAAuD;IACvD,QAAQ,CAAC,WAAW,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACvD,4CAA4C;IAC5C,QAAQ,CAAC,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAA;IACxD,8DAA8D;IAC9D,QAAQ,CAAC,eAAe,EAAE,OAAO,CAAA;CAClC;AAED,wCAAwC;AACxC,MAAM,WAAW,qBAAqB;IACpC,kDAAkD;IAClD,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAA;IAC5B,2CAA2C;IAC3C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,sCAAsC;IACtC,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAC3B;AAED,yCAAyC;AACzC,MAAM,WAAW,OAAO;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,UAAU,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;KAAE,CAAA;IACxE;;;OAGG;IACH,SAAS,IAAI,SAAS,iBAAiB,EAAE,CAAA;IACzC;;;;;;OAMG;IACH,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAA;CACrH;AAED,+BAA+B;AAC/B,MAAM,WAAW,cAAc;IAC7B,sEAAsE;IACtE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC3C,gDAAgD;IAChD,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;IAC3B;;;;;;OAMG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,CAAA;CACvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,SAAS,CAAC,UAAU,EAAE,iBAAiB,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAQhF;AAED;;;;;;;;;GASG;AACH,wBAAsB,QAAQ,CAC5B,OAAO,EAAE,WAAW,EACpB,IAAI,EAAE,OAAO,EACb,OAAO,GAAE;IACP,QAAQ,CAAC,OAAO,CAAC,EAAE,WAAW,CAAA;IAC9B,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAA;IAC7B,4EAA4E;IAC5E,QAAQ,CAAC,YAAY,CAAC,EAAE,OAAO,CAAA;IAC/B;;;;;;OAMG;IACH,QAAQ,CAAC,aAAa,CAAC,EAAE,oBAAoB,CAAA;IAC7C,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CACtB,GACL,OAAO,CAAC,cAAc,CAAC,CAsFzB"}