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

package/dist/schemas/contracts/transports/unix/in-process.transport.d.ts

@@ -0,0 +1,61 @@
+import { DefaultReferenceTable, type InvokePipeline, type RemotePeerInfo } from '@vibesdotdev/kernel';
+import { type ChannelBinder, type ConsumerEnd, type KindOf, type WireClassifier } from '@vibesdotdev/kernel-rpc';
+import * as z from 'zod/v4';
+export interface InProcessConnection {
+    /** The remote-root proxy (consumer side). `query(...)` lands here. */
+    readonly root: unknown;
+    /** The consumer-end machinery (table, proxy factory). */
+    readonly consumer: ConsumerEnd;
+    /** Owner-side ref table — the leak assertion reads `.size`. */
+    readonly ownerTable: DefaultReferenceTable;
+    /** Close the connection: pending + future invokes reject with RPC_DISCONNECTED. */
+    close(): Promise<void>;
+    /** Resolves when closed. */
+    readonly closed: Promise<void>;
+}
+export interface InProcessOptions {
+    /** The owner's root object — its methods are the remote runtime surface. */
+    readonly root: object;
+    /**
+     * The root's methods when it is not the runtime root (`RUNTIME_ROOT_METHODS`):
+     * the consumer's root proxy exposes exactly these.
+     */
+    readonly rootMethods?: readonly string[];
+    /** L1 invoke pipeline that gates arriving invokes (authz → friction). */
+    readonly pipeline: InvokePipeline;
+    /**
+     * Classify an owner return value: which returns become refs (a session, a
+     * ProcessHandle, a function). Plain data is inline. The owner (listen side)
+     * supplies this — it is the kind-aware policy, kept OUT of the protocol.
+     */
+    readonly classifyResult: WireClassifier;
+    /**
+     * Map an opaque channel name on a resolved owner object to a byte binding.
+     * E.g. channel 'pty' on a session → { onData: session.onOutput, write:
+     * session.write }. The protocol names no channel; this does.
+     */
+    readonly bindChannel: ChannelBinder;
+    /** Report the kind id for a target (for the gate context). Defaults to 'runtime/rpc'. */
+    readonly kindOf?: KindOf;
+    /**
+     * Peer identity reported to the gates. Defaults to an in-process peer that
+     * verified no caller. Its `verified` is exactly what the trusted host that
+     * wires both ends passes (RC08); nothing is inferred.
+     */
+    readonly remotePeer?: RemotePeerInfo;
+}
+export declare const InProcessInput: z.ZodObject<{
+    remotePeer: z.ZodOptional<z.ZodCustom<RemotePeerInfo, RemotePeerInfo>>;
+    root: z.ZodCustom<object, object>;
+    rootMethods: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    pipeline: z.ZodCustom<InvokePipeline, InvokePipeline>;
+    classifyResult: z.ZodCustom<WireClassifier, WireClassifier>;
+    bindChannel: z.ZodCustom<ChannelBinder, ChannelBinder>;
+    kindOf: z.ZodOptional<z.ZodCustom<KindOf, KindOf>>;
+    forward: z.ZodOptional<z.ZodObject<{
+        connect: z.ZodCustom<(peer: RemotePeerInfo) => Promise<import("@vibesdotdev/kernel-rpc").RpcConnection>, (peer: RemotePeerInfo) => Promise<import("@vibesdotdev/kernel-rpc").RpcConnection>>;
+        lifecycle: z.ZodCustom<import("@vibesdotdev/kernel-rpc").RpcLifecycle, import("@vibesdotdev/kernel-rpc").RpcLifecycle>;
+        localMethods: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+//# sourceMappingURL=in-process.transport.d.ts.map

package/dist/schemas/contracts/transports/unix/in-process.transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-process.transport.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/in-process.transport.ts"],"names":[],"mappings":"AAAA,OAAO,EACP,qBAAqB,EACrB,KAAK,cAAc,EACnB,KAAK,cAAc,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACP,KAAK,aAAa,EAClB,KAAK,WAAW,EAChB,KAAK,MAAM,EACX,KAAK,cAAc,EAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,MAAM,WAAW,mBAAmB;IACnC,sEAAsE;IACtE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;IACvB,yDAAyD;IACzD,QAAQ,CAAC,QAAQ,EAAE,WAAW,CAAC;IAC/B,+DAA+D;IAC/D,QAAQ,CAAC,UAAU,EAAE,qBAAqB,CAAC;IAC3C,mFAAmF;IACnF,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IACvB,4BAA4B;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;CAC/B;AAED,MAAM,WAAW,gBAAgB;IAChC,4EAA4E;IAC5E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,yEAAyE;IACzE,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC;;;;OAIG;IACH,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;IACpC,yFAAyF;IACzF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,QAAQ,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC;CACrC;AAED,eAAO,MAAM,cAAc;;;;;;;;;;;;;iBAA4F,CAAC"}

package/dist/schemas/contracts/transports/unix/in-process.transport.js

@@ -0,0 +1,6 @@
+import { DefaultReferenceTable } from '@vibesdotdev/kernel';
+import {} from '@vibesdotdev/kernel-rpc';
+import * as z from 'zod/v4';
+import { ListenTargetFields, objectInput } from "../../../../core/protocol/references/caller-input.js";
+export const InProcessInput = z.object({ ...ListenTargetFields, remotePeer: objectInput().optional() });
+//# sourceMappingURL=in-process.transport.js.map

package/dist/schemas/contracts/transports/unix/in-process.transport.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"in-process.transport.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/in-process.transport.ts"],"names":[],"mappings":"AAAA,OAAO,EACP,qBAAqB,EAGpB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAKN,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AA+CvG,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,kBAAkB,EAAE,UAAU,EAAE,WAAW,EAAkB,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC"}

package/dist/schemas/contracts/transports/unix/runtime-rpc-unix.plugin.d.ts

@@ -0,0 +1,79 @@
+import { type RuntimeRpcDescriptor } from '@vibesdotdev/kernel-rpc';
+import * as z from 'zod/v4';
+export interface RuntimeRpcUnixPluginOptions {
+    /** Concrete unix descriptors to register (e.g. the local-daemon socket). */
+    descriptors?: RuntimeRpcDescriptor[];
+}
+export declare const PluginOptionsInput: z.ZodOptional<z.ZodObject<{
+    descriptors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        description: z.ZodOptional<z.ZodString>;
+        tags: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        hardware: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        priority: z.ZodOptional<z.ZodNumber>;
+        capabilityId: z.ZodOptional<z.ZodString>;
+        requiredContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        optionalContext: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        config: z.ZodOptional<z.ZodUnknown>;
+        retention: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+            maxAgeDays: z.ZodOptional<z.ZodNumber>;
+            maxEntries: z.ZodOptional<z.ZodNumber>;
+            maxBytes: z.ZodOptional<z.ZodNumber>;
+            cascadeFrom: z.ZodOptional<z.ZodString>;
+            ageField: z.ZodOptional<z.ZodString>;
+            reason: z.ZodString;
+            enforcedBy: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>]>>;
+        kind: z.ZodLiteral<"runtime/rpc">;
+        transport: z.ZodEnum<{
+            cef: "cef";
+            unix: "unix";
+            tcp: "tcp";
+            http: "http";
+            relay: "relay";
+            messageport: "messageport";
+            tauri: "tauri";
+        }>;
+        target: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            transport: z.ZodLiteral<"unix">;
+            socketPath: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            transport: z.ZodLiteral<"tcp">;
+            host: z.ZodString;
+            port: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            transport: z.ZodLiteral<"http">;
+            origin: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            transport: z.ZodLiteral<"cef">;
+            channel: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            transport: z.ZodLiteral<"messageport">;
+            channel: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            transport: z.ZodLiteral<"relay">;
+            brokerOrigin: z.ZodString;
+            hostId: z.ZodString;
+            actingOrgId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            transport: z.ZodLiteral<"tauri">;
+            channel: z.ZodString;
+        }, z.core.$strip>], "transport">;
+        auth: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            source: z.ZodLiteral<"secret">;
+            key: z.ZodString;
+            store: z.ZodOptional<z.ZodString>;
+            operation: z.ZodOptional<z.ZodCustom<object, object>>;
+        }, z.core.$strict>], "source">>;
+        remoteScope: z.ZodOptional<z.ZodObject<{
+            hardware: z.ZodOptional<z.ZodEnum<{
+                consumer: "consumer";
+                cloud: "cloud";
+            }>>;
+            substrate: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>>;
+}, z.core.$strip>>;
+//# sourceMappingURL=runtime-rpc-unix.plugin.d.ts.map

package/dist/schemas/contracts/transports/unix/runtime-rpc-unix.plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-rpc-unix.plugin.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/runtime-rpc-unix.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,oBAAoB,EAAE,MAAM,yBAAyB,CAAC;AACpE,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,MAAM,WAAW,2BAA2B;IAC3C,4EAA4E;IAC5E,WAAW,CAAC,EAAE,oBAAoB,EAAE,CAAC;CACrC;AAED,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAiG,CAAC"}

package/dist/schemas/contracts/transports/unix/runtime-rpc-unix.plugin.js

@@ -0,0 +1,5 @@
+import {} from '@vibesdotdev/kernel-rpc';
+import * as z from 'zod/v4';
+import { RuntimeRpcDescriptorSchema } from "../../../../core/kinds/rpc.kind.js";
+export const PluginOptionsInput = z.object({ descriptors: z.array(RuntimeRpcDescriptorSchema).max(1024).optional() }).optional();
+//# sourceMappingURL=runtime-rpc-unix.plugin.js.map

package/dist/schemas/contracts/transports/unix/runtime-rpc-unix.plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-rpc-unix.plugin.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/runtime-rpc-unix.plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAA6B,MAAM,yBAAyB,CAAC;AACpE,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAOhF,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,WAAW,EAAE,CAAC,CAAC,KAAK,CAAC,0BAA0B,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC"}

package/dist/schemas/contracts/transports/unix/socket-codec.d.ts

@@ -0,0 +1,109 @@
+import { type StreamEnding } from '@vibesdotdev/kernel-rpc';
+import * as z from 'zod/v4';
+import type { REC } from "../../../../transports/unix/codec/socket-codec.ts";
+export declare const SocketWireRecordSchema: z.ZodObject<{
+    wire: z.ZodReadonly<z.ZodObject<{
+        dates: z.ZodOptional<z.ZodLiteral<true>>;
+        streamCredits: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type SocketWireRecord = z.infer<typeof SocketWireRecordSchema>;
+export declare const SocketMessageSchema: z.ZodUnion<readonly [z.ZodReadonly<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    verb: z.ZodLiteral<"invoke">;
+    id: z.ZodString;
+    targetRef: z.core.$ZodBranded<z.ZodString, "RefId", "out">;
+    method: z.ZodString;
+    args: z.ZodReadonly<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        t: z.ZodLiteral<"json">;
+        v: z.ZodCustom<import("@vibesdotdev/kernel-rpc").RpcData, import("@vibesdotdev/kernel-rpc").RpcData>;
+        dates: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        t: z.ZodLiteral<"ref">;
+        id: z.core.$ZodBranded<z.ZodString, "RefId", "out">;
+        kind: z.ZodEnum<{
+            object: "object";
+            function: "function";
+            stream: "stream";
+        }>;
+        methods: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        channels: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        t: z.ZodLiteral<"stream">;
+        id: z.core.$ZodBranded<z.ZodString, "RefId", "out">;
+        channel: z.ZodString;
+    }, z.core.$strict>>], "t">>>;
+    caller: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strict>, z.ZodObject<{
+    verb: z.ZodLiteral<"release">;
+    id: z.ZodString;
+    ref: z.core.$ZodBranded<z.ZodString, "RefId", "out">;
+}, z.core.$strict>, z.ZodObject<{
+    verb: z.ZodLiteral<"stream">;
+    id: z.ZodString;
+    ref: z.core.$ZodBranded<z.ZodString, "RefId", "out">;
+    channel: z.ZodString;
+}, z.core.$strict>], "verb">>, z.ZodReadonly<z.ZodObject<{
+    id: z.ZodString;
+    result: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodReadonly<z.ZodObject<{
+        t: z.ZodLiteral<"json">;
+        v: z.ZodCustom<import("@vibesdotdev/kernel-rpc").RpcData, import("@vibesdotdev/kernel-rpc").RpcData>;
+        dates: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodReadonly<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>>>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        t: z.ZodLiteral<"ref">;
+        id: z.core.$ZodBranded<z.ZodString, "RefId", "out">;
+        kind: z.ZodEnum<{
+            object: "object";
+            function: "function";
+            stream: "stream";
+        }>;
+        methods: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        channels: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+    }, z.core.$strict>>, z.ZodReadonly<z.ZodObject<{
+        t: z.ZodLiteral<"stream">;
+        id: z.core.$ZodBranded<z.ZodString, "RefId", "out">;
+        channel: z.ZodString;
+    }, z.core.$strict>>], "t">>;
+    error: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+        code: z.ZodString;
+        message: z.ZodString;
+        details: z.ZodOptional<z.ZodUnknown>;
+        reason: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>>, z.ZodObject<{
+    id: z.ZodLiteral<"attest">;
+    attest: z.ZodObject<{
+        secret: z.ZodString;
+        caller: z.ZodType<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue, z.core.$ZodTypeInternals<import("@vibesdotdev/kernel/bootstrap").JsonValue, import("@vibesdotdev/kernel/bootstrap").JsonValue>>;
+    }, z.core.$strict>;
+}, z.core.$strict>, z.ZodObject<{
+    wire: z.ZodReadonly<z.ZodObject<{
+        dates: z.ZodOptional<z.ZodLiteral<true>>;
+        streamCredits: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strict>>;
+}, z.core.$strict>]>;
+export type SocketMessage = z.infer<typeof SocketMessageSchema>;
+export type RecordKind = (typeof REC)[keyof typeof REC];
+export interface DuplexSocket {
+    write(data: Uint8Array): number;
+    end(): void;
+    /** Bytes accepted into a native userspace buffer, if any. */
+    readonly bufferedBytes?: number;
+    drain?(): void;
+}
+export type DecodedRecord = {
+    readonly kind: 'msg';
+    readonly message: SocketMessage;
+} | {
+    readonly kind: 'stream-data';
+    readonly channelId: string;
+    readonly payload: Uint8Array;
+} | {
+    readonly kind: 'stream-close';
+    readonly channelId: string;
+    readonly ending?: StreamEnding;
+} | {
+    readonly kind: 'stream-credit';
+    readonly channelId: string;
+    readonly credits: number;
+};
+//# sourceMappingURL=socket-codec.d.ts.map

package/dist/schemas/contracts/transports/unix/socket-codec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-codec.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/socket-codec.ts"],"names":[],"mappings":"AAAA,OAAO,EACP,KAAK,YAAY,EAChB,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,OAAO,KAAK,EAAE,GAAG,EAAE,MAAM,mDAAmD,CAAC;AAE7E,eAAO,MAAM,sBAAsB;;;;;kBAAmD,CAAC;AAEvF,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,mBAAmB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;oBAA0G,CAAC;AAE3I,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAEhE,MAAM,MAAM,UAAU,GAAG,CAAC,OAAO,GAAG,CAAC,CAAC,MAAM,OAAO,GAAG,CAAC,CAAC;AAExD,MAAM,WAAW,YAAY;IAC5B,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,MAAM,CAAC;IAChC,GAAG,IAAI,IAAI,CAAC;IACZ,6DAA6D;IAC7D,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAChC,KAAK,CAAC,IAAI,IAAI,CAAC;CACf;AAED,MAAM,MAAM,aAAa,GACtB;IAAE,QAAQ,CAAC,IAAI,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,aAAa,CAAA;CAAE,GACzD;IAAE,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,UAAU,CAAA;CAAE,GAC1F;IAAE,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,MAAM,CAAC,EAAE,YAAY,CAAA;CAAE,GAC7F;IAAE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC"}

package/dist/schemas/contracts/transports/unix/socket-codec.js

@@ -0,0 +1,7 @@
+import {} from '@vibesdotdev/kernel-rpc';
+import * as z from 'zod/v4';
+import { SocketAttestationEnvelopeSchema } from "../../../../core/protocol/transport/local-attestation.js";
+import { RpcRequestSchema, RpcResponseSchema, WireCapabilitiesSchema } from "../../../../core/protocol/wire/schemas.js";
+export const SocketWireRecordSchema = z.strictObject({ wire: WireCapabilitiesSchema });
+export const SocketMessageSchema = z.union([RpcRequestSchema, RpcResponseSchema, SocketAttestationEnvelopeSchema, SocketWireRecordSchema]);
+//# sourceMappingURL=socket-codec.js.map

package/dist/schemas/contracts/transports/unix/socket-codec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-codec.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/socket-codec.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,MAAM,yBAAyB,CAAC;AACjC,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,+BAA+B,EAAE,MAAM,0DAA0D,CAAC;AAC3G,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAGxH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,YAAY,CAAC,EAAE,IAAI,EAAE,sBAAsB,EAAE,CAAC,CAAC;AAIvF,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,gBAAgB,EAAE,iBAAiB,EAAE,+BAA+B,EAAE,sBAAsB,CAAC,CAAC,CAAC"}

package/dist/schemas/contracts/transports/unix/socket-handshake.d.ts

@@ -0,0 +1,25 @@
+import type { CaughtFailure } from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+export declare const SocketHandshakeSchema: z.ZodObject<{
+    id: z.ZodLiteral<"handshake">;
+    result: z.ZodObject<{
+        t: z.ZodLiteral<"json">;
+        v: z.ZodObject<{
+            rootRef: z.ZodString;
+            wire: z.ZodOptional<z.ZodReadonly<z.ZodObject<{
+                dates: z.ZodOptional<z.ZodLiteral<true>>;
+                streamCredits: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strict>>>;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+export type SocketHandshake = z.infer<typeof SocketHandshakeSchema>;
+export interface SocketHandshakeFailures {
+    /** The first record was not a well-formed handshake. */
+    invalid(message: string, cause?: CaughtFailure): Error;
+    /** The socket closed before the handshake arrived. */
+    closed(): Error;
+    /** The socket errored before the handshake arrived. */
+    failed(cause: Error): Error;
+}
+//# sourceMappingURL=socket-handshake.d.ts.map

package/dist/schemas/contracts/transports/unix/socket-handshake.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-handshake.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/socket-handshake.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,qBAAqB;;;;;;;;;;;;kBAMhC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAEpE,MAAM,WAAW,uBAAuB;IACvC,wDAAwD;IACxD,OAAO,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,EAAE,aAAa,GAAG,KAAK,CAAC;IACvD,sDAAsD;IACtD,MAAM,IAAI,KAAK,CAAC;IAChB,uDAAuD;IACvD,MAAM,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC;CAC5B"}

package/dist/schemas/contracts/transports/unix/socket-handshake.js

@@ -0,0 +1,10 @@
+import * as z from 'zod/v4';
+import { WireCapabilitiesSchema } from "../../../../core/protocol/wire/schemas.js";
+export const SocketHandshakeSchema = z.strictObject({
+    id: z.literal('handshake'),
+    result: z.strictObject({
+        t: z.literal('json'),
+        v: z.strictObject({ rootRef: z.string().min(1), wire: WireCapabilitiesSchema.optional() })
+    })
+});
+//# sourceMappingURL=socket-handshake.js.map

package/dist/schemas/contracts/transports/unix/socket-handshake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-handshake.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/socket-handshake.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,sBAAsB,EAAE,MAAM,2CAA2C,CAAC;AAEnF,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,YAAY,CAAC;IACnD,EAAE,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;IAC1B,MAAM,EAAE,CAAC,CAAC,YAAY,CAAC;QACtB,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;QACpB,CAAC,EAAE,CAAC,CAAC,YAAY,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,IAAI,EAAE,sBAAsB,CAAC,QAAQ,EAAE,EAAE,CAAC;KAC1F,CAAC;CACF,CAAC,CAAC"}

package/dist/schemas/contracts/transports/unix/socket-listener.d.ts

@@ -0,0 +1,41 @@
+import { type InvokePipeline, type RemotePeerInfo } from '@vibesdotdev/kernel';
+import { type ChannelBinder, type KindOf, type RpcConnection, type RpcLifecycle, type WireClassifier } from '@vibesdotdev/kernel-rpc';
+export interface SocketForwardTarget {
+    connect(peer: RemotePeerInfo): Promise<RpcConnection>;
+    readonly lifecycle: RpcLifecycle;
+    /** Owner-declared root methods execute locally through the same admission pipeline. */
+    readonly localMethods?: readonly string[];
+}
+export interface RpcListenConnection {
+    readonly connectionId: string;
+    readonly signal: AbortSignal;
+}
+export type ConnectionRootFactory = (connection: RpcListenConnection) => object;
+export interface ListenTarget {
+    /**
+     * The root object — its methods are the remote runtime query surface.
+     * Exactly one of `root` and `connectionRoot` is given.
+     */
+    readonly root?: object;
+    /**
+     * Builds each accepted connection's root, handed that connection's close
+     * signal, so its methods can end work the peer no longer awaits.
+     */
+    readonly connectionRoot?: ConnectionRootFactory;
+    /**
+     * The root's methods when it is not the runtime root (`RUNTIME_ROOT_METHODS`).
+     * The owner admits only these on the root; anything else is refused.
+     */
+    readonly rootMethods?: readonly string[];
+    /** L1 invoke pipeline (authz → friction) every arriving invoke runs through. */
+    readonly pipeline: InvokePipeline;
+    /** Classify an owner return value: which become refs (session/handle/function). */
+    readonly classifyResult: WireClassifier;
+    /** Map an opaque channel name on a resolved object to a byte binding. */
+    readonly bindChannel: ChannelBinder;
+    /** Report the kind id for a target (gate context). Defaults to 'runtime/rpc'. */
+    readonly kindOf?: KindOf;
+    /** Preserve opaque RPC refs across an owner-private execution boundary. */
+    readonly forward?: SocketForwardTarget;
+}
+//# sourceMappingURL=socket-listener.d.ts.map

package/dist/schemas/contracts/transports/unix/socket-listener.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-listener.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/socket-listener.ts"],"names":[],"mappings":"AAAA,OAAO,EACP,KAAK,cAAc,EACnB,KAAK,cAAc,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACP,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,cAAc,EAClB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,mBAAmB;IACnC,OAAO,CAAC,IAAI,EAAE,cAAc,GAAG,OAAO,CAAC,aAAa,CAAC,CAAC;IACtD,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,uFAAuF;IACvF,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;CAC1C;AAED,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC;CAC7B;AAED,MAAM,MAAM,qBAAqB,GAAG,CAAC,UAAU,EAAE,mBAAmB,KAAK,MAAM,CAAC;AAEhF,MAAM,WAAW,YAAY;IAC5B;;;OAGG;IACH,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAC;IACvB;;;OAGG;IACH,QAAQ,CAAC,cAAc,CAAC,EAAE,qBAAqB,CAAC;IAChD;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,mFAAmF;IACnF,QAAQ,CAAC,cAAc,EAAE,cAAc,CAAC;IACxC,yEAAyE;IACzE,QAAQ,CAAC,WAAW,EAAE,aAAa,CAAC;IACpC,iFAAiF;IACjF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,2EAA2E;IAC3E,QAAQ,CAAC,OAAO,CAAC,EAAE,mBAAmB,CAAC;CACvC"}

package/dist/schemas/contracts/transports/unix/socket-listener.js

@@ -0,0 +1,3 @@
+import {} from '@vibesdotdev/kernel';
+import {} from '@vibesdotdev/kernel-rpc';
+//# sourceMappingURL=socket-listener.js.map

package/dist/schemas/contracts/transports/unix/socket-listener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"socket-listener.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/socket-listener.ts"],"names":[],"mappings":"AAAA,OAAO,EAGN,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAMN,MAAM,yBAAyB,CAAC"}

package/dist/schemas/contracts/transports/unix/unix-transport.impl.d.ts

@@ -0,0 +1,42 @@
+import { type RuntimeRef } from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+import type { LocalAttestationPresentation, LocalAttestationVerifier } from "../../../../core/protocol/transport/local-attestation.ts";
+export type RpcSocketRuntime = Pick<RuntimeRef, 'hasKind' | 'query' | 'lifecycle' | 'registerPlugin'>;
+export interface UnixListener {
+    readonly socketPath: string;
+    /** Stop listening; rejects with the typed binding close failures of every connection it served. */
+    stop(): Promise<void>;
+}
+export declare const ConnectUnixInput: z.ZodObject<{
+    socketPath: z.ZodString;
+    options: z.ZodObject<{
+        runtime: z.ZodCustom<RpcSocketRuntime, RpcSocketRuntime>;
+        timeoutMs: z.ZodOptional<z.ZodNumber>;
+        signal: z.ZodOptional<z.ZodCustom<AbortSignal, AbortSignal>>;
+        attestation: z.ZodOptional<z.ZodCustom<LocalAttestationPresentation, LocalAttestationPresentation>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const ListenUnixInput: z.ZodObject<{
+    socketPath: z.ZodString;
+    target: z.ZodObject<{
+        root: z.ZodOptional<z.ZodCustom<object, object>>;
+        connectionRoot: z.ZodOptional<z.ZodCustom<import("./socket-listener.ts").ConnectionRootFactory, import("./socket-listener.ts").ConnectionRootFactory>>;
+        rootMethods: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        pipeline: z.ZodCustom<import("@vibesdotdev/kernel").InvokePipeline, import("@vibesdotdev/kernel").InvokePipeline>;
+        classifyResult: z.ZodCustom<import("../../protocol/wire/wire-value.ts").WireClassifier, import("../../protocol/wire/wire-value.ts").WireClassifier>;
+        bindChannel: z.ZodCustom<import("../../protocol/references/dispatch.ts").ChannelBinder, import("../../protocol/references/dispatch.ts").ChannelBinder>;
+        kindOf: z.ZodOptional<z.ZodCustom<import("../../protocol/references/dispatch.ts").KindOf, import("../../protocol/references/dispatch.ts").KindOf>>;
+        forward: z.ZodOptional<z.ZodObject<{
+            connect: z.ZodCustom<(peer: import("@vibesdotdev/kernel").RemotePeerInfo) => Promise<import("../../core/kinds/rpc.kind.ts").RpcConnection>, (peer: import("@vibesdotdev/kernel").RemotePeerInfo) => Promise<import("../../core/kinds/rpc.kind.ts").RpcConnection>>;
+            lifecycle: z.ZodCustom<import("../../protocol/lifecycle/connector.ts").RpcLifecycle, import("../../protocol/lifecycle/connector.ts").RpcLifecycle>;
+            localMethods: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>;
+    options: z.ZodObject<{
+        runtime: z.ZodCustom<RpcSocketRuntime, RpcSocketRuntime>;
+        attestation: z.ZodOptional<z.ZodCustom<LocalAttestationVerifier, LocalAttestationVerifier>>;
+        wireDates: z.ZodOptional<z.ZodBoolean>;
+        streamCredits: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=unix-transport.impl.d.ts.map

package/dist/schemas/contracts/transports/unix/unix-transport.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unix-transport.impl.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/unix-transport.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,UAAU,EAAE,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,KAAK,EAAE,4BAA4B,EAAE,wBAAwB,EAAE,MAAM,0DAA0D,CAAC;AAEvI,MAAM,MAAM,gBAAgB,GAAG,IAAI,CAAC,UAAU,EAAE,SAAS,GAAG,OAAO,GAAG,WAAW,GAAG,gBAAgB,CAAC,CAAC;AAEtG,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,mGAAmG;IACnG,IAAI,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACtB;AAED,eAAO,MAAM,gBAAgB;;;;;;;;iBAQ3B,CAAC;AAEH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;iBAS1B,CAAC"}

package/dist/schemas/contracts/transports/unix/unix-transport.impl.js

@@ -0,0 +1,23 @@
+import {} from '@vibesdotdev/kernel';
+import * as z from 'zod/v4';
+import { AbortSignalInput, DurationInput, SocketListenTargetInput, TextInput, memberInput, objectInput } from "../../../../core/protocol/references/caller-input.js";
+export const ConnectUnixInput = z.object({
+    socketPath: TextInput,
+    options: z.object({
+        runtime: memberInput('hasKind', 'query', 'registerPlugin'),
+        timeoutMs: DurationInput.optional(),
+        signal: AbortSignalInput.optional(),
+        attestation: objectInput().optional()
+    })
+});
+export const ListenUnixInput = z.object({
+    socketPath: TextInput,
+    target: SocketListenTargetInput,
+    options: z.object({
+        runtime: memberInput('hasKind', 'query', 'registerPlugin'),
+        attestation: memberInput('verify').optional(),
+        wireDates: z.boolean().optional(),
+        streamCredits: z.boolean().optional()
+    })
+});
+//# sourceMappingURL=unix-transport.impl.js.map

package/dist/schemas/contracts/transports/unix/unix-transport.impl.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unix-transport.impl.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/unix/unix-transport.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAmB,MAAM,qBAAqB,CAAC;AACtD,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,gBAAgB,EAAE,aAAa,EAAE,uBAAuB,EAAE,SAAS,EAAE,WAAW,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AAWrK,MAAM,CAAC,MAAM,gBAAgB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,UAAU,EAAE,SAAS;IACrB,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC;QACjB,OAAO,EAAE,WAAW,CAAmB,SAAS,EAAE,OAAO,EAAE,gBAAgB,CAAC;QAC5E,SAAS,EAAE,aAAa,CAAC,QAAQ,EAAE;QACnC,MAAM,EAAE,gBAAgB,CAAC,QAAQ,EAAE;QACnC,WAAW,EAAE,WAAW,EAAgC,CAAC,QAAQ,EAAE;KACnE,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC;IACvC,UAAU,EAAE,SAAS;IACrB,MAAM,EAAE,uBAAuB;IAC/B,OAAO,EAAE,CAAC,CAAC,MAAM,CAAC;QACjB,OAAO,EAAE,WAAW,CAAmB,SAAS,EAAE,OAAO,EAAE,gBAAgB,CAAC;QAC5E,WAAW,EAAE,WAAW,CAA2B,QAAQ,CAAC,CAAC,QAAQ,EAAE;QACvE,SAAS,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;QACjC,aAAa,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;KACrC,CAAC;CACF,CAAC,CAAC"}