@noopolis/daimon 0.1.1 → 0.2.0

package/dist/runtime/agySubscriptionRealm.d.ts

@@ -0,0 +1,38 @@
+export type AgySubscriptionRealm = Readonly<{
+    busAddress: string;
+    close(): Promise<void>;
+}>;
+export type AgySubscriptionRealmOptions = Readonly<{
+    dbusDaemon?: string;
+    durablePath?: string;
+    flock?: string;
+    gnomeKeyringDaemon?: string;
+    shell?: string;
+    socketReady?: (socketPath: string) => Promise<boolean>;
+    temporaryRoot?: string;
+    unlockSecretPath?: string;
+}>;
+export declare const createAgyRealmCommands: (input: {
+    busSocketPath: string;
+    controlDirectory: string;
+    dbusDaemon?: string;
+    flock?: string;
+    gnomeKeyringDaemon?: string;
+    shell?: string;
+}) => Readonly<{
+    bus: {
+        command: string;
+        args: string[];
+    };
+    keyring: {
+        command: string;
+        args: string[];
+    };
+    lease: {
+        command: string;
+        args: string[];
+    };
+}>;
+export declare function startAgySubscriptionRealm(options?: AgySubscriptionRealmOptions): Promise<AgySubscriptionRealm>;
+export declare function readAgyRealmUnlockSecret(sourcePath: string): Promise<Buffer>;
+//# sourceMappingURL=agySubscriptionRealm.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"agySubscriptionRealm.d.ts","sourceRoot":"","sources":["../../src/runtime/agySubscriptionRealm.ts"],"names":[],"mappings":"AAWA,MAAM,MAAM,oBAAoB,GAAG,QAAQ,CAAC;IAC1C,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB,CAAC,CAAC;AAEH,MAAM,MAAM,2BAA2B,GAAG,QAAQ,CAAC;IACjD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,WAAW,CAAC,EAAE,CAAC,UAAU,EAAE,MAAM,KAAK,OAAO,CAAC,OAAO,CAAC,CAAC;IACvD,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,gBAAgB,CAAC,EAAE,MAAM,CAAC;CAC3B,CAAC,CAAC;AAUH,eAAO,MAAM,sBAAsB,GAAI,OAAO;IAC5C,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,KAAK,CAAC,EAAE,MAAM,CAAC;CAChB,KAAG,QAAQ,CAAC;IACX,GAAG,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IACzC,OAAO,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;IAC7C,KAAK,EAAE;QAAE,OAAO,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAA;KAAE,CAAC;CAC5C,CAkBC,CAAC;AAEH,wBAAsB,yBAAyB,CAC7C,OAAO,GAAE,2BAAgC,GACxC,OAAO,CAAC,oBAAoB,CAAC,CA6C/B;AAED,wBAAsB,wBAAwB,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAqBlF"}

package/dist/runtime/agySubscriptionRealm.js

@@ -0,0 +1,242 @@
+import { constants } from "node:fs";
+import { spawn } from "node:child_process";
+import { chmod, lstat, mkdir, mkdtemp, open, realpath, rm } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { terminateChild, trackCliChild } from "../pi/cliProcess.js";
+import { AGY_SUBSCRIPTION_REALM } from "./contractManifest.js";
+const START_TIMEOUT_MS = 5_000;
+export const createAgyRealmCommands = (input) => ({
+    bus: {
+        command: input.dbusDaemon ?? "dbus-daemon",
+        args: ["--session", "--nofork", "--nopidfile", `--address=unix:path=${input.busSocketPath}`]
+    },
+    keyring: {
+        command: input.gnomeKeyringDaemon ?? "gnome-keyring-daemon",
+        args: ["--foreground", "--components=secrets", "--unlock", `--control-directory=${input.controlDirectory}`]
+    },
+    lease: {
+        command: input.shell ?? "/bin/sh",
+        args: [
+            "-c",
+            "\"$1\" --exclusive --nonblock --conflict-exit-code 73 3 || exit 73; printf 'ready\\n'; IFS= read -r _daimon_hold || :",
+            "daimon-agy-lease",
+            input.flock ?? "flock"
+        ]
+    }
+});
+export async function startAgySubscriptionRealm(options = {}) {
+    const durablePath = options.durablePath ?? AGY_SUBSCRIPTION_REALM.durableMountPath;
+    const unlockSecretPath = options.unlockSecretPath ?? AGY_SUBSCRIPTION_REALM.unlockMountPath;
+    await verifyPrivateDirectory(durablePath);
+    const unlockBytes = await readAgyRealmUnlockSecret(unlockSecretPath);
+    const ephemeralPath = await mkdtemp(path.join(options.temporaryRoot ?? os.tmpdir(), "daimon-agy-realm-"));
+    await chmod(ephemeralPath, 0o700);
+    const busSocketPath = path.join(ephemeralPath, "bus");
+    const controlDirectory = path.join(ephemeralPath, "keyring");
+    await mkdir(controlDirectory, { mode: 0o700 });
+    const commands = createAgyRealmCommands({
+        busSocketPath,
+        controlDirectory,
+        dbusDaemon: options.dbusDaemon,
+        flock: options.flock,
+        gnomeKeyringDaemon: options.gnomeKeyringDaemon,
+        shell: options.shell
+    });
+    const children = [];
+    let closePromise;
+    try {
+        const lease = await acquireLease(durablePath, commands.lease);
+        children.push(lease);
+        const bus = ownedSpawn(commands.bus.command, commands.bus.args, realmEnvironment(durablePath, ephemeralPath), ["ignore", "ignore", "ignore"]);
+        children.push(bus);
+        await waitForSocket(busSocketPath, bus, options.socketReady);
+        const busAddress = `unix:path=${busSocketPath}`;
+        const environment = { ...realmEnvironment(durablePath, ephemeralPath), DBUS_SESSION_BUS_ADDRESS: busAddress };
+        const keyring = ownedSpawn(commands.keyring.command, commands.keyring.args, environment, ["pipe", "ignore", "ignore"]);
+        children.push(keyring);
+        await deliverUnlockSecret(keyring, unlockBytes);
+        await waitForSocket(path.join(controlDirectory, "control"), keyring, options.socketReady);
+        const close = () => closePromise ??= cleanup(children, ephemeralPath);
+        return { busAddress, close };
+    }
+    catch (error) {
+        try {
+            await cleanup(children, ephemeralPath);
+        }
+        catch (cleanupError) {
+            throw redactRealmFailure(new AggregateError([error, cleanupError], "AGY subscription realm startup cleanup failed"));
+        }
+        throw redactRealmFailure(error);
+    }
+    finally {
+        unlockBytes.fill(0);
+    }
+}
+export async function readAgyRealmUnlockSecret(sourcePath) {
+    let handle;
+    try {
+        const before = await lstat(sourcePath);
+        assertUnlockIdentity(before);
+        handle = await open(sourcePath, constants.O_RDONLY | noFollow());
+        const opened = await handle.stat();
+        assertUnlockIdentity(opened);
+        if (!sameIdentity(identity(before), identity(opened)))
+            throw new Error("changed");
+        const bytes = Buffer.alloc(Number(opened.size));
+        const { bytesRead } = await handle.read(bytes, 0, bytes.length, 0);
+        if (bytesRead !== bytes.length || bytes.includes(0) || bytes.includes(10) || bytes.includes(13)) {
+            bytes.fill(0);
+            throw new Error("invalid bytes");
+        }
+        return bytes;
+    }
+    catch {
+        throw new Error("AGY subscription realm unlock secret is unavailable or unsafe");
+    }
+    finally {
+        await handle?.close().catch(() => undefined);
+    }
+}
+async function verifyPrivateDirectory(directory) {
+    try {
+        const before = await lstat(directory);
+        if (!before.isDirectory() || before.isSymbolicLink() || before.uid !== process.getuid?.()
+            || (before.mode & 0o777) !== AGY_SUBSCRIPTION_REALM.directoryMode)
+            throw new Error("unsafe");
+        const canonical = await realpath(directory);
+        if (canonical !== path.resolve(directory))
+            throw new Error("linked");
+    }
+    catch {
+        throw new Error("AGY subscription realm durable state is unavailable or unsafe");
+    }
+}
+async function acquireLease(durablePath, command) {
+    const lockPath = path.join(durablePath, ".daimon-lease");
+    let lock;
+    try {
+        lock = await open(lockPath, constants.O_CREAT | constants.O_RDWR | noFollow(), 0o600);
+        const entry = await lock.stat();
+        if (!entry.isFile() || entry.isSymbolicLink() || entry.uid !== process.getuid?.()
+            || entry.nlink !== 1 || (entry.mode & 0o777) !== 0o600)
+            throw new Error("unsafe lease");
+        const child = ownedSpawn(command.command, command.args, leaseEnvironment(), ["pipe", "pipe", "ignore", lock.fd]);
+        try {
+            await waitForReady(child);
+            return child;
+        }
+        catch (error) {
+            try {
+                await terminateChild(child);
+            }
+            catch (cleanupError) {
+                throw new AggregateError([error, cleanupError], "lease acquisition cleanup failed");
+            }
+            throw error;
+        }
+    }
+    catch {
+        throw new Error("AGY subscription realm is already in use or cannot be leased");
+    }
+    finally {
+        await lock?.close().catch(() => undefined);
+    }
+}
+async function deliverUnlockSecret(keyring, secret) {
+    if (keyring.stdin === null)
+        throw new Error("keyring input is unavailable");
+    await new Promise((resolve, reject) => {
+        const fail = () => reject(new Error("keyring stopped before unlock"));
+        keyring.once("close", fail);
+        keyring.once("error", fail);
+        keyring.stdin.once("error", fail);
+        keyring.stdin.end(secret, () => {
+            keyring.off("close", fail);
+            keyring.off("error", fail);
+            keyring.stdin.off("error", fail);
+            resolve();
+        });
+    });
+}
+function ownedSpawn(command, args, env, stdio) {
+    return trackCliChild(spawn(command, args, {
+        detached: process.platform !== "win32",
+        env,
+        stdio
+    }));
+}
+async function waitForSocket(socketPath, child, socketReady) {
+    const deadline = Date.now() + START_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        if (child.exitCode !== null || child.signalCode !== null)
+            throw new Error("bus stopped");
+        try {
+            if (socketReady ? await socketReady(socketPath) : await defaultSocketReady(socketPath))
+                return;
+        }
+        catch { /* not ready */ }
+        await delay(20);
+    }
+    throw new Error("bus startup timed out");
+}
+async function defaultSocketReady(socketPath) {
+    const entry = await lstat(socketPath);
+    return entry.isSocket() && entry.uid === process.getuid?.();
+}
+function waitForReady(child) {
+    return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => reject(new Error("lease startup timed out")), START_TIMEOUT_MS);
+        child.stdout?.once("data", (chunk) => {
+            clearTimeout(timer);
+            if (chunk.toString("utf8") === "ready\n")
+                resolve();
+            else
+                reject(new Error("lease response invalid"));
+        });
+        child.once("close", () => { clearTimeout(timer); reject(new Error("lease rejected")); });
+        child.once("error", () => { clearTimeout(timer); reject(new Error("lease failed")); });
+    });
+}
+async function cleanup(children, ephemeralPath) {
+    const failures = [];
+    for (const child of [...children].reverse()) {
+        child.stdin?.end();
+        try {
+            await terminateChild(child);
+        }
+        catch (error) {
+            failures.push(error);
+        }
+    }
+    try {
+        await rm(ephemeralPath, { recursive: true, force: true });
+    }
+    catch (error) {
+        failures.push(error);
+    }
+    if (failures.length > 0)
+        throw new AggregateError(failures, "AGY subscription realm cleanup failed");
+}
+const realmEnvironment = (durablePath, ephemeralPath) => ({
+    HOME: durablePath,
+    LANG: "C",
+    LC_ALL: "C",
+    PATH: process.env.PATH,
+    XDG_DATA_HOME: durablePath,
+    XDG_RUNTIME_DIR: ephemeralPath
+});
+const leaseEnvironment = () => ({ LANG: "C", LC_ALL: "C", PATH: process.env.PATH });
+const delay = (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds));
+const noFollow = () => constants.O_NOFOLLOW ?? 0;
+const identity = (value) => ({ dev: Number(value.dev), ino: Number(value.ino), mode: Number(value.mode) & 0o7777, nlink: Number(value.nlink), size: Number(value.size), uid: Number(value.uid) });
+const sameIdentity = (left, right) => left.dev === right.dev && left.ino === right.ino && left.mode === right.mode && left.nlink === right.nlink && left.size === right.size && left.uid === right.uid;
+const assertUnlockIdentity = (entry) => {
+    const value = identity(entry);
+    if (!entry.isFile() || entry.isSymbolicLink() || value.uid !== process.getuid?.() || value.nlink !== 1
+        || (value.mode & 0o777) !== AGY_SUBSCRIPTION_REALM.fileMode || value.size < 1 || value.size > AGY_SUBSCRIPTION_REALM.maxUnlockBytes)
+        throw new Error("unsafe");
+};
+const redactRealmFailure = (error) => error instanceof Error && /^AGY subscription realm/u.test(error.message)
+    ? error
+    : new Error("AGY subscription realm could not be started", { cause: error });

package/dist/runtime/attention.d.ts

@@ -0,0 +1,21 @@
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
+import type { AttentionConfig } from "../contracts/attentionContract.js";
+export type { AttentionConfig } from "../contracts/attentionContract.js";
+export type AttentionMessage = Readonly<{
+    delivery_id: string;
+    acceptance_id: string;
+    kind: string;
+    text: string;
+    occurred_at: string;
+}>;
+export type AttentionTurn = Readonly<{
+    executionId: string;
+    messages: readonly AttentionMessage[];
+    budget(): Promise<unknown>;
+    disposition(deliveryId: string, disposition: "complete" | "defer"): Promise<void>;
+}>;
+/** Owned by one control host; never shared across hosts or agent identities. */
+export type AttentionRegistry = Map<string, AttentionTurn>;
+export declare function attentionTools(agentId: string, registry: AttentionRegistry): ToolDefinition[];
+export declare function parseAttention(value: unknown): AttentionConfig;
+//# sourceMappingURL=attention.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attention.d.ts","sourceRoot":"","sources":["../../src/runtime/attention.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iCAAiC,CAAC;AAEtE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,YAAY,EAAE,eAAe,EAAE,MAAM,mCAAmC,CAAC;AACzE,MAAM,MAAM,gBAAgB,GAAG,QAAQ,CAAC;IAAE,WAAW,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,WAAW,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AACzI,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;IACnC,WAAW,EAAE,MAAM,CAAC;IACpB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACtC,MAAM,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3B,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,WAAW,EAAE,UAAU,GAAG,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACnF,CAAC,CAAC;AACH,gFAAgF;AAChF,MAAM,MAAM,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE,aAAa,CAAC,CAAC;AAE3D,wBAAgB,cAAc,CAAC,OAAO,EAAE,MAAM,EAAE,QAAQ,EAAE,iBAAiB,GAAG,cAAc,EAAE,CAqB7F;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,eAAe,CAS9D"}

package/dist/runtime/attention.js

@@ -0,0 +1,36 @@
+export function attentionTools(agentId, registry) {
+    const current = () => { const turn = registry.get(agentId); if (!turn)
+        throw new Error("No active inbox turn"); return turn; };
+    return [{
+            name: "daimon_inbox", label: "Current inbox", description: "Read this turn's selected deliveries and remaining execution allowance. Reading does not complete a delivery. Explicitly complete or defer each selected message.",
+            parameters: { type: "object", additionalProperties: false, properties: {} },
+            async execute() {
+                const turn = current();
+                const details = { version: "noopolis.daimon.inbox.v1", execution_id: turn.executionId, messages: turn.messages, budget: await turn.budget() };
+                return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+            }
+        }, {
+            name: "daimon_inbox_disposition", label: "Resolve an inbox delivery", description: "Mark one selected delivery complete only after handling it, or defer it until a later external wake. Unmarked deliveries stay pending. Completion is durable and cannot be undone.",
+            parameters: { type: "object", additionalProperties: false, required: ["delivery_id", "disposition"], properties: { delivery_id: { type: "string", minLength: 1 }, disposition: { enum: ["complete", "defer"] } } },
+            async execute(_id, params) {
+                const input = params;
+                if (input.disposition !== "complete" && input.disposition !== "defer")
+                    throw new Error("Invalid inbox disposition");
+                await current().disposition(input.delivery_id, input.disposition);
+                const details = { delivery_id: input.delivery_id, disposition: input.disposition };
+                return { content: [{ type: "text", text: JSON.stringify(details) }], details };
+            }
+        }];
+}
+export function parseAttention(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        throw new TypeError("attention must be an object");
+    const result = value;
+    const bounds = { maxBatchMessages: [1, 32], maxBatchBytes: [1024, 12000], maxExecutions: [1, Number.MAX_SAFE_INTEGER], maxTokens: [1, Number.MAX_SAFE_INTEGER] };
+    for (const [key, value] of Object.entries(result)) {
+        const bound = bounds[key];
+        if (!Object.hasOwn(bounds, key) || !bound || typeof value !== "number" || !Number.isSafeInteger(value) || value < bound[0] || value > bound[1])
+            throw new TypeError(`attention.${key} is outside its bound`);
+    }
+    return { ...result };
+}

package/dist/runtime/attentionDispatcher.d.ts

@@ -0,0 +1,66 @@
+import type { AttentionRegistry } from "./attention.js";
+import type { OrganizationRuntimeAgentConfig, OrganizationRuntimeHost } from "./organizationRuntime.js";
+import { WakeAcceptanceStore } from "./wakeAcceptanceStore.js";
+import type { StoredWakeAcceptanceRecord } from "./wakeAcceptanceRecord.js";
+import { WakeFuse } from "./wakeFuse.js";
+type Options = Readonly<{
+    store: WakeAcceptanceStore;
+    host: OrganizationRuntimeHost;
+    fuse: WakeFuse;
+    agents: readonly OrganizationRuntimeAgentConfig[];
+    registry: AttentionRegistry;
+    token: string | undefined;
+    onIdle(agentId: string): void;
+}>;
+/** Durable deliveries wait here; only a selected execution reserves a budget slot. */
+export declare class AttentionDispatcher {
+    private readonly options;
+    private readonly owner;
+    private readonly work;
+    private readonly observed;
+    private readonly generations;
+    private readonly waiters;
+    private readonly active;
+    private readonly errors;
+    private stopping;
+    private fatal;
+    constructor(options: Options);
+    notify(agentId: string, fresh?: boolean): void;
+    fatalReason(): "ledger_unavailable" | undefined;
+    busy(agentId: string): boolean;
+    activeExecutions(): {
+        state: "running";
+        execution_id: string;
+        delivery_ids: string[];
+        agent_id: string;
+    }[];
+    failure(agentId: string): string | undefined;
+    stop(): Promise<void>;
+    halt(): void;
+    private drain;
+    private execute;
+    private failClosed;
+    private waitUntil;
+}
+export declare function selectBatch(records: readonly StoredWakeAcceptanceRecord[], agent: OrganizationRuntimeAgentConfig, revisitDeferred: boolean): StoredWakeAcceptanceRecord[];
+/**
+ * The inbox turn, task first.
+ *
+ * A delivery's own text *is* the work. Leading with bookkeeping and handing the
+ * model `JSON.stringify(messages)` buried the task: an agent read the JSON, did
+ * the accounting and deferred without doing the job (observed on Grok: nine
+ * model requests, no tool calls, nothing filed). The deliveries are therefore
+ * rendered as labelled blocks and the `daimon_inbox` accounting follows them as
+ * what to do *after* the work, with the machine-readable payload kept as a
+ * trailing appendix while it fits the same budget.
+ *
+ * Both tools are named the way the agent's own engine can call them. On Grok a
+ * Daimon tool is an MCP tool of server `daimon` and its bare name reaches
+ * nothing (`grokDaimonToolName`, the same contract module the worker's system
+ * prompt and identity envelope render from), so an agent handed the bare name
+ * cannot mark its work complete — and an unmarked, finished wake is recorded as
+ * deferred.
+ */
+export declare function inboxPrompt(messages: readonly unknown[], engine: OrganizationRuntimeAgentConfig["engine"]["kind"], maxBytes?: number): string;
+export {};
+//# sourceMappingURL=attentionDispatcher.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"attentionDispatcher.d.ts","sourceRoot":"","sources":["../../src/runtime/attentionDispatcher.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAC;AACxD,OAAO,KAAK,EAAE,8BAA8B,EAAE,uBAAuB,EAAiC,MAAM,0BAA0B,CAAC;AAEvI,OAAO,EAAE,mBAAmB,EAAwD,MAAM,0BAA0B,CAAC;AACrH,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,2BAA2B,CAAC;AAC5E,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAKzC,KAAK,OAAO,GAAG,QAAQ,CAAC;IAAE,KAAK,EAAE,mBAAmB,CAAC;IAAC,IAAI,EAAE,uBAAuB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,MAAM,EAAE,SAAS,8BAA8B,EAAE,CAAC;IAAC,QAAQ,EAAE,iBAAiB,CAAC;IAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IAAC,MAAM,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAAE,CAAC,CAAC;AAEjP,sFAAsF;AACtF,qBAAa,mBAAmB;IAUlB,OAAO,CAAC,QAAQ,CAAC,OAAO;IATpC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAgB;IACtC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAoC;IACzD,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAA6B;IACtD,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA6B;IACzD,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAyB;IACjD,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuE;IAC9F,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,QAAQ,CAAS;IACzB,OAAO,CAAC,KAAK,CAAmC;gBACnB,OAAO,EAAE,OAAO;IAE7C,MAAM,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,UAAQ,GAAG,IAAI;IAW5C,WAAW,IAAI,oBAAoB,GAAG,SAAS;IAC/C,IAAI,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAC9B,gBAAgB;;sBAnB0C,MAAM;sBAAgB,MAAM,EAAE;;;IAoBxF,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,SAAS;IACtC,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;IAM3B,IAAI,IAAI,IAAI;YAEE,KAAK;YA2BL,OAAO;IAqErB,OAAO,CAAC,UAAU;YASJ,SAAS;CAOxB;AAED,wBAAgB,WAAW,CAAC,OAAO,EAAE,SAAS,0BAA0B,EAAE,EAAE,KAAK,EAAE,8BAA8B,EAAE,eAAe,EAAE,OAAO,GAAG,0BAA0B,EAAE,CAmBzK;AAcD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,WAAW,CAAC,QAAQ,EAAE,SAAS,OAAO,EAAE,EAAE,MAAM,EAAE,8BAA8B,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,EAAE,QAAQ,SAAQ,GAAG,MAAM,CAsB5I"}