@textui/core 0.1.0

package/dist/core/animation.d.ts

@@ -0,0 +1,34 @@
+import type { AnimationDriver, TickerOptions, TweenOptions } from '../types/animation.js';
+import type { Disposable } from '../types/disposable.js';
+/**
+ * One driver for everything that moves.
+ *
+ * Spinners, progress, value transitions and appearing elements all run off the
+ * same clock, so `enabled = false` is a single flag that stops all of it, and
+ * a slow link can drop the frame rate for all of it at once. The clock can
+ * also be driven by hand, which is how the test harness advances time.
+ */
+export declare class Animation implements AnimationDriver {
+    enabled: boolean;
+    maxFps: number;
+    private tickers;
+    private timer;
+    private lastTime;
+    private manual;
+    constructor(options?: {
+        enabled?: boolean;
+        maxFps?: number;
+        manual?: boolean;
+    });
+    get disabled(): boolean;
+    ticker(options: TickerOptions): Disposable;
+    tween(options: TweenOptions): Disposable;
+    /** Advance by hand. The test harness and the static renderer use this. */
+    advance(ms: number): void;
+    private tick;
+    private ensureRunning;
+    private stopIfIdle;
+    dispose(): void;
+}
+export declare function createAnimation(options?: ConstructorParameters<typeof Animation>[0]): Animation;
+//# sourceMappingURL=animation.d.ts.map

package/dist/core/animation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"animation.d.ts","sourceRoot":"","sources":["../../src/core/animation.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAU,aAAa,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AAClG,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAsBzD;;;;;;;GAOG;AACH,qBAAa,SAAU,YAAW,eAAe;IAC/C,OAAO,UAAQ;IACf,MAAM,SAAM;IAEZ,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,KAAK,CAA+C;IAC5D,OAAO,CAAC,QAAQ,CAAK;IACrB,OAAO,CAAC,MAAM,CAAU;gBAEZ,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,MAAM,CAAC,EAAE,MAAM,CAAC;QAAC,MAAM,CAAC,EAAE,OAAO,CAAA;KAAO;IAMlF,IAAI,QAAQ,IAAI,OAAO,CAEtB;IAED,MAAM,CAAC,OAAO,EAAE,aAAa,GAAG,UAAU;IAe1C,KAAK,CAAC,OAAO,EAAE,YAAY,GAAG,UAAU;IA0BxC,0EAA0E;IAC1E,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,IAAI;IAIzB,OAAO,CAAC,IAAI;IAmBZ,OAAO,CAAC,aAAa;IAarB,OAAO,CAAC,UAAU;IAMlB,OAAO,IAAI,IAAI;CAKhB;AAED,wBAAgB,eAAe,CAAC,OAAO,CAAC,EAAE,qBAAqB,CAAC,OAAO,SAAS,CAAC,CAAC,CAAC,CAAC,GAAG,SAAS,CAE/F"}

package/dist/core/animation.js

@@ -0,0 +1,125 @@
+import { toDisposable } from '../util/disposable.js';
+const EASINGS = {
+    linear: (t) => t,
+    easeIn: (t) => t * t,
+    easeOut: (t) => t * (2 - t),
+    easeInOut: (t) => (t < 0.5 ? 2 * t * t : -1 + (4 - 2 * t) * t),
+};
+function easingFn(easing) {
+    if (typeof easing === 'function')
+        return easing;
+    return EASINGS[easing ?? 'easeOut'];
+}
+/**
+ * One driver for everything that moves.
+ *
+ * Spinners, progress, value transitions and appearing elements all run off the
+ * same clock, so `enabled = false` is a single flag that stops all of it, and
+ * a slow link can drop the frame rate for all of it at once. The clock can
+ * also be driven by hand, which is how the test harness advances time.
+ */
+export class Animation {
+    enabled = true;
+    maxFps = 30;
+    tickers = new Set();
+    timer = null;
+    lastTime = 0;
+    manual;
+    constructor(options = {}) {
+        this.enabled = options.enabled ?? true;
+        this.maxFps = options.maxFps ?? 30;
+        this.manual = options.manual ?? false;
+    }
+    get disabled() {
+        return !this.enabled;
+    }
+    ticker(options) {
+        const entry = {
+            fps: Math.min(options.fps ?? this.maxFps, this.maxFps),
+            onTick: options.onTick,
+            frame: 0,
+            accumulated: 0,
+        };
+        this.tickers.add(entry);
+        this.ensureRunning();
+        return toDisposable(() => {
+            this.tickers.delete(entry);
+            this.stopIfIdle();
+        });
+    }
+    tween(options) {
+        const { from, to, durationMs, onUpdate, onComplete } = options;
+        const ease = easingFn(options.easing);
+        if (!this.enabled || durationMs <= 0) {
+            onUpdate(to);
+            onComplete?.();
+            return toDisposable(() => { });
+        }
+        let elapsed = 0;
+        const ticker = this.ticker({
+            fps: this.maxFps,
+            onTick: (_frame, delta) => {
+                elapsed += delta;
+                const t = Math.min(1, elapsed / durationMs);
+                onUpdate(from + (to - from) * ease(t));
+                if (t >= 1) {
+                    ticker.dispose();
+                    onComplete?.();
+                }
+            },
+        });
+        return ticker;
+    }
+    /** Advance by hand. The test harness and the static renderer use this. */
+    advance(ms) {
+        this.tick(ms);
+    }
+    tick(delta) {
+        if (!this.enabled)
+            return;
+        for (const ticker of [...this.tickers]) {
+            const interval = 1000 / Math.max(1, ticker.fps);
+            ticker.accumulated += delta;
+            if (ticker.accumulated < interval)
+                continue;
+            const frames = Math.floor(ticker.accumulated / interval);
+            ticker.accumulated -= frames * interval;
+            ticker.frame += frames;
+            try {
+                ticker.onTick(ticker.frame, frames * interval);
+            }
+            catch {
+                // A failing ticker must not take the frame loop down with it.
+                this.tickers.delete(ticker);
+            }
+        }
+    }
+    ensureRunning() {
+        if (this.manual || this.timer || !this.enabled || this.tickers.size === 0)
+            return;
+        const interval = Math.max(1000 / this.maxFps, 16);
+        this.lastTime = Date.now();
+        this.timer = setInterval(() => {
+            const now = Date.now();
+            const delta = now - this.lastTime;
+            this.lastTime = now;
+            this.tick(delta);
+        }, interval);
+        this.timer.unref?.();
+    }
+    stopIfIdle() {
+        if (this.tickers.size > 0 || !this.timer)
+            return;
+        clearInterval(this.timer);
+        this.timer = null;
+    }
+    dispose() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = null;
+        this.tickers.clear();
+    }
+}
+export function createAnimation(options) {
+    return new Animation(options);
+}

package/dist/core/clipboard.d.ts

@@ -0,0 +1,29 @@
+import type { BindingPath } from '../types/graph.js';
+import type { ReactiveStore } from '../types/store.js';
+import type { TerminalAdapter } from '../types/terminal.js';
+/**
+ * The clipboard.
+ *
+ * A terminal can be *told* what to put on the system clipboard - OSC 52 - and
+ * cannot be asked what is on it. The read half of that sequence is a way for
+ * anything with a pty to read whatever you last copied, so terminals worth
+ * using refuse it, and the ones that answer are the ones you would not want
+ * to. So a copy goes two places: out to the system clipboard, where the rest
+ * of the desktop can reach it, and into the store, which is the half a paste
+ * can read back.
+ *
+ * That makes the store the clipboard as far as this application is concerned.
+ * It is in the session scope because a clipboard is not worth persisting and
+ * is worth surviving a screen change.
+ */
+export declare const CLIPBOARD_PATH: BindingPath;
+export declare function readClipboard(store: ReactiveStore): string;
+/**
+ * Put text on the clipboard.
+ *
+ * The terminal is optional because the store half is the half that has to
+ * work: a session with no OSC 52 - a plain console, a pipe, the test harness -
+ * still copies and pastes within the application.
+ */
+export declare function writeClipboard(store: ReactiveStore, text: string, terminal?: TerminalAdapter | null): void;
+//# sourceMappingURL=clipboard.d.ts.map

package/dist/core/clipboard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clipboard.d.ts","sourceRoot":"","sources":["../../src/core/clipboard.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AACrD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAE5D;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,cAAc,EAA4B,WAAW,CAAC;AAEnE,wBAAgB,aAAa,CAAC,KAAK,EAAE,aAAa,GAAG,MAAM,CAE1D;AAED;;;;;;GAMG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,aAAa,EACpB,IAAI,EAAE,MAAM,EACZ,QAAQ,CAAC,EAAE,eAAe,GAAG,IAAI,GAChC,IAAI,CAGN"}

package/dist/core/clipboard.js

@@ -0,0 +1,30 @@
+/**
+ * The clipboard.
+ *
+ * A terminal can be *told* what to put on the system clipboard - OSC 52 - and
+ * cannot be asked what is on it. The read half of that sequence is a way for
+ * anything with a pty to read whatever you last copied, so terminals worth
+ * using refuse it, and the ones that answer are the ones you would not want
+ * to. So a copy goes two places: out to the system clipboard, where the rest
+ * of the desktop can reach it, and into the store, which is the half a paste
+ * can read back.
+ *
+ * That makes the store the clipboard as far as this application is concerned.
+ * It is in the session scope because a clipboard is not worth persisting and
+ * is worth surviving a screen change.
+ */
+export const CLIPBOARD_PATH = '$/session/clipboard';
+export function readClipboard(store) {
+    return store.get(CLIPBOARD_PATH) ?? '';
+}
+/**
+ * Put text on the clipboard.
+ *
+ * The terminal is optional because the store half is the half that has to
+ * work: a session with no OSC 52 - a plain console, a pipe, the test harness -
+ * still copies and pastes within the application.
+ */
+export function writeClipboard(store, text, terminal) {
+    store.set(CLIPBOARD_PATH, text);
+    terminal?.writeClipboard?.(text);
+}

package/dist/core/commands.d.ts

@@ -0,0 +1,42 @@
+import type { CommandContext, CommandDefinition, CommandRegistry, CommandScope } from '../types/command.js';
+import type { Disposable } from '../types/disposable.js';
+import type { ReactiveStore } from '../types/store.js';
+import type { WhenEngine } from '../types/when.js';
+import type { TextUIApp } from '../types/app.js';
+/**
+ * Commands are the only way an action should be spelled.
+ *
+ * A button that calls an API directly and a palette entry that calls the same
+ * API are two implementations that will drift; a button that runs a registered
+ * command cannot drift from the command. That is also why resolution walks
+ * from the most specific scope outward - `table.search` means whichever table
+ * is focused, without every table inventing its own id.
+ */
+export declare class Commands implements CommandRegistry {
+    private deps;
+    private byId;
+    /** Scope instance ids that are currently active, innermost first. */
+    private activeScopes;
+    constructor(deps: {
+        store: ReactiveStore;
+        when: WhenEngine;
+        app(): TextUIApp | null;
+        onError(err: unknown, context: string): void;
+    });
+    setActiveScopes(ids: string[]): void;
+    register(def: CommandDefinition): Disposable;
+    unregister(id: string, scopeId?: string): void;
+    get(id: string): CommandDefinition | undefined;
+    list(options?: {
+        scope?: CommandScope;
+        slot?: string;
+        enabledOnly?: boolean;
+    }): CommandDefinition[];
+    /** Innermost active scope wins; an app-scoped registration is the floor. */
+    resolve(id: string): CommandDefinition | undefined;
+    enabled(id: string): boolean;
+    isChecked(id: string): boolean | undefined;
+    execute(id: string, args?: Record<string, unknown>, source?: CommandContext['source']): Promise<unknown>;
+}
+export declare function createCommands(deps: ConstructorParameters<typeof Commands>[0]): Commands;
+//# sourceMappingURL=commands.d.ts.map

package/dist/core/commands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commands.d.ts","sourceRoot":"","sources":["../../src/core/commands.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,cAAc,EAAE,iBAAiB,EAAE,eAAe,EAAE,YAAY,EACjE,MAAM,qBAAqB,CAAC;AAC7B,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,mBAAmB,CAAC;AACvD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAKjD;;;;;;;;GAQG;AACH,qBAAa,QAAS,YAAW,eAAe;IAM5C,OAAO,CAAC,IAAI;IALd,OAAO,CAAC,IAAI,CAA0C;IACtD,qEAAqE;IACrE,OAAO,CAAC,YAAY,CAAgB;gBAG1B,IAAI,EAAE;QACZ,KAAK,EAAE,aAAa,CAAC;QACrB,IAAI,EAAE,UAAU,CAAC;QACjB,GAAG,IAAI,SAAS,GAAG,IAAI,CAAC;QACxB,OAAO,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;KAC9C;IAGH,eAAe,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI;IAIpC,QAAQ,CAAC,GAAG,EAAE,iBAAiB,GAAG,UAAU;IAc5C,UAAU,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI;IAU9C,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAI9C,IAAI,CAAC,OAAO,GAAE;QAAE,KAAK,CAAC,EAAE,YAAY,CAAC;QAAC,IAAI,CAAC,EAAE,MAAM,CAAC;QAAC,WAAW,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,iBAAiB,EAAE;IAavG,4EAA4E;IAC5E,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,iBAAiB,GAAG,SAAS;IAkBlD,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI5B,SAAS,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO,GAAG,SAAS;IAKpC,OAAO,CACX,EAAE,EAAE,MAAM,EACV,IAAI,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,EAClC,MAAM,GAAE,cAAc,CAAC,QAAQ,CAAS,GACvC,OAAO,CAAC,OAAO,CAAC;CAqDpB;AAED,wBAAgB,cAAc,CAAC,IAAI,EAAE,qBAAqB,CAAC,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,QAAQ,CAExF"}

package/dist/core/commands.js

@@ -0,0 +1,146 @@
+import { toDisposable } from '../util/disposable.js';
+const SCOPE_ORDER = ['component', 'region', 'screen', 'app'];
+/**
+ * Commands are the only way an action should be spelled.
+ *
+ * A button that calls an API directly and a palette entry that calls the same
+ * API are two implementations that will drift; a button that runs a registered
+ * command cannot drift from the command. That is also why resolution walks
+ * from the most specific scope outward - `table.search` means whichever table
+ * is focused, without every table inventing its own id.
+ */
+export class Commands {
+    deps;
+    byId = new Map();
+    /** Scope instance ids that are currently active, innermost first. */
+    activeScopes = [];
+    constructor(deps) {
+        this.deps = deps;
+    }
+    setActiveScopes(ids) {
+        this.activeScopes = ids;
+    }
+    register(def) {
+        const list = this.byId.get(def.id) ?? [];
+        list.push(def);
+        this.byId.set(def.id, list);
+        return toDisposable(() => {
+            const current = this.byId.get(def.id);
+            if (!current)
+                return;
+            const next = current.filter((d) => d !== def);
+            if (next.length === 0)
+                this.byId.delete(def.id);
+            else
+                this.byId.set(def.id, next);
+        });
+    }
+    unregister(id, scopeId) {
+        if (scopeId === undefined) {
+            this.byId.delete(id);
+            return;
+        }
+        const next = (this.byId.get(id) ?? []).filter((d) => d.scopeId !== scopeId);
+        if (next.length === 0)
+            this.byId.delete(id);
+        else
+            this.byId.set(id, next);
+    }
+    get(id) {
+        return this.resolve(id);
+    }
+    list(options = {}) {
+        const out = [];
+        for (const defs of this.byId.values()) {
+            for (const def of defs) {
+                if (options.scope && (def.scope ?? 'app') !== options.scope)
+                    continue;
+                if (options.slot && !(def.slots ?? []).includes(options.slot))
+                    continue;
+                if (options.enabledOnly && !this.deps.when.evaluate(def.when))
+                    continue;
+                out.push(def);
+            }
+        }
+        return out;
+    }
+    /** Innermost active scope wins; an app-scoped registration is the floor. */
+    resolve(id) {
+        const candidates = (this.byId.get(id) ?? []).filter((def) => this.deps.when.evaluate(def.when));
+        if (candidates.length === 0)
+            return undefined;
+        if (candidates.length === 1)
+            return candidates[0];
+        for (const scopeId of this.activeScopes) {
+            const match = candidates.find((d) => d.scopeId === scopeId);
+            if (match)
+                return match;
+        }
+        for (const scope of SCOPE_ORDER) {
+            const match = candidates.find((d) => (d.scope ?? 'app') === scope && !d.scopeId);
+            if (match)
+                return match;
+        }
+        return candidates[candidates.length - 1];
+    }
+    enabled(id) {
+        return this.resolve(id) !== undefined;
+    }
+    isChecked(id) {
+        const clause = this.resolve(id)?.checked;
+        return clause === undefined ? undefined : this.deps.when.evaluate(clause);
+    }
+    async execute(id, args = {}, source = 'api') {
+        const def = this.resolve(id);
+        if (!def) {
+            // Registered but gated is not the same as absent, and it used to be
+            // reported as absent: `alt+left` with nothing open said "no command
+            // registered as go.previousTab" about a command registered forty lines
+            // away, whose `when` simply did not pass.
+            //
+            // A `when` that does not pass is the command saying "not now", which is
+            // what it is for - so this does nothing, and the key does nothing. A
+            // typo still throws, because a keybinding pointing at a name that was
+            // never registered has to be findable.
+            if ((this.byId.get(id) ?? []).length > 0)
+                return undefined;
+            throw new Error(`[textui] no command registered as "${id}"`);
+        }
+        const missing = (def.args ?? [])
+            .filter((a) => a.required && args[a.name] === undefined && a.default === undefined)
+            .map((a) => a.name);
+        if (missing.length > 0) {
+            throw new Error(`[textui] command "${id}" needs: ${missing.join(', ')}`);
+        }
+        const filled = { ...args };
+        for (const spec of def.args ?? []) {
+            if (filled[spec.name] === undefined && spec.default !== undefined) {
+                filled[spec.name] = spec.default;
+            }
+        }
+        const app = this.deps.app();
+        const ctx = {
+            app: app,
+            store: this.deps.store,
+            scopeId: def.scopeId ?? null,
+            source,
+        };
+        // Announced, not just run. Which command fired and what asked for it is
+        // the first question anyone debugging a keybinding, a menu or a palette
+        // has, and reconstructing it from its effects is guesswork.
+        app?.events.emit('@/command/run', { id, source, args: filled });
+        try {
+            const result = await def.run(filled, ctx);
+            app?.events.emit('@/command/done', { id, source });
+            return result;
+        }
+        catch (err) {
+            app?.events.emit('@/command/error', { id, source, message: String(err) });
+            this.deps.onError(err, `command "${id}"`);
+            throw err;
+        }
+    }
+}
+export function createCommands(deps) {
+    return new Commands(deps);
+}

package/dist/core/components.d.ts

@@ -0,0 +1,27 @@
+import type { ComponentCategory, ComponentDefinition, ComponentRegistry } from '../types/component-registry.js';
+import type { Disposable } from '../types/disposable.js';
+/**
+ * Late binding is the mechanism the whole design rests on: a graph names a
+ * component, and the name is resolved at mount time. A name that was never
+ * registered is a runtime miss rather than a compile error - that is the price
+ * of a screen being data, and it is why the miss renders visibly.
+ */
+export declare class Components implements ComponentRegistry {
+    private defs;
+    private resolving;
+    register(def: ComponentDefinition): Disposable;
+    registerMany(defs: ComponentDefinition[]): Disposable;
+    unregister(component: string): void;
+    get(component: string): ComponentDefinition | undefined;
+    has(component: string): boolean;
+    list(category?: ComponentCategory): ComponentDefinition[];
+    resolve(component: string): Promise<ComponentDefinition>;
+    pending(): string[];
+    /**
+     * Which components can display a resource of this kind. The selector is not
+     * evaluated here - a caller with a store re-filters through `when`.
+     */
+    findOpeners(resourceKind: string): ComponentDefinition[];
+}
+export declare function createComponents(): Components;
+//# sourceMappingURL=components.d.ts.map

package/dist/core/components.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"components.d.ts","sourceRoot":"","sources":["../../src/core/components.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAAE,mBAAmB,EAAE,iBAAiB,EAC1D,MAAM,gCAAgC,CAAC;AACxC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAGzD;;;;;GAKG;AACH,qBAAa,UAAW,YAAW,iBAAiB;IAClD,OAAO,CAAC,IAAI,CAA0C;IACtD,OAAO,CAAC,SAAS,CAAmD;IAEpE,QAAQ,CAAC,GAAG,EAAE,mBAAmB,GAAG,UAAU;IAO9C,YAAY,CAAC,IAAI,EAAE,mBAAmB,EAAE,GAAG,UAAU;IAMrD,UAAU,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAKnC,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS;IAIvD,GAAG,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO;IAI/B,IAAI,CAAC,QAAQ,CAAC,EAAE,iBAAiB,GAAG,mBAAmB,EAAE;IAKnD,OAAO,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,mBAAmB,CAAC;IAwB9D,OAAO,IAAI,MAAM,EAAE;IAMnB;;;OAGG;IACH,WAAW,CAAC,YAAY,EAAE,MAAM,GAAG,mBAAmB,EAAE;CAKzD;AAED,wBAAgB,gBAAgB,IAAI,UAAU,CAE7C"}

package/dist/core/components.js

@@ -0,0 +1,78 @@
+import { toDisposable, createBag } from '../util/disposable.js';
+/**
+ * Late binding is the mechanism the whole design rests on: a graph names a
+ * component, and the name is resolved at mount time. A name that was never
+ * registered is a runtime miss rather than a compile error - that is the price
+ * of a screen being data, and it is why the miss renders visibly.
+ */
+export class Components {
+    defs = new Map();
+    resolving = new Map();
+    register(def) {
+        this.defs.set(def.component, def);
+        return toDisposable(() => {
+            if (this.defs.get(def.component) === def)
+                this.defs.delete(def.component);
+        });
+    }
+    registerMany(defs) {
+        const bag = createBag();
+        for (const def of defs)
+            bag.add(this.register(def));
+        return bag;
+    }
+    unregister(component) {
+        this.defs.delete(component);
+        this.resolving.delete(component);
+    }
+    get(component) {
+        return this.defs.get(component);
+    }
+    has(component) {
+        return this.defs.has(component);
+    }
+    list(category) {
+        const all = [...this.defs.values()];
+        return category ? all.filter((d) => d.category === category) : all;
+    }
+    async resolve(component) {
+        const def = this.defs.get(component);
+        if (!def)
+            throw new Error(`[textui] no component registered as "${component}"`);
+        if (def.renderer.kind !== 'lazy')
+            return def;
+        const inFlight = this.resolving.get(component);
+        if (inFlight)
+            return inFlight;
+        const load = def.renderer.load;
+        const promise = Promise.resolve(load()).then((mod) => {
+            const render = typeof mod === 'function' ? mod : mod.default;
+            const resolved = {
+                ...def,
+                renderer: { kind: 'function', render },
+            };
+            this.defs.set(component, resolved);
+            this.resolving.delete(component);
+            return resolved;
+        });
+        this.resolving.set(component, promise);
+        return promise;
+    }
+    pending() {
+        return [...this.defs.values()]
+            .filter((d) => d.renderer.kind === 'lazy')
+            .map((d) => d.component);
+    }
+    /**
+     * Which components can display a resource of this kind. The selector is not
+     * evaluated here - a caller with a store re-filters through `when`.
+     */
+    findOpeners(resourceKind) {
+        return [...this.defs.values()]
+            .filter((d) => d.opens?.resourceKinds?.some((k) => k === resourceKind || resourceKind.startsWith(k + '.')))
+            .sort((a, b) => (b.opens?.priority ?? 0) - (a.opens?.priority ?? 0));
+    }
+}
+export function createComponents() {
+    return new Components();
+}

package/dist/core/events.d.ts

@@ -0,0 +1,23 @@
+import type { EventBus } from '../types/store.js';
+import type { EventPath } from '../types/graph.js';
+import type { Disposable } from '../types/disposable.js';
+/**
+ * Transient events, addressed like store paths on purpose - `@/dialog/confirm`
+ * reads the same way `$/dialog/open` does - but with no value to read back.
+ * That difference is the whole reason they are two mechanisms.
+ */
+export declare class Events implements EventBus {
+    private listeners;
+    private disposed;
+    onError: (err: unknown, context: string) => void;
+    emit(path: EventPath, payload?: unknown): void;
+    private matches;
+    on(path: EventPath, fn: (payload: unknown, path: EventPath) => void, options?: {
+        subtree?: boolean;
+        once?: boolean;
+    }): Disposable;
+    next(path: EventPath, timeoutMs?: number): Promise<unknown>;
+    dispose(): void;
+}
+export declare function createEvents(): Events;
+//# sourceMappingURL=events.d.ts.map

package/dist/core/events.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/core/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAClD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAC;AACnD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AAiBzD;;;;GAIG;AACH,qBAAa,MAAO,YAAW,QAAQ;IACrC,OAAO,CAAC,SAAS,CAAuB;IACxC,OAAO,CAAC,QAAQ,CAAS;IAEzB,OAAO,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,CAE9C;IAEF,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,IAAI;IAc9C,OAAO,CAAC,OAAO;IAMf,EAAE,CACA,IAAI,EAAE,SAAS,EACf,EAAE,EAAE,CAAC,OAAO,EAAE,OAAO,EAAE,IAAI,EAAE,SAAS,KAAK,IAAI,EAC/C,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,CAAA;KAAO,GAClD,UAAU;IAab,IAAI,CAAC,IAAI,EAAE,SAAS,EAAE,SAAS,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAiB3D,OAAO,IAAI,IAAI;CAIhB;AAED,wBAAgB,YAAY,IAAI,MAAM,CAErC"}

package/dist/core/events.js

@@ -0,0 +1,77 @@
+import { toDisposable } from '../util/disposable.js';
+import { isDescendantKey, matchKey } from '../util/paths.js';
+function eventKey(path) {
+    const body = path.startsWith('@/') ? path.slice(2) : path.replace(/^\//, '');
+    return body.split('/').filter((s) => s !== '').join('/');
+}
+/**
+ * Transient events, addressed like store paths on purpose - `@/dialog/confirm`
+ * reads the same way `$/dialog/open` does - but with no value to read back.
+ * That difference is the whole reason they are two mechanisms.
+ */
+export class Events {
+    listeners = new Set();
+    disposed = false;
+    onError = (err, context) => {
+        console.error(`[textui/events] ${context}`, err);
+    };
+    emit(path, payload) {
+        if (this.disposed)
+            return;
+        const key = eventKey(path);
+        for (const listener of [...this.listeners]) {
+            if (!this.matches(listener, key))
+                continue;
+            if (listener.once)
+                this.listeners.delete(listener);
+            try {
+                listener.fn(payload, path);
+            }
+            catch (err) {
+                this.onError(err, `listener of @/${listener.key}`);
+            }
+        }
+    }
+    matches(listener, key) {
+        if (listener.wildcard)
+            return matchKey(key, listener.key, listener.subtree);
+        if (listener.key === key)
+            return true;
+        return listener.subtree && isDescendantKey(key, listener.key);
+    }
+    on(path, fn, options = {}) {
+        const key = eventKey(path);
+        const listener = {
+            key,
+            subtree: options.subtree ?? false,
+            wildcard: key.includes('*'),
+            once: options.once ?? false,
+            fn,
+        };
+        this.listeners.add(listener);
+        return toDisposable(() => this.listeners.delete(listener));
+    }
+    next(path, timeoutMs) {
+        return new Promise((resolve, reject) => {
+            const sub = this.on(path, (payload) => {
+                if (timer)
+                    clearTimeout(timer);
+                resolve(payload);
+            }, { once: true });
+            const timer = timeoutMs
+                ? setTimeout(() => {
+                    sub.dispose();
+                    reject(new Error(`timed out waiting for ${path}`));
+                }, timeoutMs)
+                : null;
+            timer?.unref?.();
+        });
+    }
+    dispose() {
+        this.disposed = true;
+        this.listeners.clear();
+    }
+}
+export function createEvents() {
+    return new Events();
+}