@parall/daemon 1.27.0

package/dist/config.d.ts

@@ -0,0 +1,62 @@
+/**
+ * Daemon-mode env. The daemon authenticates to the Parall API with an
+ * `mck_*` bearer token (PRLL_API_KEY) and supervises N per-agent
+ * `parall-claude-agent` subprocesses on this host.
+ *
+ * Compared to claude-agent's config:
+ *   - `apiKey` is an mck_ bearer (Machine-scoped), not an agk_
+ *   - there is no PRLL_ORG_ID — the Machine row's org_id is implicit;
+ *     each spawned per-agent subprocess is given its own PRLL_ORG_ID
+ *     resolved from the AttachedAgent's profile / org context
+ *   - per-agent state lives at `<rootStateDir>/agents/<agent_id>/`
+ */
+export type ClaudeDaemonConfig = {
+    apiUrl: string;
+    /** mck_*-prefixed Machine bearer. */
+    apiKey: string;
+    /** @deprecated Superseded by RuntimeAdapter pattern (runtimes.ts). Kept for backward compat / fallback. */
+    agentBin: string;
+    /** Root for per-agent state dirs. Each agent gets `<rootStateDir>/agents/<agent_id>`. */
+    rootStateDir: string;
+    /** Shared host home root. Per-agent HOME dirs live under `<rootClaudeHome>/agents/<agent_id>`. */
+    rootClaudeHome: string;
+    /** Optional WS URL override for the machine control-plane WebSocket. */
+    wsUrl?: string;
+    /** @deprecated Superseded by WS event-driven model; kept for backward compat. */
+    pollIntervalMs: number;
+    /** @deprecated Superseded by WS event-driven model; kept for backward compat. */
+    heartbeatIntervalMs: number;
+    /** Backoff base after a subprocess crash, in ms. */
+    restartBackoffMs: number;
+    /** Hard cap on parallel restart attempts per agent before giving up for a cycle. */
+    restartBackoffMaxMs: number;
+    /**
+     * Bootstrap retry: when `getMachineSelf` fails on startup (network blip,
+     * mck_ key not yet propagated, server warming up), wait this long and
+     * retry instead of crashing the daemon. Exponential backoff up to
+     * `bootstrapBackoffMaxMs`. Set 0 to disable (fail-fast on first error).
+     */
+    bootstrapBackoffMs: number;
+    bootstrapBackoffMaxMs: number;
+    /**
+     * Outer supervisor keepalive: if `supervisor.run()` rejects with an
+     * unexpected error, wait this long and reinstantiate. Same exp-backoff
+     * shape as bootstrap. Set 0 to disable (let main() exit, rely on K8s/PID-1).
+     */
+    supervisorRestartBackoffMs: number;
+    supervisorRestartBackoffMaxMs: number;
+};
+export declare function resolveClaudeDaemonConfig(env?: NodeJS.ProcessEnv): ClaudeDaemonConfig;
+/** Per-agent state dir under the shared host volume. */
+export declare function agentStateDirFor(rootStateDir: string, agentId: string): string;
+/** Per-agent HOME dir. Claude Code stores project/session state under
+ * `${HOME}/.claude`, so each agent gets its own HOME root while the daemon
+ * links shared OAuth credentials into that `.claude` directory. */
+export declare function agentClaudeHomeFor(rootClaudeHome: string, agentId: string): string;
+/** Shared Claude Code OAuth credential written by server-side runtime auth. */
+export declare function sharedClaudeCredentialsFileFor(rootClaudeHome: string): string;
+/** Per-agent credential location inside that agent's isolated HOME. */
+export declare function agentClaudeCredentialsFileFor(agentClaudeHome: string): string;
+/** Per-agent workspace dir where the agent runs git commands. */
+export declare function agentWorkspaceDirFor(rootStateDir: string, agentId: string): string;
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,MAAM,MAAM,kBAAkB,GAAG;IAC/B,MAAM,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,2GAA2G;IAC3G,QAAQ,EAAE,MAAM,CAAC;IACjB,yFAAyF;IACzF,YAAY,EAAE,MAAM,CAAC;IACrB,kGAAkG;IAClG,cAAc,EAAE,MAAM,CAAC;IACvB,wEAAwE;IACxE,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,iFAAiF;IACjF,cAAc,EAAE,MAAM,CAAC;IACvB,iFAAiF;IACjF,mBAAmB,EAAE,MAAM,CAAC;IAC5B,oDAAoD;IACpD,gBAAgB,EAAE,MAAM,CAAC;IACzB,oFAAoF;IACpF,mBAAmB,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,kBAAkB,EAAE,MAAM,CAAC;IAC3B,qBAAqB,EAAE,MAAM,CAAC;IAC9B;;;;OAIG;IACH,0BAA0B,EAAE,MAAM,CAAC;IACnC,6BAA6B,EAAE,MAAM,CAAC;CACvC,CAAC;AA2BF,wBAAgB,yBAAyB,CAAC,GAAG,GAAE,MAAM,CAAC,UAAwB,GAAG,kBAAkB,CA8BlG;AASD,wDAAwD;AACxD,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAE9E;AAED;;mEAEmE;AACnE,wBAAgB,kBAAkB,CAAC,cAAc,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAElF;AAED,+EAA+E;AAC/E,wBAAgB,8BAA8B,CAAC,cAAc,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,uEAAuE;AACvE,wBAAgB,6BAA6B,CAAC,eAAe,EAAE,MAAM,GAAG,MAAM,CAE7E;AAED,iEAAiE;AACjE,wBAAgB,oBAAoB,CAAC,YAAY,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAElF"}

package/dist/config.js

@@ -0,0 +1,81 @@
+import * as os from "node:os";
+import * as path from "node:path";
+function requireEnv(env, name) {
+    const value = env[name]?.trim();
+    if (!value) {
+        throw new Error(`Missing required env var: ${name}`);
+    }
+    return value;
+}
+function resolvePath(value) {
+    return path.isAbsolute(value) ? value : path.resolve(process.cwd(), value);
+}
+function parseMs(value, fallback) {
+    if (!value)
+        return fallback;
+    const n = Number(value);
+    return Number.isFinite(n) && n > 0 ? n : fallback;
+}
+/** Like parseMs but allows 0 (operator opt-out). */
+function parseMsAllowZero(value, fallback) {
+    if (value === undefined)
+        return fallback;
+    const n = Number(value);
+    return Number.isFinite(n) && n >= 0 ? n : fallback;
+}
+export function resolveClaudeDaemonConfig(env = process.env) {
+    const apiUrl = requireEnv(env, "PRLL_API_URL");
+    const apiKey = requireEnv(env, "PRLL_API_KEY");
+    if (!apiKey.startsWith("mck_")) {
+        // Fatal startup validation: the daemon must never run with an agent or
+        // human key because child launch credentials are minted from this bearer.
+        throw new Error(`PRLL_API_KEY does not look like a Machine bearer (expected prefix "mck_"). ` +
+            `Daemon mode requires a machine-scoped key issued via POST /machines/{id}/keys.`);
+    }
+    const rootClaudeHome = resolvePath(env.PRLL_CLAUDE_HOME?.trim() || env.HOME || os.homedir());
+    const rootStateDir = resolvePath(env.PRLL_CLAUDE_STATE_DIR?.trim() || path.join(rootClaudeHome, ".parall-agent"));
+    return {
+        apiUrl,
+        apiKey,
+        agentBin: env.PRLL_CLAUDE_AGENT_BIN?.trim() || "parall-claude-agent",
+        rootStateDir,
+        rootClaudeHome,
+        wsUrl: env.PRLL_WS_URL?.trim() || undefined,
+        pollIntervalMs: parseMs(env.PRLL_DAEMON_POLL_INTERVAL_MS, 30_000),
+        heartbeatIntervalMs: parseMs(env.PRLL_DAEMON_HEARTBEAT_INTERVAL_MS, 30_000),
+        restartBackoffMs: parseMs(env.PRLL_DAEMON_RESTART_BACKOFF_MS, 5_000),
+        restartBackoffMaxMs: parseMs(env.PRLL_DAEMON_RESTART_BACKOFF_MAX_MS, 5 * 60_000),
+        bootstrapBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MS, 2_000),
+        bootstrapBackoffMaxMs: parseMs(env.PRLL_DAEMON_BOOTSTRAP_BACKOFF_MAX_MS, 60_000),
+        supervisorRestartBackoffMs: parseMsAllowZero(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS, 5_000),
+        supervisorRestartBackoffMaxMs: parseMs(env.PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MAX_MS, 5 * 60_000),
+    };
+}
+function assertSafeAgentId(agentId) {
+    if (!/^[A-Za-z0-9_-]+$/.test(agentId)) {
+        throw new Error(`Invalid agentId for filesystem path: ${agentId}`);
+    }
+    return agentId;
+}
+/** Per-agent state dir under the shared host volume. */
+export function agentStateDirFor(rootStateDir, agentId) {
+    return path.join(rootStateDir, "agents", assertSafeAgentId(agentId));
+}
+/** Per-agent HOME dir. Claude Code stores project/session state under
+ * `${HOME}/.claude`, so each agent gets its own HOME root while the daemon
+ * links shared OAuth credentials into that `.claude` directory. */
+export function agentClaudeHomeFor(rootClaudeHome, agentId) {
+    return path.join(rootClaudeHome, "agents", assertSafeAgentId(agentId));
+}
+/** Shared Claude Code OAuth credential written by server-side runtime auth. */
+export function sharedClaudeCredentialsFileFor(rootClaudeHome) {
+    return path.join(rootClaudeHome, ".claude", ".credentials.json");
+}
+/** Per-agent credential location inside that agent's isolated HOME. */
+export function agentClaudeCredentialsFileFor(agentClaudeHome) {
+    return path.join(agentClaudeHome, ".claude", ".credentials.json");
+}
+/** Per-agent workspace dir where the agent runs git commands. */
+export function agentWorkspaceDirFor(rootStateDir, agentId) {
+    return path.join(rootStateDir, "agents", assertSafeAgentId(agentId), "workspace");
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":""}

package/dist/index.js

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { ParallClient } from "@parall/sdk";
+import { resolveClaudeDaemonConfig } from "./config.js";
+import { DaemonSupervisor, sleepCancellable } from "./supervisor.js";
+function createLogger(prefix) {
+    return {
+        info: (msg) => console.log(`[${prefix}] ${msg}`),
+        warn: (msg) => console.warn(`[${prefix}] ${msg}`),
+        error: (msg) => console.error(`[${prefix}] ${msg}`),
+    };
+}
+function formatError(reason) {
+    if (reason instanceof Error) {
+        return reason.stack ?? reason.message;
+    }
+    return String(reason);
+}
+/**
+ * Outer keepalive: runs `supervisor.run()` in a loop, restarting it with
+ * exponential backoff if it rejects. The daemon process only exits when
+ * the abort signal fires (SIGINT/SIGTERM) — anything else is treated as
+ * a transient failure that we recover from in-process.
+ *
+ * Why this exists in addition to entrypoint.sh's `while :; do parall-daemon; done`:
+ *   - In-process restart preserves the `client` (= same TCP/TLS pool) and
+ *     skips the ~hundreds-of-ms cost of Node startup + module loading per
+ *     cycle, which matters when the API is flapping.
+ *   - The shell wrapper is the "process really crashed" backstop —
+ *     segfault, OOM, uncaughtException, etc. The two layers are
+ *     complementary: in-process for soft failures, shell for hard failures.
+ *
+ * Operators can disable the in-process loop by setting
+ * PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS=0 — main() will then exit on
+ * any supervisor.run() rejection and rely entirely on the shell wrapper +
+ * K8s for restart.
+ */
+async function runForever(config, client, log, signal) {
+    let attempt = 0;
+    while (!signal.aborted) {
+        const supervisor = new DaemonSupervisor(config, client, log);
+        try {
+            await supervisor.run(signal);
+            // Clean exit (signal aborted) — done.
+            await supervisor.stop();
+            return;
+        }
+        catch (err) {
+            // supervisor.run() rejected. The supervisor's per-tick handlers
+            // already swallow individual failures, so the only paths that reach
+            // here are (a) bootstrap fail-fast mode and (b) genuine programmer
+            // bugs. Restart anyway — operators rely on this daemon as the only
+            // thing keeping per-agent children alive on this host.
+            log.error(`supervisor crashed: ${String(err)}`);
+            try {
+                await supervisor.stop();
+            }
+            catch (stopErr) {
+                log.warn(`supervisor.stop() after crash threw: ${String(stopErr)}`);
+            }
+            if (config.supervisorRestartBackoffMs === 0) {
+                log.error("supervisor keepalive disabled (PRLL_DAEMON_SUPERVISOR_RESTART_BACKOFF_MS=0) — exiting");
+                throw err;
+            }
+            const delay = Math.min(config.supervisorRestartBackoffMs * Math.pow(2, attempt), config.supervisorRestartBackoffMaxMs);
+            attempt += 1;
+            log.warn(`restarting supervisor in ${delay}ms (attempt ${attempt})`);
+            const slept = await sleepCancellable(delay, signal);
+            if (!slept)
+                return;
+        }
+    }
+}
+async function main() {
+    const config = resolveClaudeDaemonConfig(process.env);
+    const log = createLogger("daemon");
+    log.info(`boot: api=${config.apiUrl} pollMs=${config.pollIntervalMs} heartbeatMs=${config.heartbeatIntervalMs} agentBin=${config.agentBin}`);
+    log.info(`keepalive: bootstrapBackoffMs=${config.bootstrapBackoffMs} supervisorRestartBackoffMs=${config.supervisorRestartBackoffMs}`);
+    // The daemon talks to the API as a Machine — the bearer is mck_*.
+    // No orgId is configured here; per-agent subprocesses get their
+    // own org_id via the spawn env.
+    const client = new ParallClient({
+        baseUrl: config.apiUrl,
+        token: config.apiKey,
+    });
+    const abortController = new AbortController();
+    const onSignal = (sig) => {
+        log.info(`received ${sig} — initiating shutdown`);
+        abortController.abort();
+    };
+    process.on("SIGINT", () => onSignal("SIGINT"));
+    process.on("SIGTERM", () => onSignal("SIGTERM"));
+    // Defensive: unexpected async failures are logged explicitly. Rejections
+    // stay in-process so the supervisor loop can recover; uncaught exceptions
+    // exit so entrypoint.sh's shell-level keepalive restarts from a clean VM.
+    process.on("unhandledRejection", (reason) => {
+        log.error(`unhandledRejection: ${formatError(reason)}`);
+    });
+    process.on("uncaughtException", (err) => {
+        log.error(`uncaughtException: ${formatError(err)}`);
+        process.exitCode = 1;
+        process.exit(1);
+    });
+    await runForever(config, client, log, abortController.signal);
+}
+main().catch((err) => {
+    console.error(`[daemon] fatal: ${formatError(err)}`);
+    process.exitCode = 1;
+});

package/dist/runtimes.d.ts

@@ -0,0 +1,12 @@
+export interface RuntimeAdapter {
+    bin: string;
+    buildEnv(baseEnv: NodeJS.ProcessEnv, agentId: string, orgId: string, apiKey: string, dirs: AgentDirs): NodeJS.ProcessEnv;
+}
+export interface AgentDirs {
+    stateDir: string;
+    workspaceDir: string;
+    claudeHome: string;
+}
+export declare function getRuntimeAdapter(runtimeType: string): RuntimeAdapter;
+export declare function assertAgentKey(apiKey: string): void;
+//# sourceMappingURL=runtimes.d.ts.map

package/dist/runtimes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtimes.d.ts","sourceRoot":"","sources":["../src/runtimes.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,UAAU,EAAE,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,MAAM,CAAC,UAAU,CAAC;CAC1H;AAED,MAAM,WAAW,SAAS;IACxB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,EAAE,MAAM,CAAC;IACrB,UAAU,EAAE,MAAM,CAAC;CACpB;AAqDD,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,MAAM,GAAG,cAAc,CAErE;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAInD"}

package/dist/runtimes.js

@@ -0,0 +1,55 @@
+const claudeCodeAdapter = {
+    bin: "parall-claude-agent",
+    buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
+        const env = { ...baseEnv };
+        env.PRLL_API_KEY = apiKey;
+        env.PRLL_ORG_ID = orgId;
+        env.AGENT_ID = agentId;
+        env.PRLL_AGENT_ID = agentId;
+        env.PRLL_CLAUDE_HOME = dirs.claudeHome;
+        env.PRLL_CLAUDE_STATE_DIR = dirs.stateDir;
+        env.PRLL_CLAUDE_WORKSPACE_DIR = dirs.workspaceDir;
+        delete env.PRLL_DAEMON_MODE;
+        return env;
+    },
+};
+const codexAdapter = {
+    bin: "parall-codex-agent",
+    buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
+        const env = { ...baseEnv };
+        env.PRLL_API_KEY = apiKey;
+        env.PRLL_ORG_ID = orgId;
+        env.AGENT_ID = agentId;
+        env.PRLL_AGENT_ID = agentId;
+        env.PRLL_CODEX_STATE_DIR = dirs.stateDir;
+        env.PRLL_CODEX_WORKSPACE_DIR = dirs.workspaceDir;
+        delete env.PRLL_DAEMON_MODE;
+        return env;
+    },
+};
+const defaultAdapter = {
+    bin: "parall-agent",
+    buildEnv(baseEnv, agentId, orgId, apiKey, dirs) {
+        const env = { ...baseEnv };
+        env.PRLL_API_KEY = apiKey;
+        env.PRLL_ORG_ID = orgId;
+        env.AGENT_ID = agentId;
+        env.PRLL_AGENT_ID = agentId;
+        env.PRLL_STATE_DIR = dirs.stateDir;
+        env.PRLL_WORKSPACE_DIR = dirs.workspaceDir;
+        delete env.PRLL_DAEMON_MODE;
+        return env;
+    },
+};
+const RUNTIME_ADAPTERS = {
+    "claude-code": claudeCodeAdapter,
+    "codex": codexAdapter,
+};
+export function getRuntimeAdapter(runtimeType) {
+    return RUNTIME_ADAPTERS[runtimeType] ?? defaultAdapter;
+}
+export function assertAgentKey(apiKey) {
+    if (apiKey.startsWith("mck_")) {
+        throw new Error("BUG: machine key leaked to child process — expected agk_, got mck_");
+    }
+}

package/dist/supervisor.d.ts

@@ -0,0 +1,50 @@
+import { ParallClient } from "@parall/sdk";
+import { type ClaudeDaemonConfig } from "./config.js";
+export interface DaemonLogger {
+    info(msg: string): void;
+    warn(msg: string): void;
+    error(msg: string): void;
+}
+/**
+ * Sleep that wakes early on abort. Returns true if the full delay elapsed,
+ * false if aborted. Used by bootstrap retry and the outer keepalive in
+ * `runForever` so SIGTERM during a long backoff doesn't stall shutdown.
+ */
+declare function sleepCancellable(ms: number, signal: AbortSignal): Promise<boolean>;
+export { sleepCancellable };
+/**
+ * Supervisor orchestrates one mck_ machine bearer into N
+ * `parall-claude-agent` subprocesses, one per AttachedAgent.
+ *
+ * Lifecycle is WS event-driven:
+ *   1. Bootstrap: confirm machine identity with retry.
+ *   2. Full reconcile: list attached agents, diff with children, spawn/kill.
+ *   3. Connect WS: receive machine.agent.attached / .detached / .stop
+ *      events for incremental updates; full reconcile on every reconnect
+ *      (machine.hello) to catch events missed while disconnected.
+ */
+export declare class DaemonSupervisor {
+    private readonly config;
+    private readonly client;
+    private readonly log;
+    private readonly children;
+    private ws;
+    private running;
+    private machineOrgId;
+    private stopResolve;
+    constructor(config: ClaudeDaemonConfig, client: ParallClient, log: DaemonLogger);
+    /** Start the supervisor. Returns a promise that resolves on `stop()`. */
+    run(signal: AbortSignal): Promise<void>;
+    /** Disconnect WS, cancel timers, SIGTERM all children, await exit. */
+    stop(): Promise<void>;
+    private bootstrapWithRetry;
+    private fullReconcile;
+    private handleAgentAttached;
+    private handleAgentDetached;
+    private restartChildNow;
+    private spawnAgent;
+    private startChild;
+    private terminateChild;
+    private ensureSharedCredentialLink;
+}
+//# sourceMappingURL=supervisor.d.ts.map

package/dist/supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor.d.ts","sourceRoot":"","sources":["../src/supervisor.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAmJ,MAAM,aAAa,CAAC;AAC5L,OAAO,EACL,KAAK,kBAAkB,EAMxB,MAAM,aAAa,CAAC;AAGrB,MAAM,WAAW,YAAY;IAC3B,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,IAAI,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;IACxB,KAAK,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,CAAC;CAC1B;AAED;;;;GAIG;AACH,iBAAS,gBAAgB,CAAC,EAAE,EAAE,MAAM,EAAE,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAa3E;AAED,OAAO,EAAE,gBAAgB,EAAE,CAAC;AAmB5B;;;;;;;;;;GAUG;AACH,qBAAa,gBAAgB;IAQzB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG;IATtB,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAiC;IAC1D,OAAO,CAAC,EAAE,CAAyB;IACnC,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,YAAY,CAAuB;IAC3C,OAAO,CAAC,WAAW,CAA6B;gBAG7B,MAAM,EAAE,kBAAkB,EAC1B,MAAM,EAAE,YAAY,EACpB,GAAG,EAAE,YAAY;IAGpC,yEAAyE;IACnE,GAAG,CAAC,MAAM,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IA+D7C,sEAAsE;IAChE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YA6Bb,kBAAkB;YAoClB,aAAa;YAqDb,mBAAmB;YA6BnB,mBAAmB;YAgBnB,eAAe;YAcf,UAAU;IAmCxB,OAAO,CAAC,UAAU;YAgEJ,cAAc;IAyB5B,OAAO,CAAC,0BAA0B;CA8BnC"}