@revenexx/cli 0.2.1 → 0.3.0

package/dist/lib/tui/slash-commands.d.ts

@@ -0,0 +1,62 @@
+/**
+ * The TUI's `/`-command registry (DX-141): the closed set of words that mean
+ * "do a thing" rather than "search for a command", replacing the hardcoded
+ * exit/debug/fps chain that used to sit inline in app.tsx's filter handler.
+ *
+ * `/` does not open a separate palette — it enters the fuzzy command filter
+ * with an empty query, so `/` followed by a word *is* the slash command.
+ *
+ * The visible entries are also the source of their **nav rows**: lib/commands/
+ * tui.ts turns them into synthetic CommandNodes (slashNavEntries) so they can be
+ * browsed and searched like anything else, rather than only being findable by
+ * someone who already knows the word. One registry, both surfaces.
+ *
+ * Pure and ink-free on purpose: the matching is unit-testable without rendering
+ * an app, tui.ts can import it on the one-shot path, and the actions arrive as
+ * a context object supplied by App.
+ */
+import type { CommandLeaf, CommandNode } from "./command-tree.js";
+/** Callbacks App hands the registry; one per action a slash command can take. */
+export type SlashContext = {
+    requestQuit: () => void;
+    toggleDebug: () => void;
+    openWatchCreate: () => void;
+    openWatchList: () => void;
+};
+export type SlashCommand = {
+    name: string;
+    aliases?: readonly string[];
+    description: string;
+    /**
+     * Dispatchable by typing the word, but never given a nav row. The three
+     * inherited words are hidden to preserve their long-standing behaviour
+     * exactly: typing `exi` or `deb` has always shown "no matches", and `debug`
+     * is an undocumented diagnostics egg.
+     */
+    hidden?: boolean;
+    /** Which in-app pane a visible entry opens, for its synthetic nav row. */
+    tuiAction?: NonNullable<CommandLeaf["tuiAction"]>;
+    run: (context: SlashContext) => void;
+};
+export declare const SLASH_COMMANDS: readonly SlashCommand[];
+/**
+ * Exact-word lookup for the **hidden** words only, which fire the instant the
+ * word completes — the behaviour `exit`, `debug` and `fps` have always had, and
+ * the reason typing `exi` shows no matches rather than a row.
+ *
+ * Visible commands deliberately do NOT fire this way. `watch` is a prefix of
+ * `watchlist`, so instant-firing on the shorter word would make the longer one
+ * impossible to type; they are offered as rows and dispatched on Enter, which
+ * is also how you discover them.
+ */
+export declare const matchInstantSlash: (word: string) => SlashCommand | undefined;
+/**
+ * The visible commands as browsable nav rows. They land in the root "commands"
+ * section next to `login`/`status` — a synthetic node with no subcommands and a
+ * tuiAction, exactly the shape the `themes` entry already uses — so the
+ * watchlist is something you can find by looking rather than only by knowing
+ * the word. Because they are real nav entries, flattenTree picks them up and
+ * they appear in `/` search too, with no second code path.
+ */
+export declare const slashNavEntries: () => CommandNode[];
+//# sourceMappingURL=slash-commands.d.ts.map

package/dist/lib/tui/slash-commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"slash-commands.d.ts","sourceRoot":"","sources":["../../../lib/tui/slash-commands.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAElE,iFAAiF;AACjF,MAAM,MAAM,YAAY,GAAG;IACzB,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,eAAe,EAAE,MAAM,IAAI,CAAC;IAC5B,aAAa,EAAE,MAAM,IAAI,CAAC;CAC3B,CAAC;AAEF,MAAM,MAAM,YAAY,GAAG;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,0EAA0E;IAC1E,SAAS,CAAC,EAAE,WAAW,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC,CAAC;IAClD,GAAG,EAAE,CAAC,OAAO,EAAE,YAAY,KAAK,IAAI,CAAC;CACtC,CAAC;AAEF,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EA2BjD,CAAC;AASF;;;;;;;;;GASG;AACH,eAAO,MAAM,iBAAiB,GAAI,MAAM,MAAM,KAAG,YAAY,GAAG,SAM/D,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,eAAe,QAAO,WAAW,EAMzC,CAAC"}

package/dist/lib/tui/watch-create.d.ts

@@ -0,0 +1,17 @@
+import type { CommandNode, PaletteEntry } from "./command-tree.js";
+import type { PromptSpec, ResourceRecord } from "../interactive.js";
+export declare const WATCH_CREATE_HINTS: [string, string][];
+/**
+ * Get-by-id commands, enumerated straight off the command tree. flattenTree
+ * deliberately drops leaves folded behind their list (which is exactly what a
+ * get is), so it can't be reused here.
+ */
+export declare const getByIdEntries: (commands: CommandNode[]) => PaletteEntry[];
+export declare const WatchCreate: ({ commands, width, onClose, onNotice, loadResourceRecords, }: {
+    commands: CommandNode[];
+    width: number;
+    onClose: () => void;
+    onNotice: (text: string, tone: "success" | "danger" | "warn") => void;
+    loadResourceRecords?: (spec: PromptSpec, query?: string) => Promise<ResourceRecord[]>;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=watch-create.d.ts.map

package/dist/lib/tui/watch-create.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-create.d.ts","sourceRoot":"","sources":["../../../lib/tui/watch-create.tsx"],"names":[],"mappings":"AAsBA,OAAO,KAAK,EAAe,WAAW,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAiBhF,OAAO,KAAK,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAMpE,eAAO,MAAM,kBAAkB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAIhD,CAAC;AAIF;;;;GAIG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,WAAW,EAAE,KAAG,YAAY,EAclE,CAAC;AA+EJ,eAAO,MAAM,WAAW,GAAI,8DAMzB;IACD,QAAQ,EAAE,WAAW,EAAE,CAAC;IACxB,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,KAAK,IAAI,CAAC;IACtE,mBAAmB,CAAC,EAAE,CACpB,IAAI,EAAE,UAAU,EAChB,KAAK,CAAC,EAAE,MAAM,KACX,OAAO,CAAC,cAAc,EAAE,CAAC,CAAC;CAChC,gCAibA,CAAC"}

package/dist/lib/tui/watch-pane.d.ts

@@ -0,0 +1,7 @@
+/** Status-bar keys while this pane owns the keyboard. */
+export declare const WATCH_PANE_HINTS: [string, string][];
+export declare const WatchPane: ({ width, onClose, }: {
+    width: number;
+    onClose: () => void;
+}) => import("react").JSX.Element;
+//# sourceMappingURL=watch-pane.d.ts.map

package/dist/lib/tui/watch-pane.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"watch-pane.d.ts","sourceRoot":"","sources":["../../../lib/tui/watch-pane.tsx"],"names":[],"mappings":"AAyBA,yDAAyD;AACzD,eAAO,MAAM,gBAAgB,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EAK9C,CAAC;AA0EF,eAAO,MAAM,SAAS,GAAI,qBAGvB;IACD,KAAK,EAAE,MAAM,CAAC;IACd,OAAO,EAAE,MAAM,IAAI,CAAC;CACrB,gCAkGA,CAAC"}

package/dist/lib/type-generation/languages/csharp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"csharp.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/csharp.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpE,qBAAa,MAAO,SAAQ,YAAY;IACtC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA8DT,WAAW,IAAI,MAAM;IAqHrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}
+{"version":3,"file":"csharp.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/csharp.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGpE,qBAAa,MAAO,SAAQ,YAAY;IACtC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA8DT,WAAW,IAAI,MAAM;IAqHrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}

package/dist/lib/type-generation/languages/dart.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dart.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/dart.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,YAAY,EACZ,SAAS,EACT,UAAU,EACV,cAAc,EAEf,MAAM,eAAe,CAAC;AAmBvB,qBAAa,IAAK,SAAQ,YAAY;IACpC,cAAc,IAAI,MAAM;IAqCxB,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA8DT,YAAY,CACV,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAAE,GACjB,cAAc;IAWjB,WAAW,IAAI,MAAM;IA+GrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}
+{"version":3,"file":"dart.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/dart.ts"],"names":[],"mappings":"AAGA,OAAO,EACL,YAAY,EACZ,SAAS,EACT,UAAU,EACV,cAAc,EAEf,MAAM,eAAe,CAAC;AAoBvB,qBAAa,IAAK,SAAQ,YAAY;IACpC,cAAc,IAAI,MAAM;IAqCxB,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA8DT,YAAY,CACV,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAAE,GACjB,cAAc;IAWjB,WAAW,IAAI,MAAM;IA+GrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}

package/dist/lib/type-generation/languages/java.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/java.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpE,qBAAa,IAAK,SAAQ,YAAY;IACpC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA2DT,WAAW,IAAI,MAAM;IAiFrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}
+{"version":3,"file":"java.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/java.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGpE,qBAAa,IAAK,SAAQ,YAAY;IACpC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA2DT,WAAW,IAAI,MAAM;IAiFrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}

package/dist/lib/type-generation/languages/javascript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/javascript.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpE,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,UAAU,EAAE,GAAG,MAAM;IA4DjE,YAAY,IAAI,OAAO;IAIvB,OAAO,CAAC,iBAAiB;IAezB,WAAW,IAAI,MAAM;IA8BrB,WAAW,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM;CAG/C"}
+{"version":3,"file":"javascript.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/javascript.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGpE,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,CAAC,EAAE,UAAU,EAAE,GAAG,MAAM;IA4DjE,YAAY,IAAI,OAAO;IAIvB,OAAO,CAAC,iBAAiB;IAezB,WAAW,IAAI,MAAM;IA8BrB,WAAW,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM;CAG/C"}

package/dist/lib/type-generation/languages/kotlin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/kotlin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpE,qBAAa,MAAO,SAAQ,YAAY;IACtC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA8DT,WAAW,IAAI,MAAM;IAiCrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}
+{"version":3,"file":"kotlin.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/kotlin.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGpE,qBAAa,MAAO,SAAQ,YAAY;IACtC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA8DT,WAAW,IAAI,MAAM;IAiCrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}

package/dist/lib/type-generation/languages/php.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"php.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/php.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpE,qBAAa,GAAI,SAAQ,YAAY;IACnC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA0DT,WAAW,IAAI,MAAM;IA0DrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}
+{"version":3,"file":"php.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/php.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGpE,qBAAa,GAAI,SAAQ,YAAY;IACnC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA0DT,WAAW,IAAI,MAAM;IA0DrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}

package/dist/lib/type-generation/languages/swift.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"swift.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/swift.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAEpE,qBAAa,KAAM,SAAQ,YAAY;IACrC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA8DT,WAAW,IAAI,MAAM;IAiHrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}
+{"version":3,"file":"swift.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/swift.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAGpE,qBAAa,KAAM,SAAQ,YAAY;IACrC,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IA8DT,WAAW,IAAI,MAAM;IAiHrB,WAAW,CAAC,UAAU,EAAE,UAAU,GAAG,MAAM;CAG5C"}

package/dist/lib/type-generation/languages/typescript.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/typescript.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,SAAS,EACT,UAAU,EACV,cAAc,EAEf,MAAM,eAAe,CAAC;AAyBvB,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IAuBT,YAAY,IAAI,OAAO;IAIvB,YAAY,CACV,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAAE,GACjB,cAAc;IAWjB,WAAW,IAAI,MAAM;IAiCrB,WAAW,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM;CAG/C"}
+{"version":3,"file":"typescript.d.ts","sourceRoot":"","sources":["../../../../lib/type-generation/languages/typescript.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,YAAY,EACZ,SAAS,EACT,UAAU,EACV,cAAc,EAEf,MAAM,eAAe,CAAC;AA0BvB,qBAAa,UAAW,SAAQ,YAAY;IAC1C,OAAO,CACL,SAAS,EAAE,SAAS,EACpB,WAAW,CAAC,EAAE,UAAU,EAAE,EAC1B,cAAc,CAAC,EAAE,MAAM,GACtB,MAAM;IAuBT,YAAY,IAAI,OAAO;IAIvB,YAAY,CACV,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAAE,GACjB,cAAc;IAWjB,WAAW,IAAI,MAAM;IAiCrB,WAAW,CAAC,CAAC,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM;CAG/C"}

package/dist/lib/watch/condition.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Watch conditions (DX-141): the closed set of ways a watcher can decide it is
+ * done, plus the parser behind `--until` and the formatter the UIs echo back.
+ */
+import type { Resolved, WatchCondition } from "./types.js";
+export declare const CONDITION_KEYWORDS: readonly ["changed", "equals", "matches", "terminal", "truthy"];
+/**
+ * "Terminal" means *stopped moving*, not *won*: a watcher must stop and tell
+ * you the deploy failed, not spin to timeout while the resource sits in
+ * `failed`. Both the success and the failure sinks are in the set.
+ */
+export declare const DEFAULT_TERMINAL_STATES: readonly string[];
+export declare const defaultTerminalStates: () => readonly string[];
+/**
+ * The absent arm of each branch is declared as `undefined` rather than omitted:
+ * this package compiles with `strict: false`, where TypeScript will not narrow
+ * a union by a boolean discriminant, so callers must be able to read `.error`
+ * off the union directly.
+ */
+export type ConditionParse = {
+    ok: true;
+    condition: WatchCondition;
+    error?: undefined;
+} | {
+    ok: false;
+    condition?: undefined;
+    error: string;
+};
+export declare const parseCondition: (text: string) => ConditionParse;
+export type UntilParse = {
+    ok: true;
+    fieldPath: string;
+    condition: WatchCondition;
+    error?: undefined;
+} | {
+    ok: false;
+    fieldPath?: undefined;
+    condition?: undefined;
+    error: string;
+};
+/**
+ * `[<field-path>] <condition>` — the shape `--until` takes. One flag carries
+ * both because `--until 'status equals ready'` reads better than splitting it,
+ * and the condition keywords are a closed set, so a leading token that is not
+ * one of them is unambiguously the field path. Callers that pass `--field`
+ * separately can use parseCondition directly.
+ */
+export declare const parseUntil: (text: string) => UntilParse;
+export declare const evaluateCondition: (condition: WatchCondition, current: Resolved, baseline: Resolved | null) => boolean;
+export declare const formatCondition: (condition: WatchCondition) => string;
+//# sourceMappingURL=condition.d.ts.map

package/dist/lib/watch/condition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"condition.d.ts","sourceRoot":"","sources":["../../../lib/watch/condition.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAIH,OAAO,KAAK,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAE3D,eAAO,MAAM,kBAAkB,iEAMrB,CAAC;AAMX;;;;GAIG;AACH,eAAO,MAAM,uBAAuB,EAAE,SAAS,MAAM,EAuBpD,CAAC;AAuBF,eAAO,MAAM,qBAAqB,QAAO,SAAS,MAAM,EACoB,CAAC;AAE7E;;;;;GAKG;AACH,MAAM,MAAM,cAAc,GACtB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,cAAc,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAAE,GAC1D;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,SAAS,CAAC,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAwDxD,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,cA+B7C,CAAC;AAYF,MAAM,MAAM,UAAU,GAClB;IACE,EAAE,EAAE,IAAI,CAAC;IACT,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,cAAc,CAAC;IAC1B,KAAK,CAAC,EAAE,SAAS,CAAC;CACnB,GACD;IACE,EAAE,EAAE,KAAK,CAAC;IACV,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,SAAS,CAAC,EAAE,SAAS,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEN;;;;;;GAMG;AACH,eAAO,MAAM,UAAU,GAAI,MAAM,MAAM,KAAG,UAkBzC,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAC5B,WAAW,cAAc,EACzB,SAAS,QAAQ,EACjB,UAAU,QAAQ,GAAG,IAAI,KACxB,OAuCF,CAAC;AAEF,eAAO,MAAM,eAAe,GAAI,WAAW,cAAc,KAAG,MAe3D,CAAC"}

package/dist/lib/watch/duration.d.ts

@@ -0,0 +1,28 @@
+/**
+ * Human durations for the watch flags (`--every 5s`, `--for 10m`) and the TUI
+ * wizard's cadence step (DX-141).
+ */
+/**
+ * The absent arm of each branch is declared as `undefined` rather than omitted:
+ * this package compiles with `strict: false`, where TypeScript will not narrow
+ * a union by a boolean discriminant, so callers must be able to read `.error`
+ * off the union directly.
+ */
+export type DurationParse = {
+    ok: true;
+    ms: number;
+    error?: undefined;
+} | {
+    ok: false;
+    ms?: undefined;
+    error: string;
+};
+/**
+ * `500ms` | `5s` | `2m` | `1h` | `30` — a bare number is **seconds**, which is
+ * what everyone means when they type `--every 5`. Fractions are allowed
+ * (`0.5m`); the result is rounded to whole milliseconds.
+ */
+export declare const parseDuration: (text: string) => DurationParse;
+/** Compact, for status lines and table cells: `900ms`, `42s`, `3m 05s`, `2h 07m`. */
+export declare const formatDuration: (ms: number) => string;
+//# sourceMappingURL=duration.d.ts.map

package/dist/lib/watch/duration.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duration.d.ts","sourceRoot":"","sources":["../../../lib/watch/duration.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAeH;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GACrB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,EAAE,EAAE,MAAM,CAAC;IAAC,KAAK,CAAC,EAAE,SAAS,CAAA;CAAE,GAC3C;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,EAAE,CAAC,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAC;AAEjD;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,MAAM,MAAM,KAAG,aAoB5C,CAAC;AAEF,qFAAqF;AACrF,eAAO,MAAM,cAAc,GAAI,IAAI,MAAM,KAAG,MAS3C,CAAC"}

package/dist/lib/watch/field-path.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Dot-path resolution into a poll payload, plus the canonical text form every
+ * condition compares against (DX-141).
+ *
+ * The one design decision worth knowing before reading: there is **no implicit
+ * descent into a list envelope**. See resolveFieldPath.
+ */
+import type { Resolved } from "./types.js";
+/**
+ * Comparable text for a resolved value. Scalars stringify to exactly what a
+ * user would type at the flag (`null`, `true`, `42`, `ready`), so
+ * `--until 'code equals 200'` matches the number 200 and
+ * `--until 'error equals null'` matches JSON null without the caller having to
+ * guess the wire type. Containers get stable JSON — `equals` on them is
+ * possible, though `matches` is the sane tool there.
+ */
+export declare const canonical: (value: unknown) => string;
+/** Segments, or null when the path is malformed (an empty segment). */
+export declare const parseFieldPath: (path: string) => string[] | null;
+/**
+ * Walk `path` into `data`.
+ *
+ * Deliberately strict about list envelopes: a bare `status` against the
+ * gateway's `{ items, page }` resolves to `missing`, **not** `items[0].status`.
+ * A page of 50 records has 50 statuses, and picking `[0]` would depend on a
+ * default sort the CLI neither controls nor displays — a watcher silently
+ * tracking whichever row sorted first is a wrong answer wearing a right
+ * answer's clothes. It would also make the same `--until 'status equals ready'`
+ * mean two different things depending on which command it was pointed at.
+ * Being explicit costs eight characters: `items.0.status`. What falls out free
+ * and is worth knowing: `page.total`, `page.hasMore`, `items.length`.
+ */
+export declare const resolveFieldPath: (data: unknown, path: string) => Resolved;
+/**
+ * Every path a surface can offer as a suggestion, depth-first and capped. Used
+ * by the TUI wizard to turn a probed payload into a pick list instead of making
+ * the user know the field names.
+ */
+export declare const enumerateFieldPaths: (data: unknown, { maxDepth, maxPaths }?: {
+    maxDepth?: number;
+    maxPaths?: number;
+}) => string[];
+/**
+ * Advisory only — a prefill for the surfaces, never applied by the resolver. A
+ * get-by-id response is a bare object whose interesting field is nearly always
+ * `status`; a list envelope's is `page.total`.
+ */
+export declare const suggestFieldPath: (data: unknown) => string | null;
+/**
+ * Short display text for a resolved value: an em dash for a miss, scalars bare,
+ * containers as truncated JSON.
+ */
+export declare const formatResolved: (resolved: Resolved | null, max?: number) => string;
+//# sourceMappingURL=field-path.d.ts.map

package/dist/lib/watch/field-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"field-path.d.ts","sourceRoot":"","sources":["../../../lib/watch/field-path.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAO3C;;;;;;;GAOG;AACH,eAAO,MAAM,SAAS,GAAI,OAAO,OAAO,KAAG,MAkB1C,CAAC;AAEF,uEAAuE;AACvE,eAAO,MAAM,cAAc,GAAI,MAAM,MAAM,KAAG,MAAM,EAAE,GAAG,IAKxD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,OAAO,EAAE,MAAM,MAAM,KAAG,QAkC9D,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAC9B,MAAM,OAAO,EACb,yBAAkC;IAAE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAO,KAC9E,MAAM,EAqBR,CAAC;AAKF;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,GAAI,MAAM,OAAO,KAAG,MAAM,GAAG,IAOzD,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,GAAI,UAAU,QAAQ,GAAG,IAAI,EAAE,YAAQ,KAAG,MAIpE,CAAC"}

package/dist/lib/watch/notify.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Notification ports for the watchlist (DX-141). The scheduler calls one
+ * interface on every state transition; the TUI renders a toast and a badge, the
+ * REPL prints a line and rings the bell. Ports differ in *rendering*, not in
+ * which transitions they care about — filtering belongs to the port.
+ */
+import type { WatchState, Watcher } from "./types.js";
+export type WatchNotification = {
+    watcher: Watcher;
+    /** The state it left, so a port can ignore intra-poll churn. */
+    from: WatchState;
+    to: WatchState;
+};
+export type NotificationPort = {
+    onTransition(event: WatchNotification): void;
+};
+export type NotificationPortSet = NotificationPort & {
+    /** Returns a detach function, mirroring registry.subscribe. */
+    attach(port: NotificationPort): () => void;
+};
+export declare const createPortSet: () => NotificationPortSet;
+/** The scheduler singleton's port set. */
+export declare const watchPorts: NotificationPortSet;
+/** Test seam (and a hook for any future surface). Pass null to restore. */
+export declare const bindOutOfBandWriter: (write: ((chunk: string) => void) | null) => void;
+export declare const writeOutOfBand: (chunk: string) => void;
+/** Reset the coalescing window. Tests only. */
+export declare const resetBellState: () => void;
+export declare const ringBell: (now?: () => number) => void;
+/** Glyph + a one-line summary of how a watcher ended. */
+export declare const formatWatchOutcome: (watcher: Watcher) => {
+    glyph: string;
+    tone: "success" | "danger" | "warn";
+    text: string;
+};
+/**
+ * REPL: a line plus a bell. readline may be parked mid-prompt, so the notice
+ * starts with \r + erase-line rather than half-overwriting the prompt, and the
+ * caller's `redraw` repaints it afterwards — otherwise the user is left
+ * apparently prompt-less until the next keystroke.
+ */
+export declare const createReplNotificationPort: (redraw: () => void) => NotificationPort;
+/**
+ * TUI: an in-app toast plus the bell. Built once and handed a ref-backed
+ * callback — the scheduler holds the port for the process lifetime, so a port
+ * closing over a render-scoped setter would go stale.
+ */
+export declare const createTuiNotificationPort: (toast: (text: string, tone: "success" | "danger" | "warn") => void) => NotificationPort;
+//# sourceMappingURL=notify.d.ts.map

package/dist/lib/watch/notify.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"notify.d.ts","sourceRoot":"","sources":["../../../lib/watch/notify.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAOH,OAAO,KAAK,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAEtD,MAAM,MAAM,iBAAiB,GAAG;IAC9B,OAAO,EAAE,OAAO,CAAC;IACjB,gEAAgE;IAChE,IAAI,EAAE,UAAU,CAAC;IACjB,EAAE,EAAE,UAAU,CAAC;CAChB,CAAC;AAEF,MAAM,MAAM,gBAAgB,GAAG;IAC7B,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,IAAI,CAAC;CAC9C,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,gBAAgB,GAAG;IACnD,+DAA+D;IAC/D,MAAM,CAAC,IAAI,EAAE,gBAAgB,GAAG,MAAM,IAAI,CAAC;CAC5C,CAAC;AAEF,eAAO,MAAM,aAAa,QAAO,mBAoBhC,CAAC;AAEF,0CAA0C;AAC1C,eAAO,MAAM,UAAU,EAAE,mBAAqC,CAAC;AAsB/D,2EAA2E;AAC3E,eAAO,MAAM,mBAAmB,GAC9B,OAAO,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAC,GAAG,IAAI,KACtC,IAEF,CAAC;AAEF,eAAO,MAAM,cAAc,GAAI,OAAO,MAAM,KAAG,IAE9C,CAAC;AAgBF,+CAA+C;AAC/C,eAAO,MAAM,cAAc,QAAO,IAEjC,CAAC;AAEF,eAAO,MAAM,QAAQ,GAAI,MAAK,MAAM,MAAiB,KAAG,IAOvD,CAAC;AAEF,yDAAyD;AACzD,eAAO,MAAM,kBAAkB,GAC7B,SAAS,OAAO,KACf;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAyCpE,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,0BAA0B,GACrC,QAAQ,MAAM,IAAI,KACjB,gBAQD,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,yBAAyB,GACpC,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,GAAG,QAAQ,GAAG,MAAM,KAAK,IAAI,KACjE,gBAOD,CAAC"}

package/dist/lib/watch/registry.d.ts

@@ -0,0 +1,25 @@
+/**
+ * The watcher store (DX-141). A mutable exported singleton, which is the grain
+ * of this codebase — lib/tui/theme.ts does the same with the active palette,
+ * and the TUI has no context or event bus (everything else is prop-drilled from
+ * App). The REPL, the one-shot `watch` command and the TUI pane all read the
+ * same store, so the surfaces cannot disagree about what is running.
+ */
+import type { Watcher } from "./types.js";
+export type WatchRegistry = {
+    get(id: string): Watcher | undefined;
+    /** Referentially stable between mutations — see the note on emit(). */
+    snapshot(): readonly Watcher[];
+    add(watcher: Watcher): Watcher;
+    update(id: string, patch: Partial<Watcher>): Watcher | undefined;
+    remove(id: string): boolean;
+    clear(): void;
+    /** Drop finished watchers past MAX_RETAINED_WATCHERS, oldest-finished first. */
+    prune(): void;
+    /** Listeners are NOT invoked on subscribe; callers read snapshot() first. */
+    subscribe(listener: () => void): () => void;
+};
+export declare const createWatchRegistry: () => WatchRegistry;
+/** Process-wide store, shared by every surface. */
+export declare const watchRegistry: WatchRegistry;
+//# sourceMappingURL=registry.d.ts.map

package/dist/lib/watch/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../lib/watch/registry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAGH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE1C,MAAM,MAAM,aAAa,GAAG;IAC1B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS,CAAC;IACrC,uEAAuE;IACvE,QAAQ,IAAI,SAAS,OAAO,EAAE,CAAC;IAC/B,GAAG,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC;IAC/B,MAAM,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,GAAG,OAAO,GAAG,SAAS,CAAC;IACjE,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B,KAAK,IAAI,IAAI,CAAC;IACd,gFAAgF;IAChF,KAAK,IAAI,IAAI,CAAC;IACd,6EAA6E;IAC7E,SAAS,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAAC;CAC7C,CAAC;AAEF,eAAO,MAAM,mBAAmB,QAAO,aAmEtC,CAAC;AAEF,mDAAmD;AACnD,eAAO,MAAM,aAAa,EAAE,aAAqC,CAAC"}

package/dist/lib/watch/run-queue.d.ts

@@ -0,0 +1,55 @@
+/**
+ * One process-wide lock over "something is driving the commander program right
+ * now" (DX-141). Everything that patches the shared process globals must pass
+ * through it:
+ *
+ *   - lib/tui/executor.ts's runner patches process.exit, both stream writes,
+ *     all five console.* methods and cliConfig, restoring them in a finally.
+ *     Two overlapping calls corrupt each other — the inner finally restores
+ *     while the outer is still running, so the outer's output leaks onto the
+ *     ink frame and its captured buffers come back wrong.
+ *   - lib/commands/repl.ts's runLine patches process.exit and resets cliConfig
+ *     around a bare parseAsync — a different mechanism over the same globals.
+ *
+ * Background polls therefore cannot merely serialize against each other; they
+ * have to serialize against the foreground too. That is why the primitive here
+ * is a lock over *thunks* rather than a queue of token arrays: the REPL's line
+ * runner is not a TuiRunner call and could not otherwise be covered.
+ *
+ * RE-ENTRANCY RULE: never call withRunLock (or enqueueRun) from inside a locked
+ * task — it deadlocks. The scheduler's first poll is deliberately deferred onto
+ * a timer for exactly this reason: `watch add` typed at the REPL executes
+ * inside runLine, which already holds the lock.
+ */
+import type { ExecutionResult, TuiRunner } from "../tui/executor.js";
+export type RunPriority = "foreground" | "background";
+/** Rejection handed to entries dropped by drainRunQueue. */
+export declare class RunQueueClosed extends Error {
+    constructor();
+}
+/** The TUI and the REPL bind the live program's runner for the session. */
+export declare const bindRunQueue: (runner: TuiRunner | null) => void;
+export declare const isRunQueueBound: () => boolean;
+/** For the status bar: "polling · 2 queued". */
+export declare const runQueueDepth: () => {
+    running: boolean;
+    queued: number;
+};
+export declare const withRunLock: <T>(task: () => Promise<T>, priority?: RunPriority) => Promise<T>;
+export declare const enqueueRun: (tokens: readonly string[], options?: {
+    force?: boolean;
+    priority?: RunPriority;
+}) => Promise<ExecutionResult>;
+/**
+ * Teardown: drop everything not yet started, then await the in-flight run so
+ * nothing resolves into a torn-down ink tree.
+ *
+ * Bounded, because "in flight" can mean a request the client is still retrying:
+ * its own timeout is 30 s and it retries idempotent GETs three times, so an
+ * unbounded wait would leave someone staring at a restored terminal for a
+ * minute after pressing q. Abandoning the wait is safe — every watcher has
+ * already been cancelled by the time this runs, so the poll's continuation
+ * re-reads a terminal state and does nothing.
+ */
+export declare const drainRunQueue: (timeoutMs?: number) => Promise<void>;
+//# sourceMappingURL=run-queue.d.ts.map

package/dist/lib/watch/run-queue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-queue.d.ts","sourceRoot":"","sources":["../../../lib/watch/run-queue.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAErE,MAAM,MAAM,WAAW,GAAG,YAAY,GAAG,YAAY,CAAC;AAEtD,4DAA4D;AAC5D,qBAAa,cAAe,SAAQ,KAAK;;CAKxC;AAaD,2EAA2E;AAC3E,eAAO,MAAM,YAAY,GAAI,QAAQ,SAAS,GAAG,IAAI,KAAG,IAEvD,CAAC;AAEF,eAAO,MAAM,eAAe,QAAO,OAAyB,CAAC;AAE7D,gDAAgD;AAChD,eAAO,MAAM,aAAa,QAAO;IAAE,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAGjE,CAAC;AAqBH,eAAO,MAAM,WAAW,GAAI,CAAC,EAC3B,MAAM,MAAM,OAAO,CAAC,CAAC,CAAC,EACtB,WAAU,WAA0B,KACnC,OAAO,CAAC,CAAC,CAmBR,CAAC;AAEL,eAAO,MAAM,UAAU,GACrB,QAAQ,SAAS,MAAM,EAAE,EACzB,UAAS;IAAE,KAAK,CAAC,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,WAAW,CAAA;CAAO,KACxD,OAAO,CAAC,eAAe,CAIY,CAAC;AAKvC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,aAAa,GACxB,kBAA4B,KAC3B,OAAO,CAAC,IAAI,CAOd,CAAC"}

package/dist/lib/watch/scheduler.d.ts

@@ -0,0 +1,78 @@
+/**
+ * The poller behind the watchlist (DX-141). Surface-agnostic: it knows how to
+ * run argv, read a field, evaluate a condition and decide when to give up, and
+ * nothing at all about ink or readline.
+ *
+ * Every dependency that touches the outside world — the runner, the clock, the
+ * timers, the RNG — is injected, so tests own all four and never need
+ * vi.useFakeTimers() (which cannot drive the microtask queue an awaited poll
+ * suspends on).
+ */
+import type { WatchSpec, Watcher } from "./types.js";
+import type { NotificationPortSet } from "./notify.js";
+import type { WatchRegistry } from "./registry.js";
+import type { ExecutionResult } from "../tui/executor.js";
+export type TimerHandle = unknown;
+export type SchedulerDeps = {
+    /** Injected so tests pass a fake; production binds enqueueRun. */
+    run: (tokens: readonly string[]) => Promise<ExecutionResult>;
+    now: () => number;
+    setTimer: (fn: () => void, ms: number) => TimerHandle;
+    clearTimer: (handle: TimerHandle) => void;
+    random: () => number;
+    registry: WatchRegistry;
+    ports: NotificationPortSet;
+    newId: () => string;
+};
+/** Absent arms are declared `undefined` because this package compiles with
+ * `strict: false`, where a boolean discriminant does not narrow a union. */
+export type StartOutcome = {
+    ok: true;
+    watcher: Watcher;
+    reason?: undefined;
+} | {
+    ok: false;
+    reason: "capacity" | "duplicate";
+    watcher?: Watcher;
+};
+export type WatchContext = {
+    tenant?: string;
+    endpoint?: string;
+};
+export type WatchScheduler = {
+    start(spec: WatchSpec, context?: WatchContext): StartOutcome;
+    cancel(id: string): boolean;
+    cancelAll(): Promise<void>;
+    /** Resolves when the watcher reaches a terminal state — the await point for
+     * a blocking one-shot `watch add`. */
+    settled(id: string): Promise<Watcher>;
+    activeCount(): number;
+};
+/**
+ * Freeze the tenant/endpoint the watcher was created under onto its argv.
+ *
+ * Poll runs otherwise inherit whatever cliConfig holds *at poll time*, and that
+ * moves: the REPL calls resetCliConfig(baseline) before every line, so a
+ * watcher created after `--tenant acme` on one line would silently start
+ * polling the baseline tenant a few seconds later. "Watch this thing" has to
+ * keep meaning this thing.
+ *
+ * The flags go *in front of* the command path: the generated service commands
+ * re-declare their own --tenant/--endpoint, so a trailing global would be
+ * parsed by the subcommand (or rejected as unknown). Leading is unambiguously
+ * the program's.
+ */
+export declare const buildWatchTokens: (spec: WatchSpec, context: WatchContext) => string[];
+export declare const createWatchScheduler: (overrides?: Partial<SchedulerDeps>) => WatchScheduler;
+/**
+ * Process-wide scheduler over the singleton registry. Nothing runs until
+ * start() is called, so eager construction at import is free.
+ */
+export declare const watchScheduler: WatchScheduler;
+/** Test helper: a fully isolated scheduler with its own store and ports. */
+export declare const createIsolatedScheduler: (overrides?: Partial<SchedulerDeps>) => {
+    scheduler: WatchScheduler;
+    registry: WatchRegistry;
+    ports: NotificationPortSet;
+};
+//# sourceMappingURL=scheduler.d.ts.map

package/dist/lib/watch/scheduler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduler.d.ts","sourceRoot":"","sources":["../../../lib/watch/scheduler.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAmBH,OAAO,KAAK,EAAE,SAAS,EAAc,OAAO,EAAE,MAAM,YAAY,CAAC;AACjE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAC;AACvD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AACnD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,oBAAoB,CAAC;AAE1D,MAAM,MAAM,WAAW,GAAG,OAAO,CAAC;AAElC,MAAM,MAAM,aAAa,GAAG;IAC1B,kEAAkE;IAClE,GAAG,EAAE,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,KAAK,OAAO,CAAC,eAAe,CAAC,CAAC;IAC7D,GAAG,EAAE,MAAM,MAAM,CAAC;IAClB,QAAQ,EAAE,CAAC,EAAE,EAAE,MAAM,IAAI,EAAE,EAAE,EAAE,MAAM,KAAK,WAAW,CAAC;IACtD,UAAU,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAC;IAC1C,MAAM,EAAE,MAAM,MAAM,CAAC;IACrB,QAAQ,EAAE,aAAa,CAAC;IACxB,KAAK,EAAE,mBAAmB,CAAC;IAC3B,KAAK,EAAE,MAAM,MAAM,CAAC;CACrB,CAAC;AAEF;4EAC4E;AAC5E,MAAM,MAAM,YAAY,GACpB;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,MAAM,CAAC,EAAE,SAAS,CAAA;CAAE,GAClD;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,UAAU,GAAG,WAAW,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC;AAEvE,MAAM,MAAM,YAAY,GAAG;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,MAAM,CAAA;CAAE,CAAC;AAElE,MAAM,MAAM,cAAc,GAAG;IAC3B,KAAK,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,YAAY,GAAG,YAAY,CAAC;IAC7D,MAAM,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC;IAC5B,SAAS,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAC3B;0CACsC;IACtC,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IACtC,WAAW,IAAI,MAAM,CAAC;CACvB,CAAC;AA+CF;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,gBAAgB,GAC3B,MAAM,SAAS,EACf,SAAS,YAAY,KACpB,MAAM,EAkBR,CAAC;AAUF,eAAO,MAAM,oBAAoB,GAC/B,YAAW,OAAO,CAAC,aAAa,CAAM,KACrC,cAsRF,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,cAAuC,CAAC;AAErE,4EAA4E;AAC5E,eAAO,MAAM,uBAAuB,GAClC,YAAW,OAAO,CAAC,aAAa,CAAM,KACrC;IAAE,SAAS,EAAE,cAAc,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAC;IAAC,KAAK,EAAE,mBAAmB,CAAA;CAQlF,CAAC"}

package/dist/lib/watch/session.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Whether an interactive session is hosting watchers right now (DX-141).
+ *
+ * `watch add` means two different things depending on the answer. Inside the
+ * REPL or the TUI there is a process that outlives the command, so the watcher
+ * is registered and the prompt comes straight back. One-shot there is nothing
+ * to come back to, so the command blocks until the watcher settles and turns
+ * its outcome into an exit code.
+ *
+ * A tiny module of its own rather than a flag on cliConfig: repl.ts's
+ * resetCliConfig is a hand-maintained mirror of CliConfig with no compile-time
+ * link, and a field missing from it becomes silently sticky across REPL lines.
+ */
+export declare const beginWatchSession: () => void;
+export declare const endWatchSession: () => void;
+export declare const isWatchSessionActive: () => boolean;
+//# sourceMappingURL=session.d.ts.map

package/dist/lib/watch/session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session.d.ts","sourceRoot":"","sources":["../../../lib/watch/session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH,eAAO,MAAM,iBAAiB,QAAO,IAEpC,CAAC;AAEF,eAAO,MAAM,eAAe,QAAO,IAElC,CAAC;AAEF,eAAO,MAAM,oBAAoB,QAAO,OAAoB,CAAC"}