@vibesdotdev/kernel-rpc 0.0.0-stage → 1.0.0-rc.3

package/dist/daemon/subscriptions/manager.js

@@ -0,0 +1,73 @@
+import { encoder, formatSSE, SubscriptionClients } from "./clients.js";
+export { formatSSE } from "./clients.js";
+/** Subscription Manager Manages SSE (Server-Sent Events) connections for the runtime daemon. */
+import {} from '@vibesdotdev/kernel';
+import { startLifecycleRepeat } from "../../core/lifecycle-repeat.js";
+/**
+ * SubscriptionManager tracks active SSE connections and routes events
+ * to the appropriate subscribers based on channel and optional filter ID.
+ *
+ * Each client receives a ReadableStream that the manager pushes events into
+ * via the stream's controller. A heartbeat interval keeps connections alive.
+ */
+export class SubscriptionManager extends SubscriptionClients {
+    /** Heartbeat interval timer */
+    heartbeatTimer = null;
+    /** Heartbeat interval in milliseconds */
+    heartbeatIntervalMs;
+    /** Whether the manager has been stopped */
+    stopped = false;
+    constructor(options) {
+        super();
+        this.heartbeatIntervalMs = options?.heartbeatIntervalMs ?? 30_000;
+    }
+    // Heartbeat
+    /**
+     * Start the heartbeat interval.
+     * Sends `event: heartbeat` with a timestamp to all connected clients.
+     */
+    start(runtime) {
+        this.stopped = false;
+        if (this.heartbeatTimer)
+            return;
+        // A lifecycle interval of the daemon host (RC07): disposed by stop() and
+        // by the runtime's disposal. A finite host continues on a delay loop.
+        this.heartbeatTimer = startLifecycleRepeat(runtime, runtime.lifecycle, this.heartbeatIntervalMs, () => {
+            this.sendHeartbeat();
+        }).stop;
+    }
+    /**
+         * Stop the heartbeat interval.
+         */
+    stop() {
+        this.stopped = true;
+        if (this.heartbeatTimer) {
+            this.heartbeatTimer();
+            this.heartbeatTimer = null;
+        }
+    }
+    /**
+         * Gracefully shut down: stop heartbeat and close all client connections.
+         */
+    shutdown() {
+        this.stop();
+        // Close all client connections
+        for (const clientId of this.clients.keys()) {
+            this.removeClient(clientId);
+        }
+    }
+    // Internal
+    /**
+     * Send a heartbeat event to all connected clients.
+     */
+    sendHeartbeat() {
+        const message = formatSSE('heartbeat', {
+            timestamp: new Date().toISOString()
+        });
+        const encoded = encoder.encode(message);
+        for (const record of this.clients.values()) {
+            this.enqueueToClient(record, encoded);
+        }
+    }
+}
+//# sourceMappingURL=manager.js.map

package/dist/daemon/subscriptions/manager.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manager.js","sourceRoot":"","sources":["../../../src/daemon/subscriptions/manager.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,SAAS,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAEvE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAC;AACzC,gGAAgG;AAEhG,OAAO,EAAkC,MAAM,qBAAqB,CAAC;AACrE,OAAO,EAAE,oBAAoB,EAAE,MAAM,gCAAgC,CAAC;AAEtE;;;;;;GAMG;AACH,MAAM,OAAO,mBAAoB,SAAQ,mBAAmB;IAC5D,+BAA+B;IACpB,cAAc,GAAoB,IAAI,CAAC;IAElD,yCAAyC;IACrB,mBAAmB,CAAS;IAEhD,2CAA2C;IAChC,OAAO,GAAG,KAAK,CAAC;IAE3B,YAAY,OAA0C;QACpD,KAAK,EAAE,CAAC;QACR,IAAI,CAAC,mBAAmB,GAAG,OAAO,EAAE,mBAAmB,IAAI,MAAM,CAAC;IACnE,CAAC;IAEF,YAAY;IAEX;;;OAGG;IACH,KAAK,CAAC,OAAmB;QACxB,IAAI,CAAC,OAAO,GAAG,KAAK,CAAC;QAErB,IAAI,IAAI,CAAC,cAAc;YAAE,OAAO;QAEhC,yEAAyE;QACzE,sEAAsE;QACtE,IAAI,CAAC,cAAc,GAAG,oBAAoB,CAAC,OAAO,EAAE,OAAO,CAAC,SAAS,EAAE,IAAI,CAAC,mBAAmB,EAAE,GAAG,EAAE;YACrG,IAAI,CAAC,aAAa,EAAE,CAAC;QACtB,CAAC,CAAC,CAAC,IAAI,CAAC;IACT,CAAC;IAEF;;WAEI;IACH,IAAI;QACH,IAAI,CAAC,OAAO,GAAG,IAAI,CAAC;QAEpB,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;YACzB,IAAI,CAAC,cAAc,EAAE,CAAC;YACtB,IAAI,CAAC,cAAc,GAAG,IAAI,CAAC;QAC5B,CAAC;IACF,CAAC;IAEF;;WAEI;IACH,QAAQ;QACP,IAAI,CAAC,IAAI,EAAE,CAAC;QAEZ,+BAA+B;QAC/B,KAAK,MAAM,QAAQ,IAAI,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC;YAC5C,IAAI,CAAC,YAAY,CAAC,QAAQ,CAAC,CAAC;QAC7B,CAAC;IACF,CAAC;IAEF,WAAW;IAEV;;OAEG;IACO,aAAa;QACtB,MAAM,OAAO,GAAG,SAAS,CAAC,WAAW,EAAE;YACtC,SAAS,EAAE,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE;SACnC,CAAC,CAAC;QACH,MAAM,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;QAExC,KAAK,MAAM,MAAM,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;YAC5C,IAAI,CAAC,eAAe,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QACvC,CAAC;IACF,CAAC;CACD"}

package/dist/daemon/subscriptions/manifest-watcher.d.ts

@@ -0,0 +1,30 @@
+/** Shared subscription polling lifetime; the concrete watcher supplies its manifest owner. */
+import { type VibesRuntime } from '@vibesdotdev/kernel';
+import type { JsonValue } from '@vibesdotdev/kernel/schemas/json';
+import type { ConfigWatcherOptions } from '../../schemas/daemon/daemon-watchers.ts';
+import type { SubscriptionManager } from './manager.ts';
+export declare abstract class ManifestWatcher {
+    protected readonly runtime: VibesRuntime;
+    private readonly subscriptions;
+    private readonly channel;
+    private watchedManifests;
+    private lastHashes;
+    private pollTimer;
+    private currentPoll;
+    private polling;
+    private epoch;
+    private readonly pollIntervalMs;
+    private readonly log;
+    constructor(runtime: VibesRuntime, subscriptions: SubscriptionManager, channel: 'config' | 'storage', options?: ConfigWatcherOptions);
+    watch(manifestId: string): void;
+    unwatch(manifestId: string): void;
+    getWatched(): ReadonlySet<string>;
+    start(): void;
+    /** Join live work before clearing; a newer start owns the next generation. */
+    stop(): Promise<void>;
+    private poll;
+    private checkManifest;
+    protected abstract loadValue(manifestId: string): Promise<JsonValue | null>;
+    private hashValue;
+}
+//# sourceMappingURL=manifest-watcher.d.ts.map

package/dist/daemon/subscriptions/manifest-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-watcher.d.ts","sourceRoot":"","sources":["../../../src/daemon/subscriptions/manifest-watcher.ts"],"names":[],"mappings":"AAAA,8FAA8F;AAC9F,OAAO,EAA0D,KAAK,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAChH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AAIlE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAEpF,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD,8BAAsB,eAAe;IAWnC,SAAS,CAAC,QAAQ,CAAC,OAAO,EAAE,YAAY;IACxC,OAAO,CAAC,QAAQ,CAAC,aAAa;IAC9B,OAAO,CAAC,QAAQ,CAAC,OAAO;IAZzB,OAAO,CAAC,gBAAgB,CAAqB;IAC7C,OAAO,CAAC,UAAU,CAA6B;IAC/C,OAAO,CAAC,SAAS,CAAyB;IAC1C,OAAO,CAAC,WAAW,CAA8C;IACjE,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,KAAK,CAAK;IAClB,OAAO,CAAC,QAAQ,CAAC,cAAc,CAAS;IACxC,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;gBAGlB,OAAO,EAAE,YAAY,EACvB,aAAa,EAAE,mBAAmB,EAClC,OAAO,EAAE,QAAQ,GAAG,SAAS,EAC9C,OAAO,CAAC,EAAE,oBAAoB;IAM/B,KAAK,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAE/B,OAAO,CAAC,UAAU,EAAE,MAAM,GAAG,IAAI;IAKjC,UAAU,IAAI,WAAW,CAAC,MAAM,CAAC;IAEjC,KAAK,IAAI,IAAI;IAmBb,8EAA8E;IACxE,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC;YAWb,IAAI;YAUJ,aAAa;IAiB5B,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;YAE5D,SAAS;CAKvB"}

package/dist/daemon/subscriptions/manifest-watcher.js

@@ -0,0 +1,100 @@
+/** Shared subscription polling lifetime; the concrete watcher supplies its manifest owner. */
+import { CaughtFailureSchema } from '@vibesdotdev/kernel';
+import { startLifecycleRepeat } from "../../core/lifecycle-repeat.js";
+import { attempt } from "../../core/protocol/lifecycle/attempt.js";
+import { createNoopLogger } from "../commands/invoke/logger.js";
+export class ManifestWatcher {
+    runtime;
+    subscriptions;
+    channel;
+    watchedManifests = new Set();
+    lastHashes = new Map();
+    pollTimer = null;
+    currentPoll = null;
+    polling = false;
+    epoch = 0;
+    pollIntervalMs;
+    log;
+    constructor(runtime, subscriptions, channel, options) {
+        this.runtime = runtime;
+        this.subscriptions = subscriptions;
+        this.channel = channel;
+        this.pollIntervalMs = options?.pollIntervalMs ?? 2000;
+        this.log = options?.logger ?? createNoopLogger(channel + '-watcher');
+    }
+    watch(manifestId) { this.watchedManifests.add(manifestId); }
+    unwatch(manifestId) {
+        this.watchedManifests.delete(manifestId);
+        this.lastHashes.delete(manifestId);
+    }
+    getWatched() { return this.watchedManifests; }
+    start() {
+        if (this.pollTimer)
+            return;
+        this.epoch++;
+        this.pollTimer = startLifecycleRepeat(this.runtime, this.runtime.lifecycle, this.pollIntervalMs, () => {
+            if (this.polling)
+                return;
+            this.currentPoll = this.poll().catch(error => {
+                const failure = CaughtFailureSchema.parse(error);
+                const logged = attempt(() => this.log.error('poll error', { error: failure }));
+                if (!logged.ok) {
+                    // KernelDiagnostics.error is the owner's non-throwing fallback.
+                    this.runtime.diagnostics.error(this.channel + '-watcher.poll-log-refused', {
+                        scope: 'runtime-plugin', plugin: this.channel + '-watcher', error: logged.failure
+                    });
+                }
+                return failure;
+            });
+        }).stop;
+    }
+    /** Join live work before clearing; a newer start owns the next generation. */
+    async stop() {
+        const epoch = this.epoch;
+        this.pollTimer?.();
+        this.pollTimer = null;
+        await this.currentPoll;
+        if (this.epoch === epoch) {
+            this.watchedManifests.clear();
+            this.lastHashes.clear();
+        }
+    }
+    async poll() {
+        if (this.polling || !this.watchedManifests.size)
+            return;
+        this.polling = true;
+        try {
+            for (const id of this.watchedManifests)
+                await this.checkManifest(id);
+        }
+        finally {
+            this.polling = false;
+        }
+    }
+    async checkManifest(manifestId) {
+        try {
+            const value = await this.loadValue(manifestId);
+            const currentHash = await this.hashValue(value);
+            const previousHash = this.lastHashes.get(manifestId);
+            if (currentHash === previousHash)
+                return;
+            this.lastHashes.set(manifestId, currentHash);
+            if (previousHash === undefined)
+                return;
+            this.subscriptions.broadcast(this.channel, {
+                type: 'change', id: manifestId, value, timestamp: new Date().toISOString()
+            });
+        }
+        catch (error) {
+            const failure = CaughtFailureSchema.parse(error);
+            this.log.error('failed to check manifest', { manifestId, error: failure });
+            return failure;
+        }
+    }
+    async hashValue(value) {
+        const data = new TextEncoder().encode(JSON.stringify(value ?? null));
+        const digest = await crypto.subtle.digest('SHA-256', data);
+        return Array.from(new Uint8Array(digest), byte => byte.toString(16).padStart(2, '0')).join('');
+    }
+}
+//# sourceMappingURL=manifest-watcher.js.map

package/dist/daemon/subscriptions/manifest-watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"manifest-watcher.js","sourceRoot":"","sources":["../../../src/daemon/subscriptions/manifest-watcher.ts"],"names":[],"mappings":"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"}

package/dist/daemon/subscriptions/storage-watcher.d.ts

@@ -0,0 +1,11 @@
+import type { VibesRuntime } from '@vibesdotdev/kernel';
+import { type JsonValue } from '@vibesdotdev/kernel/schemas/json';
+import { type StorageWatcherOptions } from '../../schemas/daemon/daemon-watchers.ts';
+import type { SubscriptionManager } from './manager.ts';
+import { ManifestWatcher } from './manifest-watcher.ts';
+export type { StorageWatcherOptions } from '../../schemas/daemon/daemon-watchers.ts';
+export declare class StorageWatcher extends ManifestWatcher {
+    constructor(runtime: VibesRuntime, subscriptions: SubscriptionManager, options?: StorageWatcherOptions);
+    protected loadValue(manifestId: string): Promise<JsonValue | null>;
+}
+//# sourceMappingURL=storage-watcher.d.ts.map

package/dist/daemon/subscriptions/storage-watcher.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-watcher.d.ts","sourceRoot":"","sources":["../../../src/daemon/subscriptions/storage-watcher.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACxD,OAAO,EAAmB,KAAK,SAAS,EAAE,MAAM,kCAAkC,CAAC;AACnF,OAAO,EAA8B,KAAK,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AACjH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AACxD,YAAY,EAAE,qBAAqB,EAAE,MAAM,yCAAyC,CAAC;AAErF,qBAAa,cAAe,SAAQ,eAAe;gBACtC,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,qBAAqB;cAItF,SAAS,CAAC,UAAU,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,GAAG,IAAI,CAAC;CAMxE"}

package/dist/daemon/subscriptions/storage-watcher.js

@@ -0,0 +1,16 @@
+import { JsonValueSchema } from '@vibesdotdev/kernel/schemas/json';
+import { StorageWatchManifestSchema } from "../../schemas/daemon/daemon-watchers.js";
+import { ManifestWatcher } from "./manifest-watcher.js";
+export class StorageWatcher extends ManifestWatcher {
+    constructor(runtime, subscriptions, options) {
+        super(runtime, subscriptions, 'storage', options);
+    }
+    async loadValue(manifestId) {
+        if (!this.runtime.hasKind('storage/manifest') ||
+            this.runtime.query('storage/manifest').withId(manifestId).descriptors().length === 0)
+            return null;
+        const manifest = StorageWatchManifestSchema.parse(await this.runtime.resolve('storage/manifest', manifestId));
+        return JsonValueSchema.parse(await manifest.load());
+    }
+}
+//# sourceMappingURL=storage-watcher.js.map

package/dist/daemon/subscriptions/storage-watcher.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"storage-watcher.js","sourceRoot":"","sources":["../../../src/daemon/subscriptions/storage-watcher.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,eAAe,EAAkB,MAAM,kCAAkC,CAAC;AACnF,OAAO,EAAE,0BAA0B,EAA8B,MAAM,yCAAyC,CAAC;AAEjH,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAGxD,MAAM,OAAO,cAAe,SAAQ,eAAe;IAClD,YAAY,OAAqB,EAAE,aAAkC,EAAE,OAA+B;QACrG,KAAK,CAAC,OAAO,EAAE,aAAa,EAAE,SAAS,EAAE,OAAO,CAAC,CAAC;IACnD,CAAC;IAES,KAAK,CAAC,SAAS,CAAC,UAAkB;QAC3C,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,kBAAkB,CAAC;YAC5C,IAAI,CAAC,OAAO,CAAC,KAAK,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,UAAU,CAAC,CAAC,WAAW,EAAE,CAAC,MAAM,KAAK,CAAC;YAAE,OAAO,IAAI,CAAC;QACnG,MAAM,QAAQ,GAAG,0BAA0B,CAAC,KAAK,CAAC,MAAM,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,kBAAkB,EAAE,UAAU,CAAC,CAAC,CAAC;QAC9G,OAAO,eAAe,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,IAAI,EAAE,CAAC,CAAC;IACrD,CAAC;CACD"}

package/dist/docs/lifecycle.docs.descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=lifecycle.docs.descriptor.d.ts.map

package/dist/docs/lifecycle.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/lifecycle.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAiEvE,QAAA,MAAM,UAAU,EAAE,mBA0BjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/lifecycle.docs.descriptor.js

@@ -0,0 +1,91 @@
+/**
+ * Descriptor for runtime-plugin.lifecycle
+ * Plugin lifecycle (register, discover, activate, ready, dispose), dependencies, hooks
+ */
+const lifecycleMarkdown = `# Runtime Plugin Lifecycle
+
+The kernel owns registration, activation, retirement and disposal. Use the runtime
+handed to the host or command; a feature does not bootstrap a second runtime.
+
+## Registration and activation
+
+\`createRuntimePlugin\` validates the plugin contract. Its \`onRegister\` first
+registers static descriptors, lazy loaders and remote exposures, then calls the
+owner's registration hook. Declare required plugins in \`dependencies\` and
+optional composition in \`optionalDependencies\`; do not rely on incidental order.
+
+\`onActivate\` receives the runtime that is activating the plugin. Resolve other
+owners through that runtime and register resource cleanup with its lifecycle.
+Descriptors describe capabilities; loaders defer implementation imports until
+resolution. Registration failures remain failures, including typed refusals.
+
+## Resource ownership
+
+RPC connects use \`runtime.lifecycle.wait\`: the deadline, caller cancellation and
+runtime disposal bound one attempt. A late connection is closed rather than
+returned. \`RpcConnector\` owns reuse and reconnect policy; its hold-off uses the
+same lifecycle. Dispose the connector when its holder ends.
+
+A connection owns its references, channels and issued work. A local close starts
+teardown immediately and joins completion. Repeated closes share the outcome.
+Listener shutdown closes every session before reporting retained failures.
+Failed channel closes, disconnects and issued legs propagate typed errors; they
+are never replaced with a successful cleanup result.
+
+## Disposal and retirement
+
+The plugin contract exposes \`onDispose\` and \`onRetire\`. The runtime also exposes
+\`onDispose\` for resources acquired during activation. Cleanup must be idempotent
+and observable: release subscriptions, streams and connections, and join their
+completion. Preserve failures for the owning lifecycle to report.
+
+Call \`await runtime.dispose()\` when the owning host ends. Do not swallow cleanup
+errors or leave a detached promise that cannot be observed by the owner.
+
+## Diagnose a failure
+
+- Registration: inspect the descriptor, kind schema, dependency and loader id.
+- Resolution: check scope and the lazy implementation's import closure.
+- RPC connect: inspect the typed code and reason; resolve credentials through
+  the runtime's secret owner.
+- Close: inspect \`rpc-channel-close-failed\`, \`rpc-connection-close-failed\` or
+  \`rpc-leg-failed\` and repair the resource owner.
+
+The authoritative lifecycle and plugin schemas are in \`@vibesdotdev/kernel\`.
+RPC's connection and listener contracts are in \`@vibesdotdev/kernel-rpc\`.
+
+:::card{title="See also"}
+- [\`runtime-plugin.system\`](runtime-plugin.system) — Composition and loaders
+- [\`runtime.rpc\`](runtime.rpc) — Protocol, transports and typed refusals
+- [\`runtime.plugins\`](runtime.plugins) — Registration and management
+:::
+`;
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'runtime-plugin.lifecycle',
+    title: 'Runtime Plugin Lifecycle',
+    summary: 'Plugin lifecycle phases, hooks, dependencies, and disposal',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: lifecycleMarkdown
+    },
+    parent: 'runtime',
+    order: 6,
+    tags: ['runtime', 'plugins', 'lifecycle', 'hooks', 'dependencies'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    man: {
+        name: 'runtime-plugin.lifecycle — Plugin lifecycle management',
+        section: 1,
+        synopsis: 'vibes man runtime-plugin.lifecycle',
+        seeAlso: ['runtime-plugin.system', 'runtime.plugins', 'runtime.query']
+    },
+    subject: {
+        kind: 'docs/topic',
+        id: 'runtime-plugin.lifecycle'
+    },
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=lifecycle.docs.descriptor.js.map

package/dist/docs/lifecycle.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lifecycle.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/lifecycle.docs.descriptor.ts"],"names":[],"mappings":"AAEA;;;GAGG;AACH,MAAM,iBAAiB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAyDzB,CAAC;AAEF,MAAM,UAAU,GAAwB;IACtC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,0BAA0B;IAC9B,KAAK,EAAE,0BAA0B;IACjC,OAAO,EAAE,4DAA4D;IACrE,IAAI,EAAE;QACJ,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE,iBAAiB;KAC1B;IACD,MAAM,EAAE,SAAS;IACjB,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,SAAS,EAAE,SAAS,EAAE,WAAW,EAAE,OAAO,EAAE,cAAc,CAAC;IAClE,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,GAAG,EAAE;QACH,IAAI,EAAE,wDAAwD;QAC9D,OAAO,EAAE,CAAC;QACV,QAAQ,EAAE,oCAAoC;QAC9C,OAAO,EAAE,CAAC,uBAAuB,EAAE,iBAAiB,EAAE,eAAe,CAAC;KACvE;IACD,OAAO,EAAE;QACP,IAAI,EAAE,YAAY;QAClB,EAAE,EAAE,0BAA0B;KAC/B;IACD,OAAO,EAAE,IAAI;CACd,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/plugin.d.ts

@@ -0,0 +1,3 @@
+export declare const runtimeRpcDocsPlugin: import("@vibesdotdev/kernel").RuntimePlugin;
+export default runtimeRpcDocsPlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/docs/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../src/docs/plugin.ts"],"names":[],"mappings":"AAYA,eAAO,MAAM,oBAAoB,6CAW/B,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/dist/docs/plugin.js

@@ -0,0 +1,25 @@
+/**
+ * Docs-only plugin: registers runtime-rpc's five owner topics (`runtime.rpc`, `runtime-rpc-messageport`,
+ * `runtime-rpc-tauri`, `runtime-plugin.lifecycle`, `runtime-plugin.system`) and nothing else. It registers no kind, no transport and no config, so a documentation host
+ * (the plugins devtools umbrella the CLI loads) can make the topics discoverable without selecting any transport.
+ */
+import { createRuntimePlugin } from '@vibesdotdev/kernel';
+import messagePortRpcDocs from "../transports/messageport/docs/runtime-rpc-messageport.docs.descriptor.js";
+import tauriRpcDocs from "../transports/tauri/contracts1/docs/runtime-rpc-tauri.docs.descriptor.js";
+import runtimePluginLifecycleDocs from "./lifecycle.docs.descriptor.js";
+import runtimeRpcDocs from "./runtime-rpc.docs.descriptor.js";
+import runtimePluginSystemDocs from "./system.docs.descriptor.js";
+export const runtimeRpcDocsPlugin = createRuntimePlugin({
+    id: '@vibesdotdev/kernel-rpc/docs',
+    name: 'Runtime RPC Docs',
+    description: 'Documentation for the runtime/rpc kind, its transports, and the runtime daemon plugin system.',
+    descriptors: [
+        runtimeRpcDocs,
+        runtimePluginLifecycleDocs,
+        runtimePluginSystemDocs,
+        messagePortRpcDocs,
+        tauriRpcDocs
+    ]
+});
+export default runtimeRpcDocsPlugin;
+//# sourceMappingURL=plugin.js.map

package/dist/docs/plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.js","sourceRoot":"","sources":["../../src/docs/plugin.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,kBAAkB,MAAM,2EAA2E,CAAC;AAC3G,OAAO,YAAY,MAAM,0EAA0E,CAAC;AACpG,OAAO,0BAA0B,MAAM,gCAAgC,CAAC;AACxE,OAAO,cAAc,MAAM,kCAAkC,CAAC;AAC9D,OAAO,uBAAuB,MAAM,6BAA6B,CAAC;AAElE,MAAM,CAAC,MAAM,oBAAoB,GAAG,mBAAmB,CAAC;IACvD,EAAE,EAAE,8BAA8B;IAClC,IAAI,EAAE,kBAAkB;IACxB,WAAW,EAAE,+FAA+F;IAC5G,WAAW,EAAE;QACZ,cAAc;QACd,0BAA0B;QAC1B,uBAAuB;QACvB,kBAAkB;QAClB,YAAY;KACZ;CACD,CAAC,CAAC;AAEH,eAAe,oBAAoB,CAAC"}

package/dist/docs/runtime-rpc.docs.descriptor.d.ts

@@ -0,0 +1,9 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+/**
+ * Descriptor for runtime.rpc — the remote-runtime protocol family.
+ * Grounded in the actual code: runtime-rpc owns the kind, protocol,
+ * and transport implementations exposed through explicit package subpaths.
+ */
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=runtime-rpc.docs.descriptor.d.ts.map

package/dist/docs/runtime-rpc.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-rpc.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/runtime-rpc.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAEvE;;;;GAIG;AACH,QAAA,MAAM,UAAU,EAAE,mBAiLjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/runtime-rpc.docs.descriptor.js

@@ -0,0 +1,184 @@
+/**
+ * Descriptor for runtime.rpc — the remote-runtime protocol family.
+ * Grounded in the actual code: runtime-rpc owns the kind, protocol,
+ * and transport implementations exposed through explicit package subpaths.
+ */
+const descriptor = {
+    kind: 'docs/topic',
+    id: 'runtime.rpc',
+    title: 'Runtime RPC',
+    summary: 'Reach a remote runtime with three kind-agnostic verbs over Unix, TCP, HTTP, relay, MessagePort, CEF, or Tauri transports.',
+    body: {
+        type: 'markdown',
+        sourceType: 'raw',
+        source: `---
+title: Runtime RPC
+summary: Reach a remote runtime with three kind-agnostic verbs over Unix, TCP, HTTP, relay, MessagePort, CEF, or Tauri transports.
+tags: [runtime, rpc, remote, transport, protocol]
+parent: runtime
+order: 5
+surfaces: [cli, web, in-app]
+hardware: [consumer, cloud]
+---
+
+# Runtime RPC
+
+The \`runtime/rpc\` kind makes a remote runtime reachable as if it were local. A remote method call is never a bespoke HTTP route named after the method — it is one of exactly **three protocol verbs** routed by reference id. The protocol names no kind, no method, and no capability.
+
+## Public contracts
+
+The strict wire schemas own inferred readonly request, response and error types,
+branded references and Date metadata validation. Local callable arguments stay
+separate from serialized data. The package SPEC owns the complete entrypoint table.
+
+Daemon composition uses \`@vibesdotdev/kernel-rpc/daemon\`; client aliases are
+\`/client\` and \`/daemon/client\`. Explicit daemon subpaths expose
+\`/daemon/rpc-root\`, \`/daemon/runtime-daemon.socket-path\`, \`/daemon/plugin\`,
+\`/daemon/cli/plugin\`, \`/daemon/host-hot-reload\` and \`/daemon/hot-plugin-module\`.
+Descriptor metadata serialization is on \`/descriptor-wire\`.
+
+Conditional exports retain every target and condition in manifest order,
+including \`default\`; that order determines resolution precedence. The offline
+packed-consumer proof compares unpacked exports against an independent original
+snapshot, loads distributed entrypoints under Node and compiles declarations
+with the declared dependency closure and PM absent.
+
+## Process wire lifecycle
+
+The explicit \`@vibesdotdev/kernel-rpc/execution\` subpath owns process handle
+adaptation. Compose \`@vibesdotdev/kernel-rpc/execution/plugin\` or the RPC
+\`/plugin\` to register the lazy \`execution-wire\` runtime client. Activation
+resolves it. \`adaptWireProcessHandle\` and \`acquireWireProcess\` are exported from
+this subpath and read only the port they are handed; the kernel keeps the
+structural contracts.
+Output delivery, stdin acknowledgements, cancellation, abandonment and cleanup
+evidence retain the caller's diagnostics owner.
+
+## The three verbs
+
+| Verb | What it does |
+| --- | --- |
+| \`invoke\` | Call an opaque method on a remote reference and await the result. \`query\` is \`invoke(rootRef, 'query', [kindId])\`; a session resize is \`invoke(sessionRef, 'resize', [cols, rows])\`. |
+| \`release\` | Drop a reference. Sent on \`Symbol.dispose\` or GC of a proxy, so the owning end frees what it retained — no leaked sessions. |
+| \`stream\` | Open a raw, framed byte channel bound to a reference (the PTY fast-path). Bytes ride a 1-byte frame header, never the invoke envelope. |
+
+There is no fourth verb. If a method name ever appeared as a protocol constant, the protocol would be wrong.
+
+## Wire values and symmetric reference tables
+
+Every value crossing the wire is one of three shapes: \`json\` (inline structured-clone-safe data), \`ref\` (a handle to a non-serializable object — a session, a handle, a function — held in the *other* end's reference table), or \`stream\` (a ref with a named raw byte channel).
+
+MessagePort preserves Dates through structured cloning. HTTP negotiates Date paths at connect. Unix and TCP opt in with one wire-capability record before the first request, only when the listener advertised support. The daemon's projection listener enables this negotiation; ordinary socket listeners retain plain JSON by default. CEF negotiates through a capable native host and relay. Relay and Tauri retain plain JSON. Explicit Date paths distinguish Dates from identical ISO strings; unnegotiated metadata is refused.
+
+A **stream channel** may be credit-governed: its owner opens it at zero credit and sends one DATA frame per credit the consumer grants (\`creditedEvents\` grants the initial credit and re-grants one per event handled), so a producer never runs ahead of its consumer. On a socket this needs the \`streamCredits\` wire capability, advertised by a listener started with \`streamCredits: true\` and opted into by the client; elsewhere a credit-governed channel is refused typed (\`rpc-stream-credits-unnegotiated\`).
+
+Both ends of a connection hold a reference table. Returning a session makes the **callee** a ref owner; passing a callback argument makes the **caller** a ref owner — the tables are symmetric. Disposing a proxy (or GC without disposal, via \`FinalizationRegistry\`) sends \`release\`, and a hard disconnect clears the whole per-connection table, so nothing a connection retained outlives it.
+
+Callback arguments require an owner→consumer **reverse leg** to invoke back. The duplex socket transports (unix, tcp) have one; the http transport does not — an http \`invoke\` carrying a ref/stream argument is rejected with \`RPC_NO_REVERSE_CHANNEL\` before the method runs, never decoded to a silent no-op.
+
+## Closing a stream channel
+
+\`channel.ended\` resolves when the owner ended the channel (a data EOF) and every byte before it reached a subscriber. \`channel.close()\` is the consumer's own close: it discards locally and sends its close in frame order at once, and its promise settles to what the transport can say about the owner:
+
+| Outcome | Meaning |
+| --- | --- |
+| \`{ acknowledged: true }\` | The owner confirmed its binding closed. Over http the owner answers the close only once that binding's close settled — including a close it already started when the channel's SSE leg dropped — and states the outcome in the answer body (\`{ ack }\`); a bare 2xx is never read as an acknowledgement. In process, the owner's settle is the acknowledgement. |
+| \`{ acknowledged: false, reason: 'forwarded-unacknowledged' }\` | The relay broker accepted and forwarded the close; the owner sends no answer back. |
+| \`{ acknowledged: false, reason: 'unacknowledged-transport' }\` | The transport's close has no answer (unix/tcp frame, desktop bridges). |
+| \`{ acknowledged: false, reason: 'already-ended' }\` | The owner ended the channel or the connection dropped first, so nothing was closed. A data EOF is not an acknowledgement that the owner disposed its reader. |
+| \`{ acknowledged: false, reason: 'owner-unknown' }\` | The owner holds no such connection or channel (it disconnected, or never had it), so it cannot say what became of it. The http owner answers this explicitly rather than with a 2xx acknowledgement. |
+
+A refused close (a non-2xx answer), a close that could not be delivered, or an owner binding whose close failed rejects with a \`CapabilityError\` whose reason is \`rpc-channel-close-failed\`, carrying the status and the owner's typed error as its cause. Treat \`acknowledged: false\` as unconfirmed.
+
+## The frozen descriptor
+
+A reachable runtime registers a \`runtime/rpc\` descriptor; the resolver walks these to extend the candidate set for any kind. The schema is frozen:
+
+\`\`\`ts
+{
+  kind: 'runtime/rpc',
+  id: 'my-remote',
+  transport: 'unix' | 'tcp' | 'http' | 'relay' | 'messageport' | 'cef' | 'tauri',
+  target:
+    | { transport: 'unix', socketPath: string }
+    | { transport: 'tcp',  host: string, port: number }
+    | { transport: 'http', origin: string }
+    | { transport: 'relay', brokerOrigin: string, hostId: string, actingOrgId?: string }
+    | { transport: 'messageport', channel: string }
+    | { transport: 'cef', channel: string }
+    | { transport: 'tauri', channel: string },
+  auth?: CredentialReference,   // resolved at connect time via secrets — never a bare token
+  remoteScope?: { hardware?: 'consumer' | 'cloud', substrate?: string }
+}
+\`\`\`
+
+Transport implementations are exposed through explicit \`@vibesdotdev/kernel-rpc/*\` subpaths. Unix, TCP, HTTP, MessagePort, CEF, and Tauri also expose dedicated \`/plugin\` entrypoints. Relay registration helpers live under \`/relay\`. The consumer never sees a transport — it sees a proxy of the remote root.
+
+The unix and tcp transports bind and dial through the runtime socket capability (\`@vibesdotdev/kernel/socket\`), so a runtime environment such as \`@vibesdotdev/host-bun\` must be registered before \`listenUnix\`, \`listenTcp\`, \`connectUnix\` or \`connectTcp\` run. Without one they throw "The active runtime has no enabled socket provider"; register the environment plugin to fix it. The standalone HTTP listener lives at \`@vibesdotdev/kernel-rpc/http\`: call \`await listenHttp(port, target, { runtime })\` with the owning runtime, which selects its native listener.
+
+A relay target's \`actingOrgId\` names the organization the consumer acts in; every broker request carries it as \`x-vibes-active-org\`, so the broker admits an organization-owned host in its owner's scope. A personal host omits it.
+
+\`auth\` is refused at parse on cef, tauri, and messageport descriptors: the native host (cef, tauri) owns credential custody, and a MessagePort peer is a credential-free sandboxed frame.
+
+## The hard security gate
+
+Every arriving \`invoke\` on the listen side dispatches through the SAME L1 invoke pipeline (\`authz → friction\`) a local call runs. There is no second code path and no verb-level read/write split: a remote peer with a valid connection token is still denied an out-of-policy invoke by the gates, identically to a local caller. The http transport adds *connection-level* bearer auth (resolved from the descriptor's \`auth\` credential reference) on top — never instead — of the per-invoke gates.
+
+## Errors
+
+Stable \`RPC_*\` codes in every error envelope: \`RPC_DISCONNECTED\` (the connection closed — surfaces in the result, never a hang or silent local fallback), \`RPC_NO_TARGET\`, \`RPC_NO_METHOD\`, \`RPC_NO_CHANNEL\`, \`RPC_NO_REVERSE_CHANNEL\`, \`RPC_INVOKE_FAILED\`. A gate veto is a typed \`PERMISSION_DENIED\` (reason \`authz-denied\` or \`bright-line-violation\`): a coded throw keeps its code across the wire, and only an uncoded failure is \`RPC_INVOKE_FAILED\`.
+
+## Usage
+
+The canonical path is the resolver: \`query(kind).matching({ host })\` — the resolver inserts the transport. The sugar:
+
+\`\`\`ts
+import { getVibesRemoteFrom } from '@vibesdotdev/kernel-rpc';
+
+using remote = await getVibesRemoteFrom(runtime, 'my-remote'); // disposable: releases the root ref + closes
+const execution = await remote.query('runtime/execution');
+\`\`\`
+
+String queries are asynchronous and may return a remote implementation reference. Object queries return descriptor metadata parsed with Runtime's public \`RuntimeDescriptorQueryResultSchema\` (\`@vibesdotdev/kernel/schemas/descriptor\`). The parser validates each descriptor's base fields and retains feature metadata for the owning feature to validate. A success response states \`success: true\`; \`count\` is optional, and an advertised count is a nonnegative integer. A \`success: false\` envelope and its error are preserved. Malformed metadata rejects with \`INVALID_INPUT\` / \`rpc-query-result-invalid\`; genuine remote errors propagate.
+
+## Daemon ingress and invocation
+
+The explicit daemon surfaces are \`./daemon\`, \`./client\` (also \`./daemon/client\`),
+\`./daemon/rpc-root\`, \`./daemon/plugin\`, and \`./daemon/cli/plugin\`.
+\`./descriptor-wire\` serializes feature metadata and projects schemas without
+exporting host I/O from the root barrel.
+
+Daemon RPC, subscription nonce minting and pairing share the HTTP bounded
+reader. Bodies declaring or streaming beyond \`RPC_MAX_MESSAGE_BYTES\` are
+cancelled and refused HTTP 413 \`INVALID_INPUT\` / \`rpc-request-too-large\`
+before dispatch. Read and cancellation failures remain observable and secret-safe.
+Authentication, optional subscription bodies, nonces and route CORS are preserved.
+
+One schema owns invoke input, including legacy aliases and the runtime-command
+envelope. Malformed supplied fields refuse \`invoke-request-invalid\` with
+\`INVALID_INPUT\`; missing ids refuse \`invoke-id-missing\`. Fix the named
+fields and retry. Identity comes from the admitted actor; request fields never
+establish it. Workspace-binding refusals retain their owner's code and reason.
+
+The docs plugin registers this topic, MessagePort, Tauri, runtime lifecycle and
+runtime system topics.
+
+## Code paths
+
+- Wire schemas and bounded reasons: \`kernel-rpc/src/schemas/contracts/protocol/wire/{schemas,reason}.ts\`
+- Verbs + error codes: \`kernel-rpc/src/core/protocol/wire/verbs.ts\`
+- Wire values + symmetric encode/decode: \`kernel-rpc/src/core/protocol/wire/wire-value.ts\`
+- Owner dispatch (→ L1 pipeline): \`kernel-rpc/src/core/protocol/references/dispatch.ts\`
+- Frozen descriptor schema: \`kernel-rpc/src/core/kinds/rpc.kind.ts\`
+- Transport APIs: \`@vibesdotdev/kernel-rpc/unix\`, \`@vibesdotdev/kernel-rpc/tcp\`, \`@vibesdotdev/kernel-rpc/http\`, \`@vibesdotdev/kernel-rpc/relay\`, \`@vibesdotdev/kernel-rpc/messageport\`, \`@vibesdotdev/kernel-rpc/cef\`, \`@vibesdotdev/kernel-rpc/tauri\`
+`
+    },
+    parent: 'runtime',
+    order: 5,
+    tags: ['runtime', 'rpc', 'remote', 'transport', 'protocol'],
+    surfaces: ['cli', 'web', 'in-app'],
+    hardware: ['consumer', 'cloud'],
+    enabled: true
+};
+export default descriptor;
+//# sourceMappingURL=runtime-rpc.docs.descriptor.js.map

package/dist/docs/runtime-rpc.docs.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-rpc.docs.descriptor.js","sourceRoot":"","sources":["../../src/docs/runtime-rpc.docs.descriptor.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,GAAwB;IACvC,IAAI,EAAE,YAAY;IAClB,EAAE,EAAE,aAAa;IACjB,KAAK,EAAE,aAAa;IACpB,OAAO,EACN,2HAA2H;IAC5H,IAAI,EAAE;QACL,IAAI,EAAE,UAAU;QAChB,UAAU,EAAE,KAAK;QACjB,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgKT;KACC;IACD,MAAM,EAAE,SAAS;IACjB,KAAK,EAAE,CAAC;IACR,IAAI,EAAE,CAAC,SAAS,EAAE,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,UAAU,CAAC;IAC3D,QAAQ,EAAE,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,CAAC;IAClC,QAAQ,EAAE,CAAC,UAAU,EAAE,OAAO,CAAC;IAC/B,OAAO,EAAE,IAAI;CACb,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/docs/system.docs.descriptor.d.ts

@@ -0,0 +1,4 @@
+import type { DocsTopicDescriptor } from '@vibesdotdev/docs-contracts';
+declare const descriptor: DocsTopicDescriptor;
+export default descriptor;
+//# sourceMappingURL=system.docs.descriptor.d.ts.map

package/dist/docs/system.docs.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system.docs.descriptor.d.ts","sourceRoot":"","sources":["../../src/docs/system.docs.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,6BAA6B,CAAC;AAyFvE,QAAA,MAAM,UAAU,EAAE,mBA0BjB,CAAC;AAEF,eAAe,UAAU,CAAC"}