@getorrery/ui 0.0.0-stage → 0.2.2

package/types/getorrery-ui.d.ts

@@ -0,0 +1,2034 @@
+import * as i0 from "@angular/core";
+import { ElementRef, EnvironmentProviders, Signal } from "@angular/core";
+import { SyntaxToken } from "@getorrery/styles/syntax";
+import * as monacoApi from "monaco-editor";
+import { KjDialogRef } from "@kouji-ui/core";
+/** Every glyph: the inner markup of a 24×24 stroked SVG. */
+export declare const ICONS: Readonly<Record<string, string>>;
+/**
+ * The names the ADE (`app-icon`) and Cloud (`kjIcon`) used before the merge, mapped onto the one
+ * set. A call site keeps its old name; new code uses the canonical one. ADE `columns` meant three
+ * columns: use `columns-3` (canonical `columns` is two, the design's).
+ */
+export declare const ICON_ALIASES: Readonly<Record<string, string>>;
+/** The canonical name for `name` (an alias resolves), or null when the set has no such glyph. */
+export declare function iconName(name: string): string | null;
+/** Every name `<orr-icon>` accepts, aliases included. */
+export declare function iconNames(): string[];
+type IconSize = "xs" | "sm" | "md" | "lg" | "xl";
+/** The whole SVG for `name` (stroke 1.75, currentColor). Unknown names draw `square`. */
+export declare function iconSvg(name: string, px?: number): string;
+/**
+ * `<orr-icon name="terminal" size="sm" />`: one glyph of the merged set (`.o-icon`), drawn in
+ * `currentColor`. `size` is xs 12 · sm 14 · md 16 · lg 20 · xl 24 or a pixel number. An unknown
+ * name draws a square and warns once, listing the known names.
+ */
+export declare class OrrIconComponent {
+  readonly name: import("@angular/core").InputSignal<string>;
+  readonly size: import("@angular/core").InputSignal<number | IconSize>;
+  readonly color: import("@angular/core").InputSignal<string | null>;
+  /** Accessible name; without it the icon is decorative (`aria-hidden`). */
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly px: import("@angular/core").Signal<number>;
+  readonly resolved: import("@angular/core").Signal<string>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrIconComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrIconComponent, "orr-icon", never, {
+    "name": {
+      "alias": "name";
+      "required": true;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Registers the merged set (aliases included) with kouji-ui's icon registry, so `[kjIcon]` and
+ * kouji's own components (select caret, toast, alert) draw the same glyphs as `<orr-icon>`.
+ */
+export declare function provideOrreryIcons(): EnvironmentProviders;
+/** Session / agent / machine states. `queued` (ADE) draws as idle. */
+type DotState = "running" | "waiting" | "blocked" | "done" | "idle" | "online" | "offline" | "queued";
+/** `<orr-dot state="running" pulse />`: the 8 px state dot (`.o-dot`); `size="sm"` is 6 px. */
+export declare class OrrDotComponent {
+  readonly state: import("@angular/core").InputSignal<DotState>;
+  readonly pulse: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly size: import("@angular/core").InputSignal<"sm" | "md">;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly cls: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrDotComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrDotComponent, "orr-dot", never, {
+    "state": {
+      "alias": "state";
+      "required": false;
+      "isSignal": true;
+    };
+    "pulse": {
+      "alias": "pulse";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** `<orr-pill state="waiting">Needs you</orr-pill>`: dot + word (`.o-pill`). Empty content shows the state. */
+export declare class OrrPillComponent {
+  readonly state: import("@angular/core").InputSignal<DotState>;
+  readonly nodot: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly cls: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrPillComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrPillComponent, "orr-pill", never, {
+    "state": {
+      "alias": "state";
+      "required": false;
+      "isSignal": true;
+    };
+    "nodot": {
+      "alias": "nodot";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+type BadgeTone = "neutral" | "add" | "del" | "attn" | "change" | "live" | "accent";
+/** `<orr-badge tone="add">+128</orr-badge>`: quiet count / tag (`.o-badge`). */
+export declare class OrrBadgeComponent {
+  readonly tone: import("@angular/core").InputSignal<BadgeTone>;
+  readonly solid: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly square: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly mono: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly cls: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrBadgeComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrBadgeComponent, "orr-badge", never, {
+    "tone": {
+      "alias": "tone";
+      "required": false;
+      "isSignal": true;
+    };
+    "solid": {
+      "alias": "solid";
+      "required": false;
+      "isSignal": true;
+    };
+    "square": {
+      "alias": "square";
+      "required": false;
+      "isSignal": true;
+    };
+    "mono": {
+      "alias": "mono";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** `<orr-chip removable (remove)="…">plan.md</orr-chip>`: a removable token (`.o-chip`). */
+export declare class OrrChipComponent {
+  readonly icon: import("@angular/core").InputSignal<string | null>;
+  readonly removable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly selected: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly removeLabel: import("@angular/core").InputSignal<string>;
+  readonly remove: import("@angular/core").OutputEmitterRef<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrChipComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrChipComponent, "orr-chip", never, {
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "removable": {
+      "alias": "removable";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "removeLabel": {
+      "alias": "removeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "remove": "remove";
+  }, never, ["*"], true, never>;
+}
+/** Initials of a name: first letters of the first two words. */
+export declare function initials(name: string): string;
+/** A stable identity tone (1–7, `--id-*`) for a name. */
+export declare function nameTone(name: string): number;
+/** `<orr-avatar name="Driss Najih" />`: initials on an identity tone (`.o-avatar`). */
+export declare class OrrAvatarComponent {
+  readonly name: import("@angular/core").InputSignal<string>;
+  /** 1–7; hashed from the name when absent. */
+  readonly tone: import("@angular/core").InputSignal<number | null>;
+  readonly size: import("@angular/core").InputSignal<"sm" | "md" | "lg">;
+  readonly square: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly text: import("@angular/core").Signal<string>;
+  readonly cls: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrAvatarComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrAvatarComponent, "orr-avatar", never, {
+    "name": {
+      "alias": "name";
+      "required": false;
+      "isSignal": true;
+    };
+    "tone": {
+      "alias": "tone";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "square": {
+      "alias": "square";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+type MeterTone = "ok" | "attn" | "danger";
+/** The tone a meter takes on its own: attn from 75 %, danger from 90 %. */
+export declare function meterTone(pct: number): MeterTone | null;
+/** `<orr-meter [value]="82" />`: a thin bar (`.o-meter`); the tone follows the fill unless set. */
+export declare class OrrMeterComponent {
+  readonly value: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly max: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly tone: import("@angular/core").InputSignal<MeterTone | null>;
+  readonly size: import("@angular/core").InputSignal<"md" | "lg">;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly pct: import("@angular/core").Signal<string>;
+  readonly cls: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrMeterComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrMeterComponent, "orr-meter", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "tone": {
+      "alias": "tone";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** `<orr-ring [value]="0.4" />`: circular progress, 0..1 (from the ADE's `app-ring`). */
+export declare class OrrRingComponent {
+  readonly value: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly size: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly stroke: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly color: import("@angular/core").InputSignal<string | null>;
+  readonly r: import("@angular/core").Signal<number>;
+  readonly c: import("@angular/core").Signal<number>;
+  readonly circ: import("@angular/core").Signal<number>;
+  readonly offset: import("@angular/core").Signal<number>;
+  readonly round: import("@angular/core").Signal<number>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrRingComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrRingComponent, "orr-ring", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "stroke": {
+      "alias": "stroke";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** The VCS letters every changes list uses, with their names. */
+export declare const VCS_STATE_NAMES: Readonly<Record<string, string>>;
+/** `<orr-state state="A" />`: the file-state letter square (`.o-state`), coloured by `--vcs-*`. */
+export declare class OrrStateComponent {
+  readonly state: import("@angular/core").InputSignal<string>;
+  readonly title: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrStateComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrStateComponent, "orr-state", never, {
+    "state": {
+      "alias": "state";
+      "required": true;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** `<orr-addel [add]="3" [del]="1" />`: `+N −N`, only the non-zero counts (`.o-addel`). */
+export declare class OrrAddDelComponent {
+  readonly add: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly del: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrAddDelComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrAddDelComponent, "orr-addel", never, {
+    "add": {
+      "alias": "add";
+      "required": false;
+      "isSignal": true;
+    };
+    "del": {
+      "alias": "del";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** `"Ctrl K"`, `"Ctrl+K"` or `["Ctrl", "K"]` → one key per cap. A lone `+` stays a key. */
+export declare function splitKeys(keys: string | readonly string[]): string[];
+/**
+ * What makes a shortcut a hint inside a control rather than a standalone key: the controls of the
+ * system (and kouji's) in which `.o-kbd` turns quiet (no border, no ground, mono 11, `--ink-3`).
+ */
+export declare const KBD_INLINE_CONTEXT: string;
+/**
+ * `<orr-kbd keys="Ctrl K" />`: keyboard keys (`.o-kbd`). Standalone it draws boxed caps; inside a
+ * control (button, menu item, search pill, chip, tab, input) it is a quiet inline hint on its own
+ * (`.o-kbd--inline`). `inline` forces either form; `size="md"` is the 14 px top-bar cap.
+ */
+export declare class OrrKbdComponent {
+  readonly keys: import("@angular/core").InputSignal<string | readonly string[]>;
+  /** `true` / `false` force the form; unset follows the context. */
+  readonly inline: import("@angular/core").InputSignal<boolean | undefined>;
+  readonly size: import("@angular/core").InputSignal<"sm" | "md">;
+  readonly caps: import("@angular/core").Signal<string[]>;
+  readonly label: import("@angular/core").Signal<string>;
+  /** Whether the host sits inside a control (read once the host is in the DOM). */
+  readonly inControl: import("@angular/core").WritableSignal<boolean>;
+  readonly isInline: import("@angular/core").Signal<boolean>;
+  readonly cls: import("@angular/core").Signal<string>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrKbdComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrKbdComponent, "orr-kbd", never, {
+    "keys": {
+      "alias": "keys";
+      "required": true;
+      "isSignal": true;
+    };
+    "inline": {
+      "alias": "inline";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Brand marks per agent tool (single path, 24 grid). */
+export declare const TOOL_ICONS: Readonly<Record<string, string>>;
+/** The monogram drawn when a tool has no brand mark. */
+export declare const TOOL_GLYPHS: Readonly<Record<string, string>>;
+/**
+ * `<orr-tool-badge tool="claude" [size]="16" />`: the agent tool's brand mark on a square tinted with
+ * its `--tool-*` colour (from the ADE's `app-tool-badge`). Unknown tools show their first letter in `--ink-3`.
+ */
+export declare class OrrToolBadgeComponent {
+  readonly tool: import("@angular/core").InputSignal<string>;
+  readonly size: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly accent: import("@angular/core").Signal<string>;
+  readonly path: import("@angular/core").Signal<string>;
+  readonly glyph: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrToolBadgeComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrToolBadgeComponent, "orr-tool-badge", never, {
+    "tool": {
+      "alias": "tool";
+      "required": true;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** Marks content for the dialog / sheet head, right-aligned before the close button. */
+export declare class OrrDialogActionsDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrDialogActionsDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<OrrDialogActionsDirective, "[orrDialogActions]", never, {}, {}, never, never, true, never>;
+}
+/** Marks content drawn inline after the dialog title, on its row (e.g. the file and position of a review). */
+export declare class OrrDialogTitleDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrDialogTitleDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<OrrDialogTitleDirective, "[orrDialogTitle]", never, {}, {}, never, never, true, never>;
+}
+/** Marks content for the dialog / sheet foot (the actions row, right-aligned). */
+export declare class OrrDialogFootDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrDialogFootDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<OrrDialogFootDirective, "[orrDialogFoot]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The dialog role an outer element already declares around `host` (a component that sets `role=dialog`
+ * on its own host), named by `titleId` when it has no name; null when none does, and the shell's own
+ * panel is the dialog. kouji's `KjDialogService` gives no element the role, so the panel carries it.
+ */
+declare function outerDialog(host: HTMLElement, titleId: string): Element | null;
+/** Why a shell closed itself: its × button. Esc and the scrim are kouji's overlay. */
+type DialogCloseReason = "button";
+/**
+ * The dialog panel (`.o-dialog`) inside kouji's `<kj-dialog-shell>`: head (icon, title + sub, your
+ * `[orrDialogActions]` right-aligned, × at the far right), body, and `[orrDialogFoot]`. Open the
+ * component that uses it with kouji's `KjDialogService.open(…)`; the overlay gives the scrim, Esc,
+ * the focus trap and the return focus. × closes the `KjDialogRef` and emits `closed`.
+ *
+ * ```html
+ * <orr-dialog-shell heading="New session" icon="plus" size="md" (closed)="…">
+ *   <kj-button orrDialogActions kjVariant="ghost" kjSize="sm">Help</kj-button>
+ *   …body…
+ *   <kj-button orrDialogFoot kjVariant="outline">Cancel</kj-button>
+ * </orr-dialog-shell>
+ * ```
+ */
+export declare class OrrDialogShellComponent {
+  readonly heading: import("@angular/core").InputSignal<string>;
+  readonly sub: import("@angular/core").InputSignal<string>;
+  readonly icon: import("@angular/core").InputSignal<string | null>;
+  readonly tone: import("@angular/core").InputSignal<"danger" | "default">;
+  /** sm 480 · md 600 · lg 880 · xl 1200. */
+  readonly size: import("@angular/core").InputSignal<"sm" | "md" | "lg" | "xl">;
+  readonly closable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly closeLabel: import("@angular/core").InputSignal<string>;
+  readonly closed: import("@angular/core").OutputEmitterRef<"button">;
+  protected readonly foot: import("@angular/core").Signal<readonly OrrDialogFootDirective[]>;
+  protected readonly inline: import("@angular/core").Signal<readonly OrrDialogTitleDirective[]>;
+  protected readonly titleId: string;
+  /** The panel is the dialog (role, modal, name) unless an outer element already declares one. */
+  protected readonly ownRole: import("@angular/core").WritableSignal<boolean>;
+  private readonly ref;
+  constructor();
+  /** Closes the kouji dialog this shell sits in (if any) and emits `closed`. */
+  close(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrDialogShellComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrDialogShellComponent, "orr-dialog-shell", never, {
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+    "sub": {
+      "alias": "sub";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "tone": {
+      "alias": "tone";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "closable": {
+      "alias": "closable";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "closed": "closed";
+  }, ["foot", "inline"], ["[orrDialogTitle]", "[orrDialogActions]", "*", "[orrDialogFoot]"], true, never>;
+}
+/**
+ * The phone bottom sheet (`.o-sheet`) inside kouji's `<kj-sheet-shell>`: grab handle, title, × at
+ * thumb size, body, `[orrDialogFoot]` (buttons share the width). Open with kouji's `KjSheetService`.
+ */
+export declare class OrrSheetShellComponent {
+  readonly heading: import("@angular/core").InputSignal<string>;
+  readonly closable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly closeLabel: import("@angular/core").InputSignal<string>;
+  readonly closed: import("@angular/core").OutputEmitterRef<"button">;
+  protected readonly foot: import("@angular/core").Signal<readonly OrrDialogFootDirective[]>;
+  private readonly ref;
+  close(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrSheetShellComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrSheetShellComponent, "orr-sheet-shell", never, {
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+    "closable": {
+      "alias": "closable";
+      "required": false;
+      "isSignal": true;
+    };
+    "closeLabel": {
+      "alias": "closeLabel";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "closed": "closed";
+  }, ["foot"], ["[orrDialogActions]", "*", "[orrDialogFoot]"], true, never>;
+}
+/** Marks content for a card's head, right-aligned (`<orr-pill orrCardActions …>`). */
+export declare class OrrCardActionsDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrCardActionsDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<OrrCardActionsDirective, "[orrCardActions]", never, {}, {}, never, never, true, never>;
+}
+/** Marks content for a card's foot. */
+export declare class OrrCardFootDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrCardFootDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<OrrCardFootDirective, "[orrCardFoot]", never, {}, {}, never, never, true, never>;
+}
+/** `<orr-card heading="Machine" icon="server">…</orr-card>`: a `--panel` card (`.o-card`). */
+export declare class OrrCardComponent {
+  readonly heading: import("@angular/core").InputSignal<string>;
+  readonly icon: import("@angular/core").InputSignal<string | null>;
+  readonly selected: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Hover ring for a clickable card. */
+  readonly hover: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly actions: import("@angular/core").Signal<readonly OrrCardActionsDirective[]>;
+  protected readonly foot: import("@angular/core").Signal<readonly OrrCardFootDirective[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrCardComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrCardComponent, "orr-card", never, {
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "hover": {
+      "alias": "hover";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["actions", "foot"], ["[orrCardActions]", "*", "[orrCardFoot]"], true, never>;
+}
+/**
+ * `<orr-row label="Density" config="ui.density" hint="…"><orr-seg …/></orr-row>`: one setting
+ * (`.o-set-row`): label (`--ink`, medium), its config key (mono, `--ink-4`), the hint (`--ink-3`)
+ * on the left; the control (projected) on the right, or under it with `wide`.
+ */
+export declare class OrrSettingRowComponent {
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly hint: import("@angular/core").InputSignal<string>;
+  /** The `config.toml` key this setting writes (decision 0003: both routes, always). */
+  readonly config: import("@angular/core").InputSignal<string>;
+  readonly wide: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrSettingRowComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrSettingRowComponent, "orr-row", never, {
+    "label": {
+      "alias": "label";
+      "required": true;
+      "isSignal": true;
+    };
+    "hint": {
+      "alias": "hint";
+      "required": false;
+      "isSignal": true;
+    };
+    "config": {
+      "alias": "config";
+      "required": false;
+      "isSignal": true;
+    };
+    "wide": {
+      "alias": "wide";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["[orrRowHint]", "*"], true, never>;
+}
+/** `<orr-set-group heading="Appearance">…rows…</orr-set-group>`: a ruled settings section. */
+export declare class OrrSettingGroupComponent {
+  readonly heading: import("@angular/core").InputSignal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrSettingGroupComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrSettingGroupComponent, "orr-set-group", never, {
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/** Marks the empty state's action buttons. */
+export declare class OrrEmptyActionDirective {
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrEmptyActionDirective, never>;
+  static ɵdir: i0.ɵɵDirectiveDeclaration<OrrEmptyActionDirective, "[orrEmptyAction]", never, {}, {}, never, never, true, never>;
+}
+/**
+ * `<orr-empty icon="layers" heading="No sessions">Start one from …</orr-empty>`: an empty state
+ * (`.o-empty`) that says what to do; `line` is the one-row form inside a list.
+ */
+export declare class OrrEmptyComponent {
+  readonly icon: import("@angular/core").InputSignal<string | null>;
+  readonly heading: import("@angular/core").InputSignal<string>;
+  readonly line: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly action: import("@angular/core").Signal<readonly OrrEmptyActionDirective[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrEmptyComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrEmptyComponent, "orr-empty", never, {
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+    "line": {
+      "alias": "line";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, ["action"], ["*", "[orrEmptyAction]"], true, never>;
+}
+/** `<orr-skeleton [lines]="3" />`: shimmering placeholder lines (`.o-skel`); the last of several is shorter. */
+export declare class OrrSkeletonComponent {
+  readonly lines: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  readonly w: import("@angular/core").InputSignal<string>;
+  readonly h: import("@angular/core").InputSignal<string>;
+  readonly circle: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly rows: import("@angular/core").Signal<unknown[]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrSkeletonComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrSkeletonComponent, "orr-skeleton", never, {
+    "lines": {
+      "alias": "lines";
+      "required": false;
+      "isSignal": true;
+    };
+    "w": {
+      "alias": "w";
+      "required": false;
+      "isSignal": true;
+    };
+    "h": {
+      "alias": "h";
+      "required": false;
+      "isSignal": true;
+    };
+    "circle": {
+      "alias": "circle";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/** `<orr-spinner size="sm" />`: the ring spinner (`.o-spin`) in `currentColor`. */
+export declare class OrrSpinnerComponent {
+  readonly size: import("@angular/core").InputSignal<"sm" | "md" | "lg">;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly cls: import("@angular/core").Signal<string>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrSpinnerComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrSpinnerComponent, "orr-spinner", never, {
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * `<orr-search-pill label="Search" keys="Ctrl K" (activate)="openPalette()" />`: the top-bar search
+ * trigger (`.o-search-trigger`): icon, label, and the shortcut as an inline hint.
+ */
+export declare class OrrSearchPillComponent {
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly keys: import("@angular/core").InputSignal<string>;
+  readonly icon: import("@angular/core").InputSignal<string>;
+  readonly activate: import("@angular/core").OutputEmitterRef<void>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrSearchPillComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrSearchPillComponent, "orr-search-pill", never, {
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "keys": {
+      "alias": "keys";
+      "required": false;
+      "isSignal": true;
+    };
+    "icon": {
+      "alias": "icon";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "activate": "activate";
+  }, never, never, true, never>;
+}
+/**
+ * `<orr-pane-resizer side="right" [width]="w" (widthChange)="w = $event" (reset)="w = 300" />`: the drag
+ * handle on a side column's inner edge (the ADE's `app-pane-resizer`, shared). It owns the gesture only;
+ * the host keeps the width. `side` is where the column sits: a right-hand column grows as the pointer
+ * moves left. ← → nudge it by 16px, double-click asks for the host's default.
+ */
+export declare class OrrPaneResizerComponent {
+  private readonly host;
+  /** The column's width in px: a drag starts from it. */
+  readonly width: import("@angular/core").InputSignal<number>;
+  readonly min: import("@angular/core").InputSignal<number>;
+  readonly max: import("@angular/core").InputSignal<number>;
+  /** Where the column sits beside the handle. */
+  readonly side: import("@angular/core").InputSignal<"left" | "right">;
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** The clamped width, on every pointer move and nudge. */
+  readonly widthChange: import("@angular/core").OutputEmitterRef<number>;
+  /** Double-click: the host's default. */
+  readonly reset: import("@angular/core").OutputEmitterRef<void>;
+  readonly dragging: import("@angular/core").WritableSignal<boolean>;
+  startDrag(ev: PointerEvent): void;
+  /** The keyboard route: ← → move the edge, whichever side the column is on. */
+  nudge(by: number, ev: Event): void;
+  private emit;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrPaneResizerComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrPaneResizerComponent, "orr-pane-resizer", never, {
+    "width": {
+      "alias": "width";
+      "required": true;
+      "isSignal": true;
+    };
+    "min": {
+      "alias": "min";
+      "required": false;
+      "isSignal": true;
+    };
+    "max": {
+      "alias": "max";
+      "required": false;
+      "isSignal": true;
+    };
+    "side": {
+      "alias": "side";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "widthChange": "widthChange";
+    "reset": "reset";
+  }, never, never, true, never>;
+}
+interface SelectOption {
+  value: string;
+  label: string;
+}
+/** A titled cluster of options (the `<optgroup>` role). */
+interface SelectGroup {
+  label: string;
+  options: (string | SelectOption)[];
+  /** The heading folds and unfolds the group (Left / Right on the keyboard). */
+  collapsible?: boolean;
+  /** Starts folded; needs `collapsible`. */
+  collapsed?: boolean;
+}
+interface SelectRun {
+  label: string | null;
+  options: SelectOption[];
+  collapsible?: boolean;
+  collapsed?: boolean;
+}
+/** From this many options on, `searchable="auto"` shows the search field. */
+export declare const SELECT_SEARCH_FROM = 8;
+/** Strings, `{value, label}` pairs and groups, mixed, flattened into runs in their order. */
+export declare function selectRuns(options: readonly (string | SelectOption | SelectGroup)[]): SelectRun[];
+/**
+ * `<orr-select [(value)]="model" [options]="opts" />`: kouji's `<kj-select>` with Orrery's option
+ * shapes (from the ADE's `app-select`): strings, `{ value, label }` and `{ label, options }` groups.
+ * A long list gets a search field (`searchable`, "auto" from SELECT_SEARCH_FROM options on);
+ * a group with `collapsible` folds under its heading.
+ */
+export declare class OrrSelectComponent {
+  readonly value: import("@angular/core").ModelSignal<string>;
+  readonly options: import("@angular/core").InputSignal<readonly (string | SelectOption | SelectGroup)[]>;
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly size: import("@angular/core").InputSignal<"xs" | "sm" | "md" | "lg">;
+  readonly disabled: import("@angular/core").InputSignal<boolean>;
+  /** A search field above the options: always, never, or "auto" (from SELECT_SEARCH_FROM options on). */
+  readonly searchable: import("@angular/core").InputSignal<boolean | "auto">;
+  readonly searchPlaceholder: import("@angular/core").InputSignal<string>;
+  /** What the search shows when nothing matches, e.g. "No matching projects". */
+  readonly searchEmpty: import("@angular/core").InputSignal<string>;
+  /** The closed select's text for a value no option has (an archived agent…); unset: the value itself. */
+  readonly displayWith: import("@angular/core").InputSignal<((value: unknown) => string) | null>;
+  readonly runs: import("@angular/core").Signal<SelectRun[]>;
+  protected readonly search: import("@angular/core").Signal<boolean>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrSelectComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrSelectComponent, "orr-select", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+    "searchable": {
+      "alias": "searchable";
+      "required": false;
+      "isSignal": true;
+    };
+    "searchPlaceholder": {
+      "alias": "searchPlaceholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "searchEmpty": {
+      "alias": "searchEmpty";
+      "required": false;
+      "isSignal": true;
+    };
+    "displayWith": {
+      "alias": "displayWith";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+interface SegOption {
+  value: string;
+  label: string;
+  icon?: string;
+  title?: string;
+  disabled?: boolean;
+}
+/**
+ * `<orr-seg [(value)]="mode" [options]="[{value:'tree',label:'Tree',icon:'git-branch'}, …]" />`:
+ * a segmented switch, drawn by kouji's pill tabs, which @getorrery/styles draws as `.o-seg` (`size="xs"` is the in-pane `.tabs-xs` form).
+ * `block` fills the row and shares it between the options (`.o-seg--block`); `size="tap"` is the phone's 36 px
+ * option in body text (`.o-seg--tap`): `<orr-seg block size="tap" … />` is PhoneApp-14's Theme switch.
+ */
+export declare class OrrSegComponent {
+  readonly value: import("@angular/core").ModelSignal<string>;
+  readonly options: import("@angular/core").InputSignal<readonly SegOption[]>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly size: import("@angular/core").InputSignal<"xs" | "sm" | "tap">;
+  /** Fill the row: the options share its width. */
+  readonly block: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrSegComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrSegComponent, "orr-seg", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "options": {
+      "alias": "options";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "block": {
+      "alias": "block";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, never, never, true, never>;
+}
+/**
+ * `<orr-choices [(value)]="where" label="Run on"><orr-choice value="desk">…</orr-choice></orr-choices>`:
+ * a radio group drawn as cards (`.o-choices > .o-choice[aria-checked]`, CloudApp-00 "Run on"). `card` is the
+ * stacked size card (`.o-choice--card`: title row, spec, note on `--panel-2`; selected = accent border + ring).
+ * The whole card is the radio: click or Space picks it; ← → ↑ ↓ Home End move and pick, roving focus.
+ * `columns` sets the grid (default 2). Content is the card's own: `.o-choice__text`, `__title`, `__sub` help.
+ */
+export declare class OrrChoicesComponent {
+  readonly value: import("@angular/core").ModelSignal<string | null>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly columns: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** The stacked card form (the instance sizes). */
+  readonly card: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  private readonly options;
+  /** The option that holds the tab stop: the chosen one, else the first enabled. */
+  readonly tabStop: import("@angular/core").Signal<any>;
+  pick(v: string): void;
+  protected onKey(e: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrChoicesComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrChoicesComponent, "orr-choices", never, {
+    "value": {
+      "alias": "value";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "columns": {
+      "alias": "columns";
+      "required": false;
+      "isSignal": true;
+    };
+    "card": {
+      "alias": "card";
+      "required": false;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "value": "valueChange";
+  }, ["options"], ["*"], true, never>;
+}
+/** One card of `<orr-choices>`: `value`, `disabled`; the content is the card. */
+export declare class OrrChoiceComponent {
+  readonly value: import("@angular/core").InputSignal<string>;
+  readonly disabled: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  protected readonly group: OrrChoicesComponent;
+  readonly host: ElementRef<HTMLElement>;
+  readonly checked: import("@angular/core").Signal<boolean>;
+  readonly off: import("@angular/core").Signal<boolean>;
+  protected choose(): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrChoiceComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrChoiceComponent, "orr-choice", never, {
+    "value": {
+      "alias": "value";
+      "required": true;
+      "isSignal": true;
+    };
+    "disabled": {
+      "alias": "disabled";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, ["*"], true, never>;
+}
+/**
+ * The one model behind every changed-file list (working tree, a commit, a compare, a session): rows
+ * for a tree or a flat list. Folders carry the aggregate of everything below them (±lines, and the
+ * state when every descendant shares one), single-child folder chains collapse into one row
+ * (`src/webhooks`), folders sort before files, both alphabetically.
+ */
+/** A changed file. `status` is the VCS letter: A M D R C U ? ! (M when unset; `""` = unchanged, no letter: a file browser). */
+interface ChangedFile {
+  path: string;
+  status?: string;
+  add?: number;
+  del?: number;
+  /** R: the path before the move. */
+  from?: string;
+}
+type FileListMode = "tree" | "flat";
+/** Same file row data (path, letter, counts, rename source). */
+export declare function sameChangedFile(a: ChangedFile, b: ChangedFile): boolean;
+/**
+ * Two file lists with the same rows, in the same order. A host that rebuilds its list on every
+ * poll or stream frame hands the list an equal array: with this as a signal's `equal`, nothing
+ * downstream recomputes and no row re-renders.
+ */
+export declare function sameChangedFiles(a: readonly ChangedFile[], b: readonly ChangedFile[]): boolean;
+/** Same visible rows (what `fileRows` gives): the list's `@for` then has nothing to update. */
+export declare function sameRows(a: readonly FileRow[], b: readonly FileRow[]): boolean;
+interface FileRow {
+  kind: "dir" | "file";
+  /** Folder rows: the deepest folder of a collapsed chain. */
+  path: string;
+  /** What the row shows: a file name, a folder chain (`src/webhooks`), or in flat mode the file name. */
+  name: string;
+  depth: number;
+  /** Files: the parent folder (flat mode shows it after the name). */
+  dir: string;
+  file?: ChangedFile;
+  /** Files: their letter (M when unset). Folders: the uniform letter of everything below, or "". */
+  state: string;
+  add: number;
+  del: number;
+}
+/** The visible rows: folders collapsed in `collapsed` hide what is under them. */
+export declare function fileRows(files: readonly ChangedFile[], mode?: FileListMode, collapsed?: ReadonlySet<string>): FileRow[];
+/** The files in the order the tree shows them (all folders open): what next / previous file walk. */
+export declare function fileOrder(files: readonly ChangedFile[], mode?: FileListMode): string[];
+type TreeKey = "ArrowDown" | "ArrowUp" | "Home" | "End" | "ArrowRight" | "ArrowLeft" | "Enter" | " ";
+/** What a key does on the focused row: move the focus, toggle a folder, or open a file. */
+type TreeMove = {
+  focus: string;
+} | {
+  toggle: string;
+} | {
+  open: string;
+} | null;
+/** The tree's keyboard model, pure: ↑ ↓ Home End move, → opens / steps in, ← closes / goes to the parent, Enter / Space opens. */
+export declare function treeKey(rows: readonly FileRow[], focus: string | null, key: string, collapsed: ReadonlySet<string>): TreeMove;
+/**
+ * `<orr-filetree [files]="files" [(selected)]="path" [(mode)]="mode" />`: the changed-file list
+ * (`.o-changes`, the ADE's diff-file-list). Head: `heading · N`, the ±total, the Tree / Flat switch.
+ * Rows: the VCS letter (`--vcs-*`), the name (flat: + its folder, or `← from` for a rename), ±counts;
+ * folders aggregate and collapse. Keys inside the list: ↑ ↓ Home End move, ← → fold, Enter / Space open.
+ */
+export declare class OrrFileTreeComponent {
+  readonly files: import("@angular/core").InputSignal<readonly ChangedFile[]>;
+  /** The open file. Two-way: a click, Enter or Space sets it. */
+  readonly selected: import("@angular/core").ModelSignal<string | null>;
+  readonly mode: import("@angular/core").ModelSignal<FileListMode>;
+  readonly heading: import("@angular/core").InputSignal<string>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  readonly emptyText: import("@angular/core").InputSignal<string>;
+  /** Show the head row (title, totals, switch). */
+  readonly head: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Show the Tree / Flat switch in the head. */
+  readonly toggle: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** A file was opened (click, Enter, Space), also when it already was the selected one. */
+  readonly fileOpen: import("@angular/core").OutputEmitterRef<string>;
+  protected readonly modes: SegOption[];
+  readonly collapsed: import("@angular/core").WritableSignal<ReadonlySet<string>>;
+  private readonly focus;
+  private readonly host;
+  /** `files`, held while a new array carries the same rows: a host's poll or stream frame re-renders nothing. */
+  protected readonly list: import("@angular/core").Signal<readonly ChangedFile[]>;
+  readonly rows: import("@angular/core").Signal<FileRow[]>;
+  readonly totalAdd: import("@angular/core").Signal<number>;
+  readonly totalDel: import("@angular/core").Signal<number>;
+  /** The keyboard focus row: the last one moved to, else the selection, else the first row. */
+  readonly focusPath: import("@angular/core").Signal<string>;
+  protected stateName(s: string): string;
+  setMode(m: FileListMode): void;
+  toggleDir(path: string): void;
+  open(path: string): void;
+  onKey(e: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrFileTreeComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrFileTreeComponent, "orr-filetree", never, {
+    "files": {
+      "alias": "files";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "head": {
+      "alias": "head";
+      "required": false;
+      "isSignal": true;
+    };
+    "toggle": {
+      "alias": "toggle";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "selected": "selectedChange";
+    "mode": "modeChange";
+    "fileOpen": "fileOpen";
+  }, never, ["[orrTreeActions]"], true, never>;
+}
+/**
+ * Diff lines for `<orr-diff>`: parsed from unified diff text, or computed from the two sides of a
+ * file (line LCS, from the ADE's session-changes). `a` is the old line number, `b` the new one.
+ */
+type DiffLineKind = "add" | "del" | "ctx" | "hunk";
+interface DiffLine {
+  t: DiffLineKind;
+  /** Old-side line number (del, ctx). */
+  a?: number;
+  /** New-side line number (add, ctx). */
+  b?: number;
+  text: string;
+}
+/** Same diff lines (kind, numbers, text), whatever the array's identity. */
+export declare function sameLines(a: readonly DiffLine[], b: readonly DiffLine[]): boolean;
+/** Unified diff text → lines (`---` / `+++` / `diff` / `index` headers dropped; the `+++` path is the file). */
+export declare function parseUnified(text: string): {
+  lines: DiffLine[];
+  file: string;
+};
+/** Every line of the file, old → new, as ctx / del / add (removals before additions). Past `limit` cells the whole file is one replace. */
+export declare function fileLines(before: string, after: string, limit?: number): DiffLine[];
+/** The hunks of `before` → `after`: `context` lines around each change, every hunk opened by its `@@` line. */
+export declare function diffLines(before: string, after: string, context?: number): DiffLine[];
+/** Whole-file lines (no hunk rows) cut into hunks with `context` lines around each change. */
+export declare function hunks(all: readonly DiffLine[], context?: number): DiffLine[];
+/** Index of the first line of each change (a run of add / del lines). */
+export declare function changeStarts(lines: readonly DiffLine[]): number[];
+/** The [first, last] line indexes of the change that starts at `start`. */
+export declare function changeRange(lines: readonly DiffLine[], start: number): [number, number];
+/** A rendered row: a line (with its index in `lines`) or a fold of `n` unchanged lines starting at `fold`. */
+type DiffBlock = {
+  line: DiffLine;
+  i: number;
+} | {
+  fold: number;
+  n: number;
+};
+/**
+ * Folds long unchanged runs to `context` lines on each side (none at a hunk or file edge), unless
+ * the run is open (`open` holds its first index) or `whole` is set.
+ */
+export declare function foldBlocks(lines: readonly DiffLine[], context?: number, open?: ReadonlySet<number>, whole?: boolean): DiffBlock[];
+/** The +/− counts of a diff. */
+export declare function diffStat(lines: readonly DiffLine[]): {
+  add: number;
+  del: number;
+};
+/** A comment written on a diff line: `line` is the line number on `side`. */
+interface DiffComment {
+  path: string;
+  line: number;
+  side: "old" | "new";
+  text: string;
+  /** Index of the line in the diff's lines. */
+  index: number;
+  /** The line's own text, for quoting. */
+  quote: string;
+  /** A range's last line (Monaco's drag-select), when it spans more than `line`. */
+  to?: number;
+  /** Every line of the range, when it spans more than one. */
+  lines?: string[];
+}
+/** The number a line is known by: its new-side number, or the old one for a removed line. */
+export declare function lineNo(l: DiffLine): number | null;
+/** Moves `current` (a change's first line index, -1 for none) to the next / previous change, wrapping. */
+export declare function stepChange(starts: readonly number[], current: number, dir: 1 | -1): number;
+/**
+ * `<orr-diff [lines]="lines" file="src/a.ts" />` or `[text]="unifiedDiff"`: a unified diff (`.o-diff`).
+ * Two plain gutters (old, new numbers), the sign, and the text syntax-highlighted (`@getorrery/styles/syntax`,
+ * by `lang` or the file name) over the add / del grounds. Long unchanged runs fold (`context`), unless
+ * `whole` shows the whole file. Keys inside: n / j next change, p / k previous, Enter opens a fold.
+ * With `commentable`, a click on a line number opens a comment box under it; Add emits `comment`.
+ */
+export declare class OrrDiffComponent {
+  /** The lines; or give `text` (unified diff). */
+  readonly lines: import("@angular/core").InputSignal<readonly DiffLine[] | null>;
+  readonly text: import("@angular/core").InputSignal<string>;
+  /** The file's path (header, comments, language). Falls back to the `+++` path of `text`. */
+  readonly file: import("@angular/core").InputSignal<string>;
+  /** A language id or extension; falls back to the file name. */
+  readonly lang: import("@angular/core").InputSignal<string>;
+  /** Show every line: no folding. */
+  readonly whole: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly context: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** The file header row (`.o-diff__file`). */
+  readonly fileHead: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** No line-number gutters: sign and text only (a config fragment, e.g. Cloud's pending `config.toml` change). */
+  readonly nonum: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The current change: its first line's index, -1 for none. n / p move it. */
+  readonly current: import("@angular/core").ModelSignal<number>;
+  readonly commentable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Handle n / j / p / k itself. Off when a parent walks changes across files (the review dialog). */
+  readonly keys: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Line numbers (new side; old for removed lines) that already carry a comment. */
+  readonly notes: import("@angular/core").InputSignal<readonly number[]>;
+  readonly commentLabel: import("@angular/core").InputSignal<string>;
+  readonly addLabel: import("@angular/core").InputSignal<string>;
+  readonly placeholder: import("@angular/core").InputSignal<string>;
+  readonly emptyText: import("@angular/core").InputSignal<string>;
+  readonly comment: import("@angular/core").OutputEmitterRef<DiffComment>;
+  readonly lineSelect: import("@angular/core").OutputEmitterRef<{
+    index: number;
+    line: DiffLine;
+  }>;
+  protected readonly sign: Record<string, string>;
+  protected readonly sides: readonly ["old", "new"];
+  protected readonly lineNo: typeof lineNo;
+  protected readonly cid: string;
+  private readonly open;
+  readonly commentAt: import("@angular/core").WritableSignal<number | null>;
+  readonly draft: import("@angular/core").WritableSignal<string>;
+  private readonly host;
+  private readonly parsed;
+  /** Held while a new array carries the same lines: no re-fold, no re-highlight. */
+  readonly all: import("@angular/core").Signal<readonly DiffLine[]>;
+  readonly path: import("@angular/core").Signal<string>;
+  readonly language: import("@angular/core").Signal<import("@getorrery/styles/syntax").SyntaxLang | null>;
+  readonly stat: import("@angular/core").Signal<{
+    add: number;
+    del: number;
+  }>;
+  readonly starts: import("@angular/core").Signal<number[]>;
+  readonly blocks: import("@angular/core").Signal<DiffBlock[]>;
+  readonly toks: import("@angular/core").Signal<(SyntaxToken[] | null)[]>;
+  private readonly range;
+  constructor();
+  protected blockKey(b: DiffBlock): string;
+  protected num(l: DiffLine, side: "old" | "new"): number | "";
+  protected gutterSide(l: DiffLine): "old" | "new";
+  protected inCurrent(i: number): boolean;
+  protected noted(l: DiffLine): boolean;
+  openFold(start: number): void;
+  /** Moves to the next (1) or previous (-1) change, wrapping; returns the new current index. */
+  step(dir: 1 | -1): number;
+  openComment(i: number): void;
+  closeComment(): void;
+  addComment(i: number): void;
+  onKey(e: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrDiffComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrDiffComponent, "orr-diff", never, {
+    "lines": {
+      "alias": "lines";
+      "required": false;
+      "isSignal": true;
+    };
+    "text": {
+      "alias": "text";
+      "required": false;
+      "isSignal": true;
+    };
+    "file": {
+      "alias": "file";
+      "required": false;
+      "isSignal": true;
+    };
+    "lang": {
+      "alias": "lang";
+      "required": false;
+      "isSignal": true;
+    };
+    "whole": {
+      "alias": "whole";
+      "required": false;
+      "isSignal": true;
+    };
+    "context": {
+      "alias": "context";
+      "required": false;
+      "isSignal": true;
+    };
+    "fileHead": {
+      "alias": "fileHead";
+      "required": false;
+      "isSignal": true;
+    };
+    "nonum": {
+      "alias": "nonum";
+      "required": false;
+      "isSignal": true;
+    };
+    "current": {
+      "alias": "current";
+      "required": false;
+      "isSignal": true;
+    };
+    "commentable": {
+      "alias": "commentable";
+      "required": false;
+      "isSignal": true;
+    };
+    "keys": {
+      "alias": "keys";
+      "required": false;
+      "isSignal": true;
+    };
+    "notes": {
+      "alias": "notes";
+      "required": false;
+      "isSignal": true;
+    };
+    "commentLabel": {
+      "alias": "commentLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "addLabel": {
+      "alias": "addLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "placeholder": {
+      "alias": "placeholder";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "current": "currentChange";
+    "comment": "comment";
+    "lineSelect": "lineSelect";
+  }, never, never, true, never>;
+}
+/** `"3,5-7"` (or numbers) → the set of line numbers. */
+export declare function lineSet(spec: string | readonly number[]): Set<number>;
+/**
+ * `<orr-code [text]="src" lang="ts" highlight="3,5-7" />`: a read-only file (`.o-code`) with line
+ * numbers and syntax colours (`@getorrery/styles/syntax`); `flat` drops the well's frame.
+ */
+export declare class OrrCodeComponent {
+  readonly text: import("@angular/core").InputSignal<string>;
+  /** A language id, extension or file name. */
+  readonly lang: import("@angular/core").InputSignal<string>;
+  /** The first line's number. */
+  readonly start: import("@angular/core").InputSignalWithTransform<number, unknown>;
+  /** Lines to mark: `"3,5-7"` or numbers. */
+  readonly highlight: import("@angular/core").InputSignal<string | readonly number[]>;
+  readonly nonum: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly flat: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly language: import("@angular/core").Signal<import("@getorrery/styles/syntax").SyntaxLang | null>;
+  readonly marked: import("@angular/core").Signal<Set<number>>;
+  readonly rows: import("@angular/core").Signal<SyntaxToken[][]>;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrCodeComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrCodeComponent, "orr-code", never, {
+    "text": {
+      "alias": "text";
+      "required": false;
+      "isSignal": true;
+    };
+    "lang": {
+      "alias": "lang";
+      "required": false;
+      "isSignal": true;
+    };
+    "start": {
+      "alias": "start";
+      "required": false;
+      "isSignal": true;
+    };
+    "highlight": {
+      "alias": "highlight";
+      "required": false;
+      "isSignal": true;
+    };
+    "nonum": {
+      "alias": "nonum";
+      "required": false;
+      "isSignal": true;
+    };
+    "flat": {
+      "alias": "flat";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+/**
+ * Lazy loader for Monaco (B1.1 editor migration). Unlike the CodeMirror setup
+ * in `code-lang.ts` (esm.sh at runtime), Monaco is BUNDLED: `edcore.main.js`
+ * — the editor plus every editor contribution (find widget, folding, bracket
+ * matching, multi-cursor, diff editor) but NONE of the language services — is
+ * pulled in through a dynamic import, so it lands in its own lazy chunk that
+ * loads the first time an editor mounts. Highlighting is Monarch-only via the
+ * per-language `basic-languages` contributions, themselves lazy chunks.
+ */
+type MonacoApi = typeof monacoApi;
+/** Load (once) the Monaco editor core; retries are possible after a failure. */
+export declare function loadMonaco(): Promise<MonacoApi>;
+/** Resolve a CSS design token to a Monaco-safe #rrggbb(aa) hex, or undefined. */
+declare function tokenHex(styles: CSSStyleDeclaration, name: string): string | undefined;
+/**
+ * (Re)define + activate the app-matched Monaco theme. Monaco needs concrete
+ * hex values, so the app's CSS tokens are resolved from the `[data-theme]`
+ * root at call time — call again whenever `ui.tweaks().theme` changes (theme
+ * state is global in Monaco: one call restyles every live editor).
+ */
+export declare function applyMonacoTheme(monaco: MonacoApi, appTheme: "dark" | "light"): void;
+/**
+ * Diff-surface options that turn on Monaco's OWN diff overview ruler: a strip
+ * beside the vertical scrollbar carrying one mark per changed region (removed
+ * on the original lane, inserted on the modified lane), so a long file shows
+ * where its changes are at a glance and the strip can be clicked/dragged to
+ * scroll straight to one. Monaco owns the marks — nothing here hand-rolls a
+ * scrollbar overlay. Their colours are the two `diffEditorOverview.*` theme
+ * keys applyMonacoTheme() resolves from --code-add-ink / --code-del-ink, which
+ * is what keeps them correct in both the light and the dark theme.
+ *
+ * `overviewRulerBorder: false` drops the inner editors' own 1px ruler rule,
+ * which would otherwise draw a second vertical line right next to the strip.
+ */
+export declare function diffOverviewRulerOptions(): {
+  renderOverviewRuler: boolean;
+  overviewRulerBorder: boolean;
+};
+/**
+ * Scrollbar geometry that matches the app's own bars (styles.css
+ * `::-webkit-scrollbar`, 9px lane / 5px visible thumb). Monaco's defaults are
+ * 14px vertical and 12px horizontal with the slider filling the whole lane,
+ * which next to a native bar reads as a different widget entirely.
+ *
+ * The app fakes its 5px thumb with a 2px transparent border + background-clip;
+ * Monaco can't do that, but VerticalScrollbar centres the slider in the lane
+ * ((scrollbarSize - sliderSize) / 2), so a 9/5 pair lands in the same place.
+ * Slider size has to be given explicitly — it defaults to the scrollbar size,
+ * not to a padded fraction of it.
+ *
+ * `useShadows` kills the drop shadow Monaco casts over scrolled-away content,
+ * which the app has nowhere else and which dirties --panel. The slider colours
+ * come from the `scrollbarSlider.*` theme keys applyMonacoTheme() resolves.
+ */
+export declare function monacoScrollbarOptions(): {
+  scrollbar: {
+    verticalScrollbarSize: number;
+    horizontalScrollbarSize: number;
+    verticalSliderSize: number;
+    horizontalSliderSize: number;
+    useShadows: boolean;
+  };
+  overviewRulerBorder: boolean;
+};
+/**
+ * Resolve a `langId()` tag to a registered Monaco language id, loading its
+ * Monarch contribution on first use. Unknown tags (or a failed grammar chunk)
+ * resolve to "plaintext" — the file still renders, just untokenized.
+ */
+export declare function monacoLanguage(lang: string): Promise<string>;
+/** Canonical CodeMirror grammar tag for a path (""=no grammar / plain text). */
+export declare function langId(path: string): string;
+/** The Monaco language for a path, its grammar loaded: "plaintext" when there is none. */
+export declare function monacoLanguageFor(path: string): Promise<string>;
+/** The page's theme: light or dark by its code ground (`--well`), whatever the theme is called (graphite, paper, …). */
+declare function pageTheme(host: HTMLElement): "dark" | "light";
+/** Handed to `(ready)` each time an editor is built, for what only one app adds (symbol navigation, blame, saved scroll). */
+interface MonacoDiffReady {
+  monaco: MonacoApi;
+  /** The diff editor; `null` for a new file, which shows in a plain editor. */
+  diff: monacoApi.editor.IStandaloneDiffEditor | null;
+  /** The editor holding the new side (the diff's modified editor, or the plain one). */
+  editor: monacoApi.editor.IStandaloneCodeEditor;
+}
+/**
+ * `<orr-monaco-diff [before]="old" [after]="new" path="src/a.ts" />`: a changed file, the one way every
+ * Orrery app shows one (IDE mode, Agent mode, Cloud, the review dialog) — Monaco's diff, read-only,
+ * unchanged regions folded away, opened on its first change, coloured from the app's tokens. Inline by
+ * default with one column of line numbers; `sideBySide` puts the two sides next to each other. A new
+ * file (`before` empty) shows whole, every line marked added. New text for the same `path` refreshes in
+ * place (scroll kept); a new `path` opens on its first change. Monaco loads on first use; until then (or
+ * if it cannot) the new text shows plain.
+ */
+export declare class OrrMonacoDiffComponent {
+  readonly before: import("@angular/core").InputSignal<string>;
+  readonly after: import("@angular/core").InputSignal<string>;
+  /** The file: picks the grammar; a new path opens on its first change. */
+  readonly path: import("@angular/core").InputSignal<string>;
+  /** `null`: the page's. */
+  readonly theme: import("@angular/core").InputSignal<"dark" | "light" | null>;
+  /** The two sides next to each other (IDE mode's diff tab) instead of inline. */
+  readonly sideBySide: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** Line comments as in IDE mode: hover "+" in the margin, drag a range, write. */
+  readonly commentable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** New-side lines that already carry a comment (marked in the margin). */
+  readonly notes: import("@angular/core").InputSignal<readonly number[]>;
+  /** A new-side line to bring to the centre and mark (the review's current change); `null`: none. */
+  readonly reveal: import("@angular/core").InputSignal<number | null>;
+  /** The new side's model URI (an app's symbol navigation keys on it); `null`: Monaco's own. */
+  readonly modelUri: import("@angular/core").InputSignal<string | null>;
+  /** The host is still fetching the file: the spinner shows, centred, until the text comes. */
+  readonly loading: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** A comment written on the new side. */
+  readonly comment: import("@angular/core").OutputEmitterRef<DiffComment>;
+  readonly ready: import("@angular/core").OutputEmitterRef<MonacoDiffReady>;
+  private readonly view;
+  /** Monaco is loading or building the editor. */
+  private readonly building;
+  protected readonly busy: import("@angular/core").Signal<boolean>;
+  private monaco;
+  private diff;
+  /** A new file: no old side to diff against (Monaco draws an empty old side as a removed line 1). */
+  private added;
+  private addedMarks;
+  private marks;
+  private comments;
+  /** What the editor shows now: a refresh of the same file keeps its scroll. */
+  private shown;
+  private token;
+  constructor();
+  private editor;
+  private show;
+  /** New text for the file on show: written into the live models (value-guarded), scroll kept. */
+  private refresh;
+  private markAdded;
+  /** The current change (a bar beside it, centred when `scroll`) and the commented lines. */
+  private mark;
+  private attachComments;
+  /** Drops whichever editor is up (diff or added) with its models and comments. */
+  private reset;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrMonacoDiffComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrMonacoDiffComponent, "orr-monaco-diff", never, {
+    "before": {
+      "alias": "before";
+      "required": false;
+      "isSignal": true;
+    };
+    "after": {
+      "alias": "after";
+      "required": false;
+      "isSignal": true;
+    };
+    "path": {
+      "alias": "path";
+      "required": false;
+      "isSignal": true;
+    };
+    "theme": {
+      "alias": "theme";
+      "required": false;
+      "isSignal": true;
+    };
+    "sideBySide": {
+      "alias": "sideBySide";
+      "required": false;
+      "isSignal": true;
+    };
+    "commentable": {
+      "alias": "commentable";
+      "required": false;
+      "isSignal": true;
+    };
+    "notes": {
+      "alias": "notes";
+      "required": false;
+      "isSignal": true;
+    };
+    "reveal": {
+      "alias": "reveal";
+      "required": false;
+      "isSignal": true;
+    };
+    "modelUri": {
+      "alias": "modelUri";
+      "required": false;
+      "isSignal": true;
+    };
+    "loading": {
+      "alias": "loading";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "comment": "comment";
+    "ready": "ready";
+  }, never, never, true, never>;
+}
+/** The slice of a ReviewComment the editor needs to render. */
+interface ReviewCommentLite {
+  id: string;
+  fromLine: number;
+  toLine: number;
+  note: string;
+}
+interface CommentHost {
+  /** Persist a new comment on [fromLine, toLine] (1-based, new-side). */
+  save(fromLine: number, toLine: number, note: string): void;
+  /** Delete a saved comment. */
+  remove(id: string): void;
+}
+/** Drop comments that no longer fit the document; clamp partial overhangs. */
+export declare function clampComments(comments: ReviewCommentLite[], docLines: number): ReviewCommentLite[];
+/**
+ * Monaco port of the inline-review comment UX (review-comments.ext.ts): hover
+ * "+" in the glyph margin, drag range select, inline composer and saved-comment
+ * cards as view zones. Same host contract and the same `rc-*` class names, so
+ * the visual language carries over 1:1.
+ *
+ * Mapping from the CM extension:
+ *  - line tints (`rc-covered`/`rc-selected`) → whole-line decorations
+ *  - gutter markers (+ / anchor / dot)       → glyph-margin decoration classes
+ *    (Monaco's glyph margin takes class names, not DOM — the icons are CSS)
+ *  - card / composer block widgets           → view zones (measured after
+ *    mount, then re-laid-out, since zones need an explicit pixel height)
+ */
+interface MonacoReviewApi {
+  /** Push the current comment list (idempotent). */
+  setComments(comments: ReviewCommentLite[]): void;
+  /** Open the inline composer on a line range (drag-release target). */
+  openComposer(fromLine: number, toLine: number): void;
+  dispose(): void;
+}
+/** Saved-comment card — identical structure/classes to the CM widget. */
+declare function buildCard(c: ReviewCommentLite, onDelete: (id: string) => void): HTMLElement;
+/** Inline composer — identical structure/classes to the CM widget. */
+declare function buildComposer(from: number, to: number, cb: {
+  save(note: string): void;
+  cancel(): void;
+}): HTMLElement;
+export declare function attachReviewComments(monaco: MonacoApi, editor: monacoApi.editor.IStandaloneCodeEditor, host: CommentHost): MonacoReviewApi;
+/** A changed file with its diff: ideally every line of the file (`fileLines`), so a review can show it whole. */
+interface ReviewFile extends ChangedFile {
+  lines: readonly DiffLine[];
+  /** Both sides of the file, when the host read them: the changes view then shows IDE mode's Monaco diff. */
+  before?: string;
+  after?: string;
+  /** Its two sides are being fetched: the view shows the spinner, not the transcript's lines. */
+  reading?: boolean;
+}
+/**
+ * Two review lists with the same files and the same lines. The `equal` of a host's changes signal
+ * (and the panel's own): a session's stream or a worktree poll rebuilds the list with nothing
+ * changed, and an equal list must not re-render the tree or re-highlight the diff.
+ */
+export declare function sameReviewFiles(a: readonly ReviewFile[], b: readonly ReviewFile[]): boolean;
+/**
+ * Where a review stands: which file, which change in it. Next / previous change walks across files
+ * (past the last change of a file to the first of the next, wrapping); next / previous file wraps.
+ * Files are walked in the order the list shows them.
+ */
+export declare class ChangesReview {
+  readonly files: import("@angular/core").WritableSignal<readonly ReviewFile[]>;
+  readonly mode: import("@angular/core").WritableSignal<FileListMode>;
+  readonly fileIndex: import("@angular/core").WritableSignal<number>;
+  readonly changeIndex: import("@angular/core").WritableSignal<number>;
+  /** The files in list order. */
+  readonly ordered: import("@angular/core").Signal<ReviewFile[]>;
+  readonly current: import("@angular/core").Signal<ReviewFile | null>;
+  readonly starts: import("@angular/core").Signal<number[]>;
+  /** The current change's first line index in the current file, -1 when it has none. */
+  readonly currentLine: import("@angular/core").Signal<number>;
+  /** `file 2 of 5 · change 1 of 3`. */
+  readonly position: import("@angular/core").Signal<string>;
+  constructor(files?: readonly ReviewFile[], mode?: FileListMode, path?: string | null);
+  /** Opens `path` at its first change. */
+  select(path: string): void;
+  stepFile(dir: 1 | -1): void;
+  stepChange(dir: 1 | -1): void;
+}
+/** What the review dialog shows and where its comments go. */
+interface ChangesExpandContext {
+  review: ChangesReview;
+  /** `Review · stripe-retry`. */
+  title: string;
+  commentable: boolean;
+  /** The comment box label before `path:Lnn` (default `Comment on`). */
+  commentLabel?: string;
+  /** Commented line numbers per path: a snapshot, or a signal so a comment added in the dialog shows at once. */
+  notes: Readonly<Record<string, readonly number[]>> | Signal<Readonly<Record<string, readonly number[]>>>;
+  /** What the diff says for a file with no lines yet. */
+  emptyText?: (path: string) => string;
+  onComment: (c: DiffComment) => void;
+}
+/** The new-side line of the change starting at `i`: its first line there, else where a removal sat. */
+export declare function newSideLine(lines: readonly DiffLine[], i: number): number;
+/** True when a key event comes from a place the person types in. */
+export declare function isTyping(e: KeyboardEvent): boolean;
+/**
+ * The Expand dialog of `orr-changes-panel` (App-00): the file tree on the left, the whole file with
+ * its changes on the right, the current change marked. Keys (scoped to the dialog): N / J next change
+ * and P / K previous, across files; ] / [ next / previous file; Esc (kouji's overlay) closes.
+ * Opened by the panel through `KjDialogService`; `bind()` hands it the review.
+ */
+export declare class OrrChangesExpandComponent {
+  readonly ctx: import("@angular/core").WritableSignal<ChangesExpandContext | null>;
+  readonly file: Signal<import("@getorrery/ui").ReviewFile | null>;
+  readonly stat: Signal<{
+    add: number;
+    del: number;
+  }>;
+  /** The whole file as one hunk: `@@ -1,old +1,new @@`. */
+  readonly hunk: Signal<string>;
+  /** The current change as a new-side line, for Monaco. */
+  readonly revealLine: Signal<number | null>;
+  readonly ref: KjDialogRef<any, any> | null;
+  protected notesFor(c: ChangesExpandContext, path: string): readonly number[];
+  protected stateWord(s: string | undefined): string;
+  protected stateInk(s: string | undefined): string;
+  bind(ctx: ChangesExpandContext): void;
+  onKey(e: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrChangesExpandComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrChangesExpandComponent, "orr-changes-expand", never, {}, {}, never, never, true, never>;
+}
+/**
+ * The widths of the changes view beside a chat (plan 08 §6): `collapsed` (hidden; the app shows a
+ * counter), `column` (the changed-file tree), `expanded` (the tree and the selected file's diff).
+ */
+type ChangesState = "collapsed" | "column" | "expanded";
+/** collapsed → column → expanded → collapsed (Agent mode's C / ⌥C). */
+export declare function nextChangesState(s: ChangesState): ChangesState;
+/**
+ * `<orr-changes-panel [files]="files" [(state)]="state" [(selected)]="path" (comment)="…" />`: the
+ * changes column both ADE modes and Cloud reuse (App-00). `column` lists the changed files;
+ * `expanded` adds the selected file's diff beside them; Expand opens the review dialog (tree left,
+ * whole file right). Keys, scoped to the panel: E expand; in `expanded`, N / J and P / K walk the
+ * changes of the file and ] / [ the files; in the dialog N / P walk across files.
+ */
+export declare class OrrChangesPanelComponent {
+  readonly files: import("@angular/core").InputSignal<readonly ReviewFile[]>;
+  readonly state: import("@angular/core").ModelSignal<ChangesState>;
+  /** The file shown in `expanded` (and where the dialog opens). */
+  readonly selected: import("@angular/core").ModelSignal<string | null>;
+  readonly mode: import("@angular/core").ModelSignal<FileListMode>;
+  readonly heading: import("@angular/core").InputSignal<string>;
+  readonly treeHeading: import("@angular/core").InputSignal<string>;
+  /** The dialog's title, e.g. `Review · stripe-retry`. */
+  readonly reviewTitle: import("@angular/core").InputSignal<string>;
+  readonly commentable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** The host can open a file (an editor, a browser): the diff bar offers Open file (`openFile`). */
+  readonly openable: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  /** What the diff says for a file with no lines (e.g. changed by a command, so no diff reached the client). */
+  readonly emptyText: import("@angular/core").InputSignal<string>;
+  /** Per-file empty text (e.g. "Reading the diff…" while a host still loads it); falls back to `emptyText`. */
+  readonly emptyTextFor: import("@angular/core").InputSignal<((path: string) => string | null) | null>;
+  /** The comment box label before `path:Lnn`, e.g. `Comment for stripe-retry on`. */
+  readonly commentLabel: import("@angular/core").InputSignal<string>;
+  /** The key that cycles the panel in the host (e.g. `⌥C`), appended to the wide toggle's title. */
+  readonly cycleKey: import("@angular/core").InputSignal<string>;
+  /** Commented line numbers per path (shown as "in review"). */
+  readonly notes: import("@angular/core").InputSignal<Readonly<Record<string, readonly number[]>>>;
+  readonly comment: import("@angular/core").OutputEmitterRef<DiffComment>;
+  readonly openFile: import("@angular/core").OutputEmitterRef<string>;
+  /** The Expand dialog is open. */
+  readonly expandOpen: import("@angular/core").WritableSignal<boolean>;
+  readonly currentChange: import("@angular/core").WritableSignal<number>;
+  private readonly diff;
+  private readonly dialog;
+  private readonly host;
+  private readonly injector;
+  /** `files`, held while a new array carries the same files and lines: a host's poll or stream frame re-renders nothing. */
+  readonly list: import("@angular/core").Signal<readonly ReviewFile[]>;
+  /** File paths in list order. */
+  readonly order: import("@angular/core").Signal<string[]>;
+  /** The shown file: the selection, else the first in list order. */
+  readonly current: import("@angular/core").Signal<ReviewFile | null>;
+  readonly stat: import("@angular/core").Signal<{
+    add: number;
+    del: number;
+  }>;
+  readonly wideLabel: import("@angular/core").Signal<string>;
+  /** The review the Expand dialog walks while it is open: it follows `files` (diffs a host reads late land in it). */
+  private readonly review;
+  /** The files the Expand dialog shows, from the current one on (null while it is closed): a host reading diffs lazily reads these. */
+  readonly reviewing: import("@angular/core").Signal<string[] | null>;
+  constructor();
+  protected emptyFor(path: string): string;
+  protected notesFor(path: string): readonly number[];
+  toggleWide(): void;
+  collapse(): void;
+  /** collapsed → column → expanded → collapsed. */
+  cycle(): void;
+  /** A file picked in the list: show its diff beside the list. */
+  pick(path: string): void;
+  selectFile(path: string): void;
+  /** Next / previous file in list order, wrapping. */
+  stepFile(dir: 1 | -1): void;
+  /** Opens the review dialog on the shown file; closing it keeps the file it ended on. */
+  openExpand(): void;
+  onKey(e: KeyboardEvent): void;
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrChangesPanelComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrChangesPanelComponent, "orr-changes-panel", never, {
+    "files": {
+      "alias": "files";
+      "required": false;
+      "isSignal": true;
+    };
+    "state": {
+      "alias": "state";
+      "required": false;
+      "isSignal": true;
+    };
+    "selected": {
+      "alias": "selected";
+      "required": false;
+      "isSignal": true;
+    };
+    "mode": {
+      "alias": "mode";
+      "required": false;
+      "isSignal": true;
+    };
+    "heading": {
+      "alias": "heading";
+      "required": false;
+      "isSignal": true;
+    };
+    "treeHeading": {
+      "alias": "treeHeading";
+      "required": false;
+      "isSignal": true;
+    };
+    "reviewTitle": {
+      "alias": "reviewTitle";
+      "required": false;
+      "isSignal": true;
+    };
+    "commentable": {
+      "alias": "commentable";
+      "required": false;
+      "isSignal": true;
+    };
+    "openable": {
+      "alias": "openable";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyText": {
+      "alias": "emptyText";
+      "required": false;
+      "isSignal": true;
+    };
+    "emptyTextFor": {
+      "alias": "emptyTextFor";
+      "required": false;
+      "isSignal": true;
+    };
+    "commentLabel": {
+      "alias": "commentLabel";
+      "required": false;
+      "isSignal": true;
+    };
+    "cycleKey": {
+      "alias": "cycleKey";
+      "required": false;
+      "isSignal": true;
+    };
+    "notes": {
+      "alias": "notes";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {
+    "state": "stateChange";
+    "selected": "selectedChange";
+    "mode": "modeChange";
+    "comment": "comment";
+    "openFile": "openFile";
+  }, never, ["[orrPanelHead]"], true, never>;
+}
+type OrrLogoName = "monogram" | "eccentric" | "rings" | "parallel" | "stencil";
+type OrrLogoType = "default" | "pixel";
+/** Aliases work too: blocked, needs, executing, working, boot, queued, waiting-for-you, spinner. */
+type OrrLogoState = "static" | "idle" | "thinking" | "running" | "needs-you" | "waiting" | "done" | "error" | "offline" | "loading" | "loader" | (string & {});
+/**
+ * The mark every app draws unless an `<orr-logo>` says otherwise: switch it here, once, and every
+ * front end follows (the design's `OrrLogo.fallback` / `<html data-logo>`).
+ */
+export declare const ORRERY_LOGO: {
+  logo: OrrLogoName;
+  type: OrrLogoType;
+};
+interface LogoOptions {
+  logo?: string;
+  type?: string;
+  state?: string;
+  size?: number | "fill";
+  wordmark?: boolean;
+  plate?: boolean;
+  label?: string;
+  color?: string | null;
+  light?: boolean;
+  /** The extensions finish: painted with the level colours (or `color`) under the light-streak texture. Vector only. */
+  shader?: boolean;
+}
+/** The shadow-root markup of one `<orr-logo>`: the design's render, as a function. */
+export declare function logoMarkup(o: LogoOptions): string;
+/**
+ * `<orr-logo>`: the Orrery mark in every agent state, as vector or pixel art, the same generator as
+ * the design (`scripts/design/sync-logo.mjs`). `wordmark` writes "Orrery" with the mark as its O;
+ * `plate` is the app-icon form; `size="fill"` fills the parent; `shader` paints it with the extensions
+ * colour field. Which mark: `logo`, else ORRERY_LOGO.
+ */
+export declare class OrrLogoComponent {
+  readonly logo: import("@angular/core").InputSignal<OrrLogoName | undefined>;
+  readonly type: import("@angular/core").InputSignal<OrrLogoType | undefined>;
+  readonly state: import("@angular/core").InputSignal<OrrLogoState>;
+  /** px, or "fill"; a wordmark without a size takes the surrounding font size. */
+  readonly size: import("@angular/core").InputSignalWithTransform<number | "fill" | undefined, unknown>;
+  readonly wordmark: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly plate: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  readonly label: import("@angular/core").InputSignal<string>;
+  /** Tints the brand states instead of the gradient. */
+  readonly color: import("@angular/core").InputSignal<string | null>;
+  /** Paper surfaces; unset, the nearest `data-theme` ancestor decides ("paper" = light). */
+  readonly light: import("@angular/core").InputSignal<boolean | undefined>;
+  /** The extensions finish: every level's colour (or `color`) under the light-streak texture. Vector only. */
+  readonly shader: import("@angular/core").InputSignalWithTransform<boolean, unknown>;
+  constructor();
+  static ɵfac: i0.ɵɵFactoryDeclaration<OrrLogoComponent, never>;
+  static ɵcmp: i0.ɵɵComponentDeclaration<OrrLogoComponent, "orr-logo", never, {
+    "logo": {
+      "alias": "logo";
+      "required": false;
+      "isSignal": true;
+    };
+    "type": {
+      "alias": "type";
+      "required": false;
+      "isSignal": true;
+    };
+    "state": {
+      "alias": "state";
+      "required": false;
+      "isSignal": true;
+    };
+    "size": {
+      "alias": "size";
+      "required": false;
+      "isSignal": true;
+    };
+    "wordmark": {
+      "alias": "wordmark";
+      "required": false;
+      "isSignal": true;
+    };
+    "plate": {
+      "alias": "plate";
+      "required": false;
+      "isSignal": true;
+    };
+    "label": {
+      "alias": "label";
+      "required": false;
+      "isSignal": true;
+    };
+    "color": {
+      "alias": "color";
+      "required": false;
+      "isSignal": true;
+    };
+    "light": {
+      "alias": "light";
+      "required": false;
+      "isSignal": true;
+    };
+    "shader": {
+      "alias": "shader";
+      "required": false;
+      "isSignal": true;
+    };
+  }, {}, never, never, true, never>;
+}
+export declare const OrrLogo: {
+  LOGOS: string[];
+  STATES: string[];
+  fallback: string;
+  /** the logo in effect for an element: nearest data-logo up the tree (across shadow roots), else the fallback */
+  resolve(el: any): any;
+  light(el: any): boolean;
+  state(v: any): any;
+  /** markup for one mark: { css, defs, body } in a 200-unit box (memoised) */
+  draw(logo: any, state: any, type: any, light: any, color: any, shader: any): any;
+  word(logo: any, state: any, light: any, color: any): any;
+  /** switch the mark everywhere in this document */
+  use(logo: any): void;
+};
+export type { BadgeTone, ChangedFile, ChangesExpandContext, ChangesState, CommentHost, DialogCloseReason, DiffBlock, DiffComment, DiffLine, DiffLineKind, DotState, FileListMode, FileRow, IconSize, LogoOptions, MeterTone, MonacoApi, MonacoDiffReady, MonacoReviewApi, OrrLogoName, OrrLogoState, OrrLogoType, ReviewCommentLite, ReviewFile, SegOption, SelectGroup, SelectOption, SelectRun, TreeMove };