@vibesdotdev/pm 0.0.0-stage → 1.0.0-rc.2

package/dist/tui/pm-state-keys.d.ts

@@ -0,0 +1,316 @@
+export declare const pmProcessesStateKey: import("@vibesdotdev/tui").TuiStateKey<{
+    processes: {
+        id: string;
+        status: "pass" | "stopping" | "stopped" | "running" | "crashed" | "starting" | "completed" | "waiting" | "fail";
+        restartCount: number;
+        consecutiveCrashRestarts: number;
+        retryCount: number;
+        healthStatus: "unknown" | "healthy" | "unhealthy" | "no-check";
+        signal?: string | undefined;
+        exitCode?: number | undefined;
+        pid?: number | undefined;
+        startedAt?: Date | undefined;
+        lastError?: string | undefined;
+        idleTimeoutMs?: number | undefined;
+        stoppedAt?: Date | undefined;
+        socketPath?: string | undefined;
+        lastActivity?: Date | undefined;
+        staleSocket?: boolean | undefined;
+        killedByDaemon?: boolean | undefined;
+        ephemeral?: boolean | undefined;
+        firstObservedAt?: Date | undefined;
+        commandSignature?: string | undefined;
+        adopted?: boolean | undefined;
+        config?: {
+            id: string;
+            name: string;
+            command: string;
+            ipc: boolean;
+            autoRestart: boolean;
+            restartDelay: number;
+            maxRestarts: number;
+            restartSettleMs: number;
+            task: boolean;
+            dangerouslyDisableRunawayChecks: boolean;
+            runOnce: boolean;
+            retryOnFailure: boolean;
+            maxRetries: number;
+            scope: "local" | "global" | "project";
+            description?: string | undefined;
+            args?: string[] | undefined;
+            selfSpawn?: boolean | undefined;
+            portForward?: {
+                service: string;
+                localPort: number;
+                remotePort: number;
+                namespace?: string | undefined;
+                context?: string | undefined;
+                additionalFlags?: string[] | undefined;
+                labelSelector?: string | undefined;
+            } | undefined;
+            launchPreparation?: {
+                [x: string]: unknown;
+                adapter: string;
+                config: Record<string, unknown>;
+            } | undefined;
+            workerRuntimeTarget?: "consumer" | "cloud" | undefined;
+            cwd?: string | undefined;
+            env?: Record<string, string> | undefined;
+            inheritEnv?: string[] | undefined;
+            credentials?: Record<string, {
+                source: "secret";
+                key: string;
+                store?: string | undefined;
+                operation?: object | undefined;
+            }> | undefined;
+            socket?: string | undefined;
+            preBuild?: {
+                command: string;
+                ignoreFailure: boolean;
+                timeout: number;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                env?: Record<string, string> | undefined;
+                inheritEnv?: string[] | undefined;
+            } | undefined;
+            build?: {
+                command: string;
+                ignoreFailure: boolean;
+                timeout: number;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                env?: Record<string, string> | undefined;
+                inheritEnv?: string[] | undefined;
+            } | undefined;
+            watch?: {
+                patterns: string[];
+                debounceMs: number;
+                minIntervalMs: number;
+                quietPeriodMs: number;
+                ignore?: string[] | undefined;
+            } | undefined;
+            codeUpdatePolicy?: "runtime" | "restart" | undefined;
+            idleTimeoutMs?: number | undefined;
+            healthCheck?: {
+                type: "custom" | "tcp" | "http" | "socket";
+                interval: number;
+                timeout: number;
+                retries: number;
+                warmupMs: number;
+                gracePeriodMultiplier: number;
+                failureAction?: "report" | "restart" | undefined;
+                endpoint?: string | undefined;
+                portOwnership?: "external" | "managed" | undefined;
+                warmupEndpoints?: string[] | undefined;
+                port?: number | undefined;
+                host?: string | undefined;
+            } | undefined;
+            orphanPorts?: number[] | undefined;
+            tags?: string[] | undefined;
+            dependencies?: string[] | undefined;
+            requiresPass?: string[] | undefined;
+            metadata?: Record<string, string> | undefined;
+            presets?: string[] | undefined;
+            livenessProfiles?: string[] | undefined;
+            livenessConfig?: Record<string, unknown> | undefined;
+            launchProvenance?: {
+                declaration: {
+                    command: string;
+                    cwd?: string | undefined;
+                    args?: string[] | undefined;
+                    env?: Record<string, string> | undefined;
+                    inheritEnv?: string[] | undefined;
+                    socket?: string | undefined;
+                    credentials?: Record<string, {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                        operation?: object | undefined;
+                    }> | undefined;
+                    portForward?: {
+                        service: string;
+                        localPort: number;
+                        remotePort: number;
+                        namespace?: string | undefined;
+                        context?: string | undefined;
+                        additionalFlags?: string[] | undefined;
+                        labelSelector?: string | undefined;
+                    } | undefined;
+                    launchPreparation?: {
+                        [x: string]: unknown;
+                        adapter: string;
+                        config: Record<string, unknown>;
+                    } | undefined;
+                    selfSpawn?: boolean | undefined;
+                    preBuild?: {
+                        command: string;
+                        ignoreFailure: boolean;
+                        timeout: number;
+                        args?: string[] | undefined;
+                        cwd?: string | undefined;
+                        env?: Record<string, string> | undefined;
+                        inheritEnv?: string[] | undefined;
+                    } | undefined;
+                    build?: {
+                        command: string;
+                        ignoreFailure: boolean;
+                        timeout: number;
+                        args?: string[] | undefined;
+                        cwd?: string | undefined;
+                        env?: Record<string, string> | undefined;
+                        inheritEnv?: string[] | undefined;
+                    } | undefined;
+                };
+                prepared: {
+                    command: string;
+                    cwd?: string | undefined;
+                    args?: string[] | undefined;
+                    env?: Record<string, string> | undefined;
+                    inheritEnv?: string[] | undefined;
+                    socket?: string | undefined;
+                    credentials?: Record<string, {
+                        source: "secret";
+                        key: string;
+                        store?: string | undefined;
+                        operation?: object | undefined;
+                    }> | undefined;
+                    portForward?: {
+                        service: string;
+                        localPort: number;
+                        remotePort: number;
+                        namespace?: string | undefined;
+                        context?: string | undefined;
+                        additionalFlags?: string[] | undefined;
+                        labelSelector?: string | undefined;
+                    } | undefined;
+                    launchPreparation?: {
+                        [x: string]: unknown;
+                        adapter: string;
+                        config: Record<string, unknown>;
+                    } | undefined;
+                    selfSpawn?: boolean | undefined;
+                    preBuild?: {
+                        command: string;
+                        ignoreFailure: boolean;
+                        timeout: number;
+                        args?: string[] | undefined;
+                        cwd?: string | undefined;
+                        env?: Record<string, string> | undefined;
+                        inheritEnv?: string[] | undefined;
+                    } | undefined;
+                    build?: {
+                        command: string;
+                        ignoreFailure: boolean;
+                        timeout: number;
+                        args?: string[] | undefined;
+                        cwd?: string | undefined;
+                        env?: Record<string, string> | undefined;
+                        inheritEnv?: string[] | undefined;
+                    } | undefined;
+                };
+            } | undefined;
+        } | undefined;
+    }[];
+    processesLoading: boolean;
+    processesError: string | null;
+    lastProcessUpdate: number | null;
+    resources: {
+        id: string;
+        type: string;
+        status: "error" | "missing" | "ready" | "creating" | "updating" | "stopping" | "stopped" | "deleting";
+        lastChecked: Date;
+        createdAt?: Date | undefined;
+        updatedAt?: Date | undefined;
+        metadata?: Record<string, unknown> | undefined;
+        config?: Record<string, unknown> | undefined;
+        error?: string | undefined;
+        lastError?: string | undefined;
+        progress?: number | undefined;
+        resourceConfig?: {
+            id: string;
+            name: string;
+            type: string;
+            config: Record<string, unknown>;
+            waitForReady: boolean;
+            readyTimeout: number;
+            dependencies?: string[] | undefined;
+            onCreate?: {
+                command: string;
+                ignoreFailure: boolean;
+                timeout: number;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                env?: Record<string, string> | undefined;
+                inheritEnv?: string[] | undefined;
+                credentials?: Record<string, {
+                    source: "secret";
+                    key: string;
+                    store?: string | undefined;
+                    operation?: object | undefined;
+                }> | undefined;
+                selfSpawn?: boolean | undefined;
+            } | undefined;
+            onUpdate?: {
+                command: string;
+                ignoreFailure: boolean;
+                timeout: number;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                env?: Record<string, string> | undefined;
+                inheritEnv?: string[] | undefined;
+                credentials?: Record<string, {
+                    source: "secret";
+                    key: string;
+                    store?: string | undefined;
+                    operation?: object | undefined;
+                }> | undefined;
+                selfSpawn?: boolean | undefined;
+            } | undefined;
+            onDelete?: {
+                command: string;
+                ignoreFailure: boolean;
+                timeout: number;
+                args?: string[] | undefined;
+                cwd?: string | undefined;
+                env?: Record<string, string> | undefined;
+                inheritEnv?: string[] | undefined;
+                credentials?: Record<string, {
+                    source: "secret";
+                    key: string;
+                    store?: string | undefined;
+                    operation?: object | undefined;
+                }> | undefined;
+                selfSpawn?: boolean | undefined;
+            } | undefined;
+            tags?: string[] | undefined;
+            presets?: string[] | undefined;
+        } | undefined;
+    }[];
+    resourcesLoading: boolean;
+    resourcesError: string | null;
+    lastResourceUpdate: number | null;
+    connected: boolean;
+    connectionError: string | null;
+}>;
+export declare const pmStatusStateKey: import("@vibesdotdev/tui").TuiStateKey<{
+    pmAvailable: boolean;
+    workersReady: boolean | null;
+    executionMode: {
+        type: "worker" | "cloud" | "direct";
+        label: string;
+        available: boolean;
+    } | null;
+    fallback: {
+        requestedMode: "worker" | "cloud" | "direct" | null;
+        actualMode: "worker" | "cloud" | "direct";
+        reason: string;
+        timestamp: number;
+    } | null;
+    checkingWorkers: boolean;
+    lastWorkerCheck: number | null;
+    circuitBreaker: "closed" | "open" | "half-open";
+    consecutiveFailures: number;
+    nextCheckAllowedAt: number | null;
+    connectionError: string | null;
+}>;
+//# sourceMappingURL=pm-state-keys.d.ts.map

package/dist/tui/pm-state-keys.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm-state-keys.d.ts","sourceRoot":"","sources":["../../src/tui/pm-state-keys.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAA4D,CAAC;AAC7F,eAAO,MAAM,gBAAgB;;;;;;;;;;;;;;;;;;;;EAAqD,CAAC"}

package/dist/tui/pm-state-keys.js

@@ -0,0 +1,10 @@
+/**
+ * The PM TUI's tui/state keys: `pm.processes` (process and resource data)
+ * and `pm.status` (daemon availability and execution mode), each with the
+ * schema every value written to it is parsed by.
+ */
+import { defineTuiStateKey } from '@vibesdotdev/tui/kinds/tui-state';
+import { PMDataStoreStateSchema, PMStoreStateSchema } from '@vibesdotdev/pm/schemas/tui-state';
+export const pmProcessesStateKey = defineTuiStateKey('pm.processes', PMDataStoreStateSchema);
+export const pmStatusStateKey = defineTuiStateKey('pm.status', PMStoreStateSchema);
+//# sourceMappingURL=pm-state-keys.js.map

package/dist/tui/pm-state-keys.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm-state-keys.js","sourceRoot":"","sources":["../../src/tui/pm-state-keys.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,iBAAiB,EAAE,MAAM,kCAAkC,CAAC;AACrE,OAAO,EAAE,sBAAsB,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAE/F,MAAM,CAAC,MAAM,mBAAmB,GAAG,iBAAiB,CAAC,cAAc,EAAE,sBAAsB,CAAC,CAAC;AAC7F,MAAM,CAAC,MAAM,gBAAgB,GAAG,iBAAiB,CAAC,WAAW,EAAE,kBAAkB,CAAC,CAAC"}

package/dist/tui/pm-status.descriptor.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PM Status — tui/state descriptor
+ *
+ * Shared state for PM availability, execution mode,
+ * and worker health. Each provider owns its state and refresh lifetime,
+ * providing cross-app access to PM operational status.
+ */
+import type { TuiStateDescriptor } from '@vibesdotdev/tui/schemas/tui-state';
+declare const descriptor: TuiStateDescriptor;
+export default descriptor;
+//# sourceMappingURL=pm-status.descriptor.d.ts.map

package/dist/tui/pm-status.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm-status.descriptor.d.ts","sourceRoot":"","sources":["../../src/tui/pm-status.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oCAAoC,CAAC;AAgB7E,QAAA,MAAM,UAAU,EAAE,kBAOjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/tui/pm-status.descriptor.js

@@ -0,0 +1,29 @@
+/**
+ * PM Status — tui/state descriptor
+ *
+ * Shared state for PM availability, execution mode,
+ * and worker health. Each provider owns its state and refresh lifetime,
+ * providing cross-app access to PM operational status.
+ */
+const defaultValue = {
+    pmAvailable: false,
+    workersReady: null,
+    executionMode: null,
+    fallback: null,
+    checkingWorkers: false,
+    lastWorkerCheck: null,
+    circuitBreaker: 'closed',
+    consecutiveFailures: 0,
+    nextCheckAllowedAt: null,
+    connectionError: null
+};
+const descriptor = {
+    kind: 'tui/state',
+    id: 'pm.status',
+    defaultValue,
+    refreshInterval: 30000,
+    persist: false,
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=pm-status.descriptor.js.map

package/dist/tui/pm-status.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm-status.descriptor.js","sourceRoot":"","sources":["../../src/tui/pm-status.descriptor.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAKH,MAAM,YAAY,GAAiB;IAClC,WAAW,EAAE,KAAK;IAClB,YAAY,EAAE,IAAI;IAClB,aAAa,EAAE,IAAI;IACnB,QAAQ,EAAE,IAAI;IACd,eAAe,EAAE,KAAK;IACtB,eAAe,EAAE,IAAI;IACrB,cAAc,EAAE,QAAQ;IACxB,mBAAmB,EAAE,CAAC;IACtB,kBAAkB,EAAE,IAAI;IACxB,eAAe,EAAE,IAAI;CACrB,CAAC;AAEF,MAAM,UAAU,GAAuB;IACtC,IAAI,EAAE,WAAW;IACjB,EAAE,EAAE,WAAW;IACf,YAAY;IACZ,eAAe,EAAE,KAAK;IACtB,OAAO,EAAE,KAAK;IACd,OAAO,EAAE,IAAI;CACb,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/tui/pm-status.impl.consumer.d.ts

@@ -0,0 +1,11 @@
+/**
+ * PM Status — tui/state implementation (consumer)
+ *
+ * Fetches PM daemon availability directly via PMClient.
+ * Pushes updates into tui/state on an interval.
+ */
+import type { TuiStateImplementation } from '@vibesdotdev/tui/kinds/tui-state';
+import type { PMStoreState } from '@vibesdotdev/pm/schemas/tui-state';
+declare const impl: TuiStateImplementation<PMStoreState>;
+export default impl;
+//# sourceMappingURL=pm-status.impl.consumer.d.ts.map

package/dist/tui/pm-status.impl.consumer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm-status.impl.consumer.d.ts","sourceRoot":"","sources":["../../src/tui/pm-status.impl.consumer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAmB,sBAAsB,EAAE,MAAM,kCAAkC,CAAC;AAChG,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAyBtE,QAAA,MAAM,IAAI,EAAE,sBAAsB,CAAC,YAAY,CAoD9C,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/tui/pm-status.impl.consumer.js

@@ -0,0 +1,75 @@
+/**
+ * PM Status — tui/state implementation (consumer)
+ *
+ * Fetches PM daemon availability directly via PMClient.
+ * Pushes updates into tui/state on an interval.
+ */
+import { pmStatusStateKey } from "./pm-state-keys.js";
+import { attempt } from "../utils/attempt.js";
+/**
+ * Each mount's refresh tick (a lifecycle interval's disposer, RC07), keyed by
+ * its per-instance context as the tui/state contract provides: two coexisting
+ * mounts (or runtimes) never clobber each other's tick.
+ */
+const refreshTicks = new WeakMap();
+function errorMessage(failure) {
+    return failure instanceof Error ? failure.message : failure.description;
+}
+async function fetchStatus(client) {
+    // A `false` result is a normal "daemon not running" signal, not an error.
+    // A thrown failure (transport / unregistered client) is a real connection error,
+    // so let it propagate to refresh() where it is surfaced into connectionError.
+    const pmAvailable = await client.isDaemonRunning();
+    return { pmAvailable, connectionError: null };
+}
+const impl = {
+    key: pmStatusStateKey,
+    init(ctx) {
+        const runtime = ctx.runtime;
+        // Defensive: a re-init without dispose (hot-reload / surface remount) must not
+        // orphan the prior interval, which would double the poll rate and leak on teardown.
+        refreshTicks.get(ctx)?.();
+        refreshTicks.delete(ctx);
+        // runtime-first: resolve via pm/client context (not direct new)
+        const getClient = () => runtime.context('pm/client');
+        const refresh = async () => {
+            // getClient (unregistered pm/client) or isDaemonRunning transport failure —
+            // surface it instead of silently reporting the daemon as unavailable.
+            const fetched = await attempt(async () => fetchStatus(await getClient()));
+            if (fetched.ok) {
+                ctx.setState((prev) => ({ ...prev, ...fetched.value }));
+                return;
+            }
+            ctx.setState((prev) => ({
+                ...prev,
+                pmAvailable: false,
+                connectionError: errorMessage(fetched.failure)
+            }));
+        };
+        // Initial fetch
+        refresh();
+        // Refresh on the runtime's lifecycle tick. Poll: the PM daemon publishes
+        // no availability event to the TUI.
+        refreshTicks.set(ctx, runtime.lifecycle.interval(() => void refresh(), 30000));
+        return {
+            pmAvailable: false,
+            workersReady: null,
+            executionMode: null,
+            fallback: null,
+            checkingWorkers: false,
+            lastWorkerCheck: null,
+            circuitBreaker: 'closed',
+            consecutiveFailures: 0,
+            nextCheckAllowedAt: null,
+            connectionError: null
+        };
+    },
+    dispose(ctx) {
+        if (!ctx)
+            return;
+        refreshTicks.get(ctx)?.();
+        refreshTicks.delete(ctx);
+    }
+};
+export default impl;
+//# sourceMappingURL=pm-status.impl.consumer.js.map

package/dist/tui/pm-status.impl.consumer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm-status.impl.consumer.js","sourceRoot":"","sources":["../../src/tui/pm-status.impl.consumer.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGtD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C;;;;GAIG;AACH,MAAM,YAAY,GAAG,IAAI,OAAO,EAA2C,CAAC;AAE5E,SAAS,YAAY,CAAC,OAAsB;IAC3C,OAAO,OAAO,YAAY,KAAK,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;AACzE,CAAC;AAED,KAAK,UAAU,WAAW,CAAC,MAAoB;IAC9C,0EAA0E;IAC1E,iFAAiF;IACjF,8EAA8E;IAC9E,MAAM,WAAW,GAAG,MAAM,MAAM,CAAC,eAAe,EAAE,CAAC;IACnD,OAAO,EAAE,WAAW,EAAE,eAAe,EAAE,IAAI,EAAE,CAAC;AAC/C,CAAC;AAED,MAAM,IAAI,GAAyC;IAClD,GAAG,EAAE,gBAAgB;IACrB,IAAI,CAAC,GAAkC;QACtC,MAAM,OAAO,GAAG,GAAG,CAAC,OAAO,CAAC;QAC5B,+EAA+E;QAC/E,oFAAoF;QACpF,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QAC1B,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;QACzB,gEAAgE;QAChE,MAAM,SAAS,GAAG,GAAG,EAAE,CAAC,OAAO,CAAC,OAAO,CAAe,WAAW,CAAC,CAAC;QAEnE,MAAM,OAAO,GAAG,KAAK,IAAI,EAAE;YAC1B,4EAA4E;YAC5E,sEAAsE;YACtE,MAAM,OAAO,GAAG,MAAM,OAAO,CAAC,KAAK,IAAI,EAAE,CAAC,WAAW,CAAC,MAAM,SAAS,EAAE,CAAC,CAAC,CAAC;YAC1E,IAAI,OAAO,CAAC,EAAE,EAAE,CAAC;gBAChB,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAkB,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,CAAC,KAAK,EAAE,CAAC,CAAC,CAAC;gBACtE,OAAO;YACR,CAAC;YACD,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAkB,EAAE,EAAE,CAAC,CAAC;gBACrC,GAAG,IAAI;gBACP,WAAW,EAAE,KAAK;gBAClB,eAAe,EAAE,YAAY,CAAC,OAAO,CAAC,OAAO,CAAC;aAC9C,CAAC,CAAC,CAAC;QACL,CAAC,CAAC;QAEF,gBAAgB;QAChB,OAAO,EAAE,CAAC;QAEV,yEAAyE;QACzE,oCAAoC;QACpC,YAAY,CAAC,GAAG,CAAC,GAAG,EAAE,OAAO,CAAC,SAAS,CAAC,QAAQ,CAAC,GAAG,EAAE,CAAC,KAAK,OAAO,EAAE,EAAE,KAAK,CAAC,CAAC,CAAC;QAE/E,OAAO;YACN,WAAW,EAAE,KAAK;YAClB,YAAY,EAAE,IAAI;YAClB,aAAa,EAAE,IAAI;YACnB,QAAQ,EAAE,IAAI;YACd,eAAe,EAAE,KAAK;YACtB,eAAe,EAAE,IAAI;YACrB,cAAc,EAAE,QAAiB;YACjC,mBAAmB,EAAE,CAAC;YACtB,kBAAkB,EAAE,IAAI;YACxB,eAAe,EAAE,IAAI;SACrB,CAAC;IACH,CAAC;IAED,OAAO,CAAC,GAAmC;QAC1C,IAAI,CAAC,GAAG;YAAE,OAAO;QACjB,YAAY,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,EAAE,CAAC;QAC1B,YAAY,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IAC1B,CAAC;CACD,CAAC;AAEF,eAAe,IAAI,CAAC"}

package/dist/tui/pm-tui.plugin.d.ts

@@ -0,0 +1,13 @@
+/**
+ * PM TUI Slice Plugin
+ *
+ * Registers the PM TUI app (`pm.dashboard`), TUI command (`pm.open`), and
+ * TUI state slices (`pm.processes`, `pm.status`) against the kinds owned
+ * by `@vibesdotdev/tui`. The core `@vibesdotdev/pm/plugin` stays
+ * surface-neutral so SSR/web/worker apps can consume the PM substrate
+ * (process kinds, storage manifests, daemon subscription) without
+ * bundling the TUI machinery.
+ */
+declare const defaultExport: import("@vibesdotdev/kernel").RuntimePlugin;
+export default defaultExport;
+//# sourceMappingURL=pm-tui.plugin.d.ts.map

package/dist/tui/pm-tui.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm-tui.plugin.d.ts","sourceRoot":"","sources":["../../src/tui/pm-tui.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAcH,QAAA,MAAM,aAAa,6CAcjB,CAAC;AAEH,eAAe,aAAa,CAAC"}

package/dist/tui/pm-tui.plugin.js

@@ -0,0 +1,34 @@
+/**
+ * PM TUI Slice Plugin
+ *
+ * Registers the PM TUI app (`pm.dashboard`), TUI command (`pm.open`), and
+ * TUI state slices (`pm.processes`, `pm.status`) against the kinds owned
+ * by `@vibesdotdev/tui`. The core `@vibesdotdev/pm/plugin` stays
+ * surface-neutral so SSR/web/worker apps can consume the PM substrate
+ * (process kinds, storage manifests, daemon subscription) without
+ * bundling the TUI machinery.
+ */
+import { createRuntimePlugin, loader } from '@vibesdotdev/kernel';
+import pmDashboardApp from "./pm-dashboard.descriptor.js";
+import pmOpenCommand from "./pm-open.descriptor.js";
+import pmProcessesState from "./pm-processes.descriptor.js";
+import pmStatusState from "./pm-status.descriptor.js";
+const TUI_APP = { kind: 'tui/app' };
+const TUI_COMMAND = { kind: 'tui/command' };
+const TUI_STATE = { kind: 'tui/state' };
+// Hoisted const: tsc rewriteRelativeImportExtensions does not rewrite `.ts` specifiers inside `export default <expr>` (TS 6.0.3).
+const defaultExport = createRuntimePlugin({
+    id: 'pm.tui',
+    name: 'PM TUI Surface',
+    description: 'PM dashboard TUI app + open command + processes/status state slices',
+    dependencies: ['pm', 'tui'],
+    descriptors: [pmDashboardApp, pmOpenCommand, pmProcessesState, pmStatusState],
+    loaders: [
+        loader('pm.dashboard', TUI_APP, () => import("./pm-dashboard.impl.consumer.js")),
+        loader('pm.open', TUI_COMMAND, () => import("./pm-open.impl.consumer.js")),
+        loader('pm.processes', TUI_STATE, () => import("./pm-processes.impl.consumer.js")),
+        loader('pm.status', TUI_STATE, () => import("./pm-status.impl.consumer.js"))
+    ]
+});
+export default defaultExport;
+//# sourceMappingURL=pm-tui.plugin.js.map

package/dist/tui/pm-tui.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pm-tui.plugin.js","sourceRoot":"","sources":["../../src/tui/pm-tui.plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAElE,OAAO,cAAc,MAAM,8BAA8B,CAAC;AAC1D,OAAO,aAAa,MAAM,yBAAyB,CAAC;AACpD,OAAO,gBAAgB,MAAM,8BAA8B,CAAC;AAC5D,OAAO,aAAa,MAAM,2BAA2B,CAAC;AAEtD,MAAM,OAAO,GAAG,EAAE,IAAI,EAAE,SAAS,EAAW,CAAC;AAC7C,MAAM,WAAW,GAAG,EAAE,IAAI,EAAE,aAAa,EAAW,CAAC;AACrD,MAAM,SAAS,GAAG,EAAE,IAAI,EAAE,WAAW,EAAW,CAAC;AAEjD,kIAAkI;AAClI,MAAM,aAAa,GAAG,mBAAmB,CAAC;IACzC,EAAE,EAAE,QAAQ;IACZ,IAAI,EAAE,gBAAgB;IACtB,WAAW,EAAE,qEAAqE;IAClF,YAAY,EAAE,CAAC,IAAI,EAAE,KAAK,CAAC;IAE3B,WAAW,EAAE,CAAC,cAAc,EAAE,aAAa,EAAE,gBAAgB,EAAE,aAAa,CAAC;IAE7E,OAAO,EAAE;QACR,MAAM,CAAC,cAAc,EAAE,OAAO,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,iCAAkC,CAAC,CAAC;QACjF,MAAM,CAAC,SAAS,EAAE,WAAW,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,4BAA4B,CAAC,CAAC;QAC1E,MAAM,CAAC,cAAc,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,iCAAiC,CAAC,CAAC;QAClF,MAAM,CAAC,WAAW,EAAE,SAAS,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,8BAA8B,CAAC,CAAC;KAC5E;CACD,CAAC,CAAC;AAEH,eAAe,aAAa,CAAC"}

package/dist/utils/attempt.d.ts

@@ -0,0 +1,31 @@
+/**
+ * One attempt, captured once as an outcome: the value, or the failure that
+ * ended it. The caller reads the failure and decides (branch on its `code` /
+ * `reason`, report its value-free facts, or rethrow it); the capture itself
+ * never decides, drops or rewrites it.
+ */
+import { type CaughtFailure } from '@vibesdotdev/kernel';
+export type Attempt<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly failure: CaughtFailure;
+};
+/** Run `work`; an async failure is the outcome, never thrown. */
+export declare function attempt<T>(work: () => Promise<T>): Promise<Attempt<T>>;
+/** Run `work`; a synchronous failure is the outcome, never thrown. */
+export declare function attemptSync<T>(work: () => T): Attempt<T>;
+/**
+ * The failure named by its value-free facts only (`CapabilityError UNAVAILABLE
+ * pm-process-not-stopped`, `Error ENOENT`): safe in a message or a stored
+ * `lastError`, never the failure's own text.
+ */
+export declare function failureLabel(failure: CaughtFailure): string;
+/**
+ * The failure as text for a reply or a stored `lastError`: a typed failure's
+ * own message (value-free by the `CapabilityError` contract), else its facts
+ * only. An untyped failure's text is never copied.
+ */
+export declare function failureText(failure: CaughtFailure): string;
+//# sourceMappingURL=attempt.d.ts.map

package/dist/utils/attempt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt.d.ts","sourceRoot":"","sources":["../../src/utils/attempt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAA4D,KAAK,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAEnH,MAAM,MAAM,OAAO,CAAC,CAAC,IAClB;IAAE,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAC;IAAC,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAA;CAAE,GACxC;IAAE,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;CAAE,CAAC;AAE3D,iEAAiE;AACjE,wBAAsB,OAAO,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAM5E;AAED,sEAAsE;AACtE,wBAAgB,WAAW,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAMxD;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAG3D;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,aAAa,GAAG,MAAM,CAE1D"}

package/dist/utils/attempt.js

@@ -0,0 +1,43 @@
+/**
+ * One attempt, captured once as an outcome: the value, or the failure that
+ * ended it. The caller reads the failure and decides (branch on its `code` /
+ * `reason`, report its value-free facts, or rethrow it); the capture itself
+ * never decides, drops or rewrites it.
+ */
+import { CaughtFailureSchema, isCapabilityError, valueFreeFailure } from '@vibesdotdev/kernel';
+/** Run `work`; an async failure is the outcome, never thrown. */
+export async function attempt(work) {
+    try {
+        return { ok: true, value: await work() };
+    }
+    catch (error) {
+        return { ok: false, failure: CaughtFailureSchema.parse(error) };
+    }
+}
+/** Run `work`; a synchronous failure is the outcome, never thrown. */
+export function attemptSync(work) {
+    try {
+        return { ok: true, value: work() };
+    }
+    catch (error) {
+        return { ok: false, failure: CaughtFailureSchema.parse(error) };
+    }
+}
+/**
+ * The failure named by its value-free facts only (`CapabilityError UNAVAILABLE
+ * pm-process-not-stopped`, `Error ENOENT`): safe in a message or a stored
+ * `lastError`, never the failure's own text.
+ */
+export function failureLabel(failure) {
+    const facts = valueFreeFailure(failure);
+    return [facts.name, facts.code, facts.reason].filter((fact) => fact !== undefined).join(' ');
+}
+/**
+ * The failure as text for a reply or a stored `lastError`: a typed failure's
+ * own message (value-free by the `CapabilityError` contract), else its facts
+ * only. An untyped failure's text is never copied.
+ */
+export function failureText(failure) {
+    return isCapabilityError(failure) ? failure.message : failureLabel(failure);
+}
+//# sourceMappingURL=attempt.js.map

package/dist/utils/attempt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attempt.js","sourceRoot":"","sources":["../../src/utils/attempt.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,gBAAgB,EAAsB,MAAM,qBAAqB,CAAC;AAMnH,iEAAiE;AACjE,MAAM,CAAC,KAAK,UAAU,OAAO,CAAI,IAAsB;IACtD,IAAI,CAAC;QACJ,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,IAAI,EAAE,EAAE,CAAC;IAC1C,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;IACjE,CAAC;AACF,CAAC;AAED,sEAAsE;AACtE,MAAM,UAAU,WAAW,CAAI,IAAa;IAC3C,IAAI,CAAC;QACJ,OAAO,EAAE,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,EAAE,CAAC;IACpC,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QAChB,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,mBAAmB,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC;IACjE,CAAC;AACF,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,YAAY,CAAC,OAAsB;IAClD,MAAM,KAAK,GAAG,gBAAgB,CAAC,OAAO,CAAC,CAAC;IACxC,OAAO,CAAC,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,IAAI,KAAK,SAAS,CAAC,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;AAC9F,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,OAAsB;IACjD,OAAO,iBAAiB,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;AAC7E,CAAC"}

package/dist/utils/bounded-wait.d.ts

@@ -0,0 +1,31 @@
+/**
+ * PM's bounded waits over the runtime lifecycle (RC07).
+ *
+ * A wait awaits the owner's event or readiness promise inside
+ * `runtime.lifecycle.wait`, bounded by a deadline, the invocation's signal and
+ * the runtime's own disposal. Where the owner offers no event, `pollUntil`
+ * re-checks with `runtime.lifecycle.delay` inside that same wait; each caller
+ * names the owner and the missing event beside the call, so the poll is
+ * visible debt, never a hand-rolled sleep.
+ */
+import { type CaughtFailure, type RuntimeRef } from '@vibesdotdev/kernel';
+export type LifecycleRuntime = Pick<RuntimeRef, 'lifecycle'>;
+export interface PollUntilOptions {
+    /** Upper bound for the whole wait. */
+    timeoutMs: number;
+    /** Pause between checks. */
+    intervalMs: number;
+    /** What is awaited; carried in a wait failure's details. */
+    reason: string;
+    /** The invocation's signal. */
+    signal?: AbortSignal;
+}
+/** Whether `error` is the lifecycle's deadline (`TIMEOUT` `wait-timeout`), the one outcome read as "not yet". */
+export declare function isWaitTimeout(failure: CaughtFailure): boolean;
+/**
+ * Re-check `check` until it answers true (resolves true) or the deadline
+ * passes (resolves false). A check that throws, a caller abort and the
+ * runtime's disposal reject with their own error.
+ */
+export declare function pollUntil(runtime: LifecycleRuntime, check: () => Promise<boolean>, options: PollUntilOptions): Promise<boolean>;
+//# sourceMappingURL=bounded-wait.d.ts.map