opensquid 0.5.395

package/dist/engine-client.js

@@ -0,0 +1,301 @@
+/**
+ * Thin JSON-RPC 2.0 client that spawns `loop-engine serve` as a
+ * subprocess and talks to it over stdin/stdout.
+ *
+ * Responsibilities:
+ *  - Spawn the engine binary lazily on first call.
+ *  - Map outgoing requests to pending promises by `id`.
+ *  - Translate JSON-RPC error responses into thrown JS Errors with
+ *    `.code` and `.data` attached.
+ *  - Survive crashes: if the subprocess exits, the next call respawns.
+ *
+ * Binary discovery (v0.4 — see src/config.ts resolveEngineBin):
+ *   1. `OPENSQUID_ENGINE_BIN` env var — explicit override
+ *   2. `<data-root>/config.json` `engine_bin` field — persisted choice
+ *   3. Auto-search common dev paths (~/projects/<*>/engine/target/release/
+ *      and ~/work/<*>/engine/target/release/)
+ *   4. $PATH — system-installed binary
+ *   5. Throw with a helpful error message
+ *
+ * On first successful auto-discovery, the resolved path is written back
+ * to config.json so subsequent sessions skip the search. Moving the
+ * loop-engine checkout invalidates the cached path; the next start
+ * re-discovers automatically.
+ *
+ * v0.2 keeps the subprocess alive across the MCP session lifetime —
+ * a single engine process serves all tool calls until the MCP host
+ * disconnects.
+ */
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { resolveEngineBin } from "./config.js";
+export class RpcError extends Error {
+    code;
+    data;
+    constructor(message, code, data) {
+        super(message);
+        this.name = "RpcError";
+        this.code = code;
+        this.data = data;
+    }
+}
+export class EngineClient {
+    proc = null;
+    reader = null;
+    pending = new Map();
+    nextId = 1;
+    startupAck = null;
+    /** Lazily spawn the engine subprocess. Idempotent. */
+    async ensureStarted() {
+        if (this.proc)
+            return;
+        if (this.startupAck)
+            return this.startupAck;
+        const bin = await resolveEngineBin();
+        if (!bin) {
+            throw new Error("loop-engine binary not found. Set OPENSQUID_ENGINE_BIN, or run " +
+                "`opensquid engine set-path <path>`, or build the engine at " +
+                "~/projects/loop/engine/target/release/loop-engine");
+        }
+        const proc = spawn(bin, ["serve"], {
+            stdio: ["pipe", "pipe", "pipe"],
+            env: {
+                ...process.env,
+                // Pin the engine to opensquid's storage root so the on-disk
+                // layout is shared across both halves.
+                LOOP_HOME: process.env.LOOP_HOME ?? `${process.env.HOME}/.opensquid`,
+            },
+        });
+        this.proc = proc;
+        this.reader = createInterface({ input: proc.stdout });
+        this.reader.on("line", (line) => this.handleLine(line));
+        proc.stderr.on("data", (chunk) => {
+            // Engine logs go to stderr; mirror them but tag so they're
+            // distinguishable from opensquid's own logs.
+            const text = chunk.toString().trimEnd();
+            if (text)
+                console.error(`[engine] ${text}`);
+        });
+        proc.on("exit", (code) => {
+            const reason = `engine subprocess exited (code=${code ?? "null"})`;
+            console.error(`[opensquid] ${reason}`);
+            this.proc = null;
+            this.reader = null;
+            // #170: clear the cached startup promise so the next call's
+            // `ensureStarted()` actually respawns instead of returning the
+            // stale resolved promise from the previous lifetime. Honors the
+            // "Survive crashes: if the subprocess exits, the next call
+            // respawns" invariant in this file's header docstring.
+            this.startupAck = null;
+            // Reject all in-flight calls so callers can retry.
+            for (const [, pending] of this.pending) {
+                pending.reject(new Error(reason));
+            }
+            this.pending.clear();
+        });
+        proc.on("error", (err) => {
+            console.error(`[opensquid] engine spawn error: ${err.message}`);
+        });
+        // Single ping to confirm the engine is live before we return.
+        this.startupAck = this.call("ping", {})
+            .then(() => undefined)
+            .catch((e) => {
+            throw new Error(`engine failed to start: ${e.message}`);
+        });
+        return this.startupAck;
+    }
+    handleLine(line) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(trimmed);
+        }
+        catch (e) {
+            console.error(`[opensquid] failed to parse engine line: ${e}`);
+            return;
+        }
+        const pending = this.pending.get(msg.id);
+        if (!pending) {
+            console.error(`[opensquid] response for unknown id=${msg.id}`);
+            return;
+        }
+        this.pending.delete(msg.id);
+        if (msg.error) {
+            pending.reject(new RpcError(msg.error.message, msg.error.code, msg.error.data));
+        }
+        else {
+            pending.resolve(msg.result);
+        }
+    }
+    /**
+     * Send a JSON-RPC request, await the response. Throws `RpcError` on
+     * engine-side errors; throws `Error` on subprocess crashes.
+     */
+    async call(method, params) {
+        if (method !== "ping")
+            await this.ensureStarted();
+        const id = this.nextId++;
+        return new Promise((resolve, reject) => {
+            this.pending.set(id, {
+                resolve: (v) => resolve(v),
+                reject,
+            });
+            const req = JSON.stringify({ jsonrpc: "2.0", id, method, params });
+            if (!this.proc) {
+                reject(new Error("engine subprocess not running"));
+                return;
+            }
+            this.proc.stdin.write(req + "\n");
+        });
+    }
+    /** Graceful shutdown — kill the subprocess. */
+    shutdown() {
+        if (this.proc) {
+            this.proc.kill();
+            this.proc = null;
+        }
+    }
+}
+export class OpenSquidEngine {
+    client = new EngineClient();
+    shutdown() {
+        this.client.shutdown();
+    }
+    ping() {
+        return this.client.call("ping", {});
+    }
+    createLesson(args) {
+        return this.client.call("lesson.create", args);
+    }
+    recall(args) {
+        return this.client.call("lesson.recall", args);
+    }
+    promote(args) {
+        return this.client.call("lesson.promote", args);
+    }
+    discard(args) {
+        return this.client.call("lesson.discard", args);
+    }
+    /**
+     * v0.5 / engine v1.3: paginated list across the four non-discarded
+     * status dirs. Order is deterministic (status then id ascending).
+     * Default limit 50, capped at 500. Pass `statuses` to restrict to
+     * specific dirs (e.g. `["pending"]` for the pending-candidates flow).
+     */
+    listLessons(args) {
+        return this.client.call("lesson.list", args);
+    }
+    /**
+     * v0.5 / engine v1.3: record a thumbs-up or thumbs-down on a lesson.
+     * Adds to the lesson's `external_signal_sources`, which feeds the
+     * wedge gate's signal-diversity check. Idempotent on
+     * `source_signal_id` — passing the same signal twice doesn't
+     * double-count. If `source_signal_id` is omitted, the engine mints a
+     * synthetic one (the call still records).
+     */
+    captureFeedback(args) {
+        return this.client.call("lesson.capture_feedback", args);
+    }
+    /**
+     * v0.5 / engine v1.3: point an old lesson at a new replacement.
+     * Old lesson moves to `superseded/`, new lesson is unaffected. The
+     * causal chain is preserved via `superseded_by`. User-authored
+     * lessons are protected unless `force: true`.
+     *
+     * Engine errors:
+     *   -32004 — supersede blocked (cycle detected, self-reference,
+     *            or replacement not found)
+     *   -32001 — user lesson immune (force=true required)
+     *   -32002 — old or new lesson not found
+     */
+    supersedeLesson(args) {
+        return this.client.call("lesson.supersede", args);
+    }
+    createMemory(args) {
+        return this.client.call("memory.create", args);
+    }
+    searchMemory(args) {
+        return this.client.call("memory.search", args);
+    }
+    /**
+     * v0.3.1: fetch a single memory by id with full content + scope.
+     * Throws `RpcError` with code -32002 if no memory with that id
+     * exists (engine returns `DispatchError::NotFound`).
+     */
+    getMemory(args) {
+        return this.client.call("memory.get", args);
+    }
+    /**
+     * v0.5 / engine v1.4: central RAG-style assembly. Returns active
+     * lessons (deterministic-sorted, gate-annotated, applied_count
+     * bumped) + optional memory recall in one shot. This is what a host
+     * like Hermes calls to get "what rules apply right now" instead of
+     * stitching together listLessons + searchMemory.
+     *
+     * Skill/persona/team activation IDs are not threaded through in v0.5
+     * (deferred to a later release per find-simple-solutions). The
+     * active_skills / active_personas / active_teams arrays in the
+     * response ship empty.
+     */
+    assembleManifest(args) {
+        return this.client.call("manifest.assemble", args);
+    }
+    /**
+     * v0.5 / engine v1.3: paginated memory enumeration. Filter-optional
+     * via scope_filter (same wire shape as searchMemory). Default limit
+     * 50, capped at 500. Order is deterministic (id ascending — memory
+     * ids are ULID-shaped so this is roughly chronological).
+     *
+     * Returns frontmatter rows but NOT body — call getMemory(id) for
+     * the full content of any single hit. consumed_by_user_lessons is
+     * the reverse-citation count enforcing the user-immunity invariant
+     * (>0 means a user-authored lesson cites this memory; prune refuses).
+     */
+    listMemories(args) {
+        return this.client.call("memory.list", args);
+    }
+    /**
+     * v0.4: mutate description / content / scope on an existing memory.
+     * Identity, citation counter, derived_from, and origin are always
+     * preserved. Re-embeds on content change; cheap path for
+     * description/scope-only edits. At least one mutable field must
+     * be supplied. Throws `RpcError` -32002 if the id doesn't exist.
+     */
+    updateMemory(args) {
+        return this.client.call("memory.update", args);
+    }
+    /**
+     * v0.4: `forget` — delete a memory. `force = false` (default)
+     * respects user-immunity (returns RpcError -32003 if cited by a
+     * user-authored lesson). `force = true` is the user-initiated
+     * override.
+     */
+    deleteMemory(args) {
+        return this.client.call("memory.delete", args);
+    }
+    // ---- v0.6.1 — phase ledger (engine 0.5.0+) ----------------------
+    /**
+     * Record a phase entry for `task_id`. Idempotent: re-logging the
+     * same phase returns `newly_recorded: false`. `phase` must be one
+     * of: pre_research, learn, code, test, audit, post_research, fix.
+     *
+     * Pre-#166 this also took a `session_id`, but the writer's MCP
+     * session id and the reader's Claude Code session UUID were two
+     * different id surfaces — the ledger was unreadable across them.
+     * Dropped in favor of per-task scoping; a task that spans multiple
+     * sessions now accumulates phases correctly.
+     */
+    logPhase(args) {
+        return this.client.call("task.log_phase", args);
+    }
+    /**
+     * Fetch the workflow phase ledger for `task_id`. Returns the set of
+     * phases logged + the entries with timestamps, sorted
+     * chronologically.
+     */
+    getTaskLedger(args) {
+        return this.client.call("task.get_ledger", args);
+    }
+}

package/dist/engine-client.test.js

@@ -0,0 +1,118 @@
+/**
+ * engine-client subprocess lifecycle tests.
+ *
+ * #170 (2026-05-17): the first test for engine-client.ts. Spawned by the
+ * pkill-validation incident that surfaced a permanent-stuck-state bug
+ * when the engine subprocess exits externally:
+ *
+ *   1. ensureStarted() spawns subprocess + caches a resolved
+ *      `startupAck` promise after the initial ping succeeds.
+ *   2. Subprocess dies (pkill / OOM / crash).
+ *   3. proc.on("exit") nulls `proc` and `reader` but pre-#170 left
+ *      `startupAck` truthy.
+ *   4. Next call: ensureStarted() returns the cached resolved
+ *      startupAck without respawning. call() then sees `proc === null`
+ *      and rejects with "engine subprocess not running" — for the rest
+ *      of the MCP server's lifetime.
+ *
+ * This test mocks `node:child_process` so we can simulate the exit
+ * event deterministically without spawning a real binary.
+ */
+import { EventEmitter } from "node:events";
+import { PassThrough } from "node:stream";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+const mockSpawn = vi.fn();
+vi.mock("node:child_process", () => ({
+    spawn: (...args) => mockSpawn(...args),
+}));
+// vi.mock must be set up before the import; dynamic import keeps that ordering.
+const { EngineClient } = await import("./engine-client.js");
+function makeMockProc() {
+    const proc = new EventEmitter();
+    proc.stdin = new PassThrough();
+    proc.stdout = new PassThrough();
+    proc.stderr = new PassThrough();
+    proc.kill = vi.fn();
+    return proc;
+}
+/** Read the next line written to a stream (e.g. mock stdin). */
+function nextLine(stream) {
+    return new Promise((resolve) => {
+        let buf = "";
+        const onData = (chunk) => {
+            buf += chunk.toString("utf8");
+            const nl = buf.indexOf("\n");
+            if (nl >= 0) {
+                stream.off("data", onData);
+                resolve(buf.slice(0, nl));
+            }
+        };
+        stream.on("data", onData);
+    });
+}
+beforeEach(() => {
+    mockSpawn.mockReset();
+});
+afterEach(() => {
+    vi.useRealTimers();
+});
+describe("OpenSquidEngine subprocess lifecycle (#170)", () => {
+    it("respawns the subprocess after an external exit", async () => {
+        const proc1 = makeMockProc();
+        const proc2 = makeMockProc();
+        mockSpawn.mockReturnValueOnce(proc1).mockReturnValueOnce(proc2);
+        // Construct engine via fresh import each test so it has no resolveEngineBin
+        // memo from a previous test (resolveEngineBin reads the env var on each call).
+        process.env.OPENSQUID_ENGINE_BIN = "/fake/path/loop-engine";
+        const engine = new EngineClient();
+        // --- First call: triggers ensureStarted() → spawns proc1, sends ping ---
+        const callP1 = engine.call("task.example", {});
+        // Wait for proc1's stdin to receive the startup ping, then ack it.
+        const startupPingLine = await nextLine(proc1.stdin);
+        const startupReq = JSON.parse(startupPingLine);
+        expect(startupReq.method).toBe("ping");
+        proc1.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: startupReq.id, result: { ok: true } }) + "\n");
+        // Now proc1's stdin will receive the user's actual call. Respond.
+        const userReqLine = await nextLine(proc1.stdin);
+        const userReq = JSON.parse(userReqLine);
+        expect(userReq.method).toBe("task.example");
+        proc1.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: userReq.id, result: { ok: true } }) + "\n");
+        await expect(callP1).resolves.toEqual({ ok: true });
+        // --- Simulate external subprocess exit ---
+        proc1.emit("exit", 1);
+        // Give the exit handler microtasks a tick to run.
+        await new Promise((r) => setImmediate(r));
+        // --- Second call: must respawn proc2 (pre-#170 this would have thrown
+        // "engine subprocess not running" because startupAck was still cached) ---
+        const callP2 = engine.call("task.example", {});
+        const startupPing2 = await nextLine(proc2.stdin);
+        const startupReq2 = JSON.parse(startupPing2);
+        expect(startupReq2.method).toBe("ping");
+        proc2.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: startupReq2.id, result: { ok: true } }) + "\n");
+        const userReq2Line = await nextLine(proc2.stdin);
+        const userReq2 = JSON.parse(userReq2Line);
+        expect(userReq2.method).toBe("task.example");
+        proc2.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: userReq2.id, result: { ok: true } }) + "\n");
+        await expect(callP2).resolves.toEqual({ ok: true });
+        expect(mockSpawn).toHaveBeenCalledTimes(2);
+        delete process.env.OPENSQUID_ENGINE_BIN;
+    });
+    it("rejects in-flight pending calls when the subprocess exits", async () => {
+        const proc1 = makeMockProc();
+        mockSpawn.mockReturnValueOnce(proc1);
+        process.env.OPENSQUID_ENGINE_BIN = "/fake/path/loop-engine";
+        const engine = new EngineClient();
+        // Start a call, ack the startup ping, then DON'T respond to the user
+        // call — instead simulate exit.
+        const callP = engine.call("task.example", {});
+        const startupPing = await nextLine(proc1.stdin);
+        const startupReq = JSON.parse(startupPing);
+        proc1.stdout.write(JSON.stringify({ jsonrpc: "2.0", id: startupReq.id, result: { ok: true } }) + "\n");
+        // Drain the user-call line so the test doesn't hang on backpressure.
+        await nextLine(proc1.stdin);
+        // Simulate crash.
+        proc1.emit("exit", null);
+        await expect(callP).rejects.toThrow(/engine subprocess exited/);
+        delete process.env.OPENSQUID_ENGINE_BIN;
+    });
+});

package/dist/functions/active_task.d.ts

@@ -0,0 +1,90 @@
+/**
+ * AP.4 — read-side primitives for the workflow gate.
+ *
+ *   - `has_active_task` — is there an active task this session, and what is it?
+ *     Used by the workflow gate (rule #8) AND the scope→task Gate A (AP.5).
+ *   - `workflow_phases_complete` — are all 7 REQUIRED phases logged for the
+ *     CURRENTLY-active task? Computed at read time against the live active task
+ *     (so a new task never inherits a prior task's completion — see
+ *     workflow_phases.ts).
+ *
+ * Both are read-only, no args, never throw. GF.4 (F6): a read failure returns the
+ * conservative `ok` verdict ("no active task" / "not complete" / "not generated"),
+ * NEVER an `err` — an `err` rule result is silently skipped by the dispatcher
+ * (dispatch.ts:462), which would let a blocking gate fall through to ALLOW (fail-open).
+ * Returning a conservative `ok` makes the gate fail CLOSED. `memoizable: false` is
+ * load-bearing: the active task + phase ledger change within a session, so a memoized
+ * result would be stale.
+ *
+ * Imports from: zod, ../runtime/result.js, ../runtime/session_state.js,
+ *   ../runtime/workflow_phases.js.
+ * Imported by: src/runtime/bootstrap.ts (registry wiring).
+ */
+import { z } from 'zod';
+import type { FunctionDef } from './registry.js';
+declare const NoArgs: z.ZodObject<{}, "strict", z.ZodTypeAny, {}, {}>;
+interface HasActiveTaskResult {
+    present: boolean;
+    /** Harness numeric id, or '' when none. */
+    id: string;
+    /** Provenance track id (metadata.taskId), or '' when none — Gate A (AP.5) keys on this. */
+    task_id: string;
+}
+export declare const HasActiveTask: FunctionDef<z.input<typeof NoArgs>, HasActiveTaskResult>;
+interface WorkflowPhasesCompleteResult {
+    /** Whether there is an active task at all. */
+    active: boolean;
+    /** True ⟺ an active task exists AND all 7 REQUIRED phases are logged for it. */
+    complete: boolean;
+}
+export declare const WorkflowPhasesComplete: FunctionDef<z.input<typeof NoArgs>, WorkflowPhasesCompleteResult>;
+interface HasGeneratedSpecResult {
+    /** Whether there is an active task at all. */
+    present: boolean;
+    /** True ⟺ the active task carries a `spec` provenance path that resolves on disk. */
+    generated: boolean;
+}
+/**
+ * Does the active task have GENERATOR PROVENANCE — a `docs/tasks` 11-field spec
+ * the scope→task pipeline produced? Backs scope→task Gate A (AP.5): a code-write
+ * whose active task has no generated spec is blocked.
+ *
+ * Provenance = `active-task.json.spec` (copied by the AP.1 mirror from the
+ * harness `metadata.spec`) resolving to a real file. H7: the spec lives in the
+ * umbrella's PLANNING repo while the code-write may run in a member SUB-repo,
+ * so an ABSOLUTE `spec` is checked directly and a RELATIVE one is resolved
+ * against the event cwd AND each of its ancestors (the planning repo is an
+ * ancestor in every real layout; T-FIX-TASKSTART-GUARD-MIRROR — the old
+ * cwd-only resolution dangled from sub-repo cwds and false-fired the FU.11
+ * task_unscoped reset mid-flow). No active task OR no spec OR a path found
+ * nowhere → not generated (the conservative verdict — Gate A blocks).
+ */
+export declare const HasGeneratedSpec: FunctionDef<z.input<typeof NoArgs>, HasGeneratedSpecResult>;
+interface TaskListGeneratedResult {
+    /** True ⟺ every open (pending/in_progress) task carries a `metadata.taskId` provenance stamp. */
+    all_generated: boolean;
+    /** Harness ids of open tasks missing the provenance stamp (the smuggled-in tasks). */
+    ungenerated: string[];
+}
+/**
+ * Gate B (AP.5) read-side: does the ENTIRE open task list have generator
+ * provenance? Walks the harness store (via AP.1's isolated reader) and flags any
+ * pending/in_progress task lacking `metadata.taskId` — the stamp scope→task
+ * generation applies (H6). Closes Gate A's loophole: a task smuggled into the
+ * list manually (no spec, no pre-research) would otherwise let code through once
+ * loaded. Completed/deleted tasks are ignored (only open work must be generated).
+ */
+export declare const TaskListGenerated: FunctionDef<z.input<typeof NoArgs>, TaskListGeneratedResult>;
+interface OpenTaskCountResult {
+    count: number;
+}
+/**
+ * AF.6 — the number of OPEN (pending|in_progress) tasks. The pause-gates derive whether a
+ * workflow RUN is still active from this + the FSM state (run-active = FSM≠idle AND
+ * (count>0 OR FSM≠phases_complete)); the run auto-OFFs when the backlog is depleted.
+ * Prefers `event.openTasks` (prompt_submit, transcript-derived by the UPS hook); falls
+ * back to the harness store for older CC / non-UPS events. Never throws → count 0.
+ */
+export declare const OpenTaskCount: FunctionDef<z.input<typeof NoArgs>, OpenTaskCountResult>;
+export {};
+//# sourceMappingURL=active_task.d.ts.map

package/dist/functions/active_task.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"active_task.d.ts","sourceRoot":"","sources":["../../src/functions/active_task.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAKH,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAC;AAOxB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAEjD,QAAA,MAAM,MAAM,iDAAwB,CAAC;AAErC,UAAU,mBAAmB;IAC3B,OAAO,EAAE,OAAO,CAAC;IACjB,2CAA2C;IAC3C,EAAE,EAAE,MAAM,CAAC;IACX,2FAA2F;IAC3F,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,EAAE,mBAAmB,CAkBlF,CAAC;AAEF,UAAU,4BAA4B;IACpC,8CAA8C;IAC9C,MAAM,EAAE,OAAO,CAAC;IAChB,gFAAgF;IAChF,QAAQ,EAAE,OAAO,CAAC;CACnB;AAED,eAAO,MAAM,sBAAsB,EAAE,WAAW,CAC9C,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,EACtB,4BAA4B,CAkB7B,CAAC;AAEF,UAAU,sBAAsB;IAC9B,8CAA8C;IAC9C,OAAO,EAAE,OAAO,CAAC;IACjB,qFAAqF;IACrF,SAAS,EAAE,OAAO,CAAC;CACpB;AAWD;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,gBAAgB,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,EAAE,sBAAsB,CAiCxF,CAAC;AAEF,UAAU,uBAAuB;IAC/B,iGAAiG;IACjG,aAAa,EAAE,OAAO,CAAC;IACvB,sFAAsF;IACtF,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,EAAE,uBAAuB,CAiC1F,CAAC;AAEF,UAAU,mBAAmB;IAC3B,KAAK,EAAE,MAAM,CAAC;CACf;AAED;;;;;;GAMG;AACH,eAAO,MAAM,aAAa,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,EAAE,mBAAmB,CAmBlF,CAAC"}