cc-peer 1.3.5 → 1.4.1

package/dist/cc-peer-DFoi9JJV.d.mts

@@ -0,0 +1,310 @@
+import { EventEmitter } from "node:events";
+import { z } from "zod";
+//#region src/adapters/node/paths.d.ts
+interface PathConfig {
+  homeDir?: string;
+  socketDir?: string;
+}
+//#endregion
+//#region src/ports/transport.d.ts
+/** Transport port: per-exchange connections and the listening inbox. */
+interface Transport {
+  /**
+   * One connection, one write of the given lines (each newline-terminated), then close after a short linger. Mirrors the reference client's `Pe`.
+   */
+  connectWrite: (socketPath: string, lines: readonly string[], lingerMs?: number) => Promise<void>;
+  /** Probe whether a socket accepts connections (roster admission uses this). */
+  probe: (socketPath: string) => Promise<boolean>;
+  listen: (socketPath: string, onConnection: (conn: Readonly<InboundConnection>) => void) => Promise<ListeningSocket>;
+}
+interface InboundConnection {
+  /** Resolves once the kernel reports the connecting process's pid (macOS). */
+  peerPid: () => number | undefined;
+  readLines: () => AsyncIterable<string>;
+  close: () => void;
+}
+interface ListeningSocket {
+  socketPath: string;
+  close: () => Promise<void>;
+}
+//#endregion
+//#region src/schemas/registry.d.ts
+/** One entry of the ~/.claude/sessions/<pid>.json registry. */
+declare const RegistryEntrySchema: z.ZodObject<{
+  pid: z.ZodNumber;
+  sessionId: z.ZodString;
+  cwd: z.ZodString;
+  startedAt: z.ZodNumber;
+  procStart: z.ZodString;
+  version: z.ZodString;
+  peerProtocol: z.ZodNumber;
+  peerFeatures: z.ZodArray<z.ZodEnum<{
+    notify_idle: "notify_idle";
+    reply_across_default_dirs: "reply_across_default_dirs";
+    artifact_yield: "artifact_yield";
+  }> & {
+    is(value: unknown): value is "notify_idle" | "reply_across_default_dirs" | "artifact_yield";
+  }>;
+  kind: z.ZodEnum<{
+    interactive: "interactive";
+    bg: "bg";
+    daemon: "daemon";
+    "daemon-worker": "daemon-worker";
+  }> & {
+    is(value: unknown): value is "interactive" | "bg" | "daemon" | "daemon-worker";
+  };
+  entrypoint: z.ZodString;
+  pidDomain: z.ZodString;
+  messagingSocketPath: z.ZodString;
+  name: z.ZodOptional<z.ZodString>;
+  nameSource: z.ZodOptional<z.ZodEnum<{
+    user: "user";
+    peer: "peer";
+    derived: "derived";
+    collision: "collision";
+    auto: "auto";
+    hook: "hook";
+  }> & {
+    is(value: unknown): value is "user" | "peer" | "derived" | "collision" | "auto" | "hook";
+  }>;
+  nameSince: z.ZodOptional<z.ZodNumber>;
+  updatedAt: z.ZodNumber;
+  status: z.ZodOptional<z.ZodEnum<{
+    idle: "idle";
+    busy: "busy";
+    shell: "shell";
+    waiting: "waiting";
+  }> & {
+    is(value: unknown): value is "idle" | "busy" | "shell" | "waiting";
+  }>;
+  statusUpdatedAt: z.ZodOptional<z.ZodNumber>;
+  bridgeSessionId: z.ZodOptional<z.ZodString>;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    pid: number;
+    sessionId: string;
+    cwd: string;
+    startedAt: number;
+    procStart: string;
+    version: string;
+    peerProtocol: number;
+    peerFeatures: ("notify_idle" | "reply_across_default_dirs" | "artifact_yield")[];
+    kind: "interactive" | "bg" | "daemon" | "daemon-worker";
+    entrypoint: string;
+    pidDomain: string;
+    messagingSocketPath: string;
+    updatedAt: number;
+    name?: string | undefined;
+    nameSource?: "user" | "peer" | "derived" | "collision" | "auto" | "hook" | undefined;
+    nameSince?: number | undefined;
+    status?: "idle" | "busy" | "shell" | "waiting" | undefined;
+    statusUpdatedAt?: number | undefined;
+    bridgeSessionId?: string | undefined;
+  };
+};
+type RegistryEntry = z.infer<typeof RegistryEntrySchema>;
+//#endregion
+//#region src/ports/registry-store.d.ts
+/** Registry port: the ~/.claude/sessions/<pid>.json store. */
+interface RegistryStore {
+  list: () => Promise<RegistryEntry[]>;
+  read: (pid: number) => Promise<RegistryEntry | undefined>;
+  write: (entry: RegistryEntry) => Promise<void>;
+  /** Heartbeat: bump updatedAt/statusUpdatedAt without rewriting the rest. */
+  touch: (pid: number) => Promise<void>;
+  remove: (pid: number) => Promise<void>;
+}
+//#endregion
+//#region src/schemas/keyfile.d.ts
+/** The auth key a session publishes next to its socket. */
+declare const PeerKeyFileSchema: z.ZodObject<{
+  peerToken: z.ZodString;
+  procStart: z.ZodString;
+  pidDomain: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    peerToken: string;
+    procStart: string;
+    pidDomain: string;
+  };
+};
+type PeerKeyFile = z.infer<typeof PeerKeyFileSchema>;
+//#endregion
+//#region src/ports/key-store.d.ts
+/** Key-store port: auth keys published next to each session socket. */
+interface KeyStore {
+  readForSocket: (socketPath: string) => Promise<PeerKeyFile | undefined>;
+  /** Write our own key file for the socket we own. */
+  writeForSocket: (socketPath: string, keyFile: Readonly<PeerKeyFile>) => Promise<void>;
+  removeForSocket: (socketPath: string) => Promise<void>;
+}
+//#endregion
+//#region src/ports/proc-info.d.ts
+/** Process-info port: the liveness and proc-start facts the roster needs. */
+interface ProcInfo {
+  alive: (pid: number) => Promise<boolean>;
+  /**
+   * The process start string, byte-equal to `LC_ALL=C TZ=UTC ps -o lstart=` output — the exact value the receiver's registry byte-compares against.
+   */
+  lstart: (pid: number) => Promise<string | undefined>;
+}
+//#endregion
+//#region src/ports/clock.d.ts
+/** Clock port: injectable time for pacer/refill and freshness windows. */
+interface Clock {
+  nowMs: () => number;
+}
+//#endregion
+//#region src/schemas/wire.d.ts
+declare const PeerMessageStatusSchema: z.ZodObject<{
+  type: z.ZodLiteral<"control">;
+  action: z.ZodLiteral<"peer_message_status">;
+  status: z.ZodEnum<{
+    held: "held";
+    delivered: "delivered";
+    denied: "denied";
+    expired: "expired";
+    dropped: "dropped";
+  }>;
+  reason: z.ZodString;
+  from: z.ZodString;
+  orig_msg_id: z.ZodString;
+  status_detail: z.ZodOptional<z.ZodString>;
+  drop_reason: z.ZodOptional<z.ZodEnum<{
+    "rate-limited": "rate-limited";
+    duplicate: "duplicate";
+    "hop-loop": "hop-loop";
+    "hop-runaway": "hop-runaway";
+    "queue-full": "queue-full";
+  }> & {
+    is(value: unknown): value is "rate-limited" | "duplicate" | "hop-loop" | "hop-runaway" | "queue-full";
+  }>;
+  dropped_msg_ids: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  msgV: z.ZodNumber;
+  msg_id: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    type: "control";
+    action: "peer_message_status";
+    status: "held" | "delivered" | "denied" | "expired" | "dropped";
+    reason: string;
+    from: string;
+    orig_msg_id: string;
+    msgV: number;
+    msg_id: string;
+    status_detail?: string | undefined;
+    drop_reason?: "rate-limited" | "duplicate" | "hop-loop" | "hop-runaway" | "queue-full" | undefined;
+    dropped_msg_ids?: string[] | undefined;
+  };
+};
+type PeerMessageStatus = z.infer<typeof PeerMessageStatusSchema>;
+declare const PeerIdleNoticeSchema: z.ZodObject<{
+  type: z.ZodLiteral<"control">;
+  action: z.ZodLiteral<"peer_idle_notice">;
+  orig_msg_id: z.ZodString;
+  state: z.ZodEnum<{
+    idle: "idle";
+    exited: "exited";
+  }>;
+  finished_at: z.ZodNumber;
+  detail: z.ZodOptional<z.ZodString>;
+  from: z.ZodString;
+  from_mode: z.ZodOptional<z.ZodEnum<{
+    bypass: "bypass";
+    prompting: "prompting";
+  }>>;
+  msgV: z.ZodNumber;
+  msg_id: z.ZodString;
+}, z.core.$strip> & {
+  is(value: unknown): value is {
+    type: "control";
+    action: "peer_idle_notice";
+    orig_msg_id: string;
+    state: "idle" | "exited";
+    finished_at: number;
+    from: string;
+    msgV: number;
+    msg_id: string;
+    detail?: string | undefined;
+    from_mode?: "bypass" | "prompting" | undefined;
+  };
+};
+type PeerIdleNotice = z.infer<typeof PeerIdleNoticeSchema>;
+//#endregion
+//#region src/cc-peer.d.ts
+/** Package version placeholder until semantic-release owns it. */
+declare const CC_PEER_VERSION = "0.0.0";
+/** How a target can be addressed. */
+type PeerRef = {
+  pid: number;
+} | {
+  name: string;
+} | {
+  address: string;
+};
+interface CcPeerOptions extends PathConfig {
+  name?: string;
+  sessionId?: string;
+  heartbeatMs?: number;
+  logger?: (message: string) => void;
+}
+interface SendOptions {
+  priority?: "next" | "later";
+  /** Attaches from-mode attestation; false deliberately sends unattested (recipient holds it). */
+  fromMode?: "bypass" | "prompting" | false;
+  /** When set, must match the receiver's sessionId or the frame is silently dropped. */
+  sessionId?: string;
+}
+interface InboundMessage {
+  from?: string;
+  fromSession?: string;
+  fromName?: string;
+  fromMode?: "bypass" | "prompting";
+  hopChain?: string[];
+  body: string;
+  msgId: string;
+}
+type Receipt = PeerMessageStatus;
+type IdleNotice = PeerIdleNotice;
+interface Deps {
+  transport: Transport;
+  registry: RegistryStore;
+  keys: KeyStore;
+  procInfo: ProcInfo;
+  clock: Clock;
+}
+/**
+ * A registered peer on Claude Code's cross-session mesh. Receipts and idle notices only reach the process that owns the listening socket (the protocol verifies return addresses via kernel peer pids), so do not split sending and listening across differently-owned processes.
+ */
+declare class CcPeer extends EventEmitter {
+  private readonly options;
+  private readonly deps;
+  private listening;
+  private heartbeatTimer;
+  private ownKey;
+  private readonly pacer;
+  private readonly log;
+  private stopped;
+  constructor(options: Readonly<CcPeerOptions>, deps: Deps);
+  static create(options?: Readonly<CcPeerOptions>): Promise<CcPeer>;
+  /**
+   * Bind, publish key and registry, and begin listening. Public rather than private because dependency-injected construction (this constructor takes the full Deps) needs to trigger it explicitly; everyday callers use the static create(), which wires the real node adapters.
+   */
+  start(): Promise<void>;
+  /** procStart is a required parameter, not read from this.ownKey: start() already guarantees a non-empty value before this is called, so the type checker enforces it rather than a runtime fallback that can never actually fire. */
+  private buildRegistryEntry;
+  roster(): Promise<RegistryEntry[]>;
+  send(target: PeerRef, body: string, options?: Readonly<SendOptions>): Promise<{
+    msgId: string;
+  }>;
+  private pacedSend;
+  subscribeIdle(target: PeerRef): Promise<{
+    msgId: string;
+  }>;
+  private resolveTarget;
+  /** ownToken is passed explicitly rather than read from this.ownKey: the listener callback that invokes this is only ever registered after start() has set ownKey, so the parameter records that guarantee at the type level instead of a runtime guard that can never actually be false. */
+  private handleConnection;
+  stop(): Promise<void>;
+}
+//#endregion
+export { InboundMessage as a, SendOptions as c, IdleNotice as i, PathConfig as l, CcPeer as n, PeerRef as o, CcPeerOptions as r, Receipt as s, CC_PEER_VERSION as t };

package/dist/{cc-peer-CXzxAUE4.cjs → cc-peer-D_3Bw_NE.cjs}

@@ -1,3 +1,4 @@
+const require_errors = require("./errors-Dl_lSq1N.cjs");
 let node_events = require("node:events");
 let node_crypto = require("node:crypto");
 let node_net = require("node:net");
@@ -129,16 +130,6 @@ var SystemClock = class {
 		return Date.now();
 	}
 };
-//#endregion
-//#region src/schemas/define-schema.ts
-/**
-* Attach an `.is()` type guard to a Zod schema so schema, inferred type, and runtime guard derive from one definition (single source of truth). `Schema.parse()` at JSON boundaries; `Schema.is()` for narrowing.
-*/
-function defineSchema(schema) {
-	return Object.assign(schema, { is(value) {
-		return schema.safeParse(value).success;
-	} });
-}
 const hex = (bytes) => bytes * 2;
 const PEER_TOKEN_HEX_LENGTH = hex(16);
 const HOP_ID_HEX_LENGTH = hex(12);
@@ -150,7 +141,7 @@ const count = (n) => String(n);
 //#endregion
 //#region src/schemas/keyfile.ts
 /** The auth key a session publishes next to its socket. */
-const PeerKeyFileSchema = defineSchema(zod.z.object({
+const PeerKeyFileSchema = require_errors.defineSchema(zod.z.object({
 	peerToken: zod.z.string().regex(new RegExp(`^[0-9a-f]{${count(PEER_TOKEN_HEX_LENGTH)}}$`)),
 	procStart: zod.z.string().min(1),
 	pidDomain: zod.z.string().min(1)
@@ -260,7 +251,7 @@ var FsKeyStore = class {
 //#endregion
 //#region src/schemas/registry.ts
 /** Whitelist the receiver applies on read; other values parse to undefined. */
-const NameSourceSchema = defineSchema(zod.z.enum([
+const NameSourceSchema = require_errors.defineSchema(zod.z.enum([
 	"user",
 	"peer",
 	"derived",
@@ -268,25 +259,25 @@ const NameSourceSchema = defineSchema(zod.z.enum([
 	"auto",
 	"hook"
 ]));
-const PeerStatusSchema = defineSchema(zod.z.enum([
+const PeerStatusSchema = require_errors.defineSchema(zod.z.enum([
 	"busy",
 	"shell",
 	"idle",
 	"waiting"
 ]));
-const SessionKindSchema = defineSchema(zod.z.enum([
+const SessionKindSchema = require_errors.defineSchema(zod.z.enum([
 	"interactive",
 	"bg",
 	"daemon",
 	"daemon-worker"
 ]));
-const PeerFeatureSchema = defineSchema(zod.z.enum([
+const PeerFeatureSchema = require_errors.defineSchema(zod.z.enum([
 	"notify_idle",
 	"reply_across_default_dirs",
 	"artifact_yield"
 ]));
 /** One entry of the ~/.claude/sessions/<pid>.json registry. */
-const RegistryEntrySchema = defineSchema(zod.z.object({
+const RegistryEntrySchema = require_errors.defineSchema(zod.z.object({
 	pid: zod.z.number().int().positive(),
 	sessionId: zod.z.string().min(1),
 	cwd: zod.z.string(),
@@ -479,10 +470,10 @@ var WinProcInfo = class {
 /**
 * Grammar of the <cross-session-message> envelope attributes, mirroring the receiver's own parser. The serialized attribute ORDER is canonical (from, from-session, hop-chain, from-name, from-mode): the receiver's regex matches that sequence only, so any other order parses as nothing.
 */
-const EnvelopeAddressSchema = defineSchema(zod.z.string().regex(new RegExp(`^[A-Za-z0-9%:_/.\\\\-]{1,${count(300)}}$`)));
-const FromModeSchema = defineSchema(zod.z.enum(["bypass", "prompting"]));
+const EnvelopeAddressSchema = require_errors.defineSchema(zod.z.string().regex(new RegExp(`^[A-Za-z0-9%:_/.\\\\-]{1,${count(300)}}$`)));
+const FromModeSchema = require_errors.defineSchema(zod.z.enum(["bypass", "prompting"]));
 const HopIdSchema = zod.z.string().regex(new RegExp(`^[0-9a-f]{${count(HOP_ID_HEX_LENGTH)}}$`));
-const EnvelopeAttributesSchema = defineSchema(zod.z.object({
+const EnvelopeAttributesSchema = require_errors.defineSchema(zod.z.object({
 	from: EnvelopeAddressSchema,
 	fromSession: zod.z.string().regex(new RegExp(`^[A-Za-z0-9_-]{1,${count(80)}}$`)).optional(),
 	/** Parsed hop chain: at most 32 ids at the grammar level. */
@@ -616,12 +607,12 @@ async function checkEntry(entry, probes) {
 //#endregion
 //#region src/schemas/wire.ts
 /** Line 1 of every connection: the receiver's own peerToken (peer class) or childToken (self-sent class). */
-const AuthLineSchema = defineSchema(zod.z.object({
+const AuthLineSchema = require_errors.defineSchema(zod.z.object({
 	type: zod.z.literal("auth"),
 	token: zod.z.string().regex(new RegExp(`^[0-9a-f]{${count(PEER_TOKEN_HEX_LENGTH)}}$`))
 }));
-const PrioritySchema = defineSchema(zod.z.enum(["next", "later"]));
-const FileAttachmentSchema = defineSchema(zod.z.object({
+const PrioritySchema = require_errors.defineSchema(zod.z.enum(["next", "later"]));
+const FileAttachmentSchema = require_errors.defineSchema(zod.z.object({
 	path: zod.z.string().min(1),
 	file_name: zod.z.string().min(1),
 	file_size: zod.z.number().int().nonnegative(),
@@ -629,7 +620,7 @@ const FileAttachmentSchema = defineSchema(zod.z.object({
 	media_type: zod.z.string().optional()
 }));
 /** A user-turn message. `"type": "user"` is load-bearing: any other value is silently dropped. */
-const UserFrameSchema = defineSchema(zod.z.object({
+const UserFrameSchema = require_errors.defineSchema(zod.z.object({
 	msgV: zod.z.number().int(),
 	msg_id: zod.z.string().min(1),
 	type: zod.z.literal("user"),
@@ -643,14 +634,14 @@ const UserFrameSchema = defineSchema(zod.z.object({
 	session_id: zod.z.string().optional(),
 	file_attachments: zod.z.array(FileAttachmentSchema).max(16).optional()
 }));
-const DropReasonSchema = defineSchema(zod.z.enum([
+const DropReasonSchema = require_errors.defineSchema(zod.z.enum([
 	"rate-limited",
 	"duplicate",
 	"hop-loop",
 	"hop-runaway",
 	"queue-full"
 ]));
-const PeerMessageStatusSchema = defineSchema(zod.z.object({
+const PeerMessageStatusSchema = require_errors.defineSchema(zod.z.object({
 	type: zod.z.literal("control"),
 	action: zod.z.literal("peer_message_status"),
 	status: zod.z.enum([
@@ -669,7 +660,7 @@ const PeerMessageStatusSchema = defineSchema(zod.z.object({
 	msgV: zod.z.number().int(),
 	msg_id: zod.z.string().min(1)
 }));
-const NotifyWhenIdleSchema = defineSchema(zod.z.object({
+const NotifyWhenIdleSchema = require_errors.defineSchema(zod.z.object({
 	type: zod.z.literal("control"),
 	action: zod.z.literal("notify_when_idle"),
 	from: zod.z.string().regex(new RegExp(`^[A-Za-z0-9%:_/.\\\\-]{1,${count(300)}}$`)),
@@ -677,7 +668,7 @@ const NotifyWhenIdleSchema = defineSchema(zod.z.object({
 	msgV: zod.z.number().int(),
 	msg_id: zod.z.string().min(1)
 }));
-const PeerIdleNoticeSchema = defineSchema(zod.z.object({
+const PeerIdleNoticeSchema = require_errors.defineSchema(zod.z.object({
 	type: zod.z.literal("control"),
 	action: zod.z.literal("peer_idle_notice"),
 	orig_msg_id: zod.z.string().min(1),
@@ -691,7 +682,7 @@ const PeerIdleNoticeSchema = defineSchema(zod.z.object({
 }));
 /** Bare enum, exported separately so a test can assert its own membership directly rather than through the object field's .catch("claim") fallback, which would otherwise mask a corrupted "claim" member by coincidentally recovering the same value. */
 const YieldReasonSchema = zod.z.enum(["resume", "claim"]);
-const YieldArtifactRepliesSchema = defineSchema(zod.z.object({
+const YieldArtifactRepliesSchema = require_errors.defineSchema(zod.z.object({
 	type: zod.z.literal("control"),
 	action: zod.z.literal("yield_artifact_replies"),
 	from: zod.z.string().max(512),
@@ -707,7 +698,7 @@ const YieldArtifactRepliesSchema = defineSchema(zod.z.object({
 	}).optional(),
 	msgV: zod.z.number().int()
 }));
-const ArtifactRepliesYieldedSchema = defineSchema(zod.z.object({
+const ArtifactRepliesYieldedSchema = require_errors.defineSchema(zod.z.object({
 	type: zod.z.literal("control"),
 	action: zod.z.literal("artifact_replies_yielded"),
 	orig_msg_id: zod.z.string().max(128),
@@ -718,7 +709,7 @@ const ArtifactRepliesYieldedSchema = defineSchema(zod.z.object({
 	msg_id: zod.z.string().min(1),
 	from: zod.z.string().optional()
 }));
-const UnyieldArtifactRepliesSchema = defineSchema(zod.z.object({
+const UnyieldArtifactRepliesSchema = require_errors.defineSchema(zod.z.object({
 	type: zod.z.literal("control"),
 	action: zod.z.literal("unyield_artifact_replies"),
 	orig_msg_id: zod.z.string().max(128),
@@ -738,41 +729,6 @@ const ControlFrameSchema = zod.z.union([
 ]);
 const WireFrameSchema = zod.z.union([UserFrameSchema, ControlFrameSchema]);
 //#endregion
-//#region src/errors.ts
-/** Base error for every cc-peer failure; `code` is machine-readable. */
-var CcPeerError = class extends Error {
-	code;
-	constructor(code, message) {
-		super(message);
-		this.code = code;
-		this.name = "CcPeerError";
-	}
-};
-var NoLiveInboxError = class extends CcPeerError {
-	constructor(message) {
-		super("NO_LIVE_INBOX", message);
-		this.name = "NoLiveInboxError";
-	}
-};
-var UnknownPeerError = class extends CcPeerError {
-	constructor(message) {
-		super("UNKNOWN_PEER", message);
-		this.name = "UnknownPeerError";
-	}
-};
-var MessageTooLargeError = class extends CcPeerError {
-	constructor(message) {
-		super("MESSAGE_TOO_LARGE", message);
-		this.name = "MessageTooLargeError";
-	}
-};
-var NotStartedError = class extends CcPeerError {
-	constructor(message) {
-		super("NOT_STARTED", message);
-		this.name = "NotStartedError";
-	}
-};
-//#endregion
 //#region src/cc-peer.ts
 /** Package version placeholder until semantic-release owns it. */
 const CC_PEER_VERSION = "0.0.0";
@@ -823,7 +779,7 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 			procStart: await this.deps.procInfo.lstart(process.pid) ?? "",
 			pidDomain: process.platform
 		};
-		if (this.ownKey.procStart === "") throw new NotStartedError("could not read own procStart via ps");
+		if (this.ownKey.procStart === "") throw new require_errors.NotStartedError("could not read own procStart via ps");
 		await this.deps.keys.writeForSocket(socketPath, this.ownKey);
 		if (!isWindows()) await (0, node_fs_promises.mkdir)((0, node_path.dirname)(socketPath), {
 			recursive: true,
@@ -875,7 +831,7 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 		});
 	}
 	async send(target, body, options = {}) {
-		if (this.stopped || this.listening === void 0 || this.ownKey === void 0) throw new NotStartedError("peer is not running");
+		if (this.stopped || this.listening === void 0 || this.ownKey === void 0) throw new require_errors.NotStartedError("peer is not running");
 		const socketPath = await this.resolveTarget(target);
 		const key = await this.deps.keys.readForSocket(socketPath);
 		const msgId = newMsgId();
@@ -897,13 +853,13 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 			priority: options.priority ?? "next",
 			from
 		};
-		if (key === void 0) throw new NoLiveInboxError(`no auth key published for ${socketPath}`);
+		if (key === void 0) throw new require_errors.NoLiveInboxError(`no auth key published for ${socketPath}`);
 		const auth = AuthLineSchema.parse({
 			type: "auth",
 			token: key.peerToken
 		});
 		const line = JSON.stringify(frame);
-		if (line.length > MAX_FRAME_CHARS) throw new MessageTooLargeError(`serialized frame is ${line.length.toString()} chars, cap ${MAX_FRAME_CHARS.toString()}`);
+		if (line.length > MAX_FRAME_CHARS) throw new require_errors.MessageTooLargeError(`serialized frame is ${line.length.toString()} chars, cap ${MAX_FRAME_CHARS.toString()}`);
 		await this.pacedSend(socketPath, [JSON.stringify(auth), line]);
 		return { msgId };
 	}
@@ -918,10 +874,10 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 		await this.deps.transport.connectWrite(socketPath, lines);
 	}
 	async subscribeIdle(target) {
-		if (this.stopped || this.listening === void 0 || this.ownKey === void 0) throw new NotStartedError("peer is not running");
+		if (this.stopped || this.listening === void 0 || this.ownKey === void 0) throw new require_errors.NotStartedError("peer is not running");
 		const socketPath = await this.resolveTarget(target);
 		const key = await this.deps.keys.readForSocket(socketPath);
-		if (key === void 0) throw new NoLiveInboxError(`no auth key published for ${socketPath}`);
+		if (key === void 0) throw new require_errors.NoLiveInboxError(`no auth key published for ${socketPath}`);
 		const msgId = newMsgId();
 		const frame = {
 			msgV: 1,
@@ -942,7 +898,7 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 		if ("pid" in target) return socketPathForPid(target.pid, this.options);
 		if ("address" in target) return target.address.replace(/^uds:/, "");
 		const match = (await this.roster()).find((entry) => entry.name === target.name);
-		if (match === void 0) throw new UnknownPeerError(`no roster entry named ${target.name}`);
+		if (match === void 0) throw new require_errors.UnknownPeerError(`no roster entry named ${target.name}`);
 		return match.messagingSocketPath;
 	}
 	/** ownToken is passed explicitly rather than read from this.ownKey: the listener callback that invokes this is only ever registered after start() has set ownKey, so the parameter records that guarantee at the type level instead of a runtime guard that can never actually be false. */
@@ -1019,9 +975,3 @@ Object.defineProperty(exports, "RegistryEntrySchema", {
 		return RegistryEntrySchema;
 	}
 });
-Object.defineProperty(exports, "defineSchema", {
-	enumerable: true,
-	get: function() {
-		return defineSchema;
-	}
-});

package/dist/cc-peer.cjs

@@ -1,4 +1,4 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_cc_peer = require("./cc-peer-CXzxAUE4.cjs");
+const require_cc_peer = require("./cc-peer-D_3Bw_NE.cjs");
 exports.CC_PEER_VERSION = require_cc_peer.CC_PEER_VERSION;
 exports.CcPeer = require_cc_peer.CcPeer;