@with-logic/elwood 0.2.0 → 0.2.2

package/dist/runtime/shutdown/detached-sweep/rounds.js

@@ -0,0 +1,116 @@
+/**
+ * One round of the detached sweep (PRD §5.3 and §9.4, C-LIFE-10): what the latest table
+ * read shows about the groups the sweep has signaled, and which new groups it may stop.
+ * A group is "signaled" once a SIGSTOP to it returned, which says nothing about its
+ * members yet: `kill()` has only sent the signal, and `ps` reads each row at its own
+ * moment, so a process counts as held only when this read AND the one before it showed
+ * it stopped inside a signaled group. A held parent can neither reap an exited child,
+ * which keeps that child's group id from being reused, nor start a process the next
+ * read could miss. A signaled group can still hold a running member: `killpg` signals
+ * the members it finds, so a child forked while it runs can miss the SIGSTOP.
+ */
+import { errnoCode } from "../../../core/errors.js";
+export function newSweepState(failures) {
+    return {
+        signaledGroupIds: new Set(),
+        signaledDescendantGroupIds: [],
+        stoppedPidsLastRead: new Set(),
+        unstoppable: new Map(),
+        live: new Map(),
+        unheld: [],
+        latest: [],
+        failures,
+    };
+}
+/** The live groups in the latest read that the sweep has not tried to stop. */
+export function unreachedGroups(state) {
+    return [...state.live.keys()].filter((group) => !(state.signaledGroupIds.has(group) || state.unstoppable.has(group)));
+}
+/** Records `reason` against every group not yet confirmed stopped: unreached or unheld. */
+export function recordUnconfirmed(state, reason, error) {
+    state.failures.record(reason, error, [...unreachedGroups(state), ...state.unheld]);
+}
+/** The sweep's outcome, once each group a read showed live but no SIGSTOP reached fails. */
+export function sweepOutcome(state) {
+    for (const [group, error] of state.unstoppable) {
+        if (state.live.has(group))
+            state.failures.record("could not stop a live descendant group", error, [group]);
+    }
+    return state.failures.result();
+}
+/**
+ * The signaled groups this read does not hold: each with a live member that this read
+ * and the one before did not both show stopped, and any leader's own group while this
+ * read does not show the leader live, since its exit leaves descendants out of reach.
+ */
+export function unheldGroups(table, state, leaderPid) {
+    const unheld = new Set();
+    if (leaderPid !== undefined && !table.some((row) => row.pid === leaderPid && !row.zombie)) {
+        unheld.add(leaderPid);
+    }
+    for (const row of table) {
+        if (row.zombie || !state.signaledGroupIds.has(row.pgid))
+            continue;
+        if (!(row.stopped && state.stoppedPidsLastRead.has(row.pid)))
+            unheld.add(row.pgid);
+    }
+    return [...unheld];
+}
+/**
+ * Stops each unreached group that a held parent anchors, after noting which rows this
+ * read shows stopped for the NEXT read to rely on.
+ */
+export function stopAnchoredGroups(table, ops, state) {
+    const unreached = new Set(unreachedGroups(state));
+    const anchored = [...state.live].filter(([group, parents]) => unreached.has(group) && [...parents].some((p) => isAnchor(p, state)));
+    state.stoppedPidsLastRead = new Set(table
+        .filter((row) => row.stopped && state.signaledGroupIds.has(row.pgid))
+        .map((row) => row.pid));
+    for (const [group] of anchored)
+        stopGroup(group, ops, state);
+}
+/**
+ * Sends SIGSTOP again to each signaled group this read shows with a live member that is
+ * not stopped, such as a child forked while the group's first stop went out (it keeps
+ * running until signaled; macOS showed one in 150 stops of a shell forking pipelines,
+ * and a real Claude teardown's login shell had one still running three seconds later).
+ * Each id still names its group: the caller has just seen the leader alive, and a
+ * descendant group stays anchored by the held parent the kill pass relies on too.
+ */
+export function restopEscapedGroups(table, ops, state) {
+    const escaped = table.filter((row) => !(row.zombie || row.stopped) && state.signaledGroupIds.has(row.pgid));
+    for (const group of new Set(escaped.map((row) => row.pgid))) {
+        try {
+            ops.stopGroup(group);
+        }
+        catch (error) {
+            if (errnoCode(error) === "ESRCH")
+                continue;
+            const descendant = state.signaledDescendantGroupIds.includes(group);
+            const reason = descendant
+                ? "could not stop a live descendant group"
+                : "could not stop the leader's group";
+            state.failures.record(reason, error, [group]);
+        }
+    }
+}
+/** A parent this read and the one before both showed stopped inside a signaled group. */
+function isAnchor(parent, state) {
+    return (parent.stopped &&
+        state.signaledGroupIds.has(parent.pgid) &&
+        state.stoppedPidsLastRead.has(parent.pid));
+}
+/** A group that vanished (`ESRCH`) needs nothing; any other refusal is judged at the end. */
+export function stopGroup(group, ops, state) {
+    try {
+        ops.stopGroup(group);
+        state.signaledDescendantGroupIds.push(group);
+        state.signaledGroupIds.add(group);
+        state.unheld = [...state.unheld, group];
+    }
+    catch (error) {
+        if (errnoCode(error) !== "ESRCH")
+            state.unstoppable.set(group, error);
+    }
+}
+//# sourceMappingURL=rounds.js.map

package/dist/runtime/shutdown/detached-sweep/rounds.js.map

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

package/dist/runtime/shutdown/detached-sweep/survivors.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Reaps the recorded detached descendants that outlived a PTY leader's graceful exit
+ * (PRD §5.3 and §9.4, C-LIFE-10), with the detached sweep's rounds and kill pass. With
+ * the leader gone no parent pid links them to the session, so a group is first stopped
+ * because a read shows a recorded process in it: same pid, same start time (`record.ts`).
+ * From there the sweep's rules hold (`index.ts`), less the live leader: a held process
+ * anchors the groups it started, a group read with a member running is stopped again,
+ * and once a read converges the signaled groups are SIGKILLed deepest first, but one
+ * holding Codex's daemon, which is resumed (`kill.ts`). A group stops counting as a
+ * survivor once no recorded process is alive in it. The one exposure the identity leaves
+ * is a recorded process that exits between the read that shows it and the SIGSTOP, its
+ * group id reused within that moment; anchors rule that out only for a live leader.
+ */
+import { type SweepFailure } from "./failures.ts";
+import { type DescendantRecord } from "./record.ts";
+import { type SweepOps } from "./rounds.ts";
+/** A graceful stop's watch for survivors, from the first recording read to the reap. */
+export type SurvivorWatch = {
+    /** Settles once the read before the SIGTERM has finished, whether or not it succeeded. */
+    readonly firstRead: Promise<void>;
+    /**
+     * Stops recording, then, if `leaderExited` reports the exit, reaps the recorded
+     * processes still alive and hands the outcome, a failure or `undefined`, to `keep`.
+     */
+    readonly finish: () => Promise<void>;
+};
+/**
+ * Records `leaderPid`'s detached descendants (`watchDescendants`) until `finish`. Records
+ * nothing for an `undefined` leader, one whose id the group reap refuses.
+ */
+export declare function watchSurvivors(leaderPid: number | undefined, ops: SweepOps, leaderExited: () => boolean, keep: (failure: SweepFailure | undefined) => void): SurvivorWatch;
+/**
+ * Stops and SIGKILLs the groups holding `record`'s processes that are still alive, and
+ * any group they anchor, within the sweep's budget. Resolves to the unresolved failure,
+ * or `undefined` once a read converged and every signaled group was killed, or resumed as
+ * holding Codex's daemon. A record that does not know the leader's tree fails, and one
+ * that knows it empty reads nothing.
+ */
+export declare function reapRecordedSurvivors(record: DescendantRecord, ops: SweepOps, budgetMs?: number): Promise<SweepFailure | undefined>;
+//# sourceMappingURL=survivors.d.ts.map

package/dist/runtime/shutdown/detached-sweep/survivors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"survivors.d.ts","sourceRoot":"","sources":["../../../../src/runtime/shutdown/detached-sweep/survivors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,OAAO,EAAE,KAAK,YAAY,EAAiB,MAAM,eAAe,CAAC;AAGjE,OAAO,EAAE,KAAK,gBAAgB,EAAoB,MAAM,aAAa,CAAC;AACtE,OAAO,EAIL,KAAK,QAAQ,EAOd,MAAM,aAAa,CAAC;AAErB,wFAAwF;AACxF,MAAM,MAAM,aAAa,GAAG;IAC1B,0FAA0F;IAC1F,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAClC;;;OAGG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CACtC,CAAC;AAEF;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,SAAS,EAAE,MAAM,GAAG,SAAS,EAC7B,GAAG,EAAE,QAAQ,EACb,YAAY,EAAE,MAAM,OAAO,EAC3B,IAAI,EAAE,CAAC,OAAO,EAAE,YAAY,GAAG,SAAS,KAAK,IAAI,GAChD,aAAa,CAWf;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACzC,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,QAAQ,EACb,QAAQ,GAAE,MAAiC,GAC1C,OAAO,CAAC,YAAY,GAAG,SAAS,CAAC,CAWnC"}

package/dist/runtime/shutdown/detached-sweep/survivors.js

@@ -0,0 +1,112 @@
+/**
+ * Reaps the recorded detached descendants that outlived a PTY leader's graceful exit
+ * (PRD §5.3 and §9.4, C-LIFE-10), with the detached sweep's rounds and kill pass. With
+ * the leader gone no parent pid links them to the session, so a group is first stopped
+ * because a read shows a recorded process in it: same pid, same start time (`record.ts`).
+ * From there the sweep's rules hold (`index.ts`), less the live leader: a held process
+ * anchors the groups it started, a group read with a member running is stopped again,
+ * and once a read converges the signaled groups are SIGKILLed deepest first, but one
+ * holding Codex's daemon, which is resumed (`kill.ts`). A group stops counting as a
+ * survivor once no recorded process is alive in it. The one exposure the identity leaves
+ * is a recorded process that exits between the read that shows it and the SIGSTOP, its
+ * group id reused within that moment; anchors rule that out only for a live leader.
+ */
+import { detachedDescendantGroups } from "../process-table.js";
+import { daemonScope } from "../shared-daemon.js";
+import { SweepFailures } from "./failures.js";
+import { DETACHED_SWEEP_BUDGET_MS } from "./index.js";
+import { killOrResumeSignaledGroups } from "./kill.js";
+import { watchDescendants } from "./record.js";
+import { newSweepState, recordUnconfirmed, restopEscapedGroups, stopAnchoredGroups, stopGroup, sweepOutcome, unheldGroups, unreachedGroups, } from "./rounds.js";
+/**
+ * Records `leaderPid`'s detached descendants (`watchDescendants`) until `finish`. Records
+ * nothing for an `undefined` leader, one whose id the group reap refuses.
+ */
+export function watchSurvivors(leaderPid, ops, leaderExited, keep) {
+    if (leaderPid === undefined)
+        return { firstRead: Promise.resolve(), finish: () => Promise.resolve() };
+    const watch = watchDescendants(leaderPid, ops, leaderExited);
+    return {
+        firstRead: watch.firstRead,
+        finish: async () => {
+            const record = await watch.finish();
+            if (leaderExited())
+                keep(await reapRecordedSurvivors(record, ops));
+        },
+    };
+}
+/**
+ * Stops and SIGKILLs the groups holding `record`'s processes that are still alive, and
+ * any group they anchor, within the sweep's budget. Resolves to the unresolved failure,
+ * or `undefined` once a read converged and every signaled group was killed, or resumed as
+ * holding Codex's daemon. A record that does not know the leader's tree fails, and one
+ * that knows it empty reads nothing.
+ */
+export async function reapRecordedSurvivors(record, ops, budgetMs = DETACHED_SWEEP_BUDGET_MS) {
+    const state = newSweepState(new SweepFailures());
+    if (!record.known) {
+        state.failures.record("no read showed the leader's tree", undefined, []);
+        return state.failures.result();
+    }
+    if (record.pids.length === 0)
+        return undefined;
+    const deadline = performance.now() + budgetMs;
+    await stopSurvivorGroups(record, ops, deadline, state);
+    await killOrResumeSignaledGroups(ops, state, deadline);
+    return sweepOutcome(state);
+}
+/** Reads round by round until a read converges, as `stopDescendantGroups` does. */
+async function stopSurvivorGroups(record, ops, deadline, state) {
+    // Codex's daemon is marked under two kinds of root. A recorded pid: a recorded process
+    // may have `exec`'d the daemon since it was recorded. A stopped group: its parent's exit
+    // can leave the daemon in it under PID 1, under no recorded pid.
+    const scopeRoots = new Set(record.pids);
+    const scope = daemonScope(scopeRoots);
+    try {
+        while (true) {
+            for (const group of state.signaledGroupIds)
+                scopeRoots.add(group);
+            const remainingMs = Math.ceil(deadline - performance.now());
+            if (remainingMs <= 0)
+                return recordUnconfirmed(state, "process groups not confirmed stopped by the deadline");
+            const table = await ops.listProcesses(remainingMs, scope);
+            state.latest = table;
+            const roots = survivorGroups(record.survivors(table), table);
+            state.live = liveGroups(table, roots);
+            state.unheld = unheldGroups(table, state);
+            if (unreachedGroups(state).length === 0 && state.unheld.length === 0)
+                return;
+            restopEscapedGroups(table, ops, state);
+            stopAnchoredGroups(table, ops, state);
+            for (const group of unreachedGroups(state)) {
+                if (roots.has(group))
+                    stopGroup(group, ops, state);
+            }
+        }
+    }
+    catch (error) {
+        recordUnconfirmed(state, "process table unreadable", error);
+    }
+}
+/** The groups of `survivors`, never the host's or an id `kill(-pgid)` would misroute. */
+function survivorGroups(survivors, table) {
+    const host = table.find((row) => row.pid === process.pid)?.pgid;
+    return new Set(survivors.map((row) => row.pgid).filter((pgid) => pgid > 1 && pgid !== host));
+}
+/** The survivor groups, then every group a member of one anchors, with the parents' rows. */
+function liveGroups(table, roots) {
+    const live = new Map([...roots].map((group) => [group, new Set()]));
+    for (const member of table) {
+        if (member.zombie || !roots.has(member.pgid))
+            continue;
+        const found = detachedDescendantGroups(table, { leaderPid: member.pid, hostPid: process.pid });
+        for (const [group, parents] of found) {
+            const known = live.get(group) ?? new Set();
+            for (const parent of parents)
+                known.add(parent);
+            live.set(group, known);
+        }
+    }
+    return live;
+}
+//# sourceMappingURL=survivors.js.map

package/dist/runtime/shutdown/detached-sweep/survivors.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"survivors.js","sourceRoot":"","sources":["../../../../src/runtime/shutdown/detached-sweep/survivors.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,wBAAwB,EAAqB,MAAM,qBAAqB,CAAC;AAClF,OAAO,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAClD,OAAO,EAAqB,aAAa,EAAE,MAAM,eAAe,CAAC;AACjE,OAAO,EAAE,wBAAwB,EAAE,MAAM,YAAY,CAAC;AACtD,OAAO,EAAE,0BAA0B,EAAE,MAAM,WAAW,CAAC;AACvD,OAAO,EAAyB,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACtE,OAAO,EACL,aAAa,EACb,iBAAiB,EACjB,mBAAmB,EAGnB,kBAAkB,EAClB,SAAS,EACT,YAAY,EACZ,YAAY,EACZ,eAAe,GAChB,MAAM,aAAa,CAAC;AAarB;;;GAGG;AACH,MAAM,UAAU,cAAc,CAC5B,SAA6B,EAC7B,GAAa,EACb,YAA2B,EAC3B,IAAiD;IAEjD,IAAI,SAAS,KAAK,SAAS;QACzB,OAAO,EAAE,SAAS,EAAE,OAAO,CAAC,OAAO,EAAE,EAAE,MAAM,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,EAAE,EAAE,CAAC;IAC3E,MAAM,KAAK,GAAG,gBAAgB,CAAC,SAAS,EAAE,GAAG,EAAE,YAAY,CAAC,CAAC;IAC7D,OAAO;QACL,SAAS,EAAE,KAAK,CAAC,SAAS;QAC1B,MAAM,EAAE,KAAK,IAAI,EAAE;YACjB,MAAM,MAAM,GAAG,MAAM,KAAK,CAAC,MAAM,EAAE,CAAC;YACpC,IAAI,YAAY,EAAE;gBAAE,IAAI,CAAC,MAAM,qBAAqB,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC;QACrE,CAAC;KACF,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CACzC,MAAwB,EACxB,GAAa,EACb,WAAmB,wBAAwB;IAE3C,MAAM,KAAK,GAAG,aAAa,CAAC,IAAI,aAAa,EAAE,CAAC,CAAC;IACjD,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,CAAC;QAClB,KAAK,CAAC,QAAQ,CAAC,MAAM,CAAC,kCAAkC,EAAE,SAAS,EAAE,EAAE,CAAC,CAAC;QACzE,OAAO,KAAK,CAAC,QAAQ,CAAC,MAAM,EAAE,CAAC;IACjC,CAAC;IACD,IAAI,MAAM,CAAC,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,SAAS,CAAC;IAC/C,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,QAAQ,CAAC;IAC9C,MAAM,kBAAkB,CAAC,MAAM,EAAE,GAAG,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;IACvD,MAAM,0BAA0B,CAAC,GAAG,EAAE,KAAK,EAAE,QAAQ,CAAC,CAAC;IACvD,OAAO,YAAY,CAAC,KAAK,CAAC,CAAC;AAC7B,CAAC;AAED,mFAAmF;AACnF,KAAK,UAAU,kBAAkB,CAC/B,MAAwB,EACxB,GAAa,EACb,QAAgB,EAChB,KAAiB;IAEjB,uFAAuF;IACvF,yFAAyF;IACzF,iEAAiE;IACjE,MAAM,UAAU,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACxC,MAAM,KAAK,GAAG,WAAW,CAAC,UAAU,CAAC,CAAC;IACtC,IAAI,CAAC;QACH,OAAO,IAAI,EAAE,CAAC;YACZ,KAAK,MAAM,KAAK,IAAI,KAAK,CAAC,gBAAgB;gBAAE,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;YAClE,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;YAC5D,IAAI,WAAW,IAAI,CAAC;gBAClB,OAAO,iBAAiB,CAAC,KAAK,EAAE,sDAAsD,CAAC,CAAC;YAC1F,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,aAAa,CAAC,WAAW,EAAE,KAAK,CAAC,CAAC;YAC1D,KAAK,CAAC,MAAM,GAAG,KAAK,CAAC;YACrB,MAAM,KAAK,GAAG,cAAc,CAAC,MAAM,CAAC,SAAS,CAAC,KAAK,CAAC,EAAE,KAAK,CAAC,CAAC;YAC7D,KAAK,CAAC,IAAI,GAAG,UAAU,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YACtC,KAAK,CAAC,MAAM,GAAG,YAAY,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;YAC1C,IAAI,eAAe,CAAC,KAAK,CAAC,CAAC,MAAM,KAAK,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,MAAM,KAAK,CAAC;gBAAE,OAAO;YAC7E,mBAAmB,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YACvC,kBAAkB,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YACtC,KAAK,MAAM,KAAK,IAAI,eAAe,CAAC,KAAK,CAAC,EAAE,CAAC;gBAC3C,IAAI,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC;oBAAE,SAAS,CAAC,KAAK,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC;YACrD,CAAC;QACH,CAAC;IACH,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,iBAAiB,CAAC,KAAK,EAAE,0BAA0B,EAAE,KAAK,CAAC,CAAC;IAC9D,CAAC;AACH,CAAC;AAED,yFAAyF;AACzF,SAAS,cAAc,CACrB,SAAkC,EAClC,KAA8B;IAE9B,MAAM,IAAI,GAAG,KAAK,CAAC,IAAI,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,EAAE,IAAI,CAAC;IAChE,OAAO,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,GAAG,CAAC,IAAI,IAAI,KAAK,IAAI,CAAC,CAAC,CAAC;AAC/F,CAAC;AAED,6FAA6F;AAC7F,SAAS,UAAU,CACjB,KAA8B,EAC9B,KAA0B;IAE1B,MAAM,IAAI,GAAG,IAAI,GAAG,CAA4B,CAAC,GAAG,KAAK,CAAC,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,KAAK,EAAE,IAAI,GAAG,EAAE,CAAC,CAAC,CAAC,CAAC;IAC/F,KAAK,MAAM,MAAM,IAAI,KAAK,EAAE,CAAC;QAC3B,IAAI,MAAM,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,IAAI,CAAC;YAAE,SAAS;QACvD,MAAM,KAAK,GAAG,wBAAwB,CAAC,KAAK,EAAE,EAAE,SAAS,EAAE,MAAM,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;QAC/F,KAAK,MAAM,CAAC,KAAK,EAAE,OAAO,CAAC,IAAI,KAAK,EAAE,CAAC;YACrC,MAAM,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,IAAI,GAAG,EAAgB,CAAC;YACzD,KAAK,MAAM,MAAM,IAAI,OAAO;gBAAE,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;YAChD,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;QACzB,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/runtime/shutdown/leader-group.d.ts

@@ -0,0 +1,29 @@
+/** Numeric group guards for owned PTY reaping (PRD §5.3, C-LIFE-10). */
+import { type GroupReapOps } from "./process-tree-ops.ts";
+/**
+ * A pgid is reapable when it identifies the KNOWN-OWNED node-pty leader's group
+ * rather than a system group or the host itself. Ownership is NOT inferred from a
+ * numeric floor — that is an allocation detail, and after PID-space wrap or inside
+ * a constrained namespace a legitimate leader can be low (a prior arbitrary `< 100`
+ * floor silently no-op'd such leaders and leaked their descendants). We instead
+ * accept every valid child pid while refusing the two ids a group SIGKILL must
+ * never touch:
+ *   - `pgid <= 1` — pid 0 means "our own group" to `kill(2)`, and pid 1 is
+ *     `init`/`launchd`; a fake pid 1 in tests once reaped a developer's real apps.
+ *   - the host's OWN pid — node-pty gives the leader a fresh session via `setsid()`
+ *     so its pgid can never legitimately equal ours, but if a bad pgid ever did we
+ *     must not signal `-process.pid` and kill ourselves.
+ */
+export declare function isReapableGroupId(pgid: number): boolean;
+/**
+ * SIGKILLs the process group led by `leaderPid`, reaping every descendant still
+ * in the group — including one already reparented to PID 1. node-pty starts the
+ * leader via `setsid()`, so it heads its own session and its pgid equals its pid;
+ * that group is always distinct from the host's own group, so this cannot signal
+ * the host process. Refuses only pids the kernel would misroute (see
+ * `isReapableGroupId`), never an arbitrary numeric floor. An already-dead group
+ * (leader and children exited together) is the normal case and its `ESRCH` is
+ * swallowed; a real kill failure such as `EPERM` propagates.
+ */
+export declare function reapProcessGroup(leaderPid: number, ops?: GroupReapOps): void;
+//# sourceMappingURL=leader-group.d.ts.map

package/dist/runtime/shutdown/leader-group.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader-group.d.ts","sourceRoot":"","sources":["../../../src/runtime/shutdown/leader-group.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,OAAO,EAAwB,KAAK,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAEhF;;;;;;;;;;;;;GAaG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAC9B,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,YAAqC,GACzC,IAAI,CAGN"}

package/dist/runtime/shutdown/leader-group.js

@@ -0,0 +1,35 @@
+/** Numeric group guards for owned PTY reaping (PRD §5.3, C-LIFE-10). */
+import { activeProcessTreeOps } from "./process-tree-ops.js";
+/**
+ * A pgid is reapable when it identifies the KNOWN-OWNED node-pty leader's group
+ * rather than a system group or the host itself. Ownership is NOT inferred from a
+ * numeric floor — that is an allocation detail, and after PID-space wrap or inside
+ * a constrained namespace a legitimate leader can be low (a prior arbitrary `< 100`
+ * floor silently no-op'd such leaders and leaked their descendants). We instead
+ * accept every valid child pid while refusing the two ids a group SIGKILL must
+ * never touch:
+ *   - `pgid <= 1` — pid 0 means "our own group" to `kill(2)`, and pid 1 is
+ *     `init`/`launchd`; a fake pid 1 in tests once reaped a developer's real apps.
+ *   - the host's OWN pid — node-pty gives the leader a fresh session via `setsid()`
+ *     so its pgid can never legitimately equal ours, but if a bad pgid ever did we
+ *     must not signal `-process.pid` and kill ourselves.
+ */
+export function isReapableGroupId(pgid) {
+    return Number.isInteger(pgid) && pgid > 1 && pgid !== process.pid;
+}
+/**
+ * SIGKILLs the process group led by `leaderPid`, reaping every descendant still
+ * in the group — including one already reparented to PID 1. node-pty starts the
+ * leader via `setsid()`, so it heads its own session and its pgid equals its pid;
+ * that group is always distinct from the host's own group, so this cannot signal
+ * the host process. Refuses only pids the kernel would misroute (see
+ * `isReapableGroupId`), never an arbitrary numeric floor. An already-dead group
+ * (leader and children exited together) is the normal case and its `ESRCH` is
+ * swallowed; a real kill failure such as `EPERM` propagates.
+ */
+export function reapProcessGroup(leaderPid, ops = activeProcessTreeOps()) {
+    if (!isReapableGroupId(leaderPid))
+        return;
+    ops.killGroup(leaderPid);
+}
+//# sourceMappingURL=leader-group.js.map

package/dist/runtime/shutdown/leader-group.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"leader-group.js","sourceRoot":"","sources":["../../../src/runtime/shutdown/leader-group.ts"],"names":[],"mappings":"AAAA,wEAAwE;AACxE,OAAO,EAAE,oBAAoB,EAAqB,MAAM,uBAAuB,CAAC;AAEhF;;;;;;;;;;;;;GAaG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAY;IAC5C,OAAO,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,KAAK,OAAO,CAAC,GAAG,CAAC;AACpE,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,gBAAgB,CAC9B,SAAiB,EACjB,MAAoB,oBAAoB,EAAE;IAE1C,IAAI,CAAC,iBAAiB,CAAC,SAAS,CAAC;QAAE,OAAO;IAC1C,GAAG,CAAC,SAAS,CAAC,SAAS,CAAC,CAAC;AAC3B,CAAC"}

package/dist/runtime/shutdown/native-read-admission.d.ts

@@ -0,0 +1,13 @@
+/** Shared native scan/probe admission within each read's existing deadline (C-LIFE-10). */
+import type { PsRunner } from "./process-table.ts";
+/**
+ * Two lets native reads overlap while bounding subprocess load across sessions.
+ * PATH_READS_AT_ONCE separately batches one walk's logical requests; those requests
+ * compete for these shared slots, so the independent bounds need not match.
+ */
+export declare const MAX_NATIVE_PROCESS_READS = 2;
+/** Every adapter shares the same admission owner and forwards only its remaining native budget. */
+export declare function createAdmittedPsRunner(run: PsRunner): PsRunner;
+/** Queue only the native launch, after coalescing; never release before its runner settles. */
+export declare function admitNativeProcessRead<T>(timeoutMs: number, launch: (remainingMs: number) => Promise<T>): Promise<T>;
+//# sourceMappingURL=native-read-admission.d.ts.map

package/dist/runtime/shutdown/native-read-admission.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-read-admission.d.ts","sourceRoot":"","sources":["../../../src/runtime/shutdown/native-read-admission.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAE3F,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAGnD;;;;GAIG;AACH,eAAO,MAAM,wBAAwB,IAAI,CAAC;AAI1C,mGAAmG;AACnG,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,QAAQ,GAAG,QAAQ,CAK9D;AAED,+FAA+F;AAC/F,wBAAgB,sBAAsB,CAAC,CAAC,EACtC,SAAS,EAAE,MAAM,EACjB,MAAM,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,OAAO,CAAC,CAAC,CAAC,GAC1C,OAAO,CAAC,CAAC,CAAC,CAoCZ"}

package/dist/runtime/shutdown/native-read-admission.js

@@ -0,0 +1,64 @@
+/** Shared native scan/probe admission within each read's existing deadline (C-LIFE-10). */
+import { processReadTimeout } from "./read-timeout.js";
+/**
+ * Two lets native reads overlap while bounding subprocess load across sessions.
+ * PATH_READS_AT_ONCE separately batches one walk's logical requests; those requests
+ * compete for these shared slots, so the independent bounds need not match.
+ */
+export const MAX_NATIVE_PROCESS_READS = 2;
+const waiting = new Map();
+let active = 0;
+/** Every adapter shares the same admission owner and forwards only its remaining native budget. */
+export function createAdmittedPsRunner(run) {
+    return (file, args, options) => admitNativeProcessRead(options.timeout, (remainingMs) => run(file, args, { ...options, timeout: remainingMs }));
+}
+/** Queue only the native launch, after coalescing; never release before its runner settles. */
+export function admitNativeProcessRead(timeoutMs, launch) {
+    const deadline = performance.now() + timeoutMs;
+    return new Promise((resolve, reject) => {
+        const key = Symbol();
+        const timer = setTimeout(() => {
+            waiting.delete(key);
+            reject(timedOut());
+        }, timeoutMs);
+        waiting.set(key, () => {
+            clearTimeout(timer);
+            const remainingMs = Math.ceil(deadline - performance.now());
+            if (remainingMs <= 0) {
+                reject(timedOut());
+                return;
+            }
+            active += 1;
+            try {
+                void launch(remainingMs).then((value) => {
+                    active -= 1;
+                    resolve(value);
+                    drain();
+                }, (error) => {
+                    active -= 1;
+                    reject(error);
+                    drain();
+                });
+            }
+            catch (error) {
+                active -= 1;
+                reject(error);
+            }
+        });
+        drain();
+    });
+}
+/** FIFO admission; expired entries remove themselves without reserving capacity. */
+function drain() {
+    while (active < MAX_NATIVE_PROCESS_READS) {
+        const next = waiting.entries().next().value;
+        if (next === undefined)
+            return;
+        waiting.delete(next[0]);
+        next[1]();
+    }
+}
+function timedOut() {
+    return processReadTimeout("process read admission timed out");
+}
+//# sourceMappingURL=native-read-admission.js.map

package/dist/runtime/shutdown/native-read-admission.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-read-admission.js","sourceRoot":"","sources":["../../../src/runtime/shutdown/native-read-admission.ts"],"names":[],"mappings":"AAAA,2FAA2F;AAG3F,OAAO,EAAE,kBAAkB,EAAE,MAAM,mBAAmB,CAAC;AAEvD;;;;GAIG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC;AAC1C,MAAM,OAAO,GAAG,IAAI,GAAG,EAAsB,CAAC;AAC9C,IAAI,MAAM,GAAG,CAAC,CAAC;AAEf,mGAAmG;AACnG,MAAM,UAAU,sBAAsB,CAAC,GAAa;IAClD,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,EAAE,CAC7B,sBAAsB,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,WAAW,EAAE,EAAE,CACtD,GAAG,CAAC,IAAI,EAAE,IAAI,EAAE,EAAE,GAAG,OAAO,EAAE,OAAO,EAAE,WAAW,EAAE,CAAC,CACtD,CAAC;AACN,CAAC;AAED,+FAA+F;AAC/F,MAAM,UAAU,sBAAsB,CACpC,SAAiB,EACjB,MAA2C;IAE3C,MAAM,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE,GAAG,SAAS,CAAC;IAC/C,OAAO,IAAI,OAAO,CAAI,CAAC,OAAO,EAAE,MAAM,EAAE,EAAE;QACxC,MAAM,GAAG,GAAG,MAAM,EAAE,CAAC;QACrB,MAAM,KAAK,GAAG,UAAU,CAAC,GAAG,EAAE;YAC5B,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;YACpB,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;QACrB,CAAC,EAAE,SAAS,CAAC,CAAC;QACd,OAAO,CAAC,GAAG,CAAC,GAAG,EAAE,GAAG,EAAE;YACpB,YAAY,CAAC,KAAK,CAAC,CAAC;YACpB,MAAM,WAAW,GAAG,IAAI,CAAC,IAAI,CAAC,QAAQ,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,CAAC;YAC5D,IAAI,WAAW,IAAI,CAAC,EAAE,CAAC;gBACrB,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;gBACnB,OAAO;YACT,CAAC;YACD,MAAM,IAAI,CAAC,CAAC;YACZ,IAAI,CAAC;gBACH,KAAK,MAAM,CAAC,WAAW,CAAC,CAAC,IAAI,CAC3B,CAAC,KAAK,EAAE,EAAE;oBACR,MAAM,IAAI,CAAC,CAAC;oBACZ,OAAO,CAAC,KAAK,CAAC,CAAC;oBACf,KAAK,EAAE,CAAC;gBACV,CAAC,EACD,CAAC,KAAc,EAAE,EAAE;oBACjB,MAAM,IAAI,CAAC,CAAC;oBACZ,MAAM,CAAC,KAAK,CAAC,CAAC;oBACd,KAAK,EAAE,CAAC;gBACV,CAAC,CACF,CAAC;YACJ,CAAC;YAAC,OAAO,KAAK,EAAE,CAAC;gBACf,MAAM,IAAI,CAAC,CAAC;gBACZ,MAAM,CAAC,KAAK,CAAC,CAAC;YAChB,CAAC;QACH,CAAC,CAAC,CAAC;QACH,KAAK,EAAE,CAAC;IACV,CAAC,CAAC,CAAC;AACL,CAAC;AAED,oFAAoF;AACpF,SAAS,KAAK;IACZ,OAAO,MAAM,GAAG,wBAAwB,EAAE,CAAC;QACzC,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC;QAC5C,IAAI,IAAI,KAAK,SAAS;YAAE,OAAO;QAC/B,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QACxB,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC;IACZ,CAAC;AACH,CAAC;AAED,SAAS,QAAQ;IACf,OAAO,kBAAkB,CAAC,kCAAkC,CAAC,CAAC;AAChE,CAAC"}

package/dist/runtime/shutdown/process-table.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Reads the host process table and finds the process groups a PTY leader's
+ * descendants have moved into. Implements PRD §5.3 and §9.4 (C-LIFE-10): Claude and
+ * Codex start every hook command with `setsid()`, so a hook runs in its OWN session and
+ * process group and a SIGKILL of the leader's group cannot reach it. The parent-pid
+ * chain is the only thing tying such a descendant to the leader, and it holds only
+ * while every process between them is alive: when any of them exits, the processes
+ * below it are reparented to PID 1 and are out of reach. So this walk runs before
+ * Elwood kills the leader, and it finds only descendants still linked at that point.
+ */
+/** One row of the host process table. */
+export type ProcessEntry = {
+    readonly pid: number;
+    readonly ppid: number;
+    readonly pgid: number;
+    /** An exited process its parent has not reaped yet: nothing left to kill. */
+    readonly zombie: boolean;
+    /** Stopped (state `T`) when its row was read, as a delivered SIGSTOP leaves it. */
+    readonly stopped: boolean;
+    /** When it started, to the second (`lstart`): with the pid, it names one process. */
+    readonly startedAt: string;
+    /** Its executable's short name (`ps`'s `ucomm`), at most 16 characters on macOS. */
+    readonly name: string;
+    /** Codex's shared daemon or its updater, never followed or killed (`shared-daemon.ts`). */
+    readonly shared: boolean;
+};
+export declare const PS_PATH = "/bin/ps";
+/** One process's identity: its pid and start time, which no later process with its pid shares. */
+export declare function processIdentity(row: Pick<ProcessEntry, "pid" | "startedAt">): string;
+/** A row's fields where no read showed them: a live process not stopped, of no known start. */
+export declare const UNREAD: Omit<ProcessEntry, "pid" | "pgid">;
+/** The bounds a `ps` run gets: its timeout, its output cap, and the signal that ends it. */
+export type PsRunOptions = {
+    readonly timeout: number;
+    readonly maxBuffer: number;
+    readonly killSignal: "SIGKILL";
+    readonly env: Readonly<Record<string, string>>;
+};
+/** Runs a file to completion and resolves its stdout; `execFile`, promisified. */
+export type PsRunner = (file: string, args: readonly string[], options: PsRunOptions) => Promise<{
+    readonly stdout: string;
+}>;
+/** Full scans and daemon probes share admission without changing request coalescing. */
+export declare const runFile: PsRunner;
+/** The bounds every `ps` run gets: `timeoutMs`, the output cap, SIGKILL, and `PS_ENV`. */
+export declare function psRunOptions(timeoutMs: number): PsRunOptions;
+/** Lists every process on the host, rejecting when `ps` fails or exceeds `timeoutMs`. */
+export declare function listProcessTable(timeoutMs: number, run?: PsRunner): Promise<readonly ProcessEntry[]>;
+/** The production listing: concurrent shutdowns share one `ps` per event-loop turn. */
+export declare const listProcessTableShared: (timeoutMs: number) => Promise<readonly ProcessEntry[]>;
+/**
+ * Parses a `PS_ARGS` read (C locale). Throws on a line that is not one whole row: one cut
+ * short, or one whose trailing pid is not its first, as a line a newline in a name
+ * started is (`ROW`). Throws, too, on a pid listed twice.
+ */
+export declare function parseProcessTable(stdout: string): readonly ProcessEntry[];
+/**
+ * The process groups, other than the leader's own, that hold at least one LIVE
+ * descendant of `leaderPid`, each mapped to the rows of its members' parents that sit
+ * in OTHER groups (a parent in the same group adds nothing). Descent follows parent
+ * pids transitively, so only descendants still linked to the leader when the table was
+ * read are found. A returned group holds only descendants: a group lives inside one
+ * session, and every member of the leader's session or of a session a descendant
+ * created is itself a descendant. Its id is only a snapshot, and is free for reuse
+ * once the group is gone, so the parent rows let a caller signal it only once a parent
+ * is known to be stopped: a stopped parent cannot reap its exited child, so that child
+ * keeps its pid and the group keeps its id. A leader missing from the table is given
+ * as a row that is not stopped. The host's group (`hostPid`'s) and the ids `kill(-pgid)`
+ * would misroute (`<= 1`) are never returned. Nor is a `shared` process (Codex's daemon
+ * or its updater) or anything it started: the walk never descends into one.
+ */
+export declare function detachedDescendantGroups(table: readonly ProcessEntry[], { leaderPid, hostPid }: {
+    readonly leaderPid: number;
+    readonly hostPid: number;
+}): ReadonlyMap<number, ReadonlySet<ProcessEntry>>;
+/** The table's rows grouped by their parent's pid, built once per table. */
+export declare function childrenByParent(table: readonly ProcessEntry[]): ChildIndex;
+type ChildIndex = ReadonlyMap<number, readonly ProcessEntry[]>;
+export {};
+//# sourceMappingURL=process-table.d.ts.map

package/dist/runtime/shutdown/process-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"process-table.d.ts","sourceRoot":"","sources":["../../../src/runtime/shutdown/process-table.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAOH,yCAAyC;AACzC,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,6EAA6E;IAC7E,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,mFAAmF;IACnF,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,qFAAqF;IACrF,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,oFAAoF;IACpF,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,2FAA2F;IAC3F,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;CAC1B,CAAC;AAIF,eAAO,MAAM,OAAO,YAAY,CAAC;AAWjC,kGAAkG;AAClG,wBAAgB,eAAe,CAAC,GAAG,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,GAAG,WAAW,CAAC,GAAG,MAAM,CAEpF;AAED,+FAA+F;AAC/F,eAAO,MAAM,MAAM,EAAE,IAAI,CAAC,YAAY,EAAE,KAAK,GAAG,MAAM,CAOrD,CAAC;AAEF,4FAA4F;AAC5F,MAAM,MAAM,YAAY,GAAG;IACzB,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,CAAC;IAC/B,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;CAChD,CAAC;AAEF,kFAAkF;AAClF,MAAM,MAAM,QAAQ,GAAG,CACrB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,EAAE,YAAY,KAClB,OAAO,CAAC;IAAE,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC,CAAC;AAE1C,wFAAwF;AACxF,eAAO,MAAM,OAAO,EAAE,QAAsD,CAAC;AAE7E,0FAA0F;AAC1F,wBAAgB,YAAY,CAAC,SAAS,EAAE,MAAM,GAAG,YAAY,CAE5D;AAED,yFAAyF;AACzF,wBAAsB,gBAAgB,CACpC,SAAS,EAAE,MAAM,EACjB,GAAG,GAAE,QAAkB,GACtB,OAAO,CAAC,SAAS,YAAY,EAAE,CAAC,CAGlC;AAED,uFAAuF;AACvF,eAAO,MAAM,sBAAsB,yDAAsC,CAAC;AAE1E;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,SAAS,YAAY,EAAE,CAwBzE;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,YAAY,EAAE,EAC9B,EAAE,SAAS,EAAE,OAAO,EAAE,EAAE;IAAE,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAC/E,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,YAAY,CAAC,CAAC,CAwBhD;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,SAAS,YAAY,EAAE,GAAG,UAAU,CAW3E;AAED,KAAK,UAAU,GAAG,WAAW,CAAC,MAAM,EAAE,SAAS,YAAY,EAAE,CAAC,CAAC"}