@noopolis/daimon 0.1.2 → 0.2.1

package/dist/runtime/taskClock.js

@@ -0,0 +1,102 @@
+export const TASK_CLOCK_ENV = "NOOPOLIS_TASK_CLOCK";
+export const TASK_CLOCK_VERSION = "noopolis.task-clock.v1";
+export const TASK_CLOCK_MIN_MS = 0;
+export const TASK_CLOCK_MAX_MS = 253_402_300_799_999;
+export function validTaskInstant(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value >= TASK_CLOCK_MIN_MS && value <= TASK_CLOCK_MAX_MS;
+}
+export function assertTaskInstant(value) {
+    if (!validTaskInstant(value))
+        throw invalid("task instant must be within 1970-01-01T00:00:00.000Z .. 9999-12-31T23:59:59.999Z");
+    return value;
+}
+/** Environment-only contract: no clock callbacks or compiler config in the public API. */
+export function readTaskClock(environment = process.env) {
+    return parseTaskClock(environment[TASK_CLOCK_ENV]);
+}
+export function parseTaskClock(raw) {
+    if (raw === undefined)
+        return undefined;
+    let value;
+    try {
+        value = JSON.parse(raw);
+    }
+    catch {
+        throw invalid("must be valid JSON");
+    }
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        throw invalid("must be an object");
+    const fields = value;
+    if (Object.keys(fields).sort().join() !== "anchorEpochMs,origin,version")
+        throw invalid("requires exactly version, origin, anchorEpochMs (no unknown fields)");
+    if (fields.version !== TASK_CLOCK_VERSION)
+        throw invalid(`version must be ${TASK_CLOCK_VERSION}`);
+    if (typeof fields.origin !== "string" || !validInstant(fields.origin))
+        throw invalid("origin must be a valid ISO-8601 instant with Z or an explicit offset");
+    if (typeof fields.anchorEpochMs !== "number" || !Number.isSafeInteger(fields.anchorEpochMs))
+        throw invalid("anchorEpochMs must be a safe integer");
+    const origin = fields.origin, anchorEpochMs = fields.anchorEpochMs, originMs = Date.parse(origin);
+    assertTaskInstant(originMs);
+    const at = (realEpochMs) => assertTaskInstant(originMs + (realEpochMs - anchorEpochMs));
+    return Object.freeze({ raw, origin, anchorEpochMs, at, now: () => at(Date.now()) });
+}
+/** The caller installs libfaketime; Daimon derives one process-independent offset. */
+export function taskClockChildEnvironment(declared = {}, clock = readTaskClock(), environment = process.env) {
+    if (clock === undefined)
+        return {};
+    for (const name of Object.keys(declared)) {
+        if (declared[name] !== undefined && clockVariable(name))
+            throw invalid(`declared child environment conflicts with ${name}`);
+    }
+    // Integer arithmetic keeps every millisecond even at the safe-integer anchor limits.
+    const offset = BigInt(Date.parse(clock.origin)) - BigInt(clock.anchorEpochMs);
+    const magnitude = offset < 0n ? -offset : offset;
+    const fraction = magnitude % 1000n;
+    const seconds = `${offset < 0n ? "-" : "+"}${magnitude / 1000n}${fraction === 0n ? "" : `.${String(fraction).padStart(3, "0")}`}`;
+    const preload = taskClockPreload(environment.LD_PRELOAD);
+    if (preload === undefined)
+        throw invalid("process clock startup probe requires caller-provided LD_PRELOAD naming libfaketime*.so*; refusing clocked execution");
+    return {
+        // The child process clock owns the offset; Mneme and nested consumers use Date.now().
+        // libfaketime's relative format defaults to seconds; an `s` suffix is not supported.
+        FAKETIME: seconds,
+        FAKETIME_DONT_FAKE_MONOTONIC: "1",
+        // libfaketime parses decimal fractions using the process locale.
+        LC_ALL: "C",
+        LD_PRELOAD: preload
+    };
+}
+/** Inherited environments must not reintroduce another offset owner or loader controls. */
+export function taskClockProcessEnvironment(inherited, derived = taskClockChildEnvironment()) {
+    if (Object.keys(derived).length === 0)
+        return inherited;
+    return { ...Object.fromEntries(Object.entries(inherited).filter(([name]) => !clockVariable(name))), ...derived };
+}
+function clockVariable(name) {
+    return /^(?:LD_PRELOAD$|DYLD_|FAKETIME|NOOPOLIS_TASK_CLOCK$|MNEME_CLOCK_)/u.test(name);
+}
+/** Provider/auth/control processes must never inherit the agent's process clock. */
+export function realTimeProcessEnvironment(inherited) {
+    if (readTaskClock() === undefined)
+        return inherited;
+    return Object.fromEntries(Object.entries(inherited).filter(([name]) => !clockVariable(name)));
+}
+/** Reject mixed loader lists: unrelated libraries must never ride this exception. */
+export function taskClockPreload(value) {
+    const libraries = value?.split(/[\s:]+/u).filter(Boolean);
+    return libraries?.length && libraries.every((library) => /^libfaketime[^/]*\.so[^/]*$/u.test(library.split("/").at(-1))) ? value : undefined;
+}
+/** Project real delivery/receipt timestamps, never historical dates inside tool payloads. */
+export function taskClockTimestamp(realTimestamp, clock = readTaskClock()) {
+    return clock === undefined ? realTimestamp : new Date(clock.at(Date.parse(realTimestamp))).toISOString();
+}
+function invalid(reason) { return new Error(`${TASK_CLOCK_ENV}: ${reason}`); }
+function validInstant(value) {
+    const match = /^(\d{4})-(\d{2})-(\d{2})T([01]\d|2[0-3]):([0-5]\d):([0-5]\d)(?:\.\d+)?(?:Z|[+-](?:[01]\d|2[0-3]):?[0-5]\d)$/u.exec(value);
+    if (match === null || !Number.isFinite(Date.parse(value)))
+        return false;
+    const year = Number(match[1]), month = Number(match[2]), day = Number(match[3]);
+    const leap = year % 4 === 0 && (year % 100 !== 0 || year % 400 === 0);
+    const days = [31, leap ? 29 : 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31];
+    return month >= 1 && month <= 12 && day >= 1 && day <= days[month - 1];
+}

package/dist/runtime/taskClockProcess.d.ts

@@ -0,0 +1,17 @@
+import childProcess from "node:child_process";
+import { type TaskClock } from "./taskClock.js";
+export type { ChildProcess } from "node:child_process";
+/** @internal Synchronous injection seam; never runtime configuration. */
+export type TaskClockProcessProbe = (command: string, args: readonly string[], environment: NodeJS.ProcessEnv) => string;
+/** @internal Isolate simulated probes between tests. */
+export declare function resetTaskClockProcessForTest(): void;
+/** Shared child-launch boundary, including SDK transports and Pi's spawn hook.
+ * Keep the synchronous spawn API: only the first launch blocks for the bounded probes.
+ * Every launch derives a fresh environment; only successful interposition is memoized.
+ */
+export declare function readyTaskClockEnvironment(environment: NodeJS.ProcessEnv, clock?: TaskClock | undefined, probe?: TaskClockProcessProbe): NodeJS.ProcessEnv;
+/** Only agent-facing tool/server children cross the shifted readiness gate. */
+export declare const spawn: typeof childProcess.spawn;
+/** Engine CLIs and operational helpers stay real; no libfaketime probe runs here. */
+export declare const spawnRealTime: typeof childProcess.spawn;
+//# sourceMappingURL=taskClockProcess.d.ts.map

package/dist/runtime/taskClockProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"taskClockProcess.d.ts","sourceRoot":"","sources":["../../src/runtime/taskClockProcess.ts"],"names":[],"mappings":"AAAA,OAAO,YAAmC,MAAM,oBAAoB,CAAC;AACrE,OAAO,EAAqG,KAAK,SAAS,EAAE,MAAM,gBAAgB,CAAC;AAEnJ,YAAY,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,yEAAyE;AACzE,MAAM,MAAM,qBAAqB,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,MAAM,EAAE,EAAE,WAAW,EAAE,MAAM,CAAC,UAAU,KAAK,MAAM,CAAC;AAGzH,wDAAwD;AACxD,wBAAgB,4BAA4B,IAAI,IAAI,CAAsB;AAS1E;;;GAGG;AACH,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,MAAM,CAAC,UAAU,EAAE,KAAK,GAAE,SAAS,GAAG,SAA2B,EAAE,KAAK,GAAE,qBAAiC,GACvH,MAAM,CAAC,UAAU,CAyBnB;AAED,+EAA+E;AAC/E,eAAO,MAAM,KAAK,EAAE,OAAO,YAAY,CAAC,KAIT,CAAC;AAEhC,qFAAqF;AACrF,eAAO,MAAM,aAAa,EAAE,OAAO,YAAY,CAAC,KAIjB,CAAC"}

package/dist/runtime/taskClockProcess.js

@@ -0,0 +1,58 @@
+import childProcess from "node:child_process";
+import { readTaskClock, realTimeProcessEnvironment, taskClockChildEnvironment, taskClockProcessEnvironment } from "./taskClock.js";
+const verified = new Set();
+/** @internal Isolate simulated probes between tests. */
+export function resetTaskClockProcessForTest() { verified.clear(); }
+const dateProbe = (command, args, env) => {
+    const result = childProcess.spawnSync(command, [...args], { env, encoding: "utf8", timeout: 5000, killSignal: "SIGKILL", maxBuffer: 1024 });
+    // Loaders can ignore a missing library and still exit zero, including at zero offset.
+    if (result.error || result.status !== 0 || result.stderr?.trim())
+        throw result.error ?? new Error("date/libfaketime emitted a startup diagnostic");
+    return result.stdout;
+};
+/** Shared child-launch boundary, including SDK transports and Pi's spawn hook.
+ * Keep the synchronous spawn API: only the first launch blocks for the bounded probes.
+ * Every launch derives a fresh environment; only successful interposition is memoized.
+ */
+export function readyTaskClockEnvironment(environment, clock = readTaskClock(), probe = dateProbe) {
+    if (clock === undefined)
+        return environment;
+    const refuse = (reason) => new Error(`NOOPOLIS_TASK_CLOCK: process clock startup probe ${reason}; refusing clocked execution`);
+    if (process.platform !== "linux")
+        throw refuse("requires Linux libfaketime interposition");
+    const derived = taskClockChildEnvironment({}, clock);
+    const env = taskClockProcessEnvironment(environment, derived);
+    clock.now(); // A cached process clock never permits reads outside the supported calendar.
+    const key = JSON.stringify([process.pid, process.platform, derived.LD_PRELOAD, derived.FAKETIME]);
+    if (verified.has(key))
+        return env;
+    for (const sentinel of [true, false]) {
+        let output;
+        try {
+            // Absolute path: engine-specific PATHs need not contain system utilities.
+            output = probe("/bin/date", ["-u", "+%s"], sentinel ? { ...env, FAKETIME: "-31536000" } : env);
+        }
+        catch (cause) {
+            throw new Error(refuse("could not run date -u +%s (date/libfaketime missing or unusable)").message, { cause });
+        }
+        const seconds = Number(output.trim());
+        const expected = sentinel ? Date.now() - 31_536_000_000 : clock.now();
+        if (!/^-?\d+$/u.test(output.trim()) || !Number.isSafeInteger(seconds) || Math.abs(seconds * 1000 - expected) > 5000) {
+            throw refuse(`did not observe ${sentinel ? "sentinel offset" : "task time"} within ±5 seconds (check libfaketime and its offset)`);
+        }
+    }
+    verified.add(key);
+    return env;
+}
+/** Only agent-facing tool/server children cross the shifted readiness gate. */
+export const spawn = ((command, args, options) => {
+    const argv = Array.isArray(args) ? args : [];
+    const settings = (Array.isArray(args) ? options : args ?? options);
+    return childProcess.spawn(command, argv, { ...settings, env: readyTaskClockEnvironment(settings?.env ?? process.env) });
+});
+/** Engine CLIs and operational helpers stay real; no libfaketime probe runs here. */
+export const spawnRealTime = ((command, args, options) => {
+    const argv = Array.isArray(args) ? args : [];
+    const settings = (Array.isArray(args) ? options : args ?? options);
+    return childProcess.spawn(command, argv, { ...settings, env: realTimeProcessEnvironment(settings?.env ?? process.env) });
+});

package/dist/runtime/toolResultSpill.d.ts

@@ -0,0 +1,152 @@
+import { type McpUpstreamResult, type RenderedMcpToolResult } from "./mcpToolResult.js";
+/**
+ * Cap one declared MCP tool result, and spill the rest of it to disk.
+ *
+ * ## Why
+ *
+ * Production agents make 3–37 tool calls per wake, and every tool result stays
+ * in the transcript for every *subsequent* model request of that wake. Context
+ * per request is flat at 23–32k tokens, so one oversized result is not paid
+ * once — it is paid again on every request that follows it, at cache-read rates
+ * for the ones that hit and at fresh rates for the one that does not. A 40 KiB
+ * result returned on call three of thirty is re-billed twenty-seven times.
+ *
+ * Before this, Daimon applied no cap of its own to a declared MCP tool's answer.
+ * `mcpToolResult.ts` bounded it at 61,440 bytes — the receipt bound, not a
+ * context bound — and above that degraded it to a *head only*, with no way to
+ * recover the rest.
+ *
+ * ## The reference pattern
+ *
+ * `references/oh-my-pi` wraps **every** tool, MCP included, with the same
+ * centralized spill (`packages/coding-agent/src/tools/output-meta.ts:724-891`,
+ * mounted in `sdk.ts:2862-2869`):
+ *
+ *   - a byte threshold (`tools.artifactSpillThreshold`, default 50 KiB);
+ *   - **head + tail retention** with the middle elided, so the model keeps both
+ *     ends of the output (`truncateMiddle`,
+ *     `packages/coding-agent/src/session/streaming-output.ts`), defaults
+ *     20 KiB head + 20 KiB tail — an even split at 80% of the threshold;
+ *   - the **full output written to disk** and addressed by an id
+ *     (`session/artifacts.ts`);
+ *   - a notice naming the ranges shown and the re-fetch address:
+ *     `Showing lines X-Y of Z … Read artifact://ID for full output`
+ *     (`formatTruncationMetaNotice`, `formatFullOutputReference`);
+ *   - and the rule that a **failed save still truncates** — the recovery link is
+ *     attached only when the write actually succeeded, because re-exposing the
+ *     full output on a disk error is the one outcome worse than truncating.
+ *
+ * All five are reproduced here. What differs is only the address: oh-my-pi's
+ * `artifact://<id>` is resolved by its own `read` tool, and Daimon has no such
+ * protocol — so the notice names the **absolute path**, which every Daimon agent
+ * can already read with the mounted `bash` tool (`piHarness.ts`) or the engine's
+ * own shell. The file lives under the agent's own runtime home, which is exactly
+ * the tree that home is for and the one tree every sandbox profile leaves the
+ * agent (`grokSandboxProtectedPaths` denies *peers'* homes, never its own).
+ */
+/**
+ * The cap on one lowered MCP tool result, measured the way
+ * `mcpToolResult.ts` measures: the serialized `{content, structuredContent}`
+ * record, both channels included.
+ *
+ * **16 KiB, ≈4k tokens.** oh-my-pi's 50 KiB default is calibrated for an
+ * interactive coding agent with a 200k+ context; Daimon's whole per-request
+ * context is 23–32k tokens, so a 50 KiB result would be *half of it* and would
+ * be replayed on every remaining request of the wake. 16 KiB keeps any single
+ * result under roughly a sixth of a request while leaving a realistic answer
+ * — a page of messages, a document, a query result — entirely untouched: it is
+ * a ceiling on the pathological case, not a working budget.
+ */
+export declare const DEFAULT_TOOL_RESULT_MAX_BYTES: number;
+export declare const TOOL_RESULT_MAX_BYTES_ENV: "DAIMON_TOOL_RESULT_MAX_BYTES";
+/**
+ * Tools that must never be truncated, by mounted tool name
+ * (`mcp_<server>_<tool>`), comma-separated.
+ *
+ * Empty by default. It exists because Daimon cannot know what an organization
+ * declared: if a deployment has one MCP tool whose *whole* answer is load
+ * bearing — a signature, a checksummed document, a payload the agent must
+ * reproduce verbatim — head+tail is not a degradation there, it is a wrong
+ * answer, and no re-fetch instruction fixes a model that did not notice. That
+ * judgement belongs to whoever declared the tool, so it is configuration rather
+ * than a Daimon-side guess. An exempt tool keeps exactly today's behaviour,
+ * including `mcpToolResult.ts`'s 61,440-byte receipt bound.
+ */
+export declare const TOOL_RESULT_EXEMPT_ENV: "DAIMON_TOOL_RESULT_NO_TRUNCATE";
+/**
+ * A result may never be capped below this. Below roughly a kilobyte the head and
+ * tail stop being usable at all and the notice dominates the payload, so a
+ * mistyped bound degrades into "every tool is blind" — worse than no cap.
+ */
+export declare const MIN_TOOL_RESULT_MAX_BYTES = 2048;
+/** Spilled files live here, under the agent's own runtime home. */
+export declare const TOOL_OUTPUT_DIRECTORY_NAME: "tool-output";
+/** Newest-first retention for spilled files, mirroring `pruneReceipts`. */
+export declare const TOOL_OUTPUT_RETAINED_FILES = 256;
+export declare const resolveToolResultMaxBytes: (environment?: NodeJS.ProcessEnv) => number;
+export declare const resolveExemptToolNames: (environment?: NodeJS.ProcessEnv) => ReadonlySet<string>;
+/** Cut on a code-point boundary, from the front. */
+/** Exported for the bounded diagnostic window (`cliChildOutput.ts`): one boundary-safe implementation, not two. */
+export declare const headUtf8: (value: string, maxBytes: number) => string;
+/** Cut on a code-point boundary, from the back. */
+/** Exported for the bounded diagnostic window (`cliChildOutput.ts`): one boundary-safe implementation, not two. */
+export declare const tailUtf8: (value: string, maxBytes: number) => string;
+/**
+ * The complete payload, as the text that gets written to disk and sliced.
+ *
+ * A result that is nothing but text parts is spilled as that text, because a
+ * human-readable log is what the agent will `grep` and `sed`. Anything else — a
+ * structured result, an image part, a mixed result — is spilled as the
+ * serialized upstream record, which is lossless and is the same serialization
+ * `mcpToolResult.ts` already degrades to today.
+ */
+export declare const spillPayload: (result: McpUpstreamResult) => {
+    text: string;
+    format: "text" | "json";
+};
+/**
+ * Spilled files are group-readable and never other-readable.
+ *
+ * A brokered Grok worker runs as its own uid and reads a spill with
+ * `read_file`, so a 0600 file owned by the runtime (uid 2000) was unreadable to
+ * the very agent the notice sends there. The group grant reaches exactly that
+ * agent's worker only when the deployment provisions `tool-output` as
+ * `<runtime uid>:<worker gid> 2750` (setgid, so each file inherits the worker
+ * group; `GROK_ENGINE_BROKER.worker.home.spillDirectory`). A directory Daimon
+ * creates itself stays 0700, so for every other engine nothing new is exposed.
+ */
+export declare const SPILL_FILE_MODE = 416;
+export declare const SPILL_DIRECTORY_MAX_MODE = 1512;
+/** Pure so a foreign owner is testable without root. */
+export declare const assertSpillDirectoryStat: (entry: Readonly<{
+    uid: number;
+    gid: number;
+    mode: number;
+    isDirectory(): boolean;
+}>, runtime: Readonly<{
+    uid: number;
+    gid: number;
+}>) => void;
+export type CappedToolResult = RenderedMcpToolResult & {
+    /** Absolute path of the spilled full result, when one was written. */
+    readonly spillPath?: string;
+};
+/**
+ * Return `rendered` untouched when it fits, or a head+tail view of the full
+ * payload plus a notice naming the file that holds the rest.
+ *
+ * A result under the cap passes through **byte-identical**: the `mcp_*`
+ * passthrough contract — both channels carrying the payload, an upstream
+ * `structuredContent` forwarded verbatim — is unchanged for every result that
+ * does not blow the bound, which is the overwhelming majority of them.
+ */
+export declare const capToolResult: (input: Readonly<{
+    toolName: string;
+    rendered: RenderedMcpToolResult;
+    result: McpUpstreamResult;
+    maxBytes: number;
+    exempt: ReadonlySet<string>;
+    spillDirectory: string;
+    spillId: string;
+}>) => Promise<CappedToolResult>;
+//# sourceMappingURL=toolResultSpill.d.ts.map

package/dist/runtime/toolResultSpill.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"toolResultSpill.d.ts","sourceRoot":"","sources":["../../src/runtime/toolResultSpill.ts"],"names":[],"mappings":"AAIA,OAAO,EAAkB,KAAK,iBAAiB,EAAE,KAAK,qBAAqB,EAAE,MAAM,oBAAoB,CAAC;AAExG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AAEH;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,6BAA6B,QAAY,CAAC;AAEvD,eAAO,MAAM,yBAAyB,EAAG,8BAAuC,CAAC;AAEjF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,sBAAsB,EAAG,gCAAyC,CAAC;AAEhF;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,OAAQ,CAAC;AAE/C,mEAAmE;AACnE,eAAO,MAAM,0BAA0B,EAAG,aAAsB,CAAC;AAEjE,2EAA2E;AAC3E,eAAO,MAAM,0BAA0B,MAAM,CAAC;AAE9C,eAAO,MAAM,yBAAyB,GAAI,cAAa,MAAM,CAAC,UAAwB,KAAG,MAQxF,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,cAAa,MAAM,CAAC,UAAwB,KAAG,WAAW,CAAC,MAAM,CACsB,CAAC;AAS/H,oDAAoD;AACpD,mHAAmH;AACnH,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,EAAE,UAAU,MAAM,KAAG,MAM1D,CAAC;AAEF,mDAAmD;AACnD,mHAAmH;AACnH,eAAO,MAAM,QAAQ,GAAI,OAAO,MAAM,EAAE,UAAU,MAAM,KAAG,MAM1D,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,YAAY,GAAI,QAAQ,iBAAiB,KAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAA;CAc/F,CAAC;AAyBF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,eAAe,MAAQ,CAAC;AACrC,eAAO,MAAM,wBAAwB,OAAS,CAAC;AA0D/C,wDAAwD;AACxD,eAAO,MAAM,wBAAwB,GAAI,OAAO,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,IAAI,OAAO,CAAA;CAAE,CAAC,EAAE,SAAS,QAAQ,CAAC;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,CAAC,KAAG,IAO/K,CAAC;AAoBF,MAAM,MAAM,gBAAgB,GAAG,qBAAqB,GAAG;IACrD,sEAAsE;IACtE,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC7B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,aAAa,GAAU,OAAO,QAAQ,CAAC;IAClD,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,qBAAqB,CAAC;IAChC,MAAM,EAAE,iBAAiB,CAAC;IAC1B,QAAQ,EAAE,MAAM,CAAC;IACjB,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC5B,cAAc,EAAE,MAAM,CAAC;IACvB,OAAO,EAAE,MAAM,CAAC;CACjB,CAAC,KAAG,OAAO,CAAC,gBAAgB,CA6D5B,CAAC"}