@openagt/dashboard 0.0.0-stage → 0.8.0

package/dist/framework-gitignore.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The `.the-framework/.gitignore` (#313): one file, one content, written at install.
+ *
+ * Everything under `.the-framework/` is this machine's or transient: a run's live files, the
+ * hooks file. The lasting records (the runs, the `logs` skill's) live on the data branch
+ * (#1582/#1769), so nothing but this file is tracked: main is 100% code.
+ */
+/** The `.gitignore` path under `cwd`'s `.the-framework/`. */
+export declare function gitignorePath(cwd: string): string;
+/** The whole file: everything under `.the-framework/` stays out of git (#1582). */
+export declare function frameworkGitignore(): string;
+//# sourceMappingURL=framework-gitignore.d.ts.map

package/dist/framework-gitignore.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-gitignore.d.ts","sourceRoot":"","sources":["../src/framework-gitignore.ts"],"names":[],"mappings":"AAIA;;;;;;GAMG;AAEH,6DAA6D;AAC7D,wBAAgB,aAAa,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,mFAAmF;AACnF,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C"}

package/dist/framework-gitignore.js

@@ -0,0 +1,19 @@
+import { join } from 'node:path';
+import { DATA_BRANCH } from '@openagt/agent-data/names';
+import { THE_FRAMEWORK_DIR } from './framework-dir.js';
+/**
+ * The `.the-framework/.gitignore` (#313): one file, one content, written at install.
+ *
+ * Everything under `.the-framework/` is this machine's or transient: a run's live files, the
+ * hooks file. The lasting records (the runs, the `logs` skill's) live on the data branch
+ * (#1582/#1769), so nothing but this file is tracked: main is 100% code.
+ */
+/** The `.gitignore` path under `cwd`'s `.the-framework/`. */
+export function gitignorePath(cwd) {
+    return join(cwd, THE_FRAMEWORK_DIR, '.gitignore');
+}
+/** The whole file: everything under `.the-framework/` stays out of git (#1582). */
+export function frameworkGitignore() {
+    return `# The Framework: agent state is transient; the lasting records live on the ${DATA_BRANCH} branch.\n*\n!.gitignore\n`;
+}
+//# sourceMappingURL=framework-gitignore.js.map

package/dist/framework-gitignore.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"framework-gitignore.js","sourceRoot":"","sources":["../src/framework-gitignore.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,WAAW,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AAEtD;;;;;;GAMG;AAEH,6DAA6D;AAC7D,MAAM,UAAU,aAAa,CAAC,GAAW;IACvC,OAAO,IAAI,CAAC,GAAG,EAAE,iBAAiB,EAAE,YAAY,CAAC,CAAA;AACnD,CAAC;AAED,mFAAmF;AACnF,MAAM,UAAU,kBAAkB;IAChC,OAAO,8EAA8E,WAAW,4BAA4B,CAAA;AAC9H,CAAC"}

package/dist/gate-keepalive.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Holds the Node event loop open while the agent is parked on the user (#1359).
+ *
+ * A daemon-spawned agent has nothing ref'd at a parked gate: the daemon spawns it detached with
+ * every stdio ignored and `--no-dashboard` (so no server), the claude-code driver spawns and
+ * reaps a child per prompt (so nothing runs between turns), and the control watcher is
+ * deliberately unref'd so steering alone never keeps a finished agent alive (#344). The moment
+ * `requestChoice` parked a bare Promise between turns, the event loop was empty and Node exited
+ * 0 mid-await — no `end` event, empty stderr, and picks landing in `control.jsonl` that nothing
+ * would ever read. The same silently-unwired-channel family as #905/#922, one layer down: the
+ * channel was wired, but the process waiting on it was not held.
+ *
+ * This is the narrow inverse of the watcher's unref: a ref'd (but idle) interval that exists
+ * only while at least one held promise is pending. Waiting for the answer IS the agent's work at
+ * that moment, so holding the loop is correct exactly there — and nowhere else, which is why the
+ * watcher itself stays unref'd (the actions-abort hang is what unref'ing it fixed).
+ */
+/** The slice of a timer handle the keepalive needs; `hasRef` is what a test asserts on. */
+export interface KeepaliveTimer {
+    hasRef?(): boolean;
+}
+/** The timer seam, injected by tests so nothing waits on real time. */
+export interface KeepaliveTimers {
+    /** Start the loop-holding timer. Must return a ref'd handle. */
+    start(): KeepaliveTimer;
+    /** Stop a timer {@link start} returned. */
+    stop(timer: KeepaliveTimer): void;
+}
+/**
+ * The real timers: a ref'd no-op interval (`setInterval` refs by default — the ref IS the
+ * fix, so a test asserts `hasRef()` on what `start` returns rather than trusting this comment).
+ */
+export declare const nodeKeepaliveTimers: KeepaliveTimers;
+/** A live keepalive. One per agent process; every parked wait shares it. */
+export interface GateKeepalive {
+    /** Pass a parked promise through; the loop is held until it settles (resolve or reject). */
+    hold<T>(pending: Promise<T>): Promise<T>;
+    /** How many holds are currently pending. */
+    held(): number;
+}
+/**
+ * Create the agent's keepalive. Counter-based: the first pending hold starts one ref'd idle
+ * timer, overlapping holds share it, and the last one to settle stops it — so the process can
+ * exit the moment nothing is parked, exactly as before this existed.
+ */
+export declare function createGateKeepalive(timers?: KeepaliveTimers): GateKeepalive;
+//# sourceMappingURL=gate-keepalive.d.ts.map

package/dist/gate-keepalive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-keepalive.d.ts","sourceRoot":"","sources":["../src/gate-keepalive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,2FAA2F;AAC3F,MAAM,WAAW,cAAc;IAC7B,MAAM,CAAC,IAAI,OAAO,CAAA;CACnB;AAED,uEAAuE;AACvE,MAAM,WAAW,eAAe;IAC9B,gEAAgE;IAChE,KAAK,IAAI,cAAc,CAAA;IACvB,2CAA2C;IAC3C,IAAI,CAAC,KAAK,EAAE,cAAc,GAAG,IAAI,CAAA;CAClC;AAQD;;;GAGG;AACH,eAAO,MAAM,mBAAmB,EAAE,eAGjC,CAAA;AAED,4EAA4E;AAC5E,MAAM,WAAW,aAAa;IAC5B,4FAA4F;IAC5F,IAAI,CAAC,CAAC,EAAE,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAA;IACxC,4CAA4C;IAC5C,IAAI,IAAI,MAAM,CAAA;CACf;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,GAAE,eAAqC,GAAG,aAAa,CAuBhG"}

package/dist/gate-keepalive.js

@@ -0,0 +1,62 @@
+/**
+ * Holds the Node event loop open while the agent is parked on the user (#1359).
+ *
+ * A daemon-spawned agent has nothing ref'd at a parked gate: the daemon spawns it detached with
+ * every stdio ignored and `--no-dashboard` (so no server), the claude-code driver spawns and
+ * reaps a child per prompt (so nothing runs between turns), and the control watcher is
+ * deliberately unref'd so steering alone never keeps a finished agent alive (#344). The moment
+ * `requestChoice` parked a bare Promise between turns, the event loop was empty and Node exited
+ * 0 mid-await — no `end` event, empty stderr, and picks landing in `control.jsonl` that nothing
+ * would ever read. The same silently-unwired-channel family as #905/#922, one layer down: the
+ * channel was wired, but the process waiting on it was not held.
+ *
+ * This is the narrow inverse of the watcher's unref: a ref'd (but idle) interval that exists
+ * only while at least one held promise is pending. Waiting for the answer IS the agent's work at
+ * that moment, so holding the loop is correct exactly there — and nowhere else, which is why the
+ * watcher itself stays unref'd (the actions-abort hang is what unref'ing it fixed).
+ */
+/**
+ * The idle interval's period. The callback never matters — only the ref does — so it is set far
+ * beyond any run's life to make the no-op wakeups free.
+ */
+const IDLE_INTERVAL_MS = 2 ** 30;
+/**
+ * The real timers: a ref'd no-op interval (`setInterval` refs by default — the ref IS the
+ * fix, so a test asserts `hasRef()` on what `start` returns rather than trusting this comment).
+ */
+export const nodeKeepaliveTimers = {
+    start: () => setInterval(() => { }, IDLE_INTERVAL_MS),
+    stop: timer => clearInterval(timer),
+};
+/**
+ * Create the agent's keepalive. Counter-based: the first pending hold starts one ref'd idle
+ * timer, overlapping holds share it, and the last one to settle stops it — so the process can
+ * exit the moment nothing is parked, exactly as before this existed.
+ */
+export function createGateKeepalive(timers = nodeKeepaliveTimers) {
+    let held = 0;
+    let timer;
+    const acquire = () => {
+        if (held++ === 0)
+            timer = timers.start();
+    };
+    const release = () => {
+        if (--held === 0 && timer) {
+            timers.stop(timer);
+            timer = undefined;
+        }
+    };
+    return {
+        held: () => held,
+        async hold(pending) {
+            acquire();
+            try {
+                return await pending;
+            }
+            finally {
+                release();
+            }
+        },
+    };
+}
+//# sourceMappingURL=gate-keepalive.js.map

package/dist/gate-keepalive.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"gate-keepalive.js","sourceRoot":"","sources":["../src/gate-keepalive.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAeH;;;GAGG;AACH,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,CAAA;AAEhC;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAoB;IAClD,KAAK,EAAE,GAAG,EAAE,CAAC,WAAW,CAAC,GAAG,EAAE,GAAE,CAAC,EAAE,gBAAgB,CAAC;IACpD,IAAI,EAAE,KAAK,CAAC,EAAE,CAAC,aAAa,CAAC,KAAuB,CAAC;CACtD,CAAA;AAUD;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,MAAM,GAAoB,mBAAmB;IAC/E,IAAI,IAAI,GAAG,CAAC,CAAA;IACZ,IAAI,KAAiC,CAAA;IACrC,MAAM,OAAO,GAAG,GAAS,EAAE;QACzB,IAAI,IAAI,EAAE,KAAK,CAAC;YAAE,KAAK,GAAG,MAAM,CAAC,KAAK,EAAE,CAAA;IAC1C,CAAC,CAAA;IACD,MAAM,OAAO,GAAG,GAAS,EAAE;QACzB,IAAI,EAAE,IAAI,KAAK,CAAC,IAAI,KAAK,EAAE,CAAC;YAC1B,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;YAClB,KAAK,GAAG,SAAS,CAAA;QACnB,CAAC;IACH,CAAC,CAAA;IACD,OAAO;QACL,IAAI,EAAE,GAAG,EAAE,CAAC,IAAI;QAChB,KAAK,CAAC,IAAI,CAAC,OAAO;YAChB,OAAO,EAAE,CAAA;YACT,IAAI,CAAC;gBACH,OAAO,MAAM,OAAO,CAAA;YACtB,CAAC;oBAAS,CAAC;gBACT,OAAO,EAAE,CAAA;YACX,CAAC;QACH,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/git-exclude.d.ts

@@ -0,0 +1,11 @@
+import { type NodeFs } from './node-fs.js';
+import { type GitRunner } from './project.js';
+/**
+ * Append one ignore rule to the repository's `info/exclude` — the ignore file that is git's, not
+ * the project's, so no tracked file changes and no user ever sees a diff. The rule goes in the
+ * *common* git dir because git resolves excludes from there; a per-worktree copy looks right and
+ * is silently never read. One rule there covers every worktree of the repo. Idempotent. Throws on
+ * a non-repo or unwritable git dir — callers decide whether that is fatal (so far, never).
+ */
+export declare function excludeFromGit(repo: string, rule: string, fs?: NodeFs, git?: GitRunner): Promise<void>;
+//# sourceMappingURL=git-exclude.d.ts.map

package/dist/git-exclude.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-exclude.d.ts","sourceRoot":"","sources":["../src/git-exclude.ts"],"names":[],"mappings":"AACA,OAAO,EAAU,KAAK,MAAM,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,cAAc,CAAA;AAE5D;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,EAAE,GAAE,MAAiB,EACrB,GAAG,GAAE,SAA2B,GAC/B,OAAO,CAAC,IAAI,CAAC,CASf"}

package/dist/git-exclude.js

@@ -0,0 +1,23 @@
+import { join, isAbsolute } from 'node:path';
+import { nodeFs } from './node-fs.js';
+import { nodeGitRunner } from './project.js';
+/**
+ * Append one ignore rule to the repository's `info/exclude` — the ignore file that is git's, not
+ * the project's, so no tracked file changes and no user ever sees a diff. The rule goes in the
+ * *common* git dir because git resolves excludes from there; a per-worktree copy looks right and
+ * is silently never read. One rule there covers every worktree of the repo. Idempotent. Throws on
+ * a non-repo or unwritable git dir — callers decide whether that is fatal (so far, never).
+ */
+export async function excludeFromGit(repo, rule, fs = nodeFs(), git = nodeGitRunner()) {
+    const common = (await git(['rev-parse', '--git-common-dir'], repo)).trim();
+    if (!common)
+        return;
+    const infoDir = join(isAbsolute(common) ? common : join(repo, common), 'info');
+    const path = join(infoDir, 'exclude');
+    const current = await fs.read(path).catch(() => '');
+    if (current.split('\n').some(line => line.trim() === rule))
+        return;
+    await fs.mkdir(infoDir);
+    await fs.append(path, (current && !current.endsWith('\n') ? '\n' : '') + rule + '\n');
+}
+//# sourceMappingURL=git-exclude.js.map

package/dist/git-exclude.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"git-exclude.js","sourceRoot":"","sources":["../src/git-exclude.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,UAAU,EAAE,MAAM,WAAW,CAAA;AAC5C,OAAO,EAAE,MAAM,EAAe,MAAM,cAAc,CAAA;AAClD,OAAO,EAAE,aAAa,EAAkB,MAAM,cAAc,CAAA;AAE5D;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAClC,IAAY,EACZ,IAAY,EACZ,EAAE,GAAW,MAAM,EAAE,EACrB,GAAG,GAAc,aAAa,EAAE;IAEhC,MAAM,MAAM,GAAG,CAAC,MAAM,GAAG,CAAC,CAAC,WAAW,EAAE,kBAAkB,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,IAAI,EAAE,CAAA;IAC1E,IAAI,CAAC,MAAM;QAAE,OAAM;IACnB,MAAM,OAAO,GAAG,IAAI,CAAC,UAAU,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,IAAI,EAAE,MAAM,CAAC,EAAE,MAAM,CAAC,CAAA;IAC9E,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAA;IACrC,MAAM,OAAO,GAAG,MAAM,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,CAAC,EAAE,CAAC,CAAA;IACnD,IAAI,OAAO,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,IAAI,CAAC;QAAE,OAAM;IAClE,MAAM,EAAE,CAAC,KAAK,CAAC,OAAO,CAAC,CAAA;IACvB,MAAM,EAAE,CAAC,MAAM,CAAC,IAAI,EAAE,CAAC,OAAO,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC,CAAA;AACvF,CAAC"}

package/dist/handoff-level.d.ts

@@ -0,0 +1,56 @@
+/**
+ * What a session hands back when it finishes (#1102/#1216) — one ordinal, not three booleans (B5).
+ *
+ * These are strictly nested stages of one pipeline: push the branch, then open a PR for it, then
+ * merge that PR. As three independent booleans they described eight states of which four were
+ * reachable, and the implication had to be written in a doc comment because the type could not
+ * express it — `autoOpenPr` "implies `autoPushBranch`", so "PR without push" was never a state a
+ * session could honour. It used to resolve that contradiction by turning push back *on*, which
+ * meant a launcher offering "publish nothing" could not deliver it (#1379).
+ *
+ * One ordinal has exactly the four real states, and the implication is structural: a rung includes
+ * every rung under it, so the impossible combinations stop being representable.
+ *
+ * Node-free, like `run-location.ts`: the dashboard, the registry and the repo file all name this,
+ * and none of them should reach further than a leaf to do it.
+ */
+/** How far a finished session publishes itself. Each rung includes the ones below it. */
+export type HandoffLevel = 'local' | 'push' | 'pr' | 'merge';
+/** Every rung, lowest first — the order is the ladder. */
+export declare const HANDOFF_LEVELS: readonly ['local', 'push', 'pr', 'merge'];
+/**
+ * Where the ladder sits when nobody has said.
+ *
+ * `pr`, because that is what makes the handoff zero-config: a session left alone pushes its branch
+ * and opens a draft PR, so the work never sits on a local branch nobody is told about (#1102).
+ * Merging is the one rung above it, and landing on the default branch has to be asked for (#1216).
+ */
+export declare const DEFAULT_HANDOFF: HandoffLevel;
+/** Whether `value` names a rung. */
+export declare function isHandoffLevel(value: unknown): value is HandoffLevel;
+/** True when `level` reaches `rung` or beyond — the ladder's one comparison. */
+export declare function handoffReaches(level: HandoffLevel, rung: HandoffLevel): boolean;
+/**
+ * The ladder as the three questions the agent and the UI actually ask of it.
+ *
+ * Derived rather than stored: this is a view of the ordinal, so a caller can keep saying "is the
+ * push armed" without any of them being able to disagree with each other.
+ */
+export declare function handoffStages(level: HandoffLevel): {
+    push: boolean;
+    pr: boolean;
+    merge: boolean;
+};
+/**
+ * The rung a set of stage answers means, for a surface that offers them as separate checkboxes.
+ *
+ * The inverse of {@link handoffStages}, and the reason an impossible answer cannot survive: the
+ * highest rung whose own box is ticked *and* whose every rung below is ticked too wins, so
+ * "PR without push" resolves down to `local` rather than silently turning the push back on.
+ */
+export declare function handoffFromStages(stages: {
+    push?: boolean;
+    pr?: boolean;
+    merge?: boolean;
+}): HandoffLevel;
+//# sourceMappingURL=handoff-level.d.ts.map

package/dist/handoff-level.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-level.d.ts","sourceRoot":"","sources":["../src/handoff-level.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,yFAAyF;AACzF,MAAM,MAAM,YAAY,GAAG,OAAO,GAAG,MAAM,GAAG,IAAI,GAAG,OAAO,CAAA;AAE5D,0DAA0D;AAC1D,eAAO,MAAM,cAAc,YAAI,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAU,CAAA;AAEvE;;;;;;GAMG;AACH,eAAO,MAAM,eAAe,EAAE,YAAmB,CAAA;AAEjD,oCAAoC;AACpC,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,YAAY,CAEpE;AAED,gFAAgF;AAChF,wBAAgB,cAAc,CAAC,KAAK,EAAE,YAAY,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,CAE/E;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,OAAO,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAMjG;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,EAAE,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,GAAG,YAAY,CAIzG"}

package/dist/handoff-level.js

@@ -0,0 +1,62 @@
+/**
+ * What a session hands back when it finishes (#1102/#1216) — one ordinal, not three booleans (B5).
+ *
+ * These are strictly nested stages of one pipeline: push the branch, then open a PR for it, then
+ * merge that PR. As three independent booleans they described eight states of which four were
+ * reachable, and the implication had to be written in a doc comment because the type could not
+ * express it — `autoOpenPr` "implies `autoPushBranch`", so "PR without push" was never a state a
+ * session could honour. It used to resolve that contradiction by turning push back *on*, which
+ * meant a launcher offering "publish nothing" could not deliver it (#1379).
+ *
+ * One ordinal has exactly the four real states, and the implication is structural: a rung includes
+ * every rung under it, so the impossible combinations stop being representable.
+ *
+ * Node-free, like `run-location.ts`: the dashboard, the registry and the repo file all name this,
+ * and none of them should reach further than a leaf to do it.
+ */
+/** Every rung, lowest first — the order is the ladder. */
+export const HANDOFF_LEVELS = ['local', 'push', 'pr', 'merge'];
+/**
+ * Where the ladder sits when nobody has said.
+ *
+ * `pr`, because that is what makes the handoff zero-config: a session left alone pushes its branch
+ * and opens a draft PR, so the work never sits on a local branch nobody is told about (#1102).
+ * Merging is the one rung above it, and landing on the default branch has to be asked for (#1216).
+ */
+export const DEFAULT_HANDOFF = 'pr';
+/** Whether `value` names a rung. */
+export function isHandoffLevel(value) {
+    return typeof value === 'string' && HANDOFF_LEVELS.includes(value);
+}
+/** True when `level` reaches `rung` or beyond — the ladder's one comparison. */
+export function handoffReaches(level, rung) {
+    return HANDOFF_LEVELS.indexOf(level) >= HANDOFF_LEVELS.indexOf(rung);
+}
+/**
+ * The ladder as the three questions the agent and the UI actually ask of it.
+ *
+ * Derived rather than stored: this is a view of the ordinal, so a caller can keep saying "is the
+ * push armed" without any of them being able to disagree with each other.
+ */
+export function handoffStages(level) {
+    return {
+        push: handoffReaches(level, 'push'),
+        pr: handoffReaches(level, 'pr'),
+        merge: handoffReaches(level, 'merge'),
+    };
+}
+/**
+ * The rung a set of stage answers means, for a surface that offers them as separate checkboxes.
+ *
+ * The inverse of {@link handoffStages}, and the reason an impossible answer cannot survive: the
+ * highest rung whose own box is ticked *and* whose every rung below is ticked too wins, so
+ * "PR without push" resolves down to `local` rather than silently turning the push back on.
+ */
+export function handoffFromStages(stages) {
+    if (!stages.push)
+        return 'local';
+    if (!stages.pr)
+        return 'push';
+    return stages.merge ? 'merge' : 'pr';
+}
+//# sourceMappingURL=handoff-level.js.map

package/dist/handoff-level.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"handoff-level.js","sourceRoot":"","sources":["../src/handoff-level.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAKH,0DAA0D;AAC1D,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,CAAU,CAAA;AAEvE;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,eAAe,GAAiB,IAAI,CAAA;AAEjD,oCAAoC;AACpC,MAAM,UAAU,cAAc,CAAC,KAAc;IAC3C,OAAO,OAAO,KAAK,KAAK,QAAQ,IAAK,cAAoC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;AAC3F,CAAC;AAED,gFAAgF;AAChF,MAAM,UAAU,cAAc,CAAC,KAAmB,EAAE,IAAkB;IACpE,OAAO,cAAc,CAAC,OAAO,CAAC,KAAK,CAAC,IAAI,cAAc,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;AACtE,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAAC,KAAmB;IAC/C,OAAO;QACL,IAAI,EAAE,cAAc,CAAC,KAAK,EAAE,MAAM,CAAC;QACnC,EAAE,EAAE,cAAc,CAAC,KAAK,EAAE,IAAI,CAAC;QAC/B,KAAK,EAAE,cAAc,CAAC,KAAK,EAAE,OAAO,CAAC;KACtC,CAAA;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAyD;IACzF,IAAI,CAAC,MAAM,CAAC,IAAI;QAAE,OAAO,OAAO,CAAA;IAChC,IAAI,CAAC,MAAM,CAAC,EAAE;QAAE,OAAO,MAAM,CAAA;IAC7B,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,IAAI,CAAA;AACtC,CAAC"}

package/dist/has-remote.d.ts

@@ -0,0 +1,8 @@
+import { type GitRunner } from '@openagt/agent-data';
+/**
+ * Whether the repository at `cwd` has an `origin` remote: the one every push and pull request
+ * goes to. A remote under another name counts as none, as for the data sync. A directory that is
+ * no repository has none.
+ */
+export declare function hasRemote(cwd: string, git?: GitRunner): Promise<boolean>;
+//# sourceMappingURL=has-remote.d.ts.map

package/dist/has-remote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-remote.d.ts","sourceRoot":"","sources":["../src/has-remote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAEnE;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,GAAE,SAA2B,GAAG,OAAO,CAAC,OAAO,CAAC,CAE/F"}

package/dist/has-remote.js

@@ -0,0 +1,10 @@
+import { nodeGitRunner } from '@openagt/agent-data';
+/**
+ * Whether the repository at `cwd` has an `origin` remote: the one every push and pull request
+ * goes to. A remote under another name counts as none, as for the data sync. A directory that is
+ * no repository has none.
+ */
+export async function hasRemote(cwd, git = nodeGitRunner()) {
+    return git(['remote'], cwd).then(out => out.split('\n').some(line => line.trim() === 'origin'), () => false);
+}
+//# sourceMappingURL=has-remote.js.map

package/dist/has-remote.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"has-remote.js","sourceRoot":"","sources":["../src/has-remote.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAkB,MAAM,qBAAqB,CAAA;AAEnE;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,SAAS,CAAC,GAAW,EAAE,GAAG,GAAc,aAAa,EAAE;IAC3E,OAAO,GAAG,CAAC,CAAC,QAAQ,CAAC,EAAE,GAAG,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,KAAK,QAAQ,CAAC,EAAE,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;AAC9G,CAAC"}

package/dist/host-exec.d.ts

@@ -0,0 +1,21 @@
+import type { DeployExecutor } from '@gemstack/ai-autopilot';
+/** Options for {@link hostExecutor}. */
+export interface HostExecutorOptions {
+    /** Base environment for every command. Default `process.env`. */
+    env?: NodeJS.ProcessEnv;
+    /** Max stdout/stderr bytes to buffer per command. Default 16 MiB. */
+    maxBuffer?: number;
+}
+/**
+ * A {@link DeployExecutor} that runs shell commands on the host, in the
+ * workspace the wrapped agent built (its `cwd`). This is what lets a real deploy
+ * target (e.g. `cloudflareTarget`) install / build / run `wrangler` against the
+ * code Claude Code just wrote, since the runner seam's `LocalRunner` cannot: it
+ * mkdtemps a fresh workspace and deletes it on dispose.
+ *
+ * Never rejects: a non-zero exit or a spawn error resolves to an {@link ExecResult}
+ * with the exit code and captured output, matching the runner-session contract
+ * the deploy targets expect.
+ */
+export declare function hostExecutor(cwd: string, opts?: HostExecutorOptions): DeployExecutor;
+//# sourceMappingURL=host-exec.d.ts.map

package/dist/host-exec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-exec.d.ts","sourceRoot":"","sources":["../src/host-exec.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAA2B,MAAM,wBAAwB,CAAA;AAErF,wCAAwC;AACxC,MAAM,WAAW,mBAAmB;IAClC,iEAAiE;IACjE,GAAG,CAAC,EAAE,MAAM,CAAC,UAAU,CAAA;IACvB,qEAAqE;IACrE,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,mBAAwB,GAAG,cAAc,CAmBxF"}

package/dist/host-exec.js

@@ -0,0 +1,30 @@
+import { exec as cpExec } from 'node:child_process';
+import { isAbsolute, join } from 'node:path';
+/**
+ * A {@link DeployExecutor} that runs shell commands on the host, in the
+ * workspace the wrapped agent built (its `cwd`). This is what lets a real deploy
+ * target (e.g. `cloudflareTarget`) install / build / run `wrangler` against the
+ * code Claude Code just wrote, since the runner seam's `LocalRunner` cannot: it
+ * mkdtemps a fresh workspace and deletes it on dispose.
+ *
+ * Never rejects: a non-zero exit or a spawn error resolves to an {@link ExecResult}
+ * with the exit code and captured output, matching the runner-session contract
+ * the deploy targets expect.
+ */
+export function hostExecutor(cwd, opts = {}) {
+    const baseEnv = opts.env ?? process.env;
+    const maxBuffer = opts.maxBuffer ?? 16 * 1024 * 1024;
+    return {
+        exec(command, execOpts = {}) {
+            const dir = execOpts.cwd ? (isAbsolute(execOpts.cwd) ? execOpts.cwd : join(cwd, execOpts.cwd)) : cwd;
+            const env = execOpts.env ? { ...baseEnv, ...execOpts.env } : baseEnv;
+            return new Promise(resolvePromise => {
+                cpExec(command, { cwd: dir, env, timeout: execOpts.timeoutMs ?? 0, maxBuffer }, (err, stdout, stderr) => {
+                    const exitCode = err ? (typeof err.code === 'number' ? err.code : 1) : 0;
+                    resolvePromise({ stdout: String(stdout), stderr: String(stderr), exitCode });
+                });
+            });
+        },
+    };
+}
+//# sourceMappingURL=host-exec.js.map

package/dist/host-exec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"host-exec.js","sourceRoot":"","sources":["../src/host-exec.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,IAAI,MAAM,EAAE,MAAM,oBAAoB,CAAA;AACnD,OAAO,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAW5C;;;;;;;;;;GAUG;AACH,MAAM,UAAU,YAAY,CAAC,GAAW,EAAE,OAA4B,EAAE;IACtE,MAAM,OAAO,GAAG,IAAI,CAAC,GAAG,IAAI,OAAO,CAAC,GAAG,CAAA;IACvC,MAAM,SAAS,GAAG,IAAI,CAAC,SAAS,IAAI,EAAE,GAAG,IAAI,GAAG,IAAI,CAAA;IACpD,OAAO;QACL,IAAI,CAAC,OAAe,EAAE,WAAwB,EAAE;YAC9C,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,CAAC,GAAG,EAAE,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,CAAA;YACpG,MAAM,GAAG,GAAG,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,GAAG,OAAO,EAAE,GAAG,QAAQ,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,OAAO,CAAA;YACpE,OAAO,IAAI,OAAO,CAAa,cAAc,CAAC,EAAE;gBAC9C,MAAM,CACJ,OAAO,EACP,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,OAAO,EAAE,QAAQ,CAAC,SAAS,IAAI,CAAC,EAAE,SAAS,EAAE,EAC9D,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,EAAE,EAAE;oBACtB,MAAM,QAAQ,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,OAAO,GAAG,CAAC,IAAI,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAA;oBACxE,cAAc,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,EAAE,QAAQ,EAAE,CAAC,CAAA;gBAC9E,CAAC,CACF,CAAA;YACH,CAAC,CAAC,CAAA;QACJ,CAAC;KACF,CAAA;AACH,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,41 @@
+/**
+ * The types the dashboard reads the daemon's answers as.
+ *
+ * Not a library API: nothing imports this package by name, and the browser gets its *values* from
+ * `client.ts` (the node-free entry) and its data over `POST /_rpc/<name>`. What is left here is the
+ * vocabulary of those answers — one import site for a browser file that would otherwise reach into
+ * two dozen modules to name what an RPC returns.
+ *
+ * Type-only on purpose. A value re-exported here would pull the module that defines it into the
+ * browser bundle, which is the failure `client.ts` exists to prevent; `export type` erases at build.
+ *
+ * Every name below is imported by a file under `dashboard/`. That is the whole rule: this file
+ * ends where its consumers end, so a name nothing renders cannot quietly live on in it.
+ */
+export type { AgentError, SessionInfo } from './agent-view.js';
+export type { ChoiceRequest, FrameworkEvent } from './events.js';
+export type { QuotaBoundary } from './quota-boundary.js';
+export type { CustomPreset, Preferences } from './registry.js';
+export type { PublishPick } from './publish-levels.js';
+export type { DriverQuotaWindow } from '@openagt/agent-driver';
+export type { AgentMeta, AgentStatus } from './store/agent-store.js';
+export type { Activity } from './dashboard/activity.js';
+export type { AgentHandoff } from './dashboard/agent-handoff.js';
+export type { GitHostHome } from './store/git-host.js';
+export type { RepositoryOffer, CreateRepositoryResult } from './store/repository.js';
+export type { BridgeEvent } from './dashboard/bridge-endpoints.js';
+export type { BridgeOption, BridgeQuestion } from './dashboard/bridge-question.js';
+export type { BridgeAnswer } from './dashboard/bridge-store.js';
+export type { DashboardData } from './dashboard/dashboard.js';
+export type { WorkspaceDoc } from './dashboard/docs.js';
+export type { GitStatus } from './dashboard/git-status.js';
+export type { Intervention } from './dashboard/interventions.js';
+export type { OpenQuestion } from './dashboard/open-questions.js';
+export type { ActiveAgent, Overview, RecentAgent } from './dashboard/overview.js';
+export type { ProjectSummary, ProjectionRead } from './dashboard/projects.js';
+export type { ProjectError, ProjectErrorCode } from './project-errors.js';
+export type { ProjectQueue } from './dashboard/queue.js';
+export type { QuotaView } from './dashboard/quota.js';
+export type { Ticket } from './store/tickets.js';
+export type { AgentWorktree, OnboardingSuggestion } from './dashboard/types.js';
+//# 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":"AAAA;;;;;;;;;;;;;GAaG;AAEH,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAC9D,YAAY,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,aAAa,CAAA;AAChE,YAAY,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAA;AACxD,YAAY,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAC9D,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,YAAY,EAAE,iBAAiB,EAAE,MAAM,uBAAuB,CAAA;AAC9D,YAAY,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAA;AACpE,YAAY,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAA;AACvD,YAAY,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,YAAY,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAA;AACtD,YAAY,EAAE,eAAe,EAAE,sBAAsB,EAAE,MAAM,uBAAuB,CAAA;AACpF,YAAY,EAAE,WAAW,EAAE,MAAM,iCAAiC,CAAA;AAClE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,gCAAgC,CAAA;AAClF,YAAY,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAA;AAC/D,YAAY,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAC7D,YAAY,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAA;AACvD,YAAY,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AAC1D,YAAY,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAA;AAChE,YAAY,EAAE,YAAY,EAAE,MAAM,+BAA+B,CAAA;AACjE,YAAY,EAAE,WAAW,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AACjF,YAAY,EAAE,cAAc,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAC7E,YAAY,EAAE,YAAY,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAA;AACzE,YAAY,EAAE,YAAY,EAAE,MAAM,sBAAsB,CAAA;AACxD,YAAY,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAA;AACrD,YAAY,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAChD,YAAY,EAAE,aAAa,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/index.js

@@ -0,0 +1,16 @@
+/**
+ * The types the dashboard reads the daemon's answers as.
+ *
+ * Not a library API: nothing imports this package by name, and the browser gets its *values* from
+ * `client.ts` (the node-free entry) and its data over `POST /_rpc/<name>`. What is left here is the
+ * vocabulary of those answers — one import site for a browser file that would otherwise reach into
+ * two dozen modules to name what an RPC returns.
+ *
+ * Type-only on purpose. A value re-exported here would pull the module that defines it into the
+ * browser bundle, which is the failure `client.ts` exists to prevent; `export type` erases at build.
+ *
+ * Every name below is imported by a file under `dashboard/`. That is the whole rule: this file
+ * ends where its consumers end, so a name nothing renders cannot quietly live on in it.
+ */
+export {};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

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

package/dist/install.d.ts

@@ -0,0 +1,29 @@
+import { type GitRunner } from '@openagt/agent-data';
+import { type StoreFs } from './store/index.js';
+/**
+ * Install/activate a repo for The Framework (#391): create the `.the-framework/` marker and its
+ * ignore file, committing pre-existing dirty changes first so the install commit is clean. Pure
+ * core over the same {@link GitRunner} + {@link StoreFs} seams as project.ts.
+ */
+/** The outcome of {@link installProject}. Failures are values, never throws. */
+export type InstallResult = {
+    ok: true;
+    alreadyActivated?: boolean;
+    initialized?: boolean;
+} | {
+    ok: false;
+    error: string;
+};
+/** Injectable seams for {@link installProject}. */
+export interface InstallDeps {
+    git?: GitRunner;
+    fs?: StoreFs;
+}
+/**
+ * Activate the repo at `cwd`: create `.the-framework/` with
+ * its ignore file and layout marker (#1575), and commit the install. A repo whose ignore file is
+ * already there is a no-op (`alreadyActivated`) — the ignore file is the activation marker.
+ * Forgiving: any git/fs failure surfaces as `{ ok: false, error }`.
+ */
+export declare function installProject(cwd: string, deps?: InstallDeps): Promise<InstallResult>;
+//# sourceMappingURL=install.d.ts.map

package/dist/install.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.d.ts","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AACA,OAAO,EAAiB,KAAK,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAGnE,OAAO,EAAe,KAAK,OAAO,EAAE,MAAM,kBAAkB,CAAA;AAG5D;;;;GAIG;AAEH,gFAAgF;AAChF,MAAM,MAAM,aAAa,GACrB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAAC,WAAW,CAAC,EAAE,OAAO,CAAA;CAAE,GAC/D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAEhC,mDAAmD;AACnD,MAAM,WAAW,WAAW;IAC1B,GAAG,CAAC,EAAE,SAAS,CAAA;IACf,EAAE,CAAC,EAAE,OAAO,CAAA;CACb;AAED;;;;;GAKG;AACH,wBAAsB,cAAc,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,GAAE,WAAgB,GAAG,OAAO,CAAC,aAAa,CAAC,CA2BhG"}

package/dist/install.js

@@ -0,0 +1,40 @@
+import { join } from 'node:path';
+import { nodeGitRunner } from '@openagt/agent-data';
+import { THE_FRAMEWORK_DIR } from './framework-dir.js';
+import { frameworkGitignore, gitignorePath } from './framework-gitignore.js';
+import { nodeStoreFs } from './store/index.js';
+import { errorMessage } from './error-message.js';
+/**
+ * Activate the repo at `cwd`: create `.the-framework/` with
+ * its ignore file and layout marker (#1575), and commit the install. A repo whose ignore file is
+ * already there is a no-op (`alreadyActivated`) — the ignore file is the activation marker.
+ * Forgiving: any git/fs failure surfaces as `{ ok: false, error }`.
+ */
+export async function installProject(cwd, deps = {}) {
+    const git = deps.git ?? nodeGitRunner();
+    const fs = deps.fs ?? nodeStoreFs();
+    if (await fs.exists(gitignorePath(cwd)))
+        return { ok: true, alreadyActivated: true };
+    try {
+        // Auto-initialize a repo when the folder isn't one yet: The Framework treats
+        // git as the source of truth, so `git init` it for the user rather than erroring.
+        const insideRepo = await git(['rev-parse', '--is-inside-work-tree'], cwd)
+            .then(out => out.trim() === 'true')
+            .catch(() => false);
+        if (!insideRepo)
+            await git(['init'], cwd);
+        await fs.mkdir(join(cwd, THE_FRAMEWORK_DIR));
+        // Keep what lives under `.the-framework/` (a run's live files, the hooks file) out of git
+        // (#313). The early return above established the file is absent.
+        await fs.write(gitignorePath(cwd), frameworkGitignore());
+        // Only The Framework's own directory (#1638): whatever the user has uncommitted stays theirs,
+        // uncommitted. Nothing is ever swept into a commit on their behalf.
+        await git(['add', THE_FRAMEWORK_DIR], cwd);
+        await git(['commit', '-m', '[The Framework] install The Framework'], cwd);
+        return insideRepo ? { ok: true } : { ok: true, initialized: true };
+    }
+    catch (err) {
+        return { ok: false, error: errorMessage(err) };
+    }
+}
+//# sourceMappingURL=install.js.map

package/dist/install.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"install.js","sourceRoot":"","sources":["../src/install.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,aAAa,EAAkB,MAAM,qBAAqB,CAAA;AACnE,OAAO,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAA;AACtD,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAA;AAC5E,OAAO,EAAE,WAAW,EAAgB,MAAM,kBAAkB,CAAA;AAC5D,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AAmBjD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,GAAW,EAAE,IAAI,GAAgB,EAAE;IACtE,MAAM,GAAG,GAAG,IAAI,CAAC,GAAG,IAAI,aAAa,EAAE,CAAA;IACvC,MAAM,EAAE,GAAG,IAAI,CAAC,EAAE,IAAI,WAAW,EAAE,CAAA;IAEnC,IAAI,MAAM,EAAE,CAAC,MAAM,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QAAE,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,gBAAgB,EAAE,IAAI,EAAE,CAAA;IAEpF,IAAI,CAAC;QACH,6EAA6E;QAC7E,kFAAkF;QAClF,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,CAAC,WAAW,EAAE,uBAAuB,CAAC,EAAE,GAAG,CAAC;aACtE,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,MAAM,CAAC;aAClC,KAAK,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAA;QACrB,IAAI,CAAC,UAAU;YAAE,MAAM,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,CAAC,CAAA;QAEzC,MAAM,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,GAAG,EAAE,iBAAiB,CAAC,CAAC,CAAA;QAC5C,0FAA0F;QAC1F,iEAAiE;QACjE,MAAM,EAAE,CAAC,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC,EAAE,kBAAkB,EAAE,CAAC,CAAA;QAExD,8FAA8F;QAC9F,oEAAoE;QACpE,MAAM,GAAG,CAAC,CAAC,KAAK,EAAE,iBAAiB,CAAC,EAAE,GAAG,CAAC,CAAA;QAC1C,MAAM,GAAG,CAAC,CAAC,QAAQ,EAAE,IAAI,EAAE,uCAAuC,CAAC,EAAE,GAAG,CAAC,CAAA;QACzE,OAAO,UAAU,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,IAAI,EAAE,WAAW,EAAE,IAAI,EAAE,CAAA;IACpE,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,YAAY,CAAC,GAAG,CAAC,EAAE,CAAA;IAChD,CAAC;AACH,CAAC"}