wingfoil 0.2.1

package/dist/mcp/registrar.d.ts

@@ -0,0 +1,54 @@
+/**
+ * The MCP adapter's Tool/Resource registrar (spec-006-core-domain-api §2/§4,
+ * spec-004-mcp-surface-contract — task-006). `registerCoreModules` is the "Tool/Resource
+ * registrar" spec-006 §4.1 refers to: it iterates the exact same `enumerateOperations` order as
+ * `src/cli`'s registrar, and for each operation registers it as **either** an MCP Tool (`mutates:
+ * true`) **or** an MCP Resource (`mutates: false`) — never both, and never a hardcoded allow/deny
+ * list of operation names (§4.2). This is the structural half of REQ-SEC-05 ("MCP Resources are
+ * read-only — mutations only via validated MCP Tools"): a `mutates: true` operation is
+ * *structurally incapable* of being registered as a Resource by this function, and vice versa.
+ *
+ * Naming: Tool names use the dot form `{module}.{verb}` and Resource URIs use the `wingfoil://`
+ * scheme, both per spec-004 (§4.1, §2.1) — spec-004 is the spec explicitly scoped to `src/mcp`
+ * (`scope: "src/mcp"`), so it is authoritative for the actual wire-visible names here, ahead of
+ * spec-006 §5's own (looser, `src/core`-scoped) naming note, which uses a snake_case Tool-name
+ * form (`memory_approve`) that this task deliberately does not follow — see task-006's Execution
+ * Notes for the full reasoning on that spec-004/spec-006 naming discrepancy.
+ *
+ * Resource URIs today are the mechanical, zero-argument `wingfoil://{module}/{verb}` form — spec-004
+ * §2.1's fuller scheme (`wingfoil://memory/{type}/{id}`, `wingfoil://dna/{section}`, ...) adds
+ * sub-resource addressing that today's `CoreOperation` shape (spec-006 §2: just `{name, mutates,
+ * fn}`, no parameter metadata) cannot mechanically derive; that richer addressing is deferred to
+ * whichever feature task (018-030) first registers an operation that needs it.
+ */
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { CoreModule, ParamsBuilder } from '../core/registry';
+/** Ambient dependencies {@link registerCoreModules} needs: how to resolve the project root and how to shape each operation's params. */
+export interface RegisterCoreModulesOptions {
+    /** Resolves the project root a core call is served from (an ambient concern, not a Tool/Resource argument). */
+    readonly resolveRoot: () => string;
+    /** Turns a `ParamsContext` into one operation's typed params (`../core/registry.ts`'s {@link ParamsBuilder}). */
+    readonly buildParams: ParamsBuilder;
+}
+/**
+ * `{module}.{verb}` — spec-004 §4.1's Tool naming convention (mechanical transform of the CLI verb).
+ * An empty `verb` (`deriveVerb`'s flat/no-verb form, task-028-implement-paths-category) collapses to
+ * the bare module name — there is no verb segment to append a `.` before.
+ */
+export declare function deriveMcpToolName(moduleName: string, verb: string): string;
+/**
+ * `wingfoil://{module}/{verb}` — spec-004 §2.1's URI scheme, applied mechanically (see module doc).
+ * Same empty-verb collapse as {@link deriveMcpToolName}: `wingfoil://{module}`, not a trailing-slash
+ * `wingfoil://{module}/`.
+ */
+export declare function deriveMcpResourceUri(moduleName: string, verb: string): string;
+/**
+ * Register every operation in `modules` onto `server`: `mutates: true` as a Tool, `mutates: false`
+ * as a Resource. Each handler wraps exactly one core call (spec-006 §2) and serializes its
+ * `CoreResult` — a successful value as JSON text; a `CoreResult.error` as a Tool `isError: true`
+ * response (spec-004 §4.3's "rejected identically to the CLI path") or, for a Resource read (which
+ * has no `isError` flag in the MCP protocol), a thrown error surfaced as a protocol-level read
+ * failure (spec-004 §2.2's "resource not found"-style refusal, generalized to any read failure).
+ */
+export declare function registerCoreModules(server: McpServer, modules: readonly CoreModule[], options: RegisterCoreModulesOptions): void;
+//# sourceMappingURL=registrar.d.ts.map

package/dist/mcp/registrar.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registrar.d.ts","sourceRoot":"","sources":["../../src/mcp/registrar.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAEzE,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,kBAAkB,CAAC;AAGlE,wIAAwI;AACxI,MAAM,WAAW,0BAA0B;IACzC,+GAA+G;IAC/G,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC;IACnC,iHAAiH;IACjH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;CACrC;AAED;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE1E;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,OAAO,EAAE,SAAS,UAAU,EAAE,EAC9B,OAAO,EAAE,0BAA0B,GAClC,IAAI,CA+CN"}

package/dist/mcp/registrar.js

@@ -0,0 +1,72 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deriveMcpToolName = deriveMcpToolName;
+exports.deriveMcpResourceUri = deriveMcpResourceUri;
+exports.registerCoreModules = registerCoreModules;
+const registry_1 = require("../core/registry");
+/**
+ * `{module}.{verb}` — spec-004 §4.1's Tool naming convention (mechanical transform of the CLI verb).
+ * An empty `verb` (`deriveVerb`'s flat/no-verb form, task-028-implement-paths-category) collapses to
+ * the bare module name — there is no verb segment to append a `.` before.
+ */
+function deriveMcpToolName(moduleName, verb) {
+    return verb ? `${moduleName}.${verb}` : moduleName;
+}
+/**
+ * `wingfoil://{module}/{verb}` — spec-004 §2.1's URI scheme, applied mechanically (see module doc).
+ * Same empty-verb collapse as {@link deriveMcpToolName}: `wingfoil://{module}`, not a trailing-slash
+ * `wingfoil://{module}/`.
+ */
+function deriveMcpResourceUri(moduleName, verb) {
+    return verb ? `wingfoil://${moduleName}/${verb}` : `wingfoil://${moduleName}`;
+}
+/**
+ * Register every operation in `modules` onto `server`: `mutates: true` as a Tool, `mutates: false`
+ * as a Resource. Each handler wraps exactly one core call (spec-006 §2) and serializes its
+ * `CoreResult` — a successful value as JSON text; a `CoreResult.error` as a Tool `isError: true`
+ * response (spec-004 §4.3's "rejected identically to the CLI path") or, for a Resource read (which
+ * has no `isError` flag in the MCP protocol), a thrown error surfaced as a protocol-level read
+ * failure (spec-004 §2.2's "resource not found"-style refusal, generalized to any read failure).
+ */
+function registerCoreModules(server, modules, options) {
+    // Always advertise both channels (spec-004 §1: Resources and Tools are fixed channel types of
+    // the MCP surface), even when `modules` currently has zero operations of one kind — as is the
+    // case for the real production registry today (0 mutating ops; see task-006 Execution Notes).
+    // Without this, a client's `tools/list` call on a server with zero registered Tools fails at the
+    // protocol level ("Method not found") because the SDK only auto-declares a capability the first
+    // time something is registered under it.
+    server.server.registerCapabilities({ tools: {}, resources: {} });
+    for (const { module, operation } of (0, registry_1.enumerateOperations)(modules)) {
+        const verb = (0, registry_1.deriveVerb)(module.name, operation.name);
+        const callCore = async () => {
+            const params = options.buildParams({
+                moduleName: module.name,
+                operationName: operation.name,
+                root: options.resolveRoot(),
+            });
+            const result = await operation.fn(params);
+            return result.ok ? { ok: true, text: JSON.stringify(result.value) } : { ok: false, message: result.error.message };
+        };
+        if (operation.mutates) {
+            const toolName = deriveMcpToolName(module.name, verb);
+            server.registerTool(toolName, { description: `${module.name} ${verb} (mutating)` }, async () => {
+                const outcome = await callCore();
+                return outcome.ok
+                    ? { content: [{ type: 'text', text: outcome.text }] }
+                    : { content: [{ type: 'text', text: outcome.message }], isError: true };
+            });
+        }
+        else {
+            const uri = deriveMcpResourceUri(module.name, verb);
+            const resourceName = deriveMcpToolName(module.name, verb);
+            server.registerResource(resourceName, uri, { description: `${module.name} ${verb} (read-only)` }, async (readUri) => {
+                const outcome = await callCore();
+                if (outcome.ok) {
+                    return { contents: [{ uri: readUri.toString(), mimeType: 'application/json', text: outcome.text }] };
+                }
+                throw new Error(outcome.message);
+            });
+        }
+    }
+}
+//# sourceMappingURL=registrar.js.map

package/dist/mcp/registrar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registrar.js","sourceRoot":"","sources":["../../src/mcp/registrar.ts"],"names":[],"mappings":"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"}

package/dist/mcp/server.d.ts

@@ -0,0 +1,58 @@
+/**
+ * The PRODUCTION MCP server entry point (task-030-implement-mcp-resources, P5.2.1,
+ * spec-014-mcp-server-entry-point §2/§3, spec-004-mcp-surface-contract §1). This is the first place in
+ * the codebase that constructs a real `McpServer` for a shippable process — everything before it
+ * (task-006's `registerCoreModules`, task-011's `registerReadOnlyResources`) only ever ran against the
+ * SDK's in-memory transport inside tests.
+ *
+ * The module is split into a testable constructor and a thin, un-testable transport seam — the same
+ * pattern `src/cli/program.ts`'s `commander` wiring and `src/cli/init-command.ts`'s `createReadlinePrompt`
+ * already use, and for the same reason:
+ *
+ *  - {@link createMcpServer} does all the wiring (construct the `McpServer`, register the v0.1 channel
+ *    set) and performs NO transport / stdio / process I/O, so it is exercised end-to-end over the SDK's
+ *    in-memory transport + a real `Client` in `test/mcp/server.test.ts` (the three P5.2.1 acceptance
+ *    criteria + the read-only-only scope assertion).
+ *  - {@link startMcpServer} adds the single line that cannot be unit-tested without opening a real
+ *    stdio channel: `server.connect(new StdioServerTransport())`. It is verified by hand / at runtime,
+ *    never by an automated test (a test must never open a real stdio server against a repo).
+ *
+ * Channel scope (spec-014 §3): `createMcpServer` registers the read-only Resources channel
+ * (`registerReadOnlyResources` — spec-004 §2, P5.2.1) and, since task-058-mcp-prompts-role-based
+ * (P5.2.2, v0.2), the read-only role Prompts channel (`registerRolePrompts` — spec-004 §3). It
+ * deliberately does NOT call `registerCoreModules`, which would advertise a mutating Tool for every
+ * `mutates: true` CoreOperation (as of task-025, `dnaSet` -> the `dna.set` Tool) — Tools are P5.2.3
+ * (v0.4) scope and will extend the channel set here later; the entry point (`wingfoil mcp` + this
+ * transport wiring) is unchanged by those additions.
+ */
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Construction/connection options for the production MCP server. */
+export interface McpServerOptions {
+    /**
+     * Resolve the project root the Resource handlers read from — invoked lazily, per request, by
+     * task-011's already-registered handlers (never at construction time). The `wingfoil mcp` command
+     * resolves the root once up front and passes a closure returning that value (spec-014 §1).
+     */
+    readonly resolveRoot: () => string;
+    /** Server identity `name`; defaults to `wingfoil`. */
+    readonly name?: string;
+    /** Server identity `version`; defaults to `0.0.0` (the `wingfoil mcp` command passes the real package version). */
+    readonly version?: string;
+}
+/**
+ * Construct the production `McpServer` and register the read-only Resources and role Prompts channels
+ * on it (spec-014 §3). Pure and synchronous — no transport, no stdio, no filesystem read, no process
+ * side effects (spec-014 §2: "no I/O at construction time beyond wiring handlers"); every handler
+ * resolves the root and reads the project per request. So a test can connect it over the SDK's
+ * in-memory transport and drive it with a real `Client`, and `wingfoil mcp` never fails to start
+ * because of the project's content.
+ */
+export declare function createMcpServer(options: McpServerOptions): McpServer;
+/**
+ * Construct the server via {@link createMcpServer} and connect it over a real `StdioServerTransport`.
+ * Resolves once the transport is connected; the process then stays alive serving requests until the
+ * transport closes (client disconnect / stdin EOF). The `server.connect(...)` line is the only part of
+ * this module not covered by an automated test (the thin stdio seam — see the module doc).
+ */
+export declare function startMcpServer(options: McpServerOptions): Promise<McpServer>;
+//# sourceMappingURL=server.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,OAAO,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAKpE,qEAAqE;AACrE,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC;IACnC,sDAAsD;IACtD,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB,mHAAmH;IACnH,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;CAC3B;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,OAAO,EAAE,gBAAgB,GAAG,SAAS,CAQpE;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,SAAS,CAAC,CAKlF"}

package/dist/mcp/server.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMcpServer = createMcpServer;
+exports.startMcpServer = startMcpServer;
+/**
+ * The PRODUCTION MCP server entry point (task-030-implement-mcp-resources, P5.2.1,
+ * spec-014-mcp-server-entry-point §2/§3, spec-004-mcp-surface-contract §1). This is the first place in
+ * the codebase that constructs a real `McpServer` for a shippable process — everything before it
+ * (task-006's `registerCoreModules`, task-011's `registerReadOnlyResources`) only ever ran against the
+ * SDK's in-memory transport inside tests.
+ *
+ * The module is split into a testable constructor and a thin, un-testable transport seam — the same
+ * pattern `src/cli/program.ts`'s `commander` wiring and `src/cli/init-command.ts`'s `createReadlinePrompt`
+ * already use, and for the same reason:
+ *
+ *  - {@link createMcpServer} does all the wiring (construct the `McpServer`, register the v0.1 channel
+ *    set) and performs NO transport / stdio / process I/O, so it is exercised end-to-end over the SDK's
+ *    in-memory transport + a real `Client` in `test/mcp/server.test.ts` (the three P5.2.1 acceptance
+ *    criteria + the read-only-only scope assertion).
+ *  - {@link startMcpServer} adds the single line that cannot be unit-tested without opening a real
+ *    stdio channel: `server.connect(new StdioServerTransport())`. It is verified by hand / at runtime,
+ *    never by an automated test (a test must never open a real stdio server against a repo).
+ *
+ * Channel scope (spec-014 §3): `createMcpServer` registers the read-only Resources channel
+ * (`registerReadOnlyResources` — spec-004 §2, P5.2.1) and, since task-058-mcp-prompts-role-based
+ * (P5.2.2, v0.2), the read-only role Prompts channel (`registerRolePrompts` — spec-004 §3). It
+ * deliberately does NOT call `registerCoreModules`, which would advertise a mutating Tool for every
+ * `mutates: true` CoreOperation (as of task-025, `dnaSet` -> the `dna.set` Tool) — Tools are P5.2.3
+ * (v0.4) scope and will extend the channel set here later; the entry point (`wingfoil mcp` + this
+ * transport wiring) is unchanged by those additions.
+ */
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const index_1 = require("./index");
+/**
+ * Construct the production `McpServer` and register the read-only Resources and role Prompts channels
+ * on it (spec-014 §3). Pure and synchronous — no transport, no stdio, no filesystem read, no process
+ * side effects (spec-014 §2: "no I/O at construction time beyond wiring handlers"); every handler
+ * resolves the root and reads the project per request. So a test can connect it over the SDK's
+ * in-memory transport and drive it with a real `Client`, and `wingfoil mcp` never fails to start
+ * because of the project's content.
+ */
+function createMcpServer(options) {
+    const server = new mcp_js_1.McpServer({
+        name: options.name ?? 'wingfoil',
+        version: options.version ?? '0.0.0',
+    });
+    (0, index_1.registerReadOnlyResources)(server, { resolveRoot: options.resolveRoot });
+    (0, index_1.registerRolePrompts)(server, { resolveRoot: options.resolveRoot });
+    return server;
+}
+/**
+ * Construct the server via {@link createMcpServer} and connect it over a real `StdioServerTransport`.
+ * Resolves once the transport is connected; the process then stays alive serving requests until the
+ * transport closes (client disconnect / stdin EOF). The `server.connect(...)` line is the only part of
+ * this module not covered by an automated test (the thin stdio seam — see the module doc).
+ */
+async function startMcpServer(options) {
+    const server = createMcpServer(options);
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+    return server;
+}
+//# sourceMappingURL=server.js.map

package/dist/mcp/server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"server.js","sourceRoot":"","sources":["../../src/mcp/server.ts"],"names":[],"mappings":";;AAsDA,0CAQC;AAQD,wCAKC;AA3ED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oEAAoE;AACpE,wEAAiF;AAEjF,mCAAyE;AAgBzE;;;;;;;GAOG;AACH,SAAgB,eAAe,CAAC,OAAyB;IACvD,MAAM,MAAM,GAAG,IAAI,kBAAS,CAAC;QAC3B,IAAI,EAAE,OAAO,CAAC,IAAI,IAAI,UAAU;QAChC,OAAO,EAAE,OAAO,CAAC,OAAO,IAAI,OAAO;KACpC,CAAC,CAAC;IACH,IAAA,iCAAyB,EAAC,MAAM,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IACxE,IAAA,2BAAmB,EAAC,MAAM,EAAE,EAAE,WAAW,EAAE,OAAO,CAAC,WAAW,EAAE,CAAC,CAAC;IAClE,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,cAAc,CAAC,OAAyB;IAC5D,MAAM,MAAM,GAAG,eAAe,CAAC,OAAO,CAAC,CAAC;IACxC,MAAM,SAAS,GAAG,IAAI,+BAAoB,EAAE,CAAC;IAC7C,MAAM,MAAM,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC;IAChC,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/mcp/workflow-resource.d.ts

@@ -0,0 +1,17 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+/** Options for {@link registerWorkflowResources}. */
+export interface RegisterWorkflowResourcesOptions {
+    /** Resolves the project root each Workflow Resource read is served from (an ambient concern, not a request parameter). */
+    readonly resolveRoot: () => string;
+}
+/** spec-004 §2.1 — every loaded workflow (main + sub), summary only. */
+export declare const WORKFLOWS_COLLECTION_URI = "wingfoil://workflows";
+/** spec-004 §2.1 — one workflow definition, by `name` (Layer 2 `Workflow.name`). */
+export declare const WORKFLOW_DOCUMENT_URI_TEMPLATE = "wingfoil://workflows/{name}";
+/**
+ * Register both Workflow Resources on `server`. Reads `.wingfoil/workflows.yaml` + every included
+ * Layer-2 file fresh on every request (no server-lifetime cache), matching every other Resource this
+ * task registers.
+ */
+export declare function registerWorkflowResources(server: McpServer, options: RegisterWorkflowResourcesOptions): void;
+//# sourceMappingURL=workflow-resource.d.ts.map

package/dist/mcp/workflow-resource.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-resource.d.ts","sourceRoot":"","sources":["../../src/mcp/workflow-resource.ts"],"names":[],"mappings":"AAqBA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AAMzE,qDAAqD;AACrD,MAAM,WAAW,gCAAgC;IAC/C,0HAA0H;IAC1H,QAAQ,CAAC,WAAW,EAAE,MAAM,MAAM,CAAC;CACpC;AAED,wEAAwE;AACxE,eAAO,MAAM,wBAAwB,yBAAyB,CAAC;AAC/D,oFAAoF;AACpF,eAAO,MAAM,8BAA8B,gCAAgC,CAAC;AAE5E;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,SAAS,EAAE,OAAO,EAAE,gCAAgC,GAAG,IAAI,CAqC5G"}

package/dist/mcp/workflow-resource.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WORKFLOW_DOCUMENT_URI_TEMPLATE = exports.WORKFLOWS_COLLECTION_URI = void 0;
+exports.registerWorkflowResources = registerWorkflowResources;
+/**
+ * `wingfoil://workflows` (collection) and `wingfoil://workflows/{name}` (a single workflow
+ * definition) Resources — task-011-mcp-resources-read-only, REQ-INT-01,
+ * spec-004-mcp-surface-contract §2.1. Distinct from `registerCoreModules`'s existing
+ * `wingfoil://workflow/list` Resource (task-006-dual-interface-shared-core, the generic
+ * `wingfoil://{module}/{verb}` transform of the `workflowList` `CoreOperation`) — both coexist; this
+ * module adds the spec-004 §2.1-conformant plural `wingfoil://workflows` addressing plus
+ * per-workflow single-document addressing, neither of which `registerCoreModules`'s mechanical,
+ * zero-argument URI derivation can produce (spec-006 §2's `CoreOperation` shape has no
+ * sub-resource/parameter metadata — see `src/mcp/registrar.ts`'s own doc comment).
+ *
+ * A workflow's `name` (Layer 2 `Workflow.name`, spec-003-workflows-yaml-schema) is the addressing key
+ * — both `kind: main` and `kind: sub` workflows are addressable through the same URI form; nothing
+ * here distinguishes them beyond what each workflow's own `kind` field already reports.
+ *
+ * Registered directly via `McpServer.registerResource`, not through `registerCoreModules`'s
+ * `CoreModule[]` registry — no `workflowShow` `CoreOperation` exists yet; same
+ * spec-006-core-domain-api §4 parity deviation `memory-resource.ts`/`dna-resource.ts` document for
+ * their own Resources, for the same reason (task-030-implement-mcp-resources' scope).
+ */
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const core_1 = require("../core");
+const read_only_1 = require("./read-only");
+/** spec-004 §2.1 — every loaded workflow (main + sub), summary only. */
+exports.WORKFLOWS_COLLECTION_URI = 'wingfoil://workflows';
+/** spec-004 §2.1 — one workflow definition, by `name` (Layer 2 `Workflow.name`). */
+exports.WORKFLOW_DOCUMENT_URI_TEMPLATE = 'wingfoil://workflows/{name}';
+/**
+ * Register both Workflow Resources on `server`. Reads `.wingfoil/workflows.yaml` + every included
+ * Layer-2 file fresh on every request (no server-lifetime cache), matching every other Resource this
+ * task registers.
+ */
+function registerWorkflowResources(server, options) {
+    server.registerResource('workflows.list', exports.WORKFLOWS_COLLECTION_URI, { description: 'every loaded workflow definition, summary only (read-only)' }, async (uri, extra) => {
+        (0, read_only_1.refuseIfWriteIntent)(extra._meta);
+        const root = options.resolveRoot();
+        const { workflows } = (0, core_1.loadWorkflowsYaml)(root);
+        // Deterministic order (REQ-SYS-07): sorted by `name`, independent of `include` list order.
+        const summaries = [...workflows]
+            .map(({ name, kind, description }) => ({ name, kind, description }))
+            .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+        return (0, read_only_1.jsonResourceResult)(uri, summaries);
+    });
+    const documentTemplate = new mcp_js_1.ResourceTemplate(exports.WORKFLOW_DOCUMENT_URI_TEMPLATE, { list: undefined });
+    server.registerResource('workflows.show', documentTemplate, { description: 'one workflow definition, full content (read-only)' }, async (uri, variables, extra) => {
+        (0, read_only_1.refuseIfWriteIntent)(extra._meta);
+        const root = options.resolveRoot();
+        const { workflows } = (0, core_1.loadWorkflowsYaml)(root);
+        // `variables.name` is typed `string | string[]` (see `memory-resource.ts`'s identical note on
+        // `{type}`/`{id}`) — this template's `{name}` has no explode modifier, so it is always a single
+        // string in practice.
+        const name = variables.name;
+        const workflow = workflows.find((candidate) => candidate.name === name);
+        if (!workflow)
+            throw (0, read_only_1.resourceNotFoundError)(`workflows/${name}`);
+        return (0, read_only_1.jsonResourceResult)(uri, workflow);
+    });
+}
+//# sourceMappingURL=workflow-resource.js.map

package/dist/mcp/workflow-resource.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"workflow-resource.js","sourceRoot":"","sources":["../../src/mcp/workflow-resource.ts"],"names":[],"mappings":";;;AA2CA,8DAqCC;AAhFD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,oEAA2E;AAG3E,kCAA4C;AAE5C,2CAA6F;AAQ7F,wEAAwE;AAC3D,QAAA,wBAAwB,GAAG,sBAAsB,CAAC;AAC/D,oFAAoF;AACvE,QAAA,8BAA8B,GAAG,6BAA6B,CAAC;AAE5E;;;;GAIG;AACH,SAAgB,yBAAyB,CAAC,MAAiB,EAAE,OAAyC;IACpG,MAAM,CAAC,gBAAgB,CACrB,gBAAgB,EAChB,gCAAwB,EACxB,EAAE,WAAW,EAAE,4DAA4D,EAAE,EAC7E,KAAK,EAAE,GAAG,EAAE,KAAK,EAAE,EAAE;QACnB,IAAA,+BAAmB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACjC,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;QACnC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAA,wBAAiB,EAAC,IAAI,CAAC,CAAC;QAC9C,2FAA2F;QAC3F,MAAM,SAAS,GAAG,CAAC,GAAG,SAAS,CAAC;aAC7B,GAAG,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,EAAE,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC,CAAC;aACnE,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,IAAI,GAAG,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;QAEpE,OAAO,IAAA,8BAAkB,EAAC,GAAG,EAAE,SAAS,CAAC,CAAC;IAC5C,CAAC,CACF,CAAC;IAEF,MAAM,gBAAgB,GAAG,IAAI,yBAAgB,CAAC,sCAA8B,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;IACnG,MAAM,CAAC,gBAAgB,CACrB,gBAAgB,EAChB,gBAAgB,EAChB,EAAE,WAAW,EAAE,mDAAmD,EAAE,EACpE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE;QAC9B,IAAA,+BAAmB,EAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QACjC,MAAM,IAAI,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC;QACnC,MAAM,EAAE,SAAS,EAAE,GAAG,IAAA,wBAAiB,EAAC,IAAI,CAAC,CAAC;QAC9C,8FAA8F;QAC9F,gGAAgG;QAChG,sBAAsB;QACtB,MAAM,IAAI,GAAG,SAAS,CAAC,IAAc,CAAC;QACtC,MAAM,QAAQ,GAAG,SAAS,CAAC,IAAI,CAAC,CAAC,SAAS,EAAE,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;QACxE,IAAI,CAAC,QAAQ;YAAE,MAAM,IAAA,iCAAqB,EAAC,aAAa,IAAI,EAAE,CAAC,CAAC;QAEhE,OAAO,IAAA,8BAAkB,EAAC,GAAG,EAAE,QAAQ,CAAC,CAAC;IAC3C,CAAC,CACF,CAAC;AACJ,CAAC"}

package/dist/memory/add.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Turn a human `--title` into a single, valid `[a-z0-9-.]` ID slug piece (spec-009-validation-strategy
+ * §1's ID character class, the same one `generateId` enforces): lowercase, every run of characters
+ * outside `[a-z0-9]` collapsed to one `-`, and no leading/trailing/doubled `-`. Deterministic and
+ * idempotent-shaped so `generateId`'s Pass-B slug check (`[a-z0-9.]+(?:-[a-z0-9.]+)*`) accepts it.
+ */
+export declare function slugifyTitle(title: string): string;
+/**
+ * Parse the CLI `--tags "a,b,c"` value into a trimmed, non-empty string array, or `undefined` when the
+ * option is absent or contributes no tags (so `renderAddDocument` leaves the scaffold's `tags` at its
+ * default rather than writing an empty list).
+ */
+export declare function parseTags(raw: string | undefined): string[] | undefined;
+/** Whether an `id_pattern` contains a `{n}`-family numeric token (e.g. `task-{n}-{slug}`) — i.e. it
+ * needs a sequence counter resolved before {@link generateId} can render it. */
+export declare function hasNumericToken(idPattern: string): boolean;
+/**
+ * The directory that holds every document of a type: the type's `path` pattern
+ * (spec-001-memory-yaml-schema `MemoryTypeEntry.path`, e.g. `docs/memory/decision/{id}.md`) rendered
+ * with a dummy `{id}` and reduced to its containing directory. The directory portion never depends on
+ * the concrete id value, so this is well-defined before the id is generated (used by
+ * {@link nextSequenceNumber} to count existing siblings).
+ */
+export declare function resolveTypeDirectory(root: string, pathPattern: string): string;
+/**
+ * The next sequence number for a `{n}`-token id: `1 +` the count of existing files in `dir` whose
+ * basename (sans `.md`) matches `idPattern` (`patternToRegExp`, task-002). Deterministic — a count is
+ * independent of directory-entry order (REQ-SYS-07) — and confined to this type's own directory, so
+ * unrelated files never perturb it. Returns `1` when the directory does not yet exist.
+ */
+export declare function nextSequenceNumber(dir: string, idPattern: string): number;
+/** The fields `memory.add` pins on the freshly-created draft document (P1.3 memory.add / spec-010). */
+export interface AddDocumentFields {
+    readonly id: string;
+    readonly title: string;
+    readonly tags?: readonly string[];
+}
+/**
+ * Copy a type's `template.file` scaffold verbatim and fill only the frontmatter skeleton `memory.add`
+ * pins (P1.3; spec-010-memory-frontmatter-schema): the generated `id`, the `--title`, the
+ * initial `status: draft`, and — when `--tags` was supplied — the `tags` flow sequence. Every other
+ * field (notably `type` and `tmpl_version`, spec-010: not touched by add) and the whole body are left
+ * exactly as the scaffold had them. `title`/`tags` are JSON-quoted (valid YAML double-quoted scalars /
+ * flow sequences), so an arbitrary title with spaces or colons is written safely.
+ *
+ * @throws when the scaffold has no frontmatter block (a malformed template — a config error surfaced
+ *   as a thrown `Error` the core op maps to a `CoreError`).
+ */
+export declare function renderAddDocument(scaffold: string, fields: AddDocumentFields): string;
+//# sourceMappingURL=add.d.ts.map

package/dist/memory/add.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.d.ts","sourceRoot":"","sources":["../../src/memory/add.ts"],"names":[],"mappings":"AAmBA;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAKlD;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,EAAE,GAAG,SAAS,CAOvE;AAED;gFACgF;AAChF,wBAAgB,eAAe,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAK1D;AAED;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAQzE;AAED,uGAAuG;AACvG,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CACnC;AAsBD;;;;;;;;;;GAUG;AACH,wBAAgB,iBAAiB,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAcrF"}

package/dist/memory/add.js

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.slugifyTitle = slugifyTitle;
+exports.parseTags = parseTags;
+exports.hasNumericToken = hasNumericToken;
+exports.resolveTypeDirectory = resolveTypeDirectory;
+exports.nextSequenceNumber = nextSequenceNumber;
+exports.renderAddDocument = renderAddDocument;
+/**
+ * Pure/domain helpers behind `wingfoil memory add` (P1.3, task-020-implement-memory-add). Factored
+ * out of the `CoreResult`-wrapped orchestration in `src/core` so that (mirroring `dna set`'s split —
+ * pure `setDnaValue` in `src/dna`, the `CoreFn` in `src/core`) the surface-facing operation stays a
+ * thin composition and the id/slug/document-render logic is independently unit-testable.
+ *
+ * Every function here is deterministic (REQ-SYS-07): a slug is a pure function of the title, the
+ * rendered document a pure function of `(scaffold, id, title, tags)`, and the sequence counter a pure
+ * function of the committed on-disk state (a stable count, order-independent) — no wall-clock, no
+ * randomness, no unordered iteration in a value that reaches the produced id or document.
+ */
+const fs_1 = require("fs");
+const path_1 = require("path");
+const storage_1 = require("../storage");
+const validation_1 = require("../validation");
+const TOKEN_RE = /\{([^{}]+)\}/g;
+/**
+ * Turn a human `--title` into a single, valid `[a-z0-9-.]` ID slug piece (spec-009-validation-strategy
+ * §1's ID character class, the same one `generateId` enforces): lowercase, every run of characters
+ * outside `[a-z0-9]` collapsed to one `-`, and no leading/trailing/doubled `-`. Deterministic and
+ * idempotent-shaped so `generateId`'s Pass-B slug check (`[a-z0-9.]+(?:-[a-z0-9.]+)*`) accepts it.
+ */
+function slugifyTitle(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+/**
+ * Parse the CLI `--tags "a,b,c"` value into a trimmed, non-empty string array, or `undefined` when the
+ * option is absent or contributes no tags (so `renderAddDocument` leaves the scaffold's `tags` at its
+ * default rather than writing an empty list).
+ */
+function parseTags(raw) {
+    if (raw === undefined)
+        return undefined;
+    const tags = raw
+        .split(',')
+        .map((tag) => tag.trim())
+        .filter((tag) => tag.length > 0);
+    return tags.length > 0 ? tags : undefined;
+}
+/** Whether an `id_pattern` contains a `{n}`-family numeric token (e.g. `task-{n}-{slug}`) — i.e. it
+ * needs a sequence counter resolved before {@link generateId} can render it. */
+function hasNumericToken(idPattern) {
+    for (const match of idPattern.matchAll(TOKEN_RE)) {
+        if (/^n+$/.test(match[1] ?? ''))
+            return true;
+    }
+    return false;
+}
+/**
+ * The directory that holds every document of a type: the type's `path` pattern
+ * (spec-001-memory-yaml-schema `MemoryTypeEntry.path`, e.g. `docs/memory/decision/{id}.md`) rendered
+ * with a dummy `{id}` and reduced to its containing directory. The directory portion never depends on
+ * the concrete id value, so this is well-defined before the id is generated (used by
+ * {@link nextSequenceNumber} to count existing siblings).
+ */
+function resolveTypeDirectory(root, pathPattern) {
+    return (0, path_1.dirname)((0, path_1.join)(root, (0, storage_1.renderMemoryPath)(pathPattern, { id: '__id__' })));
+}
+/**
+ * The next sequence number for a `{n}`-token id: `1 +` the count of existing files in `dir` whose
+ * basename (sans `.md`) matches `idPattern` (`patternToRegExp`, task-002). Deterministic — a count is
+ * independent of directory-entry order (REQ-SYS-07) — and confined to this type's own directory, so
+ * unrelated files never perturb it. Returns `1` when the directory does not yet exist.
+ */
+function nextSequenceNumber(dir, idPattern) {
+    if (!(0, fs_1.existsSync)(dir) || !(0, fs_1.statSync)(dir).isDirectory())
+        return 1;
+    const re = (0, validation_1.patternToRegExp)(idPattern);
+    let count = 0;
+    for (const entry of (0, fs_1.readdirSync)(dir).sort()) {
+        if (entry.endsWith('.md') && re.test(entry.slice(0, -'.md'.length)))
+            count += 1;
+    }
+    return count + 1;
+}
+/**
+ * Escape a literal string for safe insertion into a `RegExp` source (a frontmatter key here). */
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Set one frontmatter field on the raw frontmatter text, line-based: replace the value on the existing
+ * `^<indent>key:` line if present (preserving the scaffold's ordering, comments and other fields
+ * verbatim — the P1.3 memory.add contract copies the scaffold verbatim), otherwise append the field. `valueYaml`
+ * is the already-serialized YAML scalar/flow value (e.g. a JSON-quoted string, a flow sequence).
+ */
+function setFrontmatterField(frontmatter, key, valueYaml) {
+    const re = new RegExp(`^([ \\t]*)${escapeRegExp(key)}:.*$`, 'm');
+    if (re.test(frontmatter)) {
+        return frontmatter.replace(re, (_match, indent) => `${indent}${key}: ${valueYaml}`);
+    }
+    return `${frontmatter}\n${key}: ${valueYaml}`;
+}
+/**
+ * Copy a type's `template.file` scaffold verbatim and fill only the frontmatter skeleton `memory.add`
+ * pins (P1.3; spec-010-memory-frontmatter-schema): the generated `id`, the `--title`, the
+ * initial `status: draft`, and — when `--tags` was supplied — the `tags` flow sequence. Every other
+ * field (notably `type` and `tmpl_version`, spec-010: not touched by add) and the whole body are left
+ * exactly as the scaffold had them. `title`/`tags` are JSON-quoted (valid YAML double-quoted scalars /
+ * flow sequences), so an arbitrary title with spaces or colons is written safely.
+ *
+ * @throws when the scaffold has no frontmatter block (a malformed template — a config error surfaced
+ *   as a thrown `Error` the core op maps to a `CoreError`).
+ */
+function renderAddDocument(scaffold, fields) {
+    const { frontmatter, body } = (0, storage_1.splitFrontmatter)(scaffold);
+    if (frontmatter === null) {
+        throw new Error('memory template scaffold has no frontmatter block');
+    }
+    let fm = frontmatter;
+    fm = setFrontmatterField(fm, 'id', fields.id);
+    fm = setFrontmatterField(fm, 'title', JSON.stringify(fields.title));
+    fm = setFrontmatterField(fm, 'status', 'draft');
+    if (fields.tags !== undefined) {
+        const flow = `[${fields.tags.map((tag) => JSON.stringify(tag)).join(',')}]`;
+        fm = setFrontmatterField(fm, 'tags', flow);
+    }
+    return `---\n${fm}\n---\n${body}`;
+}
+//# sourceMappingURL=add.js.map

package/dist/memory/add.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"add.js","sourceRoot":"","sources":["../../src/memory/add.ts"],"names":[],"mappings":";;AAyBA,oCAKC;AAOD,8BAOC;AAID,0CAKC;AASD,oDAEC;AAQD,gDAQC;AAwCD,8CAcC;AAtID;;;;;;;;;;GAUG;AACH,2BAAuD;AACvD,+BAAqC;AAErC,wCAAgE;AAChE,8CAAgD;AAEhD,MAAM,QAAQ,GAAG,eAAe,CAAC;AAEjC;;;;;GAKG;AACH,SAAgB,YAAY,CAAC,KAAa;IACxC,OAAO,KAAK;SACT,WAAW,EAAE;SACb,OAAO,CAAC,aAAa,EAAE,GAAG,CAAC;SAC3B,OAAO,CAAC,UAAU,EAAE,EAAE,CAAC,CAAC;AAC7B,CAAC;AAED;;;;GAIG;AACH,SAAgB,SAAS,CAAC,GAAuB;IAC/C,IAAI,GAAG,KAAK,SAAS;QAAE,OAAO,SAAS,CAAC;IACxC,MAAM,IAAI,GAAG,GAAG;SACb,KAAK,CAAC,GAAG,CAAC;SACV,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,CAAC;SACxB,MAAM,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC;IACnC,OAAO,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,SAAS,CAAC;AAC5C,CAAC;AAED;gFACgF;AAChF,SAAgB,eAAe,CAAC,SAAiB;IAC/C,KAAK,MAAM,KAAK,IAAI,SAAS,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QACjD,IAAI,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC;YAAE,OAAO,IAAI,CAAC;IAC/C,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;;;;GAMG;AACH,SAAgB,oBAAoB,CAAC,IAAY,EAAE,WAAmB;IACpE,OAAO,IAAA,cAAO,EAAC,IAAA,WAAI,EAAC,IAAI,EAAE,IAAA,0BAAgB,EAAC,WAAW,EAAE,EAAE,EAAE,EAAE,QAAQ,EAAE,CAAC,CAAC,CAAC,CAAC;AAC9E,CAAC;AAED;;;;;GAKG;AACH,SAAgB,kBAAkB,CAAC,GAAW,EAAE,SAAiB;IAC/D,IAAI,CAAC,IAAA,eAAU,EAAC,GAAG,CAAC,IAAI,CAAC,IAAA,aAAQ,EAAC,GAAG,CAAC,CAAC,WAAW,EAAE;QAAE,OAAO,CAAC,CAAC;IAC/D,MAAM,EAAE,GAAG,IAAA,4BAAe,EAAC,SAAS,CAAC,CAAC;IACtC,IAAI,KAAK,GAAG,CAAC,CAAC;IACd,KAAK,MAAM,KAAK,IAAI,IAAA,gBAAW,EAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC;QAC5C,IAAI,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;YAAE,KAAK,IAAI,CAAC,CAAC;IAClF,CAAC;IACD,OAAO,KAAK,GAAG,CAAC,CAAC;AACnB,CAAC;AASD;iGACiG;AACjG,SAAS,YAAY,CAAC,KAAa;IACjC,OAAO,KAAK,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAC;AACtD,CAAC;AAED;;;;;GAKG;AACH,SAAS,mBAAmB,CAAC,WAAmB,EAAE,GAAW,EAAE,SAAiB;IAC9E,MAAM,EAAE,GAAG,IAAI,MAAM,CAAC,aAAa,YAAY,CAAC,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IACjE,IAAI,EAAE,CAAC,IAAI,CAAC,WAAW,CAAC,EAAE,CAAC;QACzB,OAAO,WAAW,CAAC,OAAO,CAAC,EAAE,EAAE,CAAC,MAAM,EAAE,MAAc,EAAE,EAAE,CAAC,GAAG,MAAM,GAAG,GAAG,KAAK,SAAS,EAAE,CAAC,CAAC;IAC9F,CAAC;IACD,OAAO,GAAG,WAAW,KAAK,GAAG,KAAK,SAAS,EAAE,CAAC;AAChD,CAAC;AAED;;;;;;;;;;GAUG;AACH,SAAgB,iBAAiB,CAAC,QAAgB,EAAE,MAAyB;IAC3E,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,GAAG,IAAA,0BAAgB,EAAC,QAAQ,CAAC,CAAC;IACzD,IAAI,WAAW,KAAK,IAAI,EAAE,CAAC;QACzB,MAAM,IAAI,KAAK,CAAC,mDAAmD,CAAC,CAAC;IACvE,CAAC;IACD,IAAI,EAAE,GAAG,WAAW,CAAC;IACrB,EAAE,GAAG,mBAAmB,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,CAAC,CAAC;IAC9C,EAAE,GAAG,mBAAmB,CAAC,EAAE,EAAE,OAAO,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC;IACpE,EAAE,GAAG,mBAAmB,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAC;IAChD,IAAI,MAAM,CAAC,IAAI,KAAK,SAAS,EAAE,CAAC;QAC9B,MAAM,IAAI,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC;QAC5E,EAAE,GAAG,mBAAmB,CAAC,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,CAAC;IAC7C,CAAC;IACD,OAAO,QAAQ,EAAE,UAAU,IAAI,EAAE,CAAC;AACpC,CAAC"}