@cleocode/core 2026.9.26 → 2026.10.2

package/dist/resources/slot-holder.js

@@ -0,0 +1,505 @@
+/**
+ * Holder records for local lock slots: the governor's class slots and the
+ * tool semaphore's per-tool slots (T12963, gh#1222).
+ *
+ * `proper-lockfile` frees a slot whose holder died only after
+ * {@link SLOT_LOCK_STALE_MS} (10 min) of mtime staleness. With a one-slot
+ * `test-run` budget, a SIGKILLed `cleo verify tool:test` blocked every later
+ * heavy run for ten minutes, and the deferral named no one. Each slot carries
+ * a `<slot>.holder.json` record: the holder's pid and process start time, the
+ * lock directory it describes, and the process groups of the tools it started.
+ * A slot is reaped only when the holder pid is provably gone (or recycled) AND
+ * every one of those tool groups is gone too: a tool started detached outlives
+ * a SIGKILLed cleo, and it is the tool that uses the machine.
+ *
+ * Start times are `ps -o lstart=` strings rendered under `PS_STABLE_ENV` (UTC,
+ * C locale), so a string written by one process compares equal to the same
+ * process's start time read by another, whatever either one's `TZ` or locale.
+ *
+ * @task T12963
+ */
+import { existsSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
+import { hostname } from 'node:os';
+import { basename } from 'node:path';
+import lockfile from 'proper-lockfile';
+import { getLogger } from '../logger.js';
+import { readProcessEntry } from '../sessions/terminal-identity.js';
+import { followToolGroups, isProbeableId, probeProcessGroup } from './tool-groups.js';
+let _log = null;
+function log() {
+    if (_log === null)
+        _log = getLogger('resource-governor');
+    return _log;
+}
+/**
+ * A slot lock older than this may be stolen (its holder presumed dead): the
+ * `proper-lockfile` stale window of every governor slot, and the default of
+ * every tool-semaphore slot.
+ */
+export const SLOT_LOCK_STALE_MS = 600_000;
+/**
+ * How often a governor slot holder refreshes its lock. Short, so a holder
+ * frozen by a job pause keeps its slot for nearly the whole stale window
+ * (#1777 round 6).
+ */
+export const SLOT_LOCK_UPDATE_MS = 15_000;
+/** `proper-lockfile`'s "someone else holds this lock" code: the only failure that means busy. */
+const LOCK_HELD = 'ELOCKED';
+/** Whether a `proper-lockfile` error means the lock is held by someone else. */
+function isLockHeld(err) {
+    return err?.code === LOCK_HELD;
+}
+/**
+ * A lock mtime younger than this was refreshed by a live holder, which is
+ * then taken as the holder without spawning `ps`. It must cover the slowest
+ * refresher among the slots judged here: governor slots refresh every
+ * {@link SLOT_LOCK_UPDATE_MS} (15 s), tool-semaphore slots at
+ * `proper-lockfile`'s default of half their stale window (5 min); plus slack
+ * for a busy event loop. A holder frozen by a paused `cleo run` job stops
+ * refreshing but keeps its pid and start time, so it stays alive after the
+ * window too.
+ */
+const LOCK_REFRESH_WINDOW_MS = SLOT_LOCK_STALE_MS / 2 + 30_000;
+/**
+ * A lock this close to `proper-lockfile`'s own stale threshold is left to
+ * `proper-lockfile`: its stale takeover runs outside the reap guard and could
+ * replace the lock between our check and our `rm` (T12963 re-review F2).
+ */
+const STALE_TAKEOVER_MARGIN_MS = 60_000;
+/** How long a pid's start time is reused before `ps` is asked again. */
+const START_CACHE_TTL_MS = 10_000;
+/** Stale threshold of the per-slot reap guard; a reap holds it for milliseconds. */
+const REAP_GUARD_STALE_MS = 10_000;
+const _startCache = new Map();
+/** This process's own start time, read once (`undefined` until then). */
+let _ownStartedAt;
+/**
+ * Start time of `pid`, or `null` when `ps` cannot say. Cached for
+ * {@link START_CACHE_TTL_MS}: a blocked acquire polls every 200 ms, and a `ps`
+ * spawn per poll is load an overloaded machine does not need.
+ */
+function processStartedAt(pid) {
+    const now = Date.now();
+    const hit = _startCache.get(pid);
+    if (hit && now - hit.readAtMs < START_CACHE_TTL_MS)
+        return hit.startedAt;
+    const startedAt = readProcessEntry(pid)?.startedAt ?? null;
+    _startCache.set(pid, { readAtMs: now, startedAt });
+    return startedAt;
+}
+/**
+ * This process's start time (`ps -o lstart=` under `PS_STABLE_ENV`), read once
+ * per process, or `null` when `ps` could not say.
+ *
+ * @returns The start time, or `null`.
+ *
+ * @task T12963
+ */
+export function ownProcessStartedAt() {
+    if (_ownStartedAt === undefined)
+        _ownStartedAt = processStartedAt(process.pid);
+    return _ownStartedAt;
+}
+/** Default probe: `kill(pid, 0)`, `kill(-pgid, 0)` and a cached `ps` start time. */
+const defaultPidProbe = {
+    liveness(pid) {
+        if (!isProbeableId(pid))
+            return 'unknown';
+        try {
+            process.kill(pid, 0); // signal 0 = existence check, sends nothing
+            return 'alive';
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ESRCH')
+                return 'gone';
+            // EPERM: it exists but belongs to another user. Anything else: we cannot tell.
+            return code === 'EPERM' ? 'alive' : 'unknown';
+        }
+    },
+    startedAt: processStartedAt,
+    groupLiveness: probeProcessGroup,
+};
+function holderPathOf(slotPath) {
+    return `${slotPath}.holder.json`;
+}
+/**
+ * A lock directory's identity: `<ino>:<birthtimeMs>`, or `null` when the
+ * filesystem reports no birth time (NFS, FUSE, older kernels report 0). An
+ * inode alone can be reused by the next lock, so such a lock has no identity
+ * and is never reaped (T12963 re-review F3).
+ *
+ * @param ino - The lock directory's inode.
+ * @param birthtimeMs - Its birth time, as `fs.Stats.birthtimeMs`.
+ * @returns The identity, or `null`.
+ *
+ * @internal Exported for tests.
+ * @task T12963
+ */
+export function lockIdentity(ino, birthtimeMs) {
+    const birth = Math.trunc(birthtimeMs);
+    return Number.isFinite(birth) && birth > 0 ? `${ino}:${birth}` : null;
+}
+/** The slot's current lock directory (identity and mtime), or `null` when there is none. */
+function lockStatOf(slotPath) {
+    try {
+        const st = statSync(`${slotPath}.lock`);
+        return { id: lockIdentity(st.ino, st.birthtimeMs), mtimeMs: st.mtimeMs };
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * The identity of a slot's current lock directory, for a holder record's
+ * `lockId`, or `null` when there is no lock or it has no usable identity.
+ *
+ * @param slotPath - Slot lock file path.
+ * @returns The lock identity, or `null`.
+ *
+ * @task T12963
+ */
+export function currentLockId(slotPath) {
+    return lockStatOf(slotPath)?.id ?? null;
+}
+/**
+ * Write a slot's holder record. Best-effort: a failed write leaves the slot
+ * unreapable (it waits out the stale timeout), never unheld.
+ *
+ * @param slotPath - Slot lock file path.
+ * @param record - The record to write.
+ *
+ * @task T12963
+ */
+export function writeHolderRecord(slotPath, record) {
+    try {
+        writeFileSync(holderPathOf(slotPath), JSON.stringify(record), 'utf-8');
+    }
+    catch {
+        /* best-effort — never fail an acquire that succeeded */
+    }
+}
+/**
+ * Keep a held slot's record listing every tool group this process starts
+ * while it holds the slot. Rewrites only while the slot's lock is still the
+ * one the record describes.
+ *
+ * @param slotPath - Slot lock file path.
+ * @param record - The record as first written (its `toolGroups` are replaced).
+ * @returns The groups already running (put them in the first record) and `stop`.
+ *
+ * @task T12963
+ */
+export function recordToolGroupsWhileHeld(slotPath, record) {
+    return followToolGroups((groups) => {
+        const current = record();
+        if (current.lockId == null || currentLockId(slotPath) !== current.lockId)
+            return;
+        writeHolderRecord(slotPath, { ...current, toolGroups: [...groups] });
+    });
+}
+/**
+ * Write the holder record for a governor slot whose lock is held, stamping it
+ * with the current lock's identity.
+ *
+ * @param slotPath - Slot lock file path.
+ * @param holder - Who holds it.
+ * @returns The record as written.
+ *
+ * @internal Exported so tests can plant a foreign holder.
+ * @task T12963
+ */
+export function writeGovernorHolder(slotPath, holder) {
+    const record = { ...holder, lockId: currentLockId(slotPath) };
+    writeHolderRecord(slotPath, record);
+    return record;
+}
+/**
+ * Read a governor slot's holder record, or `null` when absent or malformed.
+ *
+ * @param slotPath - Slot lock file path.
+ * @returns The record, or `null`.
+ *
+ * @task T12963
+ */
+export function readGovernorHolder(slotPath) {
+    try {
+        const parsed = JSON.parse(readFileSync(holderPathOf(slotPath), 'utf-8'));
+        if (!isProbeableId(parsed.pid) ||
+            typeof parsed.host !== 'string' ||
+            typeof parsed.acquiredAtMs !== 'number' ||
+            (parsed.startedAt !== null && typeof parsed.startedAt !== 'string')) {
+            return null;
+        }
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** The holder pid alone: gone, recycled, alive or unknown. */
+function assessHolderPid(holder, lockMtimeMs, probe) {
+    const liveness = probe.liveness(holder.pid);
+    if (liveness !== 'alive')
+        return liveness === 'gone' ? 'dead' : 'unknown';
+    // Without the lock's mtime, or while it is being refreshed, a live pid is the holder.
+    if (lockMtimeMs === null || Date.now() - lockMtimeMs < LOCK_REFRESH_WINDOW_MS)
+        return 'alive';
+    if (holder.startedAt == null)
+        return 'alive';
+    const startedAt = probe.startedAt(holder.pid);
+    if (startedAt === null)
+        return 'unknown'; // ps failed: never proof of death
+    return startedAt === holder.startedAt ? 'alive' : 'dead';
+}
+/** The holder's tool groups: `dead` only when every one is provably gone. */
+function assessToolGroups(groups, probe) {
+    if (groups === undefined)
+        return 'dead';
+    if (!Array.isArray(groups))
+        return 'unknown';
+    let unknown = false;
+    for (const pgid of groups) {
+        if (!isProbeableId(pgid))
+            return 'unknown';
+        const state = probe.groupLiveness(pgid);
+        if (state === 'alive')
+            return 'alive';
+        if (state === 'unknown')
+            unknown = true;
+    }
+    return unknown ? 'unknown' : 'dead';
+}
+/**
+ * Decide whether a slot's recorded holder still holds it.
+ *
+ * - `dead`: the holder pid is gone, or alive with a different start time
+ *   than the record's (a recycled pid), AND every tool group it started is
+ *   gone.
+ * - `unknown`: no record, another host's pid, a pid of 1 or below, a record
+ *   that does not describe the current lock (or a lock with no identity), or
+ *   a probe that failed. Never treated as dead.
+ * - `alive`: otherwise, including a live pid whose start time was never
+ *   recorded, and a dead holder whose tool is still running.
+ *
+ * A live holder's `proper-lockfile` timer refreshes the lock mtime (governor
+ * slots every 15 s, tool slots every 5 min). While the mtime is within
+ * {@link LOCK_REFRESH_WINDOW_MS} a live pid is taken as the holder without
+ * asking `ps`, so a contended acquire spawns nothing. A pid recycled inside that window therefore reads as alive until
+ * the refresh lapses; that is the safe direction.
+ *
+ * @param holder - The slot's record, or `null`.
+ * @param slotPath - Slot lock file path. Without it the lock identity and
+ *   mtime are not consulted, so a live pid is always `alive` (report-only).
+ * @param probe - Pid probe; tests inject one.
+ * @returns The verdict.
+ *
+ * @task T12963
+ */
+export function assessSlotHolder(holder, slotPath, probe = defaultPidProbe) {
+    if (holder === null || holder.host !== hostname() || !isProbeableId(holder.pid)) {
+        return 'unknown';
+    }
+    let lockMtimeMs = null;
+    if (slotPath !== undefined) {
+        const lock = lockStatOf(slotPath);
+        if (lock === null || lock.id === null || holder.lockId !== lock.id)
+            return 'unknown';
+        lockMtimeMs = lock.mtimeMs;
+    }
+    const pid = assessHolderPid(holder, lockMtimeMs, probe);
+    return pid === 'dead' ? assessToolGroups(holder.toolGroups, probe) : pid;
+}
+/**
+ * {@link assessSlotHolder} for a governor slot's record.
+ *
+ * @param holder - The slot's record, or `null`.
+ * @param slotPath - Slot lock file path.
+ * @param probe - Pid probe; tests inject one.
+ * @returns The verdict.
+ *
+ * @task T12963
+ */
+export function assessGovernorHolder(holder, slotPath, probe = defaultPidProbe) {
+    return assessSlotHolder(holder, slotPath, probe);
+}
+/**
+ * Free a held slot whose holder is provably dead: its pid gone or recycled
+ * and every tool group it started gone.
+ *
+ * Runs under a per-slot guard and re-checks the holder inside it. The holder
+ * record is removed with the lock, so a second reaper that takes the guard
+ * afterwards finds no record (or the next holder's) and stands down. A lock
+ * within {@link STALE_TAKEOVER_MARGIN_MS} of `staleMs` is left to
+ * `proper-lockfile`, and the lock identity is re-read immediately before the
+ * `rm`, so a concurrent stale takeover's fresh lock is never removed.
+ *
+ * @param slotPath - Slot lock file path.
+ * @param readHolder - Reads the slot's record (the governor's or the tool semaphore's).
+ * @param opts - The slot's `proper-lockfile` stale threshold, and a probe (tests).
+ * @returns `true` when the slot was reaped; the caller then takes it.
+ *
+ * @task T12963
+ */
+export function reapSlotIfHolderDead(slotPath, readHolder, opts = {}) {
+    const staleMs = opts.staleMs ?? SLOT_LOCK_STALE_MS;
+    const probe = opts.probe ?? defaultPidProbe;
+    if (assessSlotHolder(readHolder(slotPath), slotPath, probe) !== 'dead')
+        return false;
+    let releaseGuard;
+    try {
+        releaseGuard = lockfile.lockSync(`${slotPath}.reap`, {
+            lockfilePath: `${slotPath}.reaping`,
+            stale: REAP_GUARD_STALE_MS,
+            realpath: false,
+        });
+    }
+    catch {
+        return false; // another waiter is reaping this slot
+    }
+    try {
+        const holder = readHolder(slotPath);
+        if (holder === null || assessSlotHolder(holder, slotPath, probe) !== 'dead')
+            return false;
+        const lock = lockStatOf(slotPath);
+        if (lock === null || Date.now() - lock.mtimeMs > staleMs - STALE_TAKEOVER_MARGIN_MS) {
+            return false;
+        }
+        // Re-read the identity last: a lock replaced since the check, and the
+        // record its new holder wrote, are left alone.
+        if (currentLockId(slotPath) !== holder.lockId)
+            return false;
+        rmSync(holderPathOf(slotPath), { force: true });
+        rmSync(`${slotPath}.lock`, { recursive: true, force: true });
+        log().warn({ slot: slotPath, holderPid: holder.pid, toolGroups: holder.toolGroups ?? [] }, 'reaped a slot whose holder process and tool groups are gone');
+        return true;
+    }
+    catch {
+        return false;
+    }
+    finally {
+        try {
+            releaseGuard();
+        }
+        catch {
+            /* the guard was already released */
+        }
+    }
+}
+/**
+ * Name every held governor slot and its holder, for a deferral reason.
+ *
+ * @param slots - Slot lock file paths of one class.
+ * @returns `; held by …`, or `''` when no slot is held.
+ *
+ * @task T12963
+ */
+export function describeSlotHolders(slots) {
+    const held = [];
+    for (const path of slots) {
+        if (!existsSync(`${path}.lock`))
+            continue;
+        const h = readGovernorHolder(path);
+        const groups = h?.toolGroups?.length ? ` with tool group(s) ${h.toolGroups.join(',')}` : '';
+        held.push(h
+            ? `${basename(path)}: pid ${h.pid} on ${h.host}${groups} since ` +
+                `${new Date(h.acquiredAtMs).toISOString()} (${assessGovernorHolder(h, path)})`
+            : `${basename(path)}: holder unknown`);
+    }
+    return held.length > 0 ? `; held by ${held.join(', ')}` : '';
+}
+/** A grant's release: stops recording tool groups, drops our record, then the lock. Idempotent. */
+function holderRelease(slotPath, holder, stopRecording, unlock) {
+    let released = false;
+    return async () => {
+        if (released)
+            return;
+        released = true;
+        stopRecording();
+        // Record first, lock second: the record must never outlive our lock and
+        // end up describing the next holder's.
+        const mine = holder();
+        const current = readGovernorHolder(slotPath);
+        if (current?.pid === mine.pid && current.acquiredAtMs === mine.acquiredAtMs) {
+            try {
+                rmSync(holderPathOf(slotPath), { force: true });
+            }
+            catch {
+                /* best-effort — a stale record is only ever advisory */
+            }
+        }
+        try {
+            await unlock();
+        }
+        catch {
+            // Already released (e.g. stale recovery) — post-condition holds.
+        }
+    };
+}
+/**
+ * Take a free slot without waiting; record the holder. `null` when the lock
+ * is held (`ELOCKED`). Any other lock error (EACCES from a sandbox, EROFS,
+ * ENOSPC…) is thrown, never read as busy: the governor surfaces it so its
+ * caller can fail open (#1777 round 8, R8-1).
+ */
+async function tryLockSlot(slotPath, cls) {
+    let unlock;
+    try {
+        unlock = await lockfile.lock(slotPath, {
+            retries: 0,
+            stale: SLOT_LOCK_STALE_MS,
+            update: SLOT_LOCK_UPDATE_MS,
+            realpath: false,
+            // A long grant (cleo run) can outlive a lid-closed sleep; another
+            // process may then reclaim the "stale" slot. proper-lockfile's
+            // default throws from a timer and crashes the holder; log instead
+            // and keep running (#1777 round 3, L-7).
+            onCompromised: (err) => {
+                log().warn({ cls, slot: basename(slotPath), err: err.message }, 'governor slot lock compromised (likely sleep or a stale reclaim); continuing');
+            },
+        });
+    }
+    catch (err) {
+        if (isLockHeld(err))
+            return null;
+        throw err;
+    }
+    let holder;
+    const recording = recordToolGroupsWhileHeld(slotPath, () => holder);
+    holder = writeGovernorHolder(slotPath, {
+        pid: process.pid,
+        startedAt: ownProcessStartedAt(),
+        host: hostname(),
+        cls,
+        acquiredAtMs: Date.now(),
+        toolGroups: [...recording.groups],
+    });
+    return holderRelease(slotPath, () => holder, recording.stop, unlock);
+}
+/**
+ * Take a slot without waiting: free, or freed by reaping a dead holder.
+ *
+ * @param slotPath - Slot lock file path.
+ * @param cls - Class the slot belongs to.
+ * @returns The grant's release (drops the holder record, then the lock), or
+ *   `null` when the slot is held.
+ * @throws Any lock error other than `ELOCKED` (an unwritable slot directory),
+ *   for the governor's fail-open path.
+ *
+ * @task T12963
+ */
+export async function lockSlot(slotPath, cls) {
+    const free = await tryLockSlot(slotPath, cls);
+    if (free !== null)
+        return free;
+    return reapSlotIfHolderDead(slotPath, readGovernorHolder) ? tryLockSlot(slotPath, cls) : null;
+}
+/**
+ * Forget cached start times, this process's included. Tests only.
+ * @internal
+ */
+export function _resetSlotHolderStateForTest() {
+    _startCache.clear();
+    _ownStartedAt = undefined;
+}
+//# sourceMappingURL=slot-holder.js.map

package/dist/resources/slot-holder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"slot-holder.js","sourceRoot":"","sources":["../../src/resources/slot-holder.ts"],"names":[],"mappings":"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"}

package/dist/resources/tool-groups.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Process groups of the tools this process started (T12963).
+ *
+ * The tool cache starts every tool detached, in its own process group, so a
+ * deadline can signal the whole tree. The flip side: when cleo itself dies,
+ * nothing reaches that group. A SIGKILLed `cleo verify tool:test` can leave
+ * its test runner running with PPID 1, so a slot is not free just because its
+ * holder pid is gone. Every slot this process holds therefore records the
+ * groups started while it is held, and a slot is reaped only once both its
+ * holder pid and those groups are gone.
+ *
+ * @task T12963
+ */
+/**
+ * Whether `id` may ever be probed as a pid or process group: an integer above
+ * 1. Never 0 (our own group), 1 (init) or a negative number (`kill(-1)`
+ * reaches every process we own).
+ *
+ * @param id - Candidate pid or pgid.
+ * @returns `true` when it is safe to probe.
+ *
+ * @task T12963
+ */
+export declare function isProbeableId(id: unknown): id is number;
+/**
+ * Register a tool's process group as running. Every slot this process holds
+ * is told, so its holder record lists the group. A no-op on Windows (no POSIX
+ * process groups) and for an id that is not probeable.
+ *
+ * @param pgid - The group id: the pid of a child spawned with `detached: true`.
+ * @returns Marks the group as no longer running (idempotent).
+ *
+ * @task T12963
+ */
+export declare function trackToolGroup(pgid: number | undefined): () => void;
+/**
+ * Process groups this process started that have not finished yet.
+ *
+ * @returns Group ids, oldest first.
+ *
+ * @task T12963
+ */
+export declare function activeToolGroups(): number[];
+/**
+ * Follow the tool groups started while a slot is held: seeded with the groups
+ * already running, then `onNew` is called with the full list each time
+ * another one starts.
+ *
+ * @param onNew - Called with every group recorded so far, after each new one.
+ * @returns The groups recorded so far (kept up to date) and `stop`.
+ *
+ * @task T12963
+ */
+export declare function followToolGroups(onNew: (groups: readonly number[]) => void): {
+    groups: readonly number[];
+    stop: () => void;
+};
+/**
+ * Whether a process group still has a member, by `kill(-pgid, 0)` (signal 0
+ * sends nothing).
+ *
+ * @param pgid - Group id.
+ * @returns `gone` (ESRCH), `alive` (exists, EPERM included), or `unknown`
+ *   when the id is not probeable or the probe failed some other way.
+ *
+ * @task T12963
+ */
+export declare function probeProcessGroup(pgid: number): 'gone' | 'alive' | 'unknown';
+/**
+ * Forget every tracked group and listener. Tests only.
+ * @internal
+ */
+export declare function _resetToolGroupsForTest(): void;
+//# sourceMappingURL=tool-groups.d.ts.map

package/dist/resources/tool-groups.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool-groups.d.ts","sourceRoot":"","sources":["../../src/resources/tool-groups.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAKH;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,EAAE,EAAE,OAAO,GAAG,EAAE,IAAI,MAAM,CAEvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,IAAI,CASnE;AAED;;;;;;GAMG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,EAAE,CAE3C;AAED;;;;;;;;;GASG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,KAAK,IAAI,GAAG;IAC5E,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1B,IAAI,EAAE,MAAM,IAAI,CAAC;CAClB,CAcA;AAED;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,SAAS,CAU5E;AAED;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,IAAI,CAG9C"}