@stateforge-labs/herdr-sdk 0.0.0-stage → 0.3.0

package/dist/core/events.d.ts

@@ -0,0 +1,42 @@
+import { AsyncQueue } from './kernel.js';
+import { type Duration } from './kernel.js';
+import { HcKind } from './constants.js';
+import type { HcEvent, HcHeartbeat, HcMissed, HcParams, HcSnapshot, SocketPath } from './wire.js';
+export interface HcSnapshotFeed {
+    readonly kind: typeof HcKind.Snapshot;
+    readonly snapshot: HcSnapshot;
+}
+export type HcCoreFeed = HcSnapshotFeed | HcMissed | HcHeartbeat | HcEvent;
+export interface CoreEventsTiming {
+    readonly backoffBase: Duration;
+    readonly backoffCap: Duration;
+    readonly silence: Duration;
+}
+export interface CoreEventsParts {
+    readonly path: SocketPath;
+    readonly filter?: HcParams;
+    readonly timing?: CoreEventsTiming;
+}
+export declare class CoreEvents {
+    readonly feed: AsyncQueue<HcCoreFeed>;
+    private readonly path;
+    private readonly filter;
+    private readonly timing;
+    private socket;
+    private watchdog;
+    private readonly backoff;
+    private phase;
+    private life;
+    constructor(parts: CoreEventsParts);
+    start(): void;
+    close(): Promise<void>;
+    private connect;
+    private arm;
+    private receive;
+    private readonly acceptors;
+    private accept;
+    private forward;
+    private snapshotOf;
+    private lost;
+    private clearTimers;
+}

package/dist/core/events.js

@@ -0,0 +1,128 @@
+// Role: CoreEvents: events.subscribe as a feed (snapshot, events, heartbeat watchdog, missed means a fresh snapshot).
+// Informs HERDR-ADR-0020 (the herdr-core client); ported from the desktop work in herdr-plugins.
+import { createConnection } from 'node:net';
+import { byKind, isErr, isOk, must } from './kernel.js';
+import { AsyncQueue } from './kernel.js';
+import { duration } from './kernel.js';
+import { Backoff } from './backoff.js';
+import { FIRST_CALL_ID, HC_BACKOFF_BASE, HC_BACKOFF_CAP, HC_HEARTBEAT_EVERY, HC_HEARTBEAT_MISSES, HC_SUBSCRIBE_METHOD, EventsPhase, HcKind, Life, RetryPhase, SocketEvent, TimerHold } from './constants.js';
+import { HcCoreLines, encodeHcCoreRequest, parseHcCallId, parseHcCoreMessage, parseHcParams, parseHcSnapshot, parseWireChunk } from './wire.js';
+const SUBSCRIBE_ID = must(parseHcCallId(FIRST_CALL_ID));
+const NO_FILTER = must(parseHcParams({}));
+const DEFAULT_TIMING = {
+    backoffBase: HC_BACKOFF_BASE,
+    backoffCap: HC_BACKOFF_CAP,
+    silence: duration(HC_HEARTBEAT_EVERY * HC_HEARTBEAT_MISSES),
+};
+export class CoreEvents {
+    feed = new AsyncQueue();
+    path;
+    filter;
+    timing;
+    socket = null;
+    watchdog = null;
+    backoff;
+    phase = EventsPhase.Waiting;
+    life = Life.Open;
+    constructor(parts) {
+        this.path = parts.path;
+        this.filter = parts.filter ?? NO_FILTER;
+        this.timing = parts.timing ?? DEFAULT_TIMING;
+        this.backoff = new Backoff(this.timing, TimerHold.HoldsProcess);
+    }
+    start() {
+        if (this.socket === null && this.backoff.phase === RetryPhase.Idle && this.life === Life.Open) {
+            this.connect();
+        }
+    }
+    async close() {
+        this.life = Life.Closed;
+        this.clearTimers();
+        this.feed.end();
+        const socket = this.socket;
+        if (socket === null) {
+            return;
+        }
+        this.socket = null;
+        await new Promise((resolve) => { socket.once(SocketEvent.Close, () => { resolve(); }); socket.destroy(); });
+    }
+    connect() {
+        const socket = createConnection(this.path);
+        const lines = new HcCoreLines(() => { socket.destroy(); });
+        this.socket = socket;
+        this.phase = EventsPhase.Waiting;
+        socket.on(SocketEvent.Data, (chunk) => {
+            const bytes = parseWireChunk(chunk);
+            this.arm(socket);
+            if (isOk(bytes)) {
+                this.receive(lines.feed(bytes.value), socket);
+            }
+        });
+        socket.on(SocketEvent.Error, () => undefined);
+        socket.on(SocketEvent.Close, () => { this.lost(socket); });
+        socket.once(SocketEvent.Connect, () => {
+            this.arm(socket);
+            socket.write(encodeHcCoreRequest(SUBSCRIBE_ID, HC_SUBSCRIBE_METHOD, this.filter));
+        });
+    }
+    arm(socket) {
+        if (this.watchdog !== null) {
+            clearTimeout(this.watchdog);
+        }
+        this.watchdog = setTimeout(() => { socket.destroy(); }, this.timing.silence);
+        this.watchdog.unref();
+    }
+    receive(values, socket) {
+        for (const value of values) {
+            const parsed = parseHcCoreMessage(value);
+            if (isErr(parsed)) {
+                continue;
+            }
+            this.accept(parsed.value, socket);
+        }
+    }
+    acceptors = {
+        [HcKind.Fault]: (_message, socket) => { socket.destroy(); },
+        [HcKind.Odd]: (_message, socket) => { socket.destroy(); },
+        [HcKind.Reply]: (message, socket) => { this.snapshotOf(message.result, socket); },
+        [HcKind.Event]: (message) => { this.forward(message); },
+        [HcKind.Heartbeat]: (message) => { this.forward(message); },
+        [HcKind.Missed]: (message) => { this.forward(message); },
+    };
+    accept(message, socket) {
+        byKind(this.acceptors, message, socket);
+    }
+    forward(feed) {
+        if (this.phase === EventsPhase.Subscribed) {
+            this.feed.push(feed);
+        }
+    }
+    snapshotOf(result, socket) {
+        const snapshot = parseHcSnapshot(result);
+        if (isErr(snapshot) || this.phase === EventsPhase.Subscribed) {
+            socket.destroy();
+            return;
+        }
+        this.phase = EventsPhase.Subscribed;
+        this.backoff.survive();
+        this.feed.push({ kind: HcKind.Snapshot, snapshot: snapshot.value });
+    }
+    lost(socket) {
+        if (socket !== this.socket) {
+            return;
+        }
+        this.socket = null;
+        this.clearTimers();
+        if (this.life === Life.Closed) {
+            return;
+        }
+        this.backoff.schedule(() => { this.connect(); });
+    }
+    clearTimers() {
+        if (this.watchdog !== null) {
+            clearTimeout(this.watchdog);
+        }
+        this.watchdog = null;
+        this.backoff.stop();
+    }
+}

package/dist/core/kernel.d.ts

@@ -0,0 +1,65 @@
+import { ResultKind } from './constants.js';
+import type { ParseFailure } from './errors.js';
+declare const marker: unique symbol;
+export type Brand<Carrier, Name> = Carrier & {
+    readonly [marker]: Name;
+};
+export declare function brand<Carrier, Name>(carrier: Carrier): Brand<Carrier, Name>;
+export type Fields = Readonly<Record<string, unknown>>;
+export declare function isNumber(input: unknown): input is number;
+export declare function isString(input: unknown): input is string;
+export declare function isFields(input: unknown): input is Fields;
+export type Ok<T> = {
+    readonly kind: typeof ResultKind.Ok;
+    readonly value: T;
+};
+export type Err<E> = {
+    readonly kind: typeof ResultKind.Err;
+    readonly error: E;
+};
+export type Result<T, E> = Ok<T> | Err<E>;
+export declare const ok: <T>(value: T) => Result<T, never>;
+export declare const err: <E>(error: E) => Result<never, E>;
+export declare function isOk<T, E>(result: Result<T, E>): result is Ok<T>;
+export declare function isErr<T, E>(result: Result<T, E>): result is Err<E>;
+export type KindOf<U> = U extends {
+    readonly kind: infer K extends string;
+} ? K : never;
+export type KindMap<U extends {
+    readonly kind: string;
+}, R, C = undefined> = {
+    readonly [K in KindOf<U>]: (value: Extract<U, {
+        readonly kind: K;
+    }>, context: C) => R;
+};
+export declare function byKind<U extends {
+    readonly kind: string;
+}, R, C = undefined>(map: KindMap<U, R, C>, value: U, context: C): R;
+export declare function must<T, E>(result: Result<T, E>): T;
+export type Count = Brand<number, 'Count'>;
+export type PositiveCount = Brand<number, 'PositiveCount'>;
+export declare function parseCount(input: unknown): Result<Count, ParseFailure>;
+export declare function parsePositiveCount(input: unknown): Result<PositiveCount, ParseFailure>;
+export type Text = Brand<string, 'Text'>;
+export type NonEmptyText = Brand<string, 'NonEmptyText'>;
+export declare function parseText(input: unknown): Result<Text, ParseFailure>;
+export declare function parseNonEmptyText(input: unknown): Result<NonEmptyText, ParseFailure>;
+export type Instant = Brand<number, 'Instant'>;
+export type Duration = Brand<number, 'Duration'>;
+export declare function instant(ms: number): Instant;
+export declare function duration(ms: number): Duration;
+export declare function elapsed(from: Instant, to: Instant): Duration;
+export type Milliseconds = Brand<number, 'Milliseconds'>;
+export declare function parseMilliseconds(input: unknown): Result<Milliseconds, ParseFailure>;
+export declare function parseInstant(input: unknown): Result<Instant, ParseFailure>;
+export declare function parseDuration(input: unknown): Result<Duration, ParseFailure>;
+export declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private readonly items;
+    private readonly waiters;
+    private ended;
+    push(item: T): void;
+    end(): void;
+    private next;
+    [Symbol.asyncIterator](): AsyncIterator<T>;
+}
+export {};

package/dist/core/kernel.js

@@ -0,0 +1,138 @@
+// Role: the small value types of the core layer: brand, fields, Result (with isOk/isErr), byKind dispatch, Count, Text, time and an async queue.
+// Informs HERDR-ADR-0020; merged by HERDR-ADR-0021 from brand.ts, fields.ts, result.ts, count.ts, text.ts, time.ts, async-queue.ts.
+import { JsType, ParseFailureKind, ResultKind } from './constants.js';
+import { CoreInvariantError } from './errors.js';
+export function brand(carrier) {
+    return carrier;
+}
+export function isNumber(input) {
+    return typeof input === JsType.Number;
+}
+export function isString(input) {
+    return typeof input === JsType.String;
+}
+export function isFields(input) {
+    return typeof input === JsType.Object && input !== null;
+}
+export const ok = (value) => ({ kind: ResultKind.Ok, value });
+export const err = (error) => ({ kind: ResultKind.Err, error });
+export function isOk(result) {
+    return result.kind === ResultKind.Ok;
+}
+export function isErr(result) {
+    return result.kind === ResultKind.Err;
+}
+export function byKind(map, value, context) {
+    const handle = map[value.kind];
+    return handle(value, context);
+}
+export function must(result) {
+    if (isErr(result)) {
+        throw new CoreInvariantError(JSON.stringify(result.error));
+    }
+    return result.value;
+}
+export function parseCount(input) {
+    if (!isNumber(input)) {
+        return err({ kind: ParseFailureKind.NotANumber });
+    }
+    if (!Number.isInteger(input)) {
+        return err({ kind: ParseFailureKind.NotAnInteger });
+    }
+    if (input < 0 || !Number.isSafeInteger(input)) {
+        return err({ kind: ParseFailureKind.OutOfRange });
+    }
+    return ok(brand(input));
+}
+export function parsePositiveCount(input) {
+    const count = parseCount(input);
+    if (isErr(count)) {
+        return count;
+    }
+    if (count.value === 0) {
+        return err({ kind: ParseFailureKind.OutOfRange });
+    }
+    return ok(brand(count.value));
+}
+export function parseText(input) {
+    if (!isString(input)) {
+        return err({ kind: ParseFailureKind.NotAString });
+    }
+    return ok(brand(input));
+}
+export function parseNonEmptyText(input) {
+    const text = parseText(input);
+    if (isErr(text)) {
+        return text;
+    }
+    if (text.value.trim().length === 0) {
+        return err({ kind: ParseFailureKind.Empty });
+    }
+    return ok(brand(text.value));
+}
+export function instant(ms) {
+    return ms;
+}
+export function duration(ms) {
+    return ms;
+}
+export function elapsed(from, to) {
+    return duration(Math.max(0, to - from));
+}
+export function parseMilliseconds(input) {
+    if (!isNumber(input) || !Number.isFinite(input)) {
+        return err({ kind: ParseFailureKind.NotANumber });
+    }
+    if (input < 0) {
+        return err({ kind: ParseFailureKind.OutOfRange });
+    }
+    return ok(brand(input));
+}
+export function parseInstant(input) {
+    const ms = parseMilliseconds(input);
+    if (isErr(ms)) {
+        return ms;
+    }
+    return ok(brand(ms.value));
+}
+export function parseDuration(input) {
+    const ms = parseMilliseconds(input);
+    if (isErr(ms)) {
+        return ms;
+    }
+    return ok(brand(ms.value));
+}
+export class AsyncQueue {
+    items = [];
+    waiters = [];
+    ended = false;
+    push(item) {
+        if (this.ended) {
+            return;
+        }
+        const wake = this.waiters.shift();
+        if (wake === undefined) {
+            this.items.push(item);
+            return;
+        }
+        wake({ value: item, done: false });
+    }
+    end() {
+        this.ended = true;
+        for (const wake of this.waiters.splice(0)) {
+            wake({ value: undefined, done: true });
+        }
+    }
+    next() {
+        if (this.items.length > 0) {
+            return Promise.resolve({ value: this.items.shift(), done: false });
+        }
+        if (this.ended) {
+            return Promise.resolve({ value: undefined, done: true });
+        }
+        return new Promise((resolve) => { this.waiters.push(resolve); });
+    }
+    [Symbol.asyncIterator]() {
+        return { next: () => this.next() };
+    }
+}

package/dist/core/link.d.ts

@@ -0,0 +1,47 @@
+import type { Duration } from './kernel.js';
+import { type NonEmptyText } from './kernel.js';
+import { type Unknown } from './errors.js';
+import { OutcomeKind } from './constants.js';
+import type { HcCoreHello, HcParams, HcPayload, SocketPath } from './wire.js';
+export interface HcAnswered {
+    readonly kind: typeof OutcomeKind.Answer;
+    readonly value: HcPayload;
+}
+export type HcCallResult = HcAnswered | Unknown;
+export interface CoreLinkTiming {
+    readonly helloTimeout: Duration;
+    readonly backoffBase: Duration;
+    readonly backoffCap: Duration;
+}
+export interface CoreLinkParts {
+    readonly path: SocketPath;
+    readonly timing?: CoreLinkTiming;
+}
+export declare class CoreLink {
+    private readonly path;
+    private readonly timing;
+    private readonly pending;
+    private socket;
+    private state;
+    private connecting;
+    private readonly backoff;
+    private issued;
+    private info;
+    constructor(parts: CoreLinkParts);
+    get hello(): HcCoreHello | null;
+    open(): Promise<Unknown | null>;
+    call(method: NonEmptyText, params: HcParams, timeout: Duration): Promise<HcCallResult>;
+    private attempt;
+    close(): Promise<void>;
+    private readonly readiness;
+    private ready;
+    private connect;
+    private dial;
+    private handshake;
+    private takeHello;
+    private request;
+    private receive;
+    private lost;
+    private reconnect;
+    private settleAll;
+}

package/dist/core/link.js

@@ -0,0 +1,187 @@
+// Role: CoreLink: one persistent connection to the core socket with hello, per-call timeouts, reconnect with capped backoff.
+// Informs HERDR-ADR-0020 (the herdr-core client); ported from the desktop work in herdr-plugins.
+import { createConnection } from 'node:net';
+import { parseCount } from './kernel.js';
+import { byKind, isErr, isOk, must } from './kernel.js';
+import { parseText } from './kernel.js';
+import { isUnknown, unknown } from './errors.js';
+import { CoreText, HC_BACKOFF_BASE, HC_BACKOFF_CAP, HC_GENERATION, HC_HELLO_METHOD, HC_HELLO_TIMEOUT, HcKind, LinkState, OutcomeKind, SocketEvent, TimerHold, UnknownWhy, } from './constants.js';
+import { Backoff } from './backoff.js';
+import { HcCoreLines, encodeHcCoreRequest, parseHcCallId, parseHcCoreHello, parseHcCoreMessage, parseHcParams, parseWireChunk } from './wire.js';
+const ZERO = must(parseCount(0));
+const ONE = must(parseCount(1));
+const HELLO_PARAMS = must(parseHcParams({ generation: HC_GENERATION }));
+const DEFAULT_TIMING = { helloTimeout: HC_HELLO_TIMEOUT, backoffBase: HC_BACKOFF_BASE, backoffCap: HC_BACKOFF_CAP };
+const unreachable = (detail) => unknown({ why: UnknownWhy.Unreachable, detail });
+const timedOut = (after) => unknown({ why: UnknownWhy.Timeout, after });
+const none = () => null;
+const ANSWER_OF = {
+    [HcKind.Reply]: (message) => ({ kind: OutcomeKind.Answer, value: message.result }),
+    [HcKind.Odd]: () => unknown({ why: UnknownWhy.Unreadable, detail: CoreText.OddResult }),
+    [HcKind.Fault]: (message) => unknown({ why: UnknownWhy.Failed, code: message.code, detail: CoreText.Fault(message.reason, message.message) }),
+    [HcKind.Event]: none,
+    [HcKind.Heartbeat]: none,
+    [HcKind.Missed]: none,
+};
+const ID_OF = {
+    [HcKind.Reply]: (message) => message.id,
+    [HcKind.Odd]: (message) => message.id,
+    [HcKind.Fault]: (message) => message.id,
+    [HcKind.Event]: none,
+    [HcKind.Heartbeat]: none,
+    [HcKind.Missed]: none,
+};
+export class CoreLink {
+    path;
+    timing;
+    pending = new Map();
+    socket = null;
+    state = LinkState.Idle;
+    connecting = null;
+    backoff;
+    issued = ZERO;
+    info = null;
+    constructor(parts) {
+        this.path = parts.path;
+        this.timing = parts.timing ?? DEFAULT_TIMING;
+        this.backoff = new Backoff(this.timing, TimerHold.LetsProcessEnd);
+    }
+    get hello() {
+        return this.info;
+    }
+    open() {
+        return this.ready();
+    }
+    call(method, params, timeout) {
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => { resolve(timedOut(timeout)); }, timeout);
+            timer.unref();
+            void this.attempt(method, params, timeout).then((result) => {
+                clearTimeout(timer);
+                resolve(result);
+                return result;
+            });
+        });
+    }
+    async attempt(method, params, timeout) {
+        const down = await this.ready();
+        return down === null ? this.request(method, params, timeout) : down;
+    }
+    async close() {
+        this.state = LinkState.Closed;
+        this.backoff.stop();
+        this.settleAll(unreachable(CoreText.Closed));
+        const socket = this.socket;
+        if (socket === null) {
+            return;
+        }
+        this.socket = null;
+        await new Promise((resolve) => { socket.once(SocketEvent.Close, () => { resolve(); }); socket.destroy(); });
+    }
+    readiness = {
+        [LinkState.Ready]: () => Promise.resolve(null),
+        [LinkState.Connecting]: () => this.connecting ?? Promise.resolve(unreachable(CoreText.Connecting)),
+        [LinkState.Backoff]: () => Promise.resolve(unreachable(CoreText.Down)),
+        [LinkState.Closed]: () => Promise.resolve(unreachable(CoreText.Closed)),
+        [LinkState.Idle]: () => this.connect(),
+    };
+    ready() {
+        return this.readiness[this.state]();
+    }
+    connect() {
+        this.state = LinkState.Connecting;
+        const attempt = this.dial().finally(() => { this.connecting = null; });
+        this.connecting = attempt;
+        return attempt;
+    }
+    dial() {
+        return new Promise((resolve) => {
+            const socket = createConnection(this.path);
+            const lines = new HcCoreLines(() => { socket.destroy(); });
+            let reason = CoreText.Dropped;
+            this.socket = socket;
+            socket.on(SocketEvent.Data, (chunk) => {
+                const bytes = parseWireChunk(chunk);
+                if (isOk(bytes)) {
+                    this.receive(lines.feed(bytes.value));
+                }
+            });
+            socket.on(SocketEvent.Error, (cause) => { reason = must(parseText(cause.message)); });
+            socket.on(SocketEvent.Close, () => { this.lost(socket); resolve(unreachable(reason)); });
+            socket.once(SocketEvent.Connect, () => { void this.handshake(socket).then(resolve); });
+        });
+    }
+    async handshake(socket) {
+        const reply = await this.request(HC_HELLO_METHOD, HELLO_PARAMS, this.timing.helloTimeout);
+        const refusal = this.takeHello(reply);
+        if (refusal !== null) {
+            socket.destroy();
+            return refusal;
+        }
+        this.state = LinkState.Ready;
+        this.backoff.survive();
+        return null;
+    }
+    takeHello(reply) {
+        if (isUnknown(reply)) {
+            return reply;
+        }
+        const hello = parseHcCoreHello(reply.value);
+        if (isErr(hello)) {
+            return unknown({ why: UnknownWhy.Unreadable, detail: CoreText.HelloUnreadable });
+        }
+        if (hello.value.generation !== HC_GENERATION) {
+            return unknown({ why: UnknownWhy.Unreadable, detail: CoreText.Generation(hello.value.generation) });
+        }
+        this.info = hello.value;
+        return null;
+    }
+    request(method, params, timeout) {
+        const socket = this.socket;
+        if (socket === null || socket.destroyed) {
+            return Promise.resolve(unreachable(CoreText.NoConnection));
+        }
+        this.issued = must(parseCount(this.issued + ONE));
+        const id = must(parseHcCallId(this.issued));
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => { this.pending.delete(id); resolve(timedOut(timeout)); }, timeout);
+            timer.unref();
+            this.pending.set(id, (result) => { clearTimeout(timer); resolve(result); });
+            socket.write(encodeHcCoreRequest(id, method, params));
+        });
+    }
+    receive(values) {
+        for (const value of values) {
+            const parsed = parseHcCoreMessage(value);
+            const id = isOk(parsed) ? byKind(ID_OF, parsed.value, undefined) : null;
+            const answer = isOk(parsed) ? byKind(ANSWER_OF, parsed.value, undefined) : null;
+            const settle = id === null ? undefined : this.pending.get(id);
+            if (id !== null && settle !== undefined && answer !== null) {
+                this.pending.delete(id);
+                settle(answer);
+            }
+        }
+    }
+    lost(socket) {
+        if (socket !== this.socket) {
+            return;
+        }
+        this.socket = null;
+        this.settleAll(unreachable(CoreText.Dropped));
+        if (this.state === LinkState.Closed) {
+            return;
+        }
+        this.state = LinkState.Backoff;
+        this.backoff.schedule(() => { void this.reconnect(); });
+    }
+    reconnect() {
+        return this.state === LinkState.Backoff ? this.connect() : Promise.resolve(null);
+    }
+    settleAll(result) {
+        const settles = [...this.pending.values()];
+        this.pending.clear();
+        for (const settle of settles) {
+            settle(result);
+        }
+    }
+}

package/dist/core/test-kit/constants.d.ts

@@ -0,0 +1,51 @@
+export declare const FakeName: {
+    readonly DirPrefix: 'herdr-core-fake-';
+    readonly Socket: 'default.sock';
+};
+export declare const FakeFaultKind: {
+    readonly MethodNotFound: 'method_not_found';
+    readonly NotFound: 'not_found';
+};
+export declare const FakeRpcCode: {
+    readonly MethodNotFound: -32601;
+    readonly NotFound: -32000;
+};
+export declare const FrameName: {
+    readonly Hello: 'hello';
+    readonly Subscribed: 'subscribed';
+    readonly Created: 'event:created';
+    readonly eventOf: (type: string) => string;
+};
+export declare const FakeField: {
+    readonly Address: 'address';
+    readonly HiddenFinished: 'hidden_finished';
+    readonly Channel: 'channel';
+};
+export declare const FakeText: {
+    readonly NoFrame: (name: string) => string;
+    readonly NoMethod: (method: string) => string;
+    readonly NoTerminal: (address: unknown) => string;
+    readonly Screen: (terminal: unknown) => string;
+};
+export declare const FakeScreen: {
+    readonly How: 'screen';
+};
+export declare const SPLIT_AT = 7;
+export declare const SPLIT_DELAY = 15;
+export declare const DemoTerminal: {
+    readonly First: 't1';
+    readonly Second: 't2';
+    readonly Working: 'working';
+    readonly Idle: 'idle';
+    readonly Live: 'live';
+    readonly App: 'claude-code';
+    readonly Argv: readonly ['claude'];
+    readonly Cwd: '~/work/probe';
+    readonly Name: 'claude';
+    readonly Pid: 4242;
+    readonly Labels: {
+        readonly 'herdr.tab': 'tb1';
+        readonly 'herdr.space': 'sp1';
+        readonly where: 'S / 1';
+    };
+};