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

package/dist/schemas/contracts/transports/messageport/contracts.d.ts

@@ -0,0 +1,88 @@
+import * as z from 'zod/v4';
+import type { RpcSource } from "../../../../core/protocol/wire/rpc-data.ts";
+export declare const MessagePortRpcFrameSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    t: z.ZodLiteral<"handshake">;
+    rootRef: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"req">;
+    req: 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.core.$strip>, z.ZodObject<{
+    t: z.ZodLiteral<"res">;
+    res: 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.core.$strip>], "t">;
+export type MessagePortRpcFrame = z.infer<typeof MessagePortRpcFrameSchema>;
+export interface RpcMessagePort {
+    /** Posts one frame: the port carries whatever structured clone can, so it is typed by the sender. */
+    postMessage: <F extends RpcSource>(value: F) => void;
+    /** `event.data` is whatever the peer cloned: a frame only once {@link MessagePortRpcFrameSchema} parsed it. */
+    addEventListener: (type: 'message', listener: (event: {
+        data: RpcSource;
+    }) => void) => void;
+    removeEventListener?: (type: 'message', listener: (event: {
+        data: RpcSource;
+    }) => void) => void;
+    start?: () => void;
+    close?: () => void;
+}
+//# sourceMappingURL=contracts.d.ts.map

package/dist/schemas/contracts/transports/messageport/contracts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/messageport/contracts.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,4CAA4C,CAAC;AAE5E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wBAKkC,CAAC;AAEzE,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,MAAM,WAAW,cAAc;IAC9B,qGAAqG;IACrG,WAAW,EAAE,CAAC,CAAC,SAAS,SAAS,EAAE,KAAK,EAAE,CAAC,KAAK,IAAI,CAAC;IACrD,+GAA+G;IAC/G,gBAAgB,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAK,IAAI,KAAK,IAAI,CAAC;IAC5F,mBAAmB,CAAC,EAAE,CAAC,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,KAAK,EAAE;QAAE,IAAI,EAAE,SAAS,CAAA;KAAE,KAAK,IAAI,KAAK,IAAI,CAAC;IAChG,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,IAAI,CAAC;CACnB"}

package/dist/schemas/contracts/transports/messageport/contracts.js

@@ -0,0 +1,9 @@
+import { RpcRequestSchema, RpcResponseSchema } from '@vibesdotdev/kernel-rpc';
+import * as z from 'zod/v4';
+import { hasWireDates } from "../../../../core/protocol/wire/json-wire.js";
+export const MessagePortRpcFrameSchema = z.discriminatedUnion('t', [
+    z.object({ t: z.literal('handshake'), rootRef: z.string().min(1).max(256) }),
+    z.object({ t: z.literal('req'), req: RpcRequestSchema }),
+    z.object({ t: z.literal('res'), res: RpcResponseSchema })
+]).refine((frame) => frame.t === 'handshake' || !hasWireDates(frame.t === 'req' ? frame.req : frame.res), 'MessagePort carries structured Dates rather than JSON Date metadata.');
+//# sourceMappingURL=contracts.js.map

package/dist/schemas/contracts/transports/messageport/contracts.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"contracts.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/messageport/contracts.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,yBAAyB,CAAC;AAC9E,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,YAAY,EAAE,MAAM,6CAA6C,CAAC;AAG3E,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,kBAAkB,CAAC,GAAG,EAAE;IAClE,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC,EAAE,OAAO,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC;IAC5E,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,gBAAgB,EAAE,CAAC;IACxD,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,iBAAiB,EAAE,CAAC;CACzD,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,WAAW,IAAI,CAAC,YAAY,CAAC,KAAK,CAAC,CAAC,KAAK,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,EACvG,sEAAsE,CAAC,CAAC"}

package/dist/schemas/contracts/transports/messageport/descriptors/messageport.rpc.descriptor.d.ts

@@ -0,0 +1,6 @@
+import * as z from 'zod/v4';
+export declare const DescriptorInput: z.ZodObject<{
+    id: z.ZodString;
+    channel: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=messageport.rpc.descriptor.d.ts.map

package/dist/schemas/contracts/transports/messageport/descriptors/messageport.rpc.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageport.rpc.descriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/schemas/contracts/transports/messageport/descriptors/messageport.rpc.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAG5B,eAAO,MAAM,eAAe;;;iBAAkD,CAAC"}

package/dist/schemas/contracts/transports/messageport/descriptors/messageport.rpc.descriptor.js

@@ -0,0 +1,4 @@
+import * as z from 'zod/v4';
+import { TextInput } from "../../../../../core/protocol/references/caller-input.js";
+export const DescriptorInput = z.object({ id: TextInput, channel: TextInput });
+//# sourceMappingURL=messageport.rpc.descriptor.js.map

package/dist/schemas/contracts/transports/messageport/descriptors/messageport.rpc.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageport.rpc.descriptor.js","sourceRoot":"","sources":["../../../../../../src/schemas/contracts/transports/messageport/descriptors/messageport.rpc.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,SAAS,EAAE,MAAM,yDAAyD,CAAC;AAEpF,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,EAAE,CAAC,CAAC"}

package/dist/schemas/contracts/transports/messageport/messageport-listener.d.ts

@@ -0,0 +1,79 @@
+import { type InvokePipeline } from '@vibesdotdev/kernel';
+import { type KindOf, type RpcLifecycle, type WireClassifier } from '@vibesdotdev/kernel-rpc';
+import { type VerifiedTransportIdentity } from '@vibesdotdev/kernel/schemas';
+import * as z from 'zod/v4';
+import { type RpcMessagePort } from "../../../../transports/messageport/connection/contracts.ts";
+export interface MessagePortInvocationBoundary {
+    <T>(work: () => T): T;
+}
+export interface MessagePortListenTarget {
+    readonly root: object;
+    /**
+     * 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[];
+    readonly pipeline: InvokePipeline;
+    /** The kind id reported on the gate context. */
+    readonly kindId?: string;
+    /** Explicit owner result capabilities; omitted keeps the function-only applet policy. */
+    readonly classifyResult?: WireClassifier;
+    /** The owner's kind policy for every retained target entering the invoke pipeline. */
+    readonly kindOf?: KindOf;
+    /** Host-established verification on an owner-private port; never read from a frame. */
+    readonly verifiedPeer?: VerifiedTransportIdentity;
+    /** Runs canonical dispatch in the composing owner's admitted workspace scope. */
+    readonly runInvocation?: MessagePortInvocationBoundary;
+    /** How long one dispatch may run. Configurable so it can be PROVEN. */
+    readonly deadlineMs?: number;
+    /** The owning runtime's lifecycle: it bounds every dispatch. */
+    readonly lifecycle: RpcLifecycle;
+}
+export interface MessagePortListener {
+    /** The ref the consumer must target. Advertised in the handshake. */
+    readonly rootRef: string;
+    close(): void;
+}
+export declare const ListenMessagePortInput: z.ZodObject<{
+    port: z.ZodCustom<RpcMessagePort, RpcMessagePort>;
+    target: z.ZodObject<{
+        root: z.ZodCustom<object, object>;
+        rootMethods: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodString>>>;
+        pipeline: z.ZodCustom<InvokePipeline, InvokePipeline>;
+        kindId: z.ZodOptional<z.ZodString>;
+        classifyResult: z.ZodOptional<z.ZodCustom<WireClassifier, WireClassifier>>;
+        kindOf: z.ZodOptional<z.ZodCustom<KindOf, KindOf>>;
+        runInvocation: z.ZodOptional<z.ZodCustom<MessagePortInvocationBoundary, MessagePortInvocationBoundary>>;
+        verifiedPeer: z.ZodOptional<z.ZodObject<{
+            source: z.ZodString;
+            caller: z.ZodObject<{
+                agentId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                harness: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                agentSystemId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                harnessSessionId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                userId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                orgId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                projectId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                teamId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                home: z.ZodOptional<z.ZodEnum<{
+                    user: "user";
+                    organization: "organization";
+                    team: "team";
+                }>>;
+                projectIds: z.ZodOptional<z.ZodReadonly<z.ZodArray<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>>>;
+                participantId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                sessionId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                instanceId: z.ZodOptional<z.ZodPipe<z.ZodPipe<z.ZodString, z.ZodTransform<string, string>>, z.ZodString>>;
+                extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>>;
+        deadlineMs: z.ZodOptional<z.ZodNumber>;
+        lifecycle: z.ZodCustom<RpcLifecycle, RpcLifecycle>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const OversizedRequestIdSchema: z.ZodObject<{
+    req: z.ZodObject<{
+        id: z.ZodString;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+//# sourceMappingURL=messageport-listener.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messageport-listener.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/messageport/messageport-listener.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EACP,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,cAAc,EAClB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAA6B,KAAK,yBAAyB,EAAE,MAAM,6BAA6B,CAAC;AACxG,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAE5B,OAAO,EACP,KAAK,cAAc,EAClB,MAAM,4DAA4D,CAAC;AAEpE,MAAM,WAAW,6BAA6B;IAC7C,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,GAAG,CAAC,CAAC;CACtB;AAED,MAAM,WAAW,uBAAuB;IACvC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;OAGG;IACH,QAAQ,CAAC,WAAW,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IACzC,QAAQ,CAAC,QAAQ,EAAE,cAAc,CAAC;IAClC,gDAAgD;IAChD,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,yFAAyF;IACzF,QAAQ,CAAC,cAAc,CAAC,EAAE,cAAc,CAAC;IACzC,sFAAsF;IACtF,QAAQ,CAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IACzB,uFAAuF;IACvF,QAAQ,CAAC,YAAY,CAAC,EAAE,yBAAyB,CAAC;IAClD,iFAAiF;IACjF,QAAQ,CAAC,aAAa,CAAC,EAAE,6BAA6B,CAAC;IACvD,uEAAuE;IACvE,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAC;IAC7B,gEAAgE;IAChE,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;CACjC;AAED,MAAM,WAAW,mBAAmB;IACnC,qEAAqE;IACrE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,KAAK,IAAI,IAAI,CAAC;CACd;AAED,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAcjC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;iBAAkE,CAAC"}

package/dist/schemas/contracts/transports/messageport/messageport-listener.js

@@ -0,0 +1,23 @@
+import {} from '@vibesdotdev/kernel';
+import {} from '@vibesdotdev/kernel-rpc';
+import { RuntimeInvokeCallerSchema } from '@vibesdotdev/kernel/schemas';
+import * as z from 'zod/v4';
+import { DurationInput, functionInput, LifecycleInput, memberInput, objectInput, RootMethodsInput, TextInput } from "../../../../core/protocol/references/caller-input.js";
+import {} from "../../../../transports/messageport/connection/contracts.js";
+export const ListenMessagePortInput = z.object({
+    port: memberInput('postMessage', 'addEventListener'),
+    target: z.object({
+        root: objectInput(),
+        rootMethods: RootMethodsInput.optional(),
+        pipeline: memberInput('wrap'),
+        kindId: TextInput.optional(),
+        classifyResult: functionInput().optional(),
+        kindOf: functionInput().optional(),
+        runInvocation: functionInput().optional(),
+        verifiedPeer: z.object({ source: TextInput, caller: RuntimeInvokeCallerSchema }).optional(),
+        deadlineMs: DurationInput.optional(),
+        lifecycle: LifecycleInput
+    })
+});
+export const OversizedRequestIdSchema = z.object({ req: z.object({ id: z.string().min(1).max(128) }) });
+//# sourceMappingURL=messageport-listener.js.map

package/dist/schemas/contracts/transports/messageport/messageport-listener.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"messageport-listener.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/messageport/messageport-listener.ts"],"names":[],"mappings":"AAAA,OAAO,EAAuB,MAAM,qBAAqB,CAAC;AAC1D,OAAO,EAIN,MAAM,yBAAyB,CAAC;AACjC,OAAO,EAAE,yBAAyB,EAAkC,MAAM,6BAA6B,CAAC;AACxG,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,aAAa,EAAE,aAAa,EAAE,cAAc,EAAE,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,SAAS,EAAE,MAAM,sDAAsD,CAAC;AAC3K,OAAO,EAEN,MAAM,4DAA4D,CAAC;AAoCpE,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC9C,IAAI,EAAE,WAAW,CAAiB,aAAa,EAAE,kBAAkB,CAAC;IACpE,MAAM,EAAE,CAAC,CAAC,MAAM,CAAC;QAChB,IAAI,EAAE,WAAW,EAAU;QAC3B,WAAW,EAAE,gBAAgB,CAAC,QAAQ,EAAE;QACxC,QAAQ,EAAE,WAAW,CAAiB,MAAM,CAAC;QAC7C,MAAM,EAAE,SAAS,CAAC,QAAQ,EAAE;QAC5B,cAAc,EAAE,aAAa,EAAkB,CAAC,QAAQ,EAAE;QAC1D,MAAM,EAAE,aAAa,EAAU,CAAC,QAAQ,EAAE;QAC1C,aAAa,EAAE,aAAa,EAAiC,CAAC,QAAQ,EAAE;QACxE,YAAY,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,yBAAyB,EAAE,CAAC,CAAC,QAAQ,EAAE;QAC3F,UAAU,EAAE,aAAa,CAAC,QAAQ,EAAE;QACpC,SAAS,EAAE,cAAc;KACzB,CAAC;CACF,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,GAAG,EAAE,CAAC,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,EAAE,CAAC,CAAC"}

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

@@ -0,0 +1,78 @@
+import type { RuntimeRpcDescriptor } from '@vibesdotdev/kernel-rpc';
+import * as z from 'zod/v4';
+export interface RuntimeRpcMessagePortPluginOptions {
+    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-messageport.plugin.d.ts.map

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

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

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

@@ -0,0 +1,4 @@
+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-messageport.plugin.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"runtime-rpc-messageport.plugin.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/messageport/runtime-rpc-messageport.plugin.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAMhF,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/relay/descriptors/relay.rpc.descriptor.d.ts

@@ -0,0 +1,13 @@
+import * as z from 'zod/v4';
+export declare const RelayDescriptorInput: z.ZodObject<{
+    brokerOrigin: z.ZodString;
+    hostId: z.ZodString;
+    id: z.ZodString;
+    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">>;
+}, z.core.$strip>;
+//# sourceMappingURL=relay.rpc.descriptor.d.ts.map

package/dist/schemas/contracts/transports/relay/descriptors/relay.rpc.descriptor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.rpc.descriptor.d.ts","sourceRoot":"","sources":["../../../../../../src/schemas/contracts/transports/relay/descriptors/relay.rpc.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAI5B,eAAO,MAAM,oBAAoB;;;;;;;;;;iBAAsH,CAAC"}

package/dist/schemas/contracts/transports/relay/descriptors/relay.rpc.descriptor.js

@@ -0,0 +1,5 @@
+import * as z from 'zod/v4';
+import { CredentialReferenceSchema } from "../../../../../core/kinds/rpc.kind.js";
+import { TextInput } from "../../../../../core/protocol/references/caller-input.js";
+export const RelayDescriptorInput = z.object({ brokerOrigin: TextInput, hostId: TextInput, id: TextInput, auth: CredentialReferenceSchema.optional() });
+//# sourceMappingURL=relay.rpc.descriptor.js.map

package/dist/schemas/contracts/transports/relay/descriptors/relay.rpc.descriptor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay.rpc.descriptor.js","sourceRoot":"","sources":["../../../../../../src/schemas/contracts/transports/relay/descriptors/relay.rpc.descriptor.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,SAAS,EAAE,MAAM,yDAAyD,CAAC;AAEpF,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,yBAAyB,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC"}

package/dist/schemas/contracts/transports/relay/relay-connection.d.ts

@@ -0,0 +1,45 @@
+import type { RuntimeLifecycle } from '@vibesdotdev/kernel';
+import type { RpcLifecycle } from '@vibesdotdev/kernel-rpc';
+export type RelayLifecycle = RpcLifecycle & Pick<RuntimeLifecycle, 'own'>;
+export interface RelayConnectionInit {
+    readonly lifecycle: RelayLifecycle;
+    /** Absolute origin of the broker, e.g. `https://platform.vibes.dev`. */
+    readonly brokerOrigin: string;
+    /** The host id — identifies the daemon's DO instance. */
+    readonly hostId: string;
+    /** The remote root ref id advertised by the daemon at connect time. */
+    readonly rootRef: string;
+    /**
+     * CAPABILITY-TOKEN MODEL (A, B):
+     * The server-minted consumerId returned by the DO's __relay_handshake response.
+     * Every subsequent request MUST carry this id. The consumer never chooses their
+     * own consumerId — it is always DO-minted and validated FAIL-CLOSED.
+     */
+    readonly consumerId: string;
+    /**
+     * CAPABILITY-TOKEN MODEL (A, B):
+     * The server-minted session-token returned alongside consumerId by __relay_handshake.
+     * Every subsequent request MUST include this token. The DO validates the
+     * (consumerId, sessionToken) pair FAIL-CLOSED on every call.
+     */
+    readonly sessionToken: string;
+    /** Resolved bearer token for invoking the broker (optional). */
+    readonly token?: string;
+    /**
+     * Caller headers sent on every broker request (handshake, rpc, stream,
+     * write, close and reverse legs), for example the user a service acts for.
+     */
+    readonly headers?: Readonly<Record<string, string>>;
+    /** Injected fetch (tests pass a local fake broker). */
+    readonly fetchImpl?: RelayFetch;
+    /**
+     * The owning runtime's `lifecycle.signal`: its abort (disposal) closes this connection, aborting every stream
+     * and reverse-channel fetch, and later sends are refused `RPC_DISCONNECTED`.
+     */
+    readonly signal?: AbortSignal;
+}
+export type RelayFetch = (input: URL | string, init?: RequestInit) => Promise<Response>;
+export interface RelayHeaders {
+    readonly [name: string]: string;
+}
+//# sourceMappingURL=relay-connection.d.ts.map

package/dist/schemas/contracts/transports/relay/relay-connection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-connection.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/relay/relay-connection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AAE5D,MAAM,MAAM,cAAc,GAAG,YAAY,GAAG,IAAI,CAAC,gBAAgB,EAAE,KAAK,CAAC,CAAC;AAE1E,MAAM,WAAW,mBAAmB;IACnC,QAAQ,CAAC,SAAS,EAAE,cAAc,CAAC;IACnC,wEAAwE;IACxE,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,yDAAyD;IACzD,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,uEAAuE;IACvE,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB;;;;;OAKG;IACH,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B;;;;;OAKG;IACH,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC;IAC9B,gEAAgE;IAChE,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IACxB;;;OAGG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IACpD,uDAAuD;IACvD,QAAQ,CAAC,SAAS,CAAC,EAAE,UAAU,CAAC;IAChC;;;OAGG;IACH,QAAQ,CAAC,MAAM,CAAC,EAAE,WAAW,CAAC;CAC9B;AAED,MAAM,MAAM,UAAU,GAAG,CAAC,KAAK,EAAE,GAAG,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAC;AAExF,MAAM,WAAW,YAAY;IAC5B,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,MAAM,CAAC;CAChC"}

package/dist/schemas/contracts/transports/relay/relay-connection.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=relay-connection.js.map

package/dist/schemas/contracts/transports/relay/relay-connection.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-connection.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/relay/relay-connection.ts"],"names":[],"mappings":""}

package/dist/schemas/contracts/transports/relay/relay-listen-session.d.ts

@@ -0,0 +1,29 @@
+import { type InvokePipeline } from '@vibesdotdev/kernel';
+import { type ChannelBinder, type KindOf, type RpcLifecycle, type WireClassifier } from '@vibesdotdev/kernel-rpc';
+export interface RelayListenTarget {
+    /** The root object — its methods are the remote runtime query surface. */
+    readonly root: object;
+    /**
+     * 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;
+    /** When true, error stacks cross the wire (operator opt-in). Default false. */
+    readonly debug?: boolean;
+    /** The owning runtime's lifecycle: it bounds every reverse-leg invoke. */
+    readonly lifecycle: RpcLifecycle;
+    /** Bind native per-consumer cancellation around canonical dispatch. */
+    readonly runInvocation?: <T>(work: () => T, connection: {
+        id: string;
+        signal: AbortSignal;
+    }) => T;
+}
+//# sourceMappingURL=relay-listen-session.d.ts.map

package/dist/schemas/contracts/transports/relay/relay-listen-session.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-listen-session.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/relay/relay-listen-session.ts"],"names":[],"mappings":"AAAA,OAAO,EACP,KAAK,cAAc,EAClB,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EACP,KAAK,aAAa,EAClB,KAAK,MAAM,EACX,KAAK,YAAY,EACjB,KAAK,cAAc,EAClB,MAAM,yBAAyB,CAAC;AAEjC,MAAM,WAAW,iBAAiB;IAC9B,0EAA0E;IAC1E,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB;;;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,+EAA+E;IAC/E,QAAQ,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC;IACzB,0EAA0E;IAC1E,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,uEAAuE;IACvE,QAAQ,CAAC,aAAa,CAAC,EAAE,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,CAAC,EAAE,UAAU,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,WAAW,CAAA;KAAE,KAAK,CAAC,CAAC;CACrG"}

package/dist/schemas/contracts/transports/relay/relay-listen-session.js

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

package/dist/schemas/contracts/transports/relay/relay-listen-session.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-listen-session.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/relay/relay-listen-session.ts"],"names":[],"mappings":"AAAA,OAAO,EAEN,MAAM,qBAAqB,CAAC;AAC7B,OAAO,EAKN,MAAM,yBAAyB,CAAC"}

package/dist/schemas/contracts/transports/relay/relay-server.d.ts

@@ -0,0 +1,41 @@
+import * as z from 'zod/v4';
+export interface RelaySocket {
+    /** Send a text frame (JSON-encoded RpcResponse or a reverse-leg RpcInvoke). */
+    send(data: string): void;
+    /** Send a binary frame (stream DATA/CLOSE — R1's encodeBinaryFrame layout). */
+    sendBinary(data: Uint8Array): void;
+    /** Register a handler for inbound text frames (JSON envelope from the broker). */
+    onMessage(handler: (data: string) => void): void;
+    /** Register a handler for inbound binary frames (consumer→owner stream bytes). */
+    onBinary(handler: (data: Uint8Array) => void): void;
+    /** Resolves when the socket closes (any cause). */
+    readonly closed: Promise<void>;
+    /** Close the socket. */
+    close(): void;
+}
+export declare const ServeRelaySocketInput: z.ZodObject<{
+    socket: z.ZodCustom<RelaySocket, RelaySocket>;
+    target: z.ZodObject<{
+        debug: z.ZodOptional<z.ZodBoolean>;
+        lifecycle: z.ZodCustom<import("../../protocol/lifecycle/connector.ts").RpcLifecycle, import("../../protocol/lifecycle/connector.ts").RpcLifecycle>;
+        runInvocation: z.ZodOptional<z.ZodCustom<(<T>(work: () => T, connection: {
+            id: string;
+            signal: AbortSignal;
+        }) => T) | undefined, (<T>(work: () => T, connection: {
+            id: string;
+            signal: AbortSignal;
+        }) => T) | undefined>>;
+        root: z.ZodCustom<object, object>;
+        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>;
+}, z.core.$strip>;
+//# sourceMappingURL=relay-server.d.ts.map

package/dist/schemas/contracts/transports/relay/relay-server.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-server.d.ts","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/relay/relay-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAI5B,MAAM,WAAW,WAAW;IAC3B,+EAA+E;IAC/E,IAAI,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IACzB,+EAA+E;IAC/E,UAAU,CAAC,IAAI,EAAE,UAAU,GAAG,IAAI,CAAC;IACnC,kFAAkF;IAClF,SAAS,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GAAG,IAAI,CAAC;IACjD,kFAAkF;IAClF,QAAQ,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;IACpD,mDAAmD;IACnD,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC;IAC/B,wBAAwB;IACxB,KAAK,IAAI,IAAI,CAAC;CACd;AAED,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;iBAAyI,CAAC"}

package/dist/schemas/contracts/transports/relay/relay-server.js

@@ -0,0 +1,5 @@
+import * as z from 'zod/v4';
+import { memberInput } from "../../../../core/protocol/references/caller-input.js";
+import { RelayListenTargetInput } from "../../../../transports/relay/relay-transport.impl.js";
+export const ServeRelaySocketInput = z.object({ socket: memberInput('send', 'sendBinary', 'onMessage', 'onBinary', 'close'), target: RelayListenTargetInput });
+//# sourceMappingURL=relay-server.js.map

package/dist/schemas/contracts/transports/relay/relay-server.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relay-server.js","sourceRoot":"","sources":["../../../../../src/schemas/contracts/transports/relay/relay-server.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,QAAQ,CAAC;AAC5B,OAAO,EAAE,WAAW,EAAE,MAAM,sDAAsD,CAAC;AACnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAiB9F,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,MAAM,EAAE,WAAW,CAAc,MAAM,EAAE,YAAY,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,CAAC,EAAE,MAAM,EAAE,sBAAsB,EAAE,CAAC,CAAC"}