@joe-broadhead/messaging 0.7.1 → 0.8.0

package/dist/types/core/schema/relay.d.ts

@@ -68,6 +68,7 @@ export declare const NackFrame: z.ZodObject<{
         refused: "refused";
         declined: "declined";
         request_required: "request_required";
+        peer_outdated: "peer_outdated";
         rate_limited: "rate_limited";
         loop_guard: "loop_guard";
         too_large: "too_large";
@@ -272,6 +273,7 @@ export declare const ErrorFrame: z.ZodObject<{
         refused: "refused";
         declined: "declined";
         request_required: "request_required";
+        peer_outdated: "peer_outdated";
         rate_limited: "rate_limited";
         loop_guard: "loop_guard";
         too_large: "too_large";
@@ -350,6 +352,7 @@ export declare const RelayToClient: z.ZodDiscriminatedUnion<[z.ZodObject<{
         refused: "refused";
         declined: "declined";
         request_required: "request_required";
+        peer_outdated: "peer_outdated";
         rate_limited: "rate_limited";
         loop_guard: "loop_guard";
         too_large: "too_large";
@@ -549,6 +552,7 @@ export declare const RelayToClient: z.ZodDiscriminatedUnion<[z.ZodObject<{
         refused: "refused";
         declined: "declined";
         request_required: "request_required";
+        peer_outdated: "peer_outdated";
         rate_limited: "rate_limited";
         loop_guard: "loop_guard";
         too_large: "too_large";
@@ -749,9 +753,9 @@ export declare const SendFrame: z.ZodObject<{
         realm: z.ZodString;
         type: z.ZodEnum<{
             message: "message";
-            "task.cancel": "task.cancel";
             receipt: "receipt";
             presence: "presence";
+            "task.cancel": "task.cancel";
             "task.status": "task.status";
             "task.artifact": "task.artifact";
         }>;
@@ -806,9 +810,9 @@ export declare const PresenceFrame: z.ZodObject<{
         realm: z.ZodString;
         type: z.ZodEnum<{
             message: "message";
-            "task.cancel": "task.cancel";
             receipt: "receipt";
             presence: "presence";
+            "task.cancel": "task.cancel";
             "task.status": "task.status";
             "task.artifact": "task.artifact";
         }>;
@@ -1016,9 +1020,9 @@ export declare const ClientToRelay: z.ZodDiscriminatedUnion<[z.ZodObject<{
         realm: z.ZodString;
         type: z.ZodEnum<{
             message: "message";
-            "task.cancel": "task.cancel";
             receipt: "receipt";
             presence: "presence";
+            "task.cancel": "task.cancel";
             "task.status": "task.status";
             "task.artifact": "task.artifact";
         }>;
@@ -1071,9 +1075,9 @@ export declare const ClientToRelay: z.ZodDiscriminatedUnion<[z.ZodObject<{
         realm: z.ZodString;
         type: z.ZodEnum<{
             message: "message";
-            "task.cancel": "task.cancel";
             receipt: "receipt";
             presence: "presence";
+            "task.cancel": "task.cancel";
             "task.status": "task.status";
             "task.artifact": "task.artifact";
         }>;

package/dist/types/core/testing.d.ts

@@ -7,7 +7,7 @@ export { encodeTicket } from "./roster.js";
 export { grantHash } from "./delegation.js";
 export { signJellyToken } from "./directory/jelly-issuer.js";
 export { jellyHostDouble, type JellyHostDouble } from "./jelly-host-double.js";
-export { sealConvMetaWith, sealConvMsgWith, sealKeySharesWith, type ShareRandomness } from "./conversation/seal.js";
+export { sealConvMetaWith, sealConvMsgWith, sealConvStateWith, sealKeyShareWith, type ShareRandomness } from "./conversation/seal.js";
 /**
  * Narrows a result whose `kind` tells its shape (`item.read`, `conv.read`) to the expected kind, and
  * throws with both kinds named otherwise: `client.call("item.read", p).then(asKind("received"))`.

package/dist/types/core/version.d.ts

@@ -3,4 +3,4 @@
  * its IPC hello and a client compares it with its own (spec §8.2). A test keeps it equal to the
  * root package.json.
  */
-export declare const VERSION = "0.7.1";
+export declare const VERSION = "0.8.0";

package/dist/types/ipc/client.d.ts

@@ -1,4 +1,4 @@
-import { IpcEvent, IpcHello, MessagingError, type IpcMethod, type IpcParams, type IpcResult } from "../core/index.js";
+import { IpcEvent, IpcHello, MessagingError, type IpcMethod, type IpcParams, type IpcResult, type ConversationMethod, type ConversationParams, type ConversationResult } from "../core/index.js";
 import { type SocketTier } from "./paths.js";
 export interface ClientOptions {
     /** Explicit socket path (on Windows, the pipe pointer file). Defaults to the `tier` socket of `home`. */
@@ -76,6 +76,9 @@ export declare class MessagingClient {
     get daemon(): IpcHello;
     get closed(): boolean;
     call<M extends IpcMethod>(method: M, params: IpcParams<M>, options?: CallOptions): Promise<IpcResult<M>>;
+    /** The staged conversation contract. Use only with a server that opted into it, until cut-over. */
+    callConversation<M extends ConversationMethod>(method: M, params: ConversationParams<M>, options?: CallOptions): Promise<ConversationResult<M>>;
+    private callWith;
     onEvent(listener: (event: IpcEvent) => void): () => void;
     onClose(listener: (error?: Error) => void): () => void;
     close(): void;

package/dist/types/ipc/server.d.ts

@@ -1,5 +1,5 @@
 import type { z } from "zod";
-import { IpcEvent, type IpcMethod, type IpcMethods, type IpcResult } from "../core/index.js";
+import { IpcEvent, type IpcMethod, type IpcMethods, type IpcResult, type ConversationMethod, type ConversationParams, type ConversationResult } from "../core/index.js";
 import { type SocketTier } from "./paths.js";
 export interface ConnectionContext {
     /** Unique across every server in this process, so a daemon with two sockets can key state by it. */
@@ -34,6 +34,11 @@ export type Handler<M extends IpcMethod> = (params: z.output<IpcMethods[M]["para
 export type Handlers = {
     [M in IpcMethod]?: Handler<M>;
 };
+/** Handler types for the opt-in conversation contract test server. */
+export type ConversationHandler<M extends ConversationMethod> = (params: ConversationParams<M>, ctx: ConnectionContext, authority: CallAuthority | undefined) => Promise<ConversationResult<M>> | ConversationResult<M>;
+export type ConversationHandlers = {
+    [M in ConversationMethod]?: ConversationHandler<M>;
+};
 export interface IpcServerOptions {
     socketPath: string;
     /**
@@ -92,3 +97,7 @@ export interface IpcServer {
  * `group` is refused there: Node cannot give a pipe to a group.
  */
 export declare function createIpcServer(options: IpcServerOptions): Promise<IpcServer>;
+/** Used only by the test entry: never changes the real daemon's method table. */
+export declare function createConversationIpcServerForTesting(options: Omit<IpcServerOptions, "handlers" | "authorize"> & {
+    handlers: ConversationHandlers;
+}): Promise<IpcServer>;

package/dist/types/ipc/testing.d.ts

@@ -1,8 +1,8 @@
 import type net from "node:net";
-import { type IpcEvent, type IpcMethod } from "../core/index.js";
+import { CONVERSATION_METHODS, type ConversationMethod, type IpcEvent, type IpcMethod } from "../core/index.js";
 import { MessagingClient } from "./client.js";
 import { type SocketTier } from "./paths.js";
-import { type Handler, type Handlers } from "./server.js";
+import { type ConversationHandler, type ConversationHandlers, type Handler, type Handlers } from "./server.js";
 /**
  * `@messaging/ipc/testing`: helpers for tests only. Production code never imports this entry point.
  *
@@ -26,8 +26,8 @@ export declare function listenAt(server: net.Server, socketPath: string, { pid }
 export declare function rawEndpoint(socketPath: string): string;
 /** A deterministic ULID for test fixtures: `ulid(7)` is `01JC0000000000000000000007`. */
 export declare function ulid(n: number): string;
-/** Polls `predicate` every 10 ms until it holds; throws after `timeoutMs`. */
-export declare function until(predicate: () => boolean, timeoutMs?: number, what?: string): Promise<void>;
+/** Polls state with no notification; the enclosing test's timeout is the single bound. Legacy timeout and label are ignored. */
+export declare function until(predicate: () => boolean, _timeoutMs?: number, _what?: string): Promise<void>;
 /** One call the fake received: the method and a copy of its parsed params, taken before its handler ran. */
 export interface Recorded {
     method: IpcMethod;
@@ -35,6 +35,7 @@ export interface Recorded {
 }
 export type Params<M extends IpcMethod> = Parameters<Handler<M>>[0];
 export interface RecordingDaemonOptions {
+    methods?: never;
     /** Handlers by method; `handle` adds or replaces one later. Every other method is refused with `forbidden`. */
     handlers?: Handlers;
     /** Prefix of the temp home the fake creates (and removes on `close`). */
@@ -69,10 +70,6 @@ export interface RecordingDaemon {
     handle<M extends IpcMethod>(method: M, handler: Handler<M>): void;
     /** `IpcServer.publish`: to every connection that subscribed to the event's key (key-less: to all of them). */
     publish(event: IpcEvent): void;
-    /** A `conv` event to the connections whose `conv.subscribe` succeeded, as messagingd sends it. */
-    conv(event: Extract<IpcEvent, {
-        type: "conv";
-    }>): void;
     /** A client on the agent socket, or the `admin` one. */
     connect(tier?: SocketTier): Promise<MessagingClient>;
     /** Open connections on both sockets. */
@@ -86,4 +83,20 @@ export interface RecordingDaemon {
     /** `stop`, and remove the temp home the fake created. */
     close(): Promise<void>;
 }
+export interface ConversationRecordingDaemonOptions extends Omit<RecordingDaemonOptions, "handlers" | "methods"> {
+    /** Opt into the full conversation contract, including staged methods, instead of the live table. */
+    methods: typeof CONVERSATION_METHODS;
+    handlers?: ConversationHandlers;
+}
+export interface ConversationRecordingDaemon extends Omit<RecordingDaemon, "calls" | "methods" | "callsTo" | "last" | "handle"> {
+    readonly calls: {
+        method: ConversationMethod;
+        params: Record<string, unknown>;
+    }[];
+    methods(): ConversationMethod[];
+    callsTo<M extends ConversationMethod>(method: M): Parameters<ConversationHandler<M>>[0][];
+    last<M extends ConversationMethod>(method: M): Parameters<ConversationHandler<M>>[0] | undefined;
+    handle<M extends ConversationMethod>(method: M, handler: ConversationHandler<M>): void;
+}
 export declare function recordingDaemon(options?: RecordingDaemonOptions): Promise<RecordingDaemon>;
+export declare function recordingDaemon(options: ConversationRecordingDaemonOptions): Promise<ConversationRecordingDaemon>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@joe-broadhead/messaging",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Messaging: the relay, the per-machine daemon and its CLI, and the MCP server as bundled single files, plus the client libraries and the protocol spec. Zero dependencies.",
   "type": "module",
   "license": "MIT",