@namzu/sdk 46.0.0 → 48.0.0

package/dist/peers/index.js

@@ -0,0 +1,22 @@
+/**
+ * Cross-session peer messaging: the live-session registry, the
+ * `namzu-peer/1` transport, and the runtime-context rendering for a
+ * delivered message or notice (design "Sessions that talk", Part 1, §1.1-1.3,
+ * §1.7, and the SDK half of §1.4/§1.8, 2026-09-24).
+ *
+ * This module is the transport and storage layer only. Inbox policy —
+ * bounded queues, the mode-mismatch hold/approve flow, `/peers off`,
+ * subscriber bookkeeping and its 24h expiry, and drain-at-iteration-boundary
+ * injection — is host (CLI) territory and is not implemented here.
+ *
+ * @experimental
+ */
+export { parsePeerAddress, pipePeerAddress, PeerAddressError, udsPeerAddress } from './address.js';
+export { hardenPeerRuntimeDir, LONGEST_PEER_SOCKET_FILE_NAME_LENGTH, PeerDirectoryError, peerSocketFileName, resolvePeerRuntimeDir, } from './dir.js';
+export { derivePeerRef, PEER_RECORD_VERSION, PeerRecordSchema } from './record.js';
+export { isPeerRecordLive, listLivePeers, PeerRegistryError, readPeerRecord, readPeerRecords, removePeerRecord, writePeerRecord, } from './registry.js';
+export { DEFAULT_PEER_READ_DEADLINE_MS, DeliverRequestSchema, DeliverResponseSchema, DeliverStatusSchema, MAX_PEER_CONNECTIONS, MAX_PEER_MESSAGE_TEXT_BYTES, MAX_PEER_REQUEST_BYTES, NoticeRequestSchema, NoticeResponseSchema, PEER_PROTOCOL_VERSION, PeerFromSchema, PeerNoticeAboutSchema, PeerNoticePayloadSchema, PeerRefSchema, PeerRequestSchema, PeerSessionKindSchema, PeerSessionStateSchema, PingRequestSchema, PingResponseSchema, SubscribeIdleRequestSchema, SubscribeIdleResponseSchema, } from './protocol.js';
+export { createPeerEndpoint, MAX_OUTSTANDING_PEERS, MAX_OUTSTANDING_PER_PEER, OUTSTANDING_EXPIRY_MS, PeerEndpointError, } from './endpoint.js';
+export { PeerClient, PeerClientError, pingPeer } from './client.js';
+export { formatPeerMessage, formatPeerNotice } from './envelope.js';
+//# sourceMappingURL=index.js.map

package/dist/peers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/peers/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,gBAAgB,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAGlG,OAAO,EACN,oBAAoB,EACpB,oCAAoC,EACpC,kBAAkB,EAClB,kBAAkB,EAClB,qBAAqB,GACrB,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,aAAa,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAGlF,OAAO,EACN,gBAAgB,EAChB,aAAa,EACb,iBAAiB,EACjB,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,eAAe,GACf,MAAM,eAAe,CAAA;AAGtB,OAAO,EACN,6BAA6B,EAC7B,oBAAoB,EACpB,qBAAqB,EACrB,mBAAmB,EACnB,oBAAoB,EACpB,2BAA2B,EAC3B,sBAAsB,EACtB,mBAAmB,EACnB,oBAAoB,EACpB,qBAAqB,EACrB,cAAc,EACd,qBAAqB,EACrB,uBAAuB,EACvB,aAAa,EACb,iBAAiB,EACjB,qBAAqB,EACrB,sBAAsB,EACtB,iBAAiB,EACjB,kBAAkB,EAClB,0BAA0B,EAC1B,2BAA2B,GAC3B,MAAM,eAAe,CAAA;AAoBtB,OAAO,EACN,kBAAkB,EAClB,qBAAqB,EACrB,wBAAwB,EACxB,qBAAqB,EACrB,iBAAiB,GACjB,MAAM,eAAe,CAAA;AAGtB,OAAO,EAAE,UAAU,EAAE,eAAe,EAAE,QAAQ,EAAE,MAAM,aAAa,CAAA;AAGnE,OAAO,EAAE,iBAAiB,EAAE,gBAAgB,EAAE,MAAM,eAAe,CAAA"}

package/dist/peers/protocol.d.ts

@@ -0,0 +1,645 @@
+/**
+ * The `namzu-peer/1` wire protocol: newline-delimited JSON, one request and
+ * one response per connection, a closed set of four operations (design
+ * §1.1, §1.3).
+ *
+ * Two deliberate departures from the design note, both narrow and both
+ * documented where they matter most:
+ *
+ * 1. **`ping` carries no token.** Every other op requires and verifies the
+ *    recipient's token; `ping` is idempotent, has no side effect, and its
+ *    answer (`{ok, state}`) discloses nothing the OS-user directory
+ *    permission does not already gate (design §1.1: "the directory
+ *    permission is the real gate"). `PeerClient.ping(address)` — the shape
+ *    the spec's own client API names — takes no record and so has no token
+ *    to send.
+ * 2. **`notice`'s `delivery` kind carries an optional `outcome`.** The design
+ *    lists `notice`'s payload as `{kind, about, detail?}` with prose detail
+ *    ("approved" / "denied" / "expired") for a delivery outcome, but gives
+ *    `formatSystemEvent` a closed status set that a delivery notice must
+ *    report from (`queued` | `held` | `refused`). `outcome` supplies that
+ *    machine-readable status without parsing `detail`'s prose.
+ *
+ * @experimental
+ */
+import { z } from 'zod';
+export declare const PEER_PROTOCOL_VERSION = "namzu-peer/1";
+/** One request line, or one response line, must not exceed this many bytes. */
+export declare const MAX_PEER_REQUEST_BYTES: number;
+/** `deliver.text` must not exceed this many UTF-8 bytes. */
+export declare const MAX_PEER_MESSAGE_TEXT_BYTES: number;
+/** A connection that has not completed one request/response by this deadline is dropped. */
+export declare const DEFAULT_PEER_READ_DEADLINE_MS = 2000;
+/** Concurrent connections a `createPeerEndpoint` server accepts before refusing new ones. */
+export declare const MAX_PEER_CONNECTIONS = 16;
+export declare const PeerSessionKindSchema: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+export type PeerSessionKind = z.infer<typeof PeerSessionKindSchema>;
+export declare const PeerSessionStateSchema: z.ZodEnum<["busy", "idle", "awaiting-permission"]>;
+export type PeerSessionState = z.infer<typeof PeerSessionStateSchema>;
+/** First 6 hex characters of `sha256(sessionId)` — see `registry.ts` `derivePeerRef`. */
+export declare const PeerRefSchema: z.ZodString;
+/** The sender's asserted identity, checked by the recipient against its own registry (§1.3). */
+export declare const PeerFromSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    ref: z.ZodString;
+    name: z.ZodString;
+    address: z.ZodString;
+    mode: z.ZodString;
+    kind: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    kind: "resident" | "exec" | "scheduled" | "tui";
+    sessionId: string;
+    address: string;
+    mode: string;
+    ref: string;
+}, {
+    name: string;
+    kind: "resident" | "exec" | "scheduled" | "tui";
+    sessionId: string;
+    address: string;
+    mode: string;
+    ref: string;
+}>;
+export type PeerFrom = z.infer<typeof PeerFromSchema>;
+export declare const PingRequestSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"ping">;
+}, "strict", z.ZodTypeAny, {
+    protocol: "namzu-peer/1";
+    op: "ping";
+}, {
+    protocol: "namzu-peer/1";
+    op: "ping";
+}>;
+export type PingRequest = z.infer<typeof PingRequestSchema>;
+export declare const PingResponseSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+    state: z.ZodEnum<["busy", "idle", "awaiting-permission"]>;
+}, "strict", z.ZodTypeAny, {
+    state: "busy" | "idle" | "awaiting-permission";
+    ok: boolean;
+}, {
+    state: "busy" | "idle" | "awaiting-permission";
+    ok: boolean;
+}>;
+export type PingResponse = z.infer<typeof PingResponseSchema>;
+export declare const DeliverRequestSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"deliver">;
+    token: z.ZodString;
+    id: z.ZodString;
+    from: z.ZodObject<{
+        sessionId: z.ZodString;
+        ref: z.ZodString;
+        name: z.ZodString;
+        address: z.ZodString;
+        mode: z.ZodString;
+        kind: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }>;
+    text: z.ZodEffects<z.ZodString, string, string>;
+    inReplyTo: z.ZodOptional<z.ZodString>;
+    subscribeIdle: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    text: string;
+    id: string;
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "deliver";
+    inReplyTo?: string | undefined;
+    subscribeIdle?: boolean | undefined;
+}, {
+    text: string;
+    id: string;
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "deliver";
+    inReplyTo?: string | undefined;
+    subscribeIdle?: boolean | undefined;
+}>;
+export type DeliverRequest = z.infer<typeof DeliverRequestSchema>;
+export declare const DeliverStatusSchema: z.ZodEnum<["queued", "held", "refused"]>;
+export type DeliverStatus = z.infer<typeof DeliverStatusSchema>;
+export declare const DeliverResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<["queued", "held", "refused"]>;
+    reason: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    status: "refused" | "queued" | "held";
+    reason?: string | undefined;
+}, {
+    status: "refused" | "queued" | "held";
+    reason?: string | undefined;
+}>;
+export type DeliverResponse = z.infer<typeof DeliverResponseSchema>;
+export declare const SubscribeIdleRequestSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"subscribe_idle">;
+    token: z.ZodString;
+    id: z.ZodString;
+    from: z.ZodObject<{
+        sessionId: z.ZodString;
+        ref: z.ZodString;
+        name: z.ZodString;
+        address: z.ZodString;
+        mode: z.ZodString;
+        kind: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "subscribe_idle";
+}, {
+    id: string;
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "subscribe_idle";
+}>;
+export type SubscribeIdleRequest = z.infer<typeof SubscribeIdleRequestSchema>;
+export declare const SubscribeIdleResponseSchema: z.ZodObject<{
+    status: z.ZodEnum<["subscribed", "refused"]>;
+}, "strict", z.ZodTypeAny, {
+    status: "refused" | "subscribed";
+}, {
+    status: "refused" | "subscribed";
+}>;
+export type SubscribeIdleResponse = z.infer<typeof SubscribeIdleResponseSchema>;
+export declare const PeerNoticeAboutSchema: z.ZodObject<{
+    sessionId: z.ZodString;
+    name: z.ZodString;
+    ref: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    name: string;
+    sessionId: string;
+    ref: string;
+}, {
+    name: string;
+    sessionId: string;
+    ref: string;
+}>;
+export type PeerNoticeAbout = z.infer<typeof PeerNoticeAboutSchema>;
+export declare const NoticeRequestSchema: z.ZodObject<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"notice">;
+    token: z.ZodString;
+    /**
+     * The sender's asserted identity, checked the same way `deliver` and
+     * `subscribe_idle` check theirs (§1.3): the recipient's endpoint runs it
+     * through `verifySender` before calling `onNotice`. A notice with no
+     * `from` — the shape this protocol shipped with first — is not a
+     * well-formed request at all, the same as a `deliver` with no `from`.
+     */
+    from: z.ZodObject<{
+        sessionId: z.ZodString;
+        ref: z.ZodString;
+        name: z.ZodString;
+        address: z.ZodString;
+        mode: z.ZodString;
+        kind: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }>;
+    kind: z.ZodEnum<["idle", "exited", "delivery"]>;
+    about: z.ZodObject<{
+        sessionId: z.ZodString;
+        name: z.ZodString;
+        ref: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        sessionId: string;
+        ref: string;
+    }, {
+        name: string;
+        sessionId: string;
+        ref: string;
+    }>;
+    /** Only meaningful, and only ever set, when `kind === 'delivery'`. */
+    outcome: z.ZodOptional<z.ZodEnum<["queued", "held", "refused"]>>;
+    detail: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: "idle" | "exited" | "delivery";
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "notice";
+    about: {
+        name: string;
+        sessionId: string;
+        ref: string;
+    };
+    outcome?: "refused" | "queued" | "held" | undefined;
+    detail?: string | undefined;
+}, {
+    kind: "idle" | "exited" | "delivery";
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "notice";
+    about: {
+        name: string;
+        sessionId: string;
+        ref: string;
+    };
+    outcome?: "refused" | "queued" | "held" | undefined;
+    detail?: string | undefined;
+}>;
+export type NoticeRequest = z.infer<typeof NoticeRequestSchema>;
+export declare const NoticeResponseSchema: z.ZodObject<{
+    ok: z.ZodBoolean;
+}, "strict", z.ZodTypeAny, {
+    ok: boolean;
+}, {
+    ok: boolean;
+}>;
+export type NoticeResponse = z.infer<typeof NoticeResponseSchema>;
+/** The notice payload alone, with no envelope — what a host builds and what `formatPeerNotice` renders. */
+export declare const PeerNoticePayloadSchema: z.ZodObject<Omit<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"notice">;
+    token: z.ZodString;
+    /**
+     * The sender's asserted identity, checked the same way `deliver` and
+     * `subscribe_idle` check theirs (§1.3): the recipient's endpoint runs it
+     * through `verifySender` before calling `onNotice`. A notice with no
+     * `from` — the shape this protocol shipped with first — is not a
+     * well-formed request at all, the same as a `deliver` with no `from`.
+     */
+    from: z.ZodObject<{
+        sessionId: z.ZodString;
+        ref: z.ZodString;
+        name: z.ZodString;
+        address: z.ZodString;
+        mode: z.ZodString;
+        kind: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }>;
+    kind: z.ZodEnum<["idle", "exited", "delivery"]>;
+    about: z.ZodObject<{
+        sessionId: z.ZodString;
+        name: z.ZodString;
+        ref: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        sessionId: string;
+        ref: string;
+    }, {
+        name: string;
+        sessionId: string;
+        ref: string;
+    }>;
+    /** Only meaningful, and only ever set, when `kind === 'delivery'`. */
+    outcome: z.ZodOptional<z.ZodEnum<["queued", "held", "refused"]>>;
+    detail: z.ZodOptional<z.ZodString>;
+}, "token" | "protocol" | "op">, "strict", z.ZodTypeAny, {
+    kind: "idle" | "exited" | "delivery";
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    about: {
+        name: string;
+        sessionId: string;
+        ref: string;
+    };
+    outcome?: "refused" | "queued" | "held" | undefined;
+    detail?: string | undefined;
+}, {
+    kind: "idle" | "exited" | "delivery";
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    about: {
+        name: string;
+        sessionId: string;
+        ref: string;
+    };
+    outcome?: "refused" | "queued" | "held" | undefined;
+    detail?: string | undefined;
+}>;
+export type PeerNoticePayload = z.infer<typeof PeerNoticePayloadSchema>;
+export declare const PeerRequestSchema: z.ZodDiscriminatedUnion<"op", [z.ZodObject<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"ping">;
+}, "strict", z.ZodTypeAny, {
+    protocol: "namzu-peer/1";
+    op: "ping";
+}, {
+    protocol: "namzu-peer/1";
+    op: "ping";
+}>, z.ZodObject<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"deliver">;
+    token: z.ZodString;
+    id: z.ZodString;
+    from: z.ZodObject<{
+        sessionId: z.ZodString;
+        ref: z.ZodString;
+        name: z.ZodString;
+        address: z.ZodString;
+        mode: z.ZodString;
+        kind: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }>;
+    text: z.ZodEffects<z.ZodString, string, string>;
+    inReplyTo: z.ZodOptional<z.ZodString>;
+    subscribeIdle: z.ZodOptional<z.ZodBoolean>;
+}, "strict", z.ZodTypeAny, {
+    text: string;
+    id: string;
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "deliver";
+    inReplyTo?: string | undefined;
+    subscribeIdle?: boolean | undefined;
+}, {
+    text: string;
+    id: string;
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "deliver";
+    inReplyTo?: string | undefined;
+    subscribeIdle?: boolean | undefined;
+}>, z.ZodObject<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"subscribe_idle">;
+    token: z.ZodString;
+    id: z.ZodString;
+    from: z.ZodObject<{
+        sessionId: z.ZodString;
+        ref: z.ZodString;
+        name: z.ZodString;
+        address: z.ZodString;
+        mode: z.ZodString;
+        kind: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }>;
+}, "strict", z.ZodTypeAny, {
+    id: string;
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "subscribe_idle";
+}, {
+    id: string;
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "subscribe_idle";
+}>, z.ZodObject<{
+    protocol: z.ZodLiteral<"namzu-peer/1">;
+    op: z.ZodLiteral<"notice">;
+    token: z.ZodString;
+    /**
+     * The sender's asserted identity, checked the same way `deliver` and
+     * `subscribe_idle` check theirs (§1.3): the recipient's endpoint runs it
+     * through `verifySender` before calling `onNotice`. A notice with no
+     * `from` — the shape this protocol shipped with first — is not a
+     * well-formed request at all, the same as a `deliver` with no `from`.
+     */
+    from: z.ZodObject<{
+        sessionId: z.ZodString;
+        ref: z.ZodString;
+        name: z.ZodString;
+        address: z.ZodString;
+        mode: z.ZodString;
+        kind: z.ZodEnum<["tui", "exec", "resident", "scheduled"]>;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }, {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    }>;
+    kind: z.ZodEnum<["idle", "exited", "delivery"]>;
+    about: z.ZodObject<{
+        sessionId: z.ZodString;
+        name: z.ZodString;
+        ref: z.ZodString;
+    }, "strict", z.ZodTypeAny, {
+        name: string;
+        sessionId: string;
+        ref: string;
+    }, {
+        name: string;
+        sessionId: string;
+        ref: string;
+    }>;
+    /** Only meaningful, and only ever set, when `kind === 'delivery'`. */
+    outcome: z.ZodOptional<z.ZodEnum<["queued", "held", "refused"]>>;
+    detail: z.ZodOptional<z.ZodString>;
+}, "strict", z.ZodTypeAny, {
+    kind: "idle" | "exited" | "delivery";
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "notice";
+    about: {
+        name: string;
+        sessionId: string;
+        ref: string;
+    };
+    outcome?: "refused" | "queued" | "held" | undefined;
+    detail?: string | undefined;
+}, {
+    kind: "idle" | "exited" | "delivery";
+    token: string;
+    from: {
+        name: string;
+        kind: "resident" | "exec" | "scheduled" | "tui";
+        sessionId: string;
+        address: string;
+        mode: string;
+        ref: string;
+    };
+    protocol: "namzu-peer/1";
+    op: "notice";
+    about: {
+        name: string;
+        sessionId: string;
+        ref: string;
+    };
+    outcome?: "refused" | "queued" | "held" | undefined;
+    detail?: string | undefined;
+}>]>;
+export type PeerRequest = z.infer<typeof PeerRequestSchema>;
+export type PeerResponse = PingResponse | DeliverResponse | SubscribeIdleResponse | NoticeResponse;
+//# sourceMappingURL=protocol.d.ts.map

package/dist/peers/protocol.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"protocol.d.ts","sourceRoot":"","sources":["../../src/peers/protocol.ts"],"names":[],"mappings":"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"}