cc-peer 1.5.3 → 1.6.1

package/README.md

@@ -78,11 +78,19 @@ aliases.on("message", (m) => {
 // time, give it a reply-able name (idempotent; a no-op if already active).
 await aliases.ensure("alice");
 
+// Deliver alice's message to the relayed session from alice's own alias
+// (starting it if needed), so the session sees alice as the sender and its
+// own reply-to-sender comes back on the "message" handler above rather than
+// to the relay. Rejects if the alias cannot start, or if it cannot send.
+const { msgId } = await aliases.send("alice", { pid: relayedSessionPid }, "ping");
+
 // …later, once a correspondent is no longer relevant:
 await aliases.retire("alice");
 await aliases.stopAll();
 ```
 
+Sending from the alias rather than from the relay's own peer is what makes a relayed session's natural reply reach the right correspondent: a session replies to whoever sent it a message, so a message delivered from the relay comes back to the relay with nothing to say which correspondent it answers.
+
 ## Limitations
 
 - **Same-process constraint**: receipts and idle notices only reach the process that owns the peer's listening socket (the protocol verifies return addresses via kernel peer-pids). Do not split `CcPeer` listening and sending across processes or differently-owned workers.

package/dist/adapters/node/alias-worker.cjs

@@ -1,6 +1,7 @@
 const require_rolldown_runtime = require("../../rolldown-runtime-VH7oDXx4.cjs");
-const require_cc_peer = require("../../cc-peer-CPPV05My.cjs");
-const require_alias_ipc = require("../../alias-ipc-Cjs5yivH.cjs");
+const require_cc_peer = require("../../cc-peer-BvoaikwI.cjs");
+const require_errors = require("../../errors-BAbklcGw.cjs");
+const require_alias_ipc = require("../../alias-ipc-BPc2wfmz.cjs");
 let node_process = require("node:process");
 node_process = require_rolldown_runtime.__toESM(node_process, 1);
 //#region src/adapters/node/alias-worker.ts
@@ -11,11 +12,25 @@ let peer;
 node_process.default.on("message", (raw) => {
 	handleCommand(raw);
 });
+node_process.default.on("disconnect", () => {
+	shutdown();
+});
+async function shutdown() {
+	await peer?.stop();
+	node_process.default.exit(0);
+}
+/** Relays an event to the parent unless its channel has already closed, since a send on a closed channel raises an error event on the process that nothing handles. */
+function relay(message) {
+	if (node_process.default.connected) node_process.default.send?.(message);
+}
 async function handleCommand(raw) {
 	if (!require_alias_ipc.AliasCommandSchema.is(raw)) return;
 	if (raw.type === "stop") {
-		await peer?.stop();
-		node_process.default.exit(0);
+		await shutdown();
+		return;
+	}
+	if (raw.type === "send") {
+		await handleSend(raw);
 		return;
 	}
 	let created;
@@ -32,11 +47,38 @@ async function handleCommand(raw) {
 	}
 	peer = created;
 	peer.on("message", (message) => {
-		node_process.default.send?.({
+		relay({
 			type: "message",
 			...message
 		});
 	});
-	node_process.default.send?.({ type: "started" });
+	relay({ type: "started" });
+}
+async function handleSend(command) {
+	const active = peer;
+	if (active === void 0) {
+		relay({
+			type: "send_failed",
+			requestId: command.requestId,
+			code: "NOT_STARTED",
+			message: "alias peer has not started"
+		});
+		return;
+	}
+	try {
+		const { msgId } = await active.send(command.target, command.body);
+		relay({
+			type: "sent",
+			requestId: command.requestId,
+			msgId
+		});
+	} catch (error) {
+		relay({
+			type: "send_failed",
+			requestId: command.requestId,
+			code: error instanceof require_errors.CcPeerError ? error.code : "UNKNOWN",
+			message: error instanceof Error ? error.message : "unknown alias send failure"
+		});
+	}
 }
 //#endregion

package/dist/adapters/node/alias-worker.mjs

@@ -1,5 +1,6 @@
-import { n as CcPeer } from "../../cc-peer-D3maNn_Z.mjs";
-import { t as AliasCommandSchema } from "../../alias-ipc-DkaozCo7.mjs";
+import { n as CcPeer } from "../../cc-peer-CQV4Qv_H.mjs";
+import { r as CcPeerError } from "../../errors-KYBco8pU.mjs";
+import { t as AliasCommandSchema } from "../../alias-ipc-BSh7Q4LL.mjs";
 import process from "node:process";
 //#region src/adapters/node/alias-worker.ts
 /**
@@ -9,11 +10,25 @@ let peer;
 process.on("message", (raw) => {
 	handleCommand(raw);
 });
+process.on("disconnect", () => {
+	shutdown();
+});
+async function shutdown() {
+	await peer?.stop();
+	process.exit(0);
+}
+/** Relays an event to the parent unless its channel has already closed, since a send on a closed channel raises an error event on the process that nothing handles. */
+function relay(message) {
+	if (process.connected) process.send?.(message);
+}
 async function handleCommand(raw) {
 	if (!AliasCommandSchema.is(raw)) return;
 	if (raw.type === "stop") {
-		await peer?.stop();
-		process.exit(0);
+		await shutdown();
+		return;
+	}
+	if (raw.type === "send") {
+		await handleSend(raw);
 		return;
 	}
 	let created;
@@ -30,12 +45,39 @@ async function handleCommand(raw) {
 	}
 	peer = created;
 	peer.on("message", (message) => {
-		process.send?.({
+		relay({
 			type: "message",
 			...message
 		});
 	});
-	process.send?.({ type: "started" });
+	relay({ type: "started" });
+}
+async function handleSend(command) {
+	const active = peer;
+	if (active === void 0) {
+		relay({
+			type: "send_failed",
+			requestId: command.requestId,
+			code: "NOT_STARTED",
+			message: "alias peer has not started"
+		});
+		return;
+	}
+	try {
+		const { msgId } = await active.send(command.target, command.body);
+		relay({
+			type: "sent",
+			requestId: command.requestId,
+			msgId
+		});
+	} catch (error) {
+		relay({
+			type: "send_failed",
+			requestId: command.requestId,
+			code: error instanceof CcPeerError ? error.code : "UNKNOWN",
+			message: error instanceof Error ? error.message : "unknown alias send failure"
+		});
+	}
 }
 //#endregion
 export {};

package/dist/alias-ipc-BPc2wfmz.cjs

@@ -0,0 +1,97 @@
+const require_errors = require("./errors-BAbklcGw.cjs");
+let zod = require("zod");
+//#region src/schemas/alias-ipc.ts
+/**
+* The parent-to-child and child-to-parent IPC contract `AliasPool`'s Node adapter (`adapters/node/forked-alias-process.ts`) and worker (`adapters/node/alias-worker.ts`) exchange over `child_process.fork()`'s built-in channel. This is deliberately independent of the wire protocol schemas in `wire.ts`: it never touches a socket, it only carries commands and events between a pool and the real OS process backing one reply alias.
+*/
+const AliasStartCommandSchema = require_errors.defineSchema(zod.z.object({
+	type: zod.z.literal("start"),
+	name: zod.z.string().min(1),
+	homeDir: zod.z.string().optional(),
+	socketDir: zod.z.string().optional(),
+	sessionId: zod.z.string().optional()
+}));
+const AliasStopCommandSchema = require_errors.defineSchema(zod.z.object({ type: zod.z.literal("stop") }));
+/**
+* How an alias addresses an outbound send, mirroring `CcPeer`'s own `PeerRef` union. Each variant is strict so a target carrying fields from more than one variant is rejected outright rather than resolved by whichever branch happens to match first.
+*/
+const AliasSendTargetSchema = require_errors.defineSchema(zod.z.union([
+	zod.z.strictObject({ pid: zod.z.number() }),
+	zod.z.strictObject({ name: zod.z.string().min(1) }),
+	zod.z.strictObject({ address: zod.z.string().min(1) })
+]));
+/** Asks the alias's own CcPeer to send `body` to `target`; the worker answers with a sent or send_failed event carrying the same `requestId`. */
+const AliasSendCommandSchema = require_errors.defineSchema(zod.z.object({
+	type: zod.z.literal("send"),
+	requestId: zod.z.string().min(1),
+	target: AliasSendTargetSchema,
+	body: zod.z.string()
+}));
+const AliasCommandSchema = require_errors.defineSchema(zod.z.union([
+	AliasStartCommandSchema,
+	AliasStopCommandSchema,
+	AliasSendCommandSchema
+]));
+/** Sent once the worker's own CcPeer is listening and registered. */
+const AliasStartedEventSchema = require_errors.defineSchema(zod.z.object({ type: zod.z.literal("started") }));
+/** Mirrors CcPeer's own InboundMessage shape, carried over IPC instead of an EventEmitter within one process. */
+const AliasMessageEventSchema = require_errors.defineSchema(zod.z.object({
+	type: zod.z.literal("message"),
+	from: zod.z.string().optional(),
+	fromSession: zod.z.string().optional(),
+	fromName: zod.z.string().optional(),
+	fromMode: zod.z.enum(["bypass", "prompting"]).optional(),
+	hopChain: zod.z.array(zod.z.string()).optional(),
+	body: zod.z.string(),
+	msgId: zod.z.string()
+}));
+/** Acknowledges the send command with the same `requestId`, carrying the id the alias's own peer gave the message. */
+const AliasSentEventSchema = require_errors.defineSchema(zod.z.object({
+	type: zod.z.literal("sent"),
+	requestId: zod.z.string().min(1),
+	msgId: zod.z.string().min(1)
+}));
+/** Reports a send the alias could not make; `code` is the originating `CcPeerError`'s own machine-readable code where one was thrown. */
+const AliasSendFailedEventSchema = require_errors.defineSchema(zod.z.object({
+	type: zod.z.literal("send_failed"),
+	requestId: zod.z.string().min(1),
+	code: zod.z.string().min(1),
+	message: zod.z.string()
+}));
+require_errors.defineSchema(zod.z.union([
+	AliasStartedEventSchema,
+	AliasMessageEventSchema,
+	AliasSentEventSchema,
+	AliasSendFailedEventSchema
+]));
+//#endregion
+Object.defineProperty(exports, "AliasCommandSchema", {
+	enumerable: true,
+	get: function() {
+		return AliasCommandSchema;
+	}
+});
+Object.defineProperty(exports, "AliasMessageEventSchema", {
+	enumerable: true,
+	get: function() {
+		return AliasMessageEventSchema;
+	}
+});
+Object.defineProperty(exports, "AliasSendFailedEventSchema", {
+	enumerable: true,
+	get: function() {
+		return AliasSendFailedEventSchema;
+	}
+});
+Object.defineProperty(exports, "AliasSentEventSchema", {
+	enumerable: true,
+	get: function() {
+		return AliasSentEventSchema;
+	}
+});
+Object.defineProperty(exports, "AliasStartedEventSchema", {
+	enumerable: true,
+	get: function() {
+		return AliasStartedEventSchema;
+	}
+});

package/dist/alias-ipc-BSh7Q4LL.mjs

@@ -0,0 +1,68 @@
+import { l as defineSchema } from "./errors-KYBco8pU.mjs";
+import { z } from "zod";
+//#region src/schemas/alias-ipc.ts
+/**
+* The parent-to-child and child-to-parent IPC contract `AliasPool`'s Node adapter (`adapters/node/forked-alias-process.ts`) and worker (`adapters/node/alias-worker.ts`) exchange over `child_process.fork()`'s built-in channel. This is deliberately independent of the wire protocol schemas in `wire.ts`: it never touches a socket, it only carries commands and events between a pool and the real OS process backing one reply alias.
+*/
+const AliasStartCommandSchema = defineSchema(z.object({
+	type: z.literal("start"),
+	name: z.string().min(1),
+	homeDir: z.string().optional(),
+	socketDir: z.string().optional(),
+	sessionId: z.string().optional()
+}));
+const AliasStopCommandSchema = defineSchema(z.object({ type: z.literal("stop") }));
+/**
+* How an alias addresses an outbound send, mirroring `CcPeer`'s own `PeerRef` union. Each variant is strict so a target carrying fields from more than one variant is rejected outright rather than resolved by whichever branch happens to match first.
+*/
+const AliasSendTargetSchema = defineSchema(z.union([
+	z.strictObject({ pid: z.number() }),
+	z.strictObject({ name: z.string().min(1) }),
+	z.strictObject({ address: z.string().min(1) })
+]));
+/** Asks the alias's own CcPeer to send `body` to `target`; the worker answers with a sent or send_failed event carrying the same `requestId`. */
+const AliasSendCommandSchema = defineSchema(z.object({
+	type: z.literal("send"),
+	requestId: z.string().min(1),
+	target: AliasSendTargetSchema,
+	body: z.string()
+}));
+const AliasCommandSchema = defineSchema(z.union([
+	AliasStartCommandSchema,
+	AliasStopCommandSchema,
+	AliasSendCommandSchema
+]));
+/** Sent once the worker's own CcPeer is listening and registered. */
+const AliasStartedEventSchema = defineSchema(z.object({ type: z.literal("started") }));
+/** Mirrors CcPeer's own InboundMessage shape, carried over IPC instead of an EventEmitter within one process. */
+const AliasMessageEventSchema = defineSchema(z.object({
+	type: z.literal("message"),
+	from: z.string().optional(),
+	fromSession: z.string().optional(),
+	fromName: z.string().optional(),
+	fromMode: z.enum(["bypass", "prompting"]).optional(),
+	hopChain: z.array(z.string()).optional(),
+	body: z.string(),
+	msgId: z.string()
+}));
+/** Acknowledges the send command with the same `requestId`, carrying the id the alias's own peer gave the message. */
+const AliasSentEventSchema = defineSchema(z.object({
+	type: z.literal("sent"),
+	requestId: z.string().min(1),
+	msgId: z.string().min(1)
+}));
+/** Reports a send the alias could not make; `code` is the originating `CcPeerError`'s own machine-readable code where one was thrown. */
+const AliasSendFailedEventSchema = defineSchema(z.object({
+	type: z.literal("send_failed"),
+	requestId: z.string().min(1),
+	code: z.string().min(1),
+	message: z.string()
+}));
+defineSchema(z.union([
+	AliasStartedEventSchema,
+	AliasMessageEventSchema,
+	AliasSentEventSchema,
+	AliasSendFailedEventSchema
+]));
+//#endregion
+export { AliasStartedEventSchema as a, AliasSentEventSchema as i, AliasMessageEventSchema as n, AliasSendFailedEventSchema as r, AliasCommandSchema as t };

package/dist/alias-pool.cjs

@@ -1,6 +1,6 @@
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
-const require_errors = require("./errors-Dl_lSq1N.cjs");
-const require_alias_ipc = require("./alias-ipc-Cjs5yivH.cjs");
+const require_errors = require("./errors-BAbklcGw.cjs");
+const require_alias_ipc = require("./alias-ipc-BPc2wfmz.cjs");
 let node_events = require("node:events");
 let node_child_process = require("node:child_process");
 let node_url = require("node:url");
@@ -12,6 +12,7 @@ var ForkedAliasProcess = class {
 	events = new node_events.EventEmitter();
 	forkFn;
 	workerPath;
+	pendingSends = /* @__PURE__ */ new Map();
 	child;
 	constructor(deps) {
 		this.forkFn = deps.fork ?? node_child_process.fork;
@@ -21,9 +22,14 @@ var ForkedAliasProcess = class {
 		const child = this.forkFn(this.workerPath, [], {});
 		this.child = child;
 		child.on("message", (raw) => {
-			if (require_alias_ipc.AliasMessageEventSchema.is(raw)) this.events.emit("message", toInboundMessage(raw));
+			if (require_alias_ipc.AliasMessageEventSchema.is(raw)) {
+				this.events.emit("message", toInboundMessage(raw));
+				return;
+			}
+			this.settleSend(raw);
 		});
 		child.on("exit", () => {
+			this.failPendingSends("alias worker exited before the send was acknowledged");
 			this.events.emit("exit");
 		});
 		await new Promise((resolve, reject) => {
@@ -49,10 +55,51 @@ var ForkedAliasProcess = class {
 			});
 		});
 	}
-	async stop() {
+	async send(target, body) {
+		const child = this.runningChild();
+		if (child === void 0) throw new require_errors.AliasSendError("alias worker is not running");
+		const requestId = require_errors.newMsgId();
+		return new Promise((resolve, reject) => {
+			this.pendingSends.set(requestId, {
+				resolve,
+				reject
+			});
+			child.send({
+				type: "send",
+				requestId,
+				target,
+				body
+			});
+		});
+	}
+	/** Settles the one in-flight send an acknowledgement names. An acknowledgement for an unknown request is ignored: the send it belongs to was already settled by the worker exiting. */
+	settleSend(raw) {
+		if (require_alias_ipc.AliasSentEventSchema.is(raw)) {
+			this.takePendingSend(raw.requestId)?.resolve({ msgId: raw.msgId });
+			return;
+		}
+		if (require_alias_ipc.AliasSendFailedEventSchema.is(raw)) this.takePendingSend(raw.requestId)?.reject(new require_errors.AliasSendError(`${raw.code}: ${raw.message}`));
+	}
+	takePendingSend(requestId) {
+		const pending = this.pendingSends.get(requestId);
+		this.pendingSends.delete(requestId);
+		return pending;
+	}
+	failPendingSends(reason) {
+		const pending = [...this.pendingSends.values()];
+		this.pendingSends.clear();
+		for (const send of pending) send.reject(new require_errors.AliasSendError(reason));
+	}
+	/** The forked child while it is still running, or undefined before start() and once it has ended: a command written past that point reaches a channel nothing is reading. */
+	runningChild() {
 		const child = this.child;
+		if (child === void 0) return void 0;
+		if (child.exitCode !== null || child.signalCode !== null) return void 0;
+		return child;
+	}
+	async stop() {
+		const child = this.runningChild();
 		if (child === void 0) return;
-		if (child.exitCode !== null || child.signalCode !== null) return;
 		await new Promise((resolve) => {
 			child.once("exit", () => {
 				resolve();
@@ -106,16 +153,24 @@ var AliasPool = class AliasPool extends node_events.EventEmitter {
 	}
 	/** Idempotent: a no-op if the alias is already active, and dedup'd if another ensure() for the same name is already in flight. */
 	async ensure(name) {
-		if (this.active.has(name)) return;
+		await this.acquire(name);
+	}
+	/**
+	* Sends `body` to `target` from the named alias's own peer identity, starting that alias first if it is not already running, so the recipient sees the correspondent rather than the relay as the sender. Resolves with the id the alias gave the message; rejects with an `AliasStartError` if the alias could not be started, or an `AliasSendError` if it refused the send or its process ended before acknowledging it.
+	*/
+	async send(name, target, body) {
+		return (await this.acquire(name)).send(target, body);
+	}
+	/** The single start path behind ensure() and send(): returns the running process for the name, starting one only if neither an active nor an in-flight process already exists. */
+	async acquire(name) {
+		const active = this.active.get(name);
+		if (active !== void 0) return active;
 		const inFlight = this.pending.get(name);
-		if (inFlight !== void 0) {
-			await inFlight;
-			return;
-		}
+		if (inFlight !== void 0) return inFlight;
 		const started = this.startAlias(name);
 		this.pending.set(name, started);
 		try {
-			await started;
+			return await started;
 		} finally {
 			this.pending.delete(name);
 		}
@@ -139,6 +194,7 @@ var AliasPool = class AliasPool extends node_events.EventEmitter {
 		});
 		this.active.set(name, proc);
 		this.log(`alias ${name} active`);
+		return proc;
 	}
 	/** Waits for any in-flight ensure() of the same name to settle first, so a retire() issued while an alias is still starting stops it once (and if) it becomes active. A no-op for a name that is neither active nor pending. */
 	async retire(name) {

package/dist/alias-pool.d.cts

@@ -1,4 +1,4 @@
-import { a as InboundMessage, l as PathConfig } from "./cc-peer-B3i4ZlKV.cjs";
+import { a as InboundMessage, l as PathConfig, o as PeerRef } from "./cc-peer-mYIVwlKe.cjs";
 import { EventEmitter } from "node:events";
 //#region src/ports/alias-process.d.ts
 interface AliasStartOptions extends PathConfig {
@@ -11,6 +11,12 @@ interface AliasStartOptions extends PathConfig {
 interface AliasProcess {
   readonly events: EventEmitter;
   start: (options: Readonly<AliasStartOptions>) => Promise<void>;
+  /**
+   * Sends `body` to `target` from the alias's own peer identity, so the recipient sees the alias as the sender and replies to it natively. Resolves with the id the alias's peer gave the message; rejects with an `AliasSendError` when the alias refuses the send or its process ends before acknowledging it.
+   */
+  send: (target: Readonly<PeerRef>, body: string) => Promise<{
+    msgId: string;
+  }>;
   stop: () => Promise<void>;
 }
 //#endregion
@@ -42,6 +48,14 @@ export declare class AliasPool extends EventEmitter {
   static create(options?: Readonly<AliasPoolOptions>): AliasPool;
   /** Idempotent: a no-op if the alias is already active, and dedup'd if another ensure() for the same name is already in flight. */
   ensure(name: string): Promise<void>;
+  /**
+   * Sends `body` to `target` from the named alias's own peer identity, starting that alias first if it is not already running, so the recipient sees the correspondent rather than the relay as the sender. Resolves with the id the alias gave the message; rejects with an `AliasStartError` if the alias could not be started, or an `AliasSendError` if it refused the send or its process ended before acknowledging it.
+   */
+  send(name: string, target: Readonly<PeerRef>, body: string): Promise<{
+    msgId: string;
+  }>;
+  /** The single start path behind ensure() and send(): returns the running process for the name, starting one only if neither an active nor an in-flight process already exists. */
+  private acquire;
   private startAlias;
   /** Waits for any in-flight ensure() of the same name to settle first, so a retire() issued while an alias is still starting stops it once (and if) it becomes active. A no-op for a name that is neither active nor pending. */
   retire(name: string): Promise<void>;

package/dist/alias-pool.d.mts

@@ -1,4 +1,4 @@
-import { a as InboundMessage, l as PathConfig } from "./cc-peer-B3i4ZlKV.mjs";
+import { a as InboundMessage, l as PathConfig, o as PeerRef } from "./cc-peer-mYIVwlKe.mjs";
 import { EventEmitter } from "node:events";
 //#region src/ports/alias-process.d.ts
 interface AliasStartOptions extends PathConfig {
@@ -11,6 +11,12 @@ interface AliasStartOptions extends PathConfig {
 interface AliasProcess {
   readonly events: EventEmitter;
   start: (options: Readonly<AliasStartOptions>) => Promise<void>;
+  /**
+   * Sends `body` to `target` from the alias's own peer identity, so the recipient sees the alias as the sender and replies to it natively. Resolves with the id the alias's peer gave the message; rejects with an `AliasSendError` when the alias refuses the send or its process ends before acknowledging it.
+   */
+  send: (target: Readonly<PeerRef>, body: string) => Promise<{
+    msgId: string;
+  }>;
   stop: () => Promise<void>;
 }
 //#endregion
@@ -42,6 +48,14 @@ export declare class AliasPool extends EventEmitter {
   static create(options?: Readonly<AliasPoolOptions>): AliasPool;
   /** Idempotent: a no-op if the alias is already active, and dedup'd if another ensure() for the same name is already in flight. */
   ensure(name: string): Promise<void>;
+  /**
+   * Sends `body` to `target` from the named alias's own peer identity, starting that alias first if it is not already running, so the recipient sees the correspondent rather than the relay as the sender. Resolves with the id the alias gave the message; rejects with an `AliasStartError` if the alias could not be started, or an `AliasSendError` if it refused the send or its process ended before acknowledging it.
+   */
+  send(name: string, target: Readonly<PeerRef>, body: string): Promise<{
+    msgId: string;
+  }>;
+  /** The single start path behind ensure() and send(): returns the running process for the name, starting one only if neither an active nor an in-flight process already exists. */
+  private acquire;
   private startAlias;
   /** Waits for any in-flight ensure() of the same name to settle first, so a retire() issued while an alias is still starting stops it once (and if) it becomes active. A no-op for a name that is neither active nor pending. */
   retire(name: string): Promise<void>;

package/dist/alias-pool.mjs

@@ -1,5 +1,5 @@
-import { t as AliasStartError } from "./errors-Dcqq2MIW.mjs";
-import { n as AliasMessageEventSchema, r as AliasStartedEventSchema } from "./alias-ipc-DkaozCo7.mjs";
+import { c as newMsgId, n as AliasStartError, t as AliasSendError } from "./errors-KYBco8pU.mjs";
+import { a as AliasStartedEventSchema, i as AliasSentEventSchema, n as AliasMessageEventSchema, r as AliasSendFailedEventSchema } from "./alias-ipc-BSh7Q4LL.mjs";
 import { EventEmitter } from "node:events";
 import { fork } from "node:child_process";
 import { fileURLToPath } from "node:url";
@@ -11,6 +11,7 @@ var ForkedAliasProcess = class {
 	events = new EventEmitter();
 	forkFn;
 	workerPath;
+	pendingSends = /* @__PURE__ */ new Map();
 	child;
 	constructor(deps) {
 		this.forkFn = deps.fork ?? fork;
@@ -20,9 +21,14 @@ var ForkedAliasProcess = class {
 		const child = this.forkFn(this.workerPath, [], {});
 		this.child = child;
 		child.on("message", (raw) => {
-			if (AliasMessageEventSchema.is(raw)) this.events.emit("message", toInboundMessage(raw));
+			if (AliasMessageEventSchema.is(raw)) {
+				this.events.emit("message", toInboundMessage(raw));
+				return;
+			}
+			this.settleSend(raw);
 		});
 		child.on("exit", () => {
+			this.failPendingSends("alias worker exited before the send was acknowledged");
 			this.events.emit("exit");
 		});
 		await new Promise((resolve, reject) => {
@@ -48,10 +54,51 @@ var ForkedAliasProcess = class {
 			});
 		});
 	}
-	async stop() {
+	async send(target, body) {
+		const child = this.runningChild();
+		if (child === void 0) throw new AliasSendError("alias worker is not running");
+		const requestId = newMsgId();
+		return new Promise((resolve, reject) => {
+			this.pendingSends.set(requestId, {
+				resolve,
+				reject
+			});
+			child.send({
+				type: "send",
+				requestId,
+				target,
+				body
+			});
+		});
+	}
+	/** Settles the one in-flight send an acknowledgement names. An acknowledgement for an unknown request is ignored: the send it belongs to was already settled by the worker exiting. */
+	settleSend(raw) {
+		if (AliasSentEventSchema.is(raw)) {
+			this.takePendingSend(raw.requestId)?.resolve({ msgId: raw.msgId });
+			return;
+		}
+		if (AliasSendFailedEventSchema.is(raw)) this.takePendingSend(raw.requestId)?.reject(new AliasSendError(`${raw.code}: ${raw.message}`));
+	}
+	takePendingSend(requestId) {
+		const pending = this.pendingSends.get(requestId);
+		this.pendingSends.delete(requestId);
+		return pending;
+	}
+	failPendingSends(reason) {
+		const pending = [...this.pendingSends.values()];
+		this.pendingSends.clear();
+		for (const send of pending) send.reject(new AliasSendError(reason));
+	}
+	/** The forked child while it is still running, or undefined before start() and once it has ended: a command written past that point reaches a channel nothing is reading. */
+	runningChild() {
 		const child = this.child;
+		if (child === void 0) return void 0;
+		if (child.exitCode !== null || child.signalCode !== null) return void 0;
+		return child;
+	}
+	async stop() {
+		const child = this.runningChild();
 		if (child === void 0) return;
-		if (child.exitCode !== null || child.signalCode !== null) return;
 		await new Promise((resolve) => {
 			child.once("exit", () => {
 				resolve();
@@ -105,16 +152,24 @@ var AliasPool = class AliasPool extends EventEmitter {
 	}
 	/** Idempotent: a no-op if the alias is already active, and dedup'd if another ensure() for the same name is already in flight. */
 	async ensure(name) {
-		if (this.active.has(name)) return;
+		await this.acquire(name);
+	}
+	/**
+	* Sends `body` to `target` from the named alias's own peer identity, starting that alias first if it is not already running, so the recipient sees the correspondent rather than the relay as the sender. Resolves with the id the alias gave the message; rejects with an `AliasStartError` if the alias could not be started, or an `AliasSendError` if it refused the send or its process ended before acknowledging it.
+	*/
+	async send(name, target, body) {
+		return (await this.acquire(name)).send(target, body);
+	}
+	/** The single start path behind ensure() and send(): returns the running process for the name, starting one only if neither an active nor an in-flight process already exists. */
+	async acquire(name) {
+		const active = this.active.get(name);
+		if (active !== void 0) return active;
 		const inFlight = this.pending.get(name);
-		if (inFlight !== void 0) {
-			await inFlight;
-			return;
-		}
+		if (inFlight !== void 0) return inFlight;
 		const started = this.startAlias(name);
 		this.pending.set(name, started);
 		try {
-			await started;
+			return await started;
 		} finally {
 			this.pending.delete(name);
 		}
@@ -138,6 +193,7 @@ var AliasPool = class AliasPool extends EventEmitter {
 		});
 		this.active.set(name, proc);
 		this.log(`alias ${name} active`);
+		return proc;
 	}
 	/** Waits for any in-flight ensure() of the same name to settle first, so a retire() issued while an alias is still starting stops it once (and if) it becomes active. A no-op for a name that is neither active nor pending. */
 	async retire(name) {

package/dist/bin/cc-peer.cjs

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 const require_rolldown_runtime = require("../rolldown-runtime-VH7oDXx4.cjs");
-const require_cc_peer = require("../cc-peer-CPPV05My.cjs");
-const require_errors = require("../errors-Dl_lSq1N.cjs");
+const require_cc_peer = require("../cc-peer-BvoaikwI.cjs");
+const require_errors = require("../errors-BAbklcGw.cjs");
 let node_crypto = require("node:crypto");
 let zod = require("zod");
 let node_process = require("node:process");

package/dist/bin/cc-peer.mjs

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
-import { i as RegistryEntrySchema, n as CcPeer, r as PrioritySchema } from "../cc-peer-D3maNn_Z.mjs";
-import { o as defineSchema } from "../errors-Dcqq2MIW.mjs";
+import { i as RegistryEntrySchema, n as CcPeer, r as PrioritySchema } from "../cc-peer-CQV4Qv_H.mjs";
+import { l as defineSchema } from "../errors-KYBco8pU.mjs";
 import { randomBytes } from "node:crypto";
 import { z } from "zod";
 import process from "node:process";

package/dist/{cc-peer-CPPV05My.cjs → cc-peer-BvoaikwI.cjs}

@@ -1,4 +1,4 @@
-const require_errors = require("./errors-Dl_lSq1N.cjs");
+const require_errors = require("./errors-BAbklcGw.cjs");
 let node_events = require("node:events");
 let node_crypto = require("node:crypto");
 let node_net = require("node:net");
@@ -8,7 +8,7 @@ let zod = require("zod");
 let node_os = require("node:os");
 let node_child_process = require("node:child_process");
 //#region package.json
-var version = "1.5.3";
+var version = "1.6.1";
 //#endregion
 //#region src/adapters/node/uds-transport.ts
 /** macOS linger before close, matching the reference client's ~150ms. */
@@ -564,12 +564,6 @@ var Pacer = class {
 	}
 };
 //#endregion
-//#region src/domain/ids.ts
-/** Message ids are UUID v4, matching the reference client's `qM()`. */
-function newMsgId() {
-	return (0, node_crypto.randomUUID)();
-}
-//#endregion
 //#region src/domain/roster.ts
 /**
 * The receiver's own admission rules, verified live: an entry is listed when it has a socket, is not the caller's own, is not spare/parked, its socket accepts a live connect probe, and its pid is alive with a procStart that byte-matches the ps output. Mismatches classify as recycled and are silently skipped by the reference roster builder.
@@ -807,7 +801,7 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 		const now = this.deps.clock.nowMs();
 		return {
 			pid: process.pid,
-			sessionId: this.options.sessionId ?? newMsgId(),
+			sessionId: this.options.sessionId ?? require_errors.newMsgId(),
 			cwd: process.cwd(),
 			startedAt: now,
 			procStart,
@@ -840,7 +834,7 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 		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();
+		const msgId = require_errors.newMsgId();
 		const from = `uds:${this.listening.socketPath}`;
 		const frame = {
 			msgV: 1,
@@ -884,7 +878,7 @@ var CcPeer = class CcPeer extends node_events.EventEmitter {
 		const socketPath = await this.resolveTarget(target);
 		const key = await this.deps.keys.readForSocket(socketPath);
 		if (key === void 0) throw new require_errors.NoLiveInboxError(`no auth key published for ${socketPath}`);
-		const msgId = newMsgId();
+		const msgId = require_errors.newMsgId();
 		const frame = {
 			msgV: 1,
 			msg_id: msgId,

package/dist/{cc-peer-D3maNn_Z.mjs → cc-peer-CQV4Qv_H.mjs}

@@ -1,6 +1,6 @@
-import { a as UnknownPeerError, i as NotStartedError, n as MessageTooLargeError, o as defineSchema, r as NoLiveInboxError } from "./errors-Dcqq2MIW.mjs";
+import { a as NoLiveInboxError, c as newMsgId, i as MessageTooLargeError, l as defineSchema, o as NotStartedError, s as UnknownPeerError } from "./errors-KYBco8pU.mjs";
 import { EventEmitter } from "node:events";
-import { createHash, randomBytes, randomUUID } from "node:crypto";
+import { createHash, randomBytes } from "node:crypto";
 import { connect, createServer } from "node:net";
 import { mkdir, readFile, readdir, rename, unlink, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
@@ -8,7 +8,7 @@ import { z } from "zod";
 import { homedir } from "node:os";
 import { spawn } from "node:child_process";
 //#region package.json
-var version = "1.5.3";
+var version = "1.6.1";
 //#endregion
 //#region src/adapters/node/uds-transport.ts
 /** macOS linger before close, matching the reference client's ~150ms. */
@@ -564,12 +564,6 @@ var Pacer = class {
 	}
 };
 //#endregion
-//#region src/domain/ids.ts
-/** Message ids are UUID v4, matching the reference client's `qM()`. */
-function newMsgId() {
-	return randomUUID();
-}
-//#endregion
 //#region src/domain/roster.ts
 /**
 * The receiver's own admission rules, verified live: an entry is listed when it has a socket, is not the caller's own, is not spare/parked, its socket accepts a live connect probe, and its pid is alive with a procStart that byte-matches the ps output. Mismatches classify as recycled and are silently skipped by the reference roster builder.

package/dist/{cc-peer-B3i4ZlKV.d.cts → cc-peer-mYIVwlKe.d.cts}

@@ -71,12 +71,12 @@ declare const RegistryEntrySchema: z.ZodObject<{
   nameSince: z.ZodOptional<z.ZodNumber>;
   updatedAt: z.ZodNumber;
   status: z.ZodOptional<z.ZodEnum<{
-    idle: "idle";
     busy: "busy";
     shell: "shell";
+    idle: "idle";
     waiting: "waiting";
   }> & {
-    is(value: unknown): value is "idle" | "busy" | "shell" | "waiting";
+    is(value: unknown): value is "busy" | "shell" | "idle" | "waiting";
   }>;
   statusUpdatedAt: z.ZodOptional<z.ZodNumber>;
   bridgeSessionId: z.ZodOptional<z.ZodString>;
@@ -99,7 +99,7 @@ declare const RegistryEntrySchema: z.ZodObject<{
     name?: string | undefined;
     nameSource?: "user" | "peer" | "derived" | "collision" | "auto" | "hook" | undefined;
     nameSince?: number | undefined;
-    status?: "idle" | "busy" | "shell" | "waiting" | undefined;
+    status?: "busy" | "shell" | "idle" | "waiting" | undefined;
     statusUpdatedAt?: number | undefined;
     bridgeSessionId?: string | undefined;
   };

package/dist/{cc-peer-B3i4ZlKV.d.mts → cc-peer-mYIVwlKe.d.mts}

@@ -71,12 +71,12 @@ declare const RegistryEntrySchema: z.ZodObject<{
   nameSince: z.ZodOptional<z.ZodNumber>;
   updatedAt: z.ZodNumber;
   status: z.ZodOptional<z.ZodEnum<{
-    idle: "idle";
     busy: "busy";
     shell: "shell";
+    idle: "idle";
     waiting: "waiting";
   }> & {
-    is(value: unknown): value is "idle" | "busy" | "shell" | "waiting";
+    is(value: unknown): value is "busy" | "shell" | "idle" | "waiting";
   }>;
   statusUpdatedAt: z.ZodOptional<z.ZodNumber>;
   bridgeSessionId: z.ZodOptional<z.ZodString>;
@@ -99,7 +99,7 @@ declare const RegistryEntrySchema: z.ZodObject<{
     name?: string | undefined;
     nameSource?: "user" | "peer" | "derived" | "collision" | "auto" | "hook" | undefined;
     nameSince?: number | undefined;
-    status?: "idle" | "busy" | "shell" | "waiting" | undefined;
+    status?: "busy" | "shell" | "idle" | "waiting" | undefined;
     statusUpdatedAt?: number | undefined;
     bridgeSessionId?: string | undefined;
   };

package/dist/cc-peer.cjs

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

package/dist/cc-peer.d.cts

@@ -1,2 +1,2 @@
-import { a as InboundMessage, c as SendOptions, i as IdleNotice, n as CcPeer, o as PeerRef, r as CcPeerOptions, s as Receipt, t as CC_PEER_VERSION } from "./cc-peer-B3i4ZlKV.cjs";
+import { a as InboundMessage, c as SendOptions, i as IdleNotice, n as CcPeer, o as PeerRef, r as CcPeerOptions, s as Receipt, t as CC_PEER_VERSION } from "./cc-peer-mYIVwlKe.cjs";
 export { CC_PEER_VERSION, CcPeer, CcPeerOptions, IdleNotice, InboundMessage, PeerRef, Receipt, SendOptions };

package/dist/cc-peer.d.mts

@@ -1,2 +1,2 @@
-import { a as InboundMessage, c as SendOptions, i as IdleNotice, n as CcPeer, o as PeerRef, r as CcPeerOptions, s as Receipt, t as CC_PEER_VERSION } from "./cc-peer-B3i4ZlKV.mjs";
+import { a as InboundMessage, c as SendOptions, i as IdleNotice, n as CcPeer, o as PeerRef, r as CcPeerOptions, s as Receipt, t as CC_PEER_VERSION } from "./cc-peer-mYIVwlKe.mjs";
 export { CC_PEER_VERSION, CcPeer, CcPeerOptions, IdleNotice, InboundMessage, PeerRef, Receipt, SendOptions };

package/dist/cc-peer.mjs

@@ -1,2 +1,2 @@
-import { n as CcPeer, t as CC_PEER_VERSION } from "./cc-peer-D3maNn_Z.mjs";
+import { n as CcPeer, t as CC_PEER_VERSION } from "./cc-peer-CQV4Qv_H.mjs";
 export { CC_PEER_VERSION, CcPeer };

package/dist/{errors-Dl_lSq1N.cjs → errors-BAbklcGw.cjs}

@@ -1,3 +1,4 @@
+let node_crypto = require("node:crypto");
 //#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.
@@ -8,6 +9,12 @@ function defineSchema(schema) {
 	} });
 }
 //#endregion
+//#region src/domain/ids.ts
+/** Message ids are UUID v4, matching the reference client's `qM()`. */
+function newMsgId() {
+	return (0, node_crypto.randomUUID)();
+}
+//#endregion
 //#region src/errors.ts
 /** Base error for every cc-peer failure; `code` is machine-readable. */
 var CcPeerError = class extends Error {
@@ -49,13 +56,32 @@ var AliasStartError = class extends CcPeerError {
 		this.name = "AliasStartError";
 	}
 };
+/** A message could not be sent from a reply alias: its own peer refused the send, or its worker process was gone (or went away) before acknowledging the command. */
+var AliasSendError = class extends CcPeerError {
+	constructor(message) {
+		super("ALIAS_SEND_FAILED", message);
+		this.name = "AliasSendError";
+	}
+};
 //#endregion
+Object.defineProperty(exports, "AliasSendError", {
+	enumerable: true,
+	get: function() {
+		return AliasSendError;
+	}
+});
 Object.defineProperty(exports, "AliasStartError", {
 	enumerable: true,
 	get: function() {
 		return AliasStartError;
 	}
 });
+Object.defineProperty(exports, "CcPeerError", {
+	enumerable: true,
+	get: function() {
+		return CcPeerError;
+	}
+});
 Object.defineProperty(exports, "MessageTooLargeError", {
 	enumerable: true,
 	get: function() {
@@ -86,3 +112,9 @@ Object.defineProperty(exports, "defineSchema", {
 		return defineSchema;
 	}
 });
+Object.defineProperty(exports, "newMsgId", {
+	enumerable: true,
+	get: function() {
+		return newMsgId;
+	}
+});

package/dist/{errors-Dcqq2MIW.mjs → errors-KYBco8pU.mjs}

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 //#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.
@@ -8,6 +9,12 @@ function defineSchema(schema) {
 	} });
 }
 //#endregion
+//#region src/domain/ids.ts
+/** Message ids are UUID v4, matching the reference client's `qM()`. */
+function newMsgId() {
+	return randomUUID();
+}
+//#endregion
 //#region src/errors.ts
 /** Base error for every cc-peer failure; `code` is machine-readable. */
 var CcPeerError = class extends Error {
@@ -49,5 +56,12 @@ var AliasStartError = class extends CcPeerError {
 		this.name = "AliasStartError";
 	}
 };
+/** A message could not be sent from a reply alias: its own peer refused the send, or its worker process was gone (or went away) before acknowledging the command. */
+var AliasSendError = class extends CcPeerError {
+	constructor(message) {
+		super("ALIAS_SEND_FAILED", message);
+		this.name = "AliasSendError";
+	}
+};
 //#endregion
-export { UnknownPeerError as a, NotStartedError as i, MessageTooLargeError as n, defineSchema as o, NoLiveInboxError as r, AliasStartError as t };
+export { NoLiveInboxError as a, newMsgId as c, MessageTooLargeError as i, defineSchema as l, AliasStartError as n, NotStartedError as o, CcPeerError as r, UnknownPeerError as s, AliasSendError as t };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-peer",
-  "version": "1.5.3",
+  "version": "1.6.1",
   "description": "Communicate with local Claude Code instances over their native cross-session peer messaging: send and receive messages, register as a named discoverable peer, receipts, idle subscriptions, and a REST facade via `npx cc-peer`.",
   "type": "module",
   "license": "MIT",

package/dist/alias-ipc-Cjs5yivH.cjs

@@ -1,48 +0,0 @@
-const require_errors = require("./errors-Dl_lSq1N.cjs");
-let zod = require("zod");
-//#region src/schemas/alias-ipc.ts
-/**
-* The parent-to-child and child-to-parent IPC contract `AliasPool`'s Node adapter (`adapters/node/forked-alias-process.ts`) and worker (`adapters/node/alias-worker.ts`) exchange over `child_process.fork()`'s built-in channel. This is deliberately independent of the wire protocol schemas in `wire.ts`: it never touches a socket, it only carries commands and events between a pool and the real OS process backing one reply alias.
-*/
-const AliasStartCommandSchema = require_errors.defineSchema(zod.z.object({
-	type: zod.z.literal("start"),
-	name: zod.z.string().min(1),
-	homeDir: zod.z.string().optional(),
-	socketDir: zod.z.string().optional(),
-	sessionId: zod.z.string().optional()
-}));
-const AliasStopCommandSchema = require_errors.defineSchema(zod.z.object({ type: zod.z.literal("stop") }));
-const AliasCommandSchema = require_errors.defineSchema(zod.z.union([AliasStartCommandSchema, AliasStopCommandSchema]));
-/** Sent once the worker's own CcPeer is listening and registered. */
-const AliasStartedEventSchema = require_errors.defineSchema(zod.z.object({ type: zod.z.literal("started") }));
-/** Mirrors CcPeer's own InboundMessage shape, carried over IPC instead of an EventEmitter within one process. */
-const AliasMessageEventSchema = require_errors.defineSchema(zod.z.object({
-	type: zod.z.literal("message"),
-	from: zod.z.string().optional(),
-	fromSession: zod.z.string().optional(),
-	fromName: zod.z.string().optional(),
-	fromMode: zod.z.enum(["bypass", "prompting"]).optional(),
-	hopChain: zod.z.array(zod.z.string()).optional(),
-	body: zod.z.string(),
-	msgId: zod.z.string()
-}));
-require_errors.defineSchema(zod.z.union([AliasStartedEventSchema, AliasMessageEventSchema]));
-//#endregion
-Object.defineProperty(exports, "AliasCommandSchema", {
-	enumerable: true,
-	get: function() {
-		return AliasCommandSchema;
-	}
-});
-Object.defineProperty(exports, "AliasMessageEventSchema", {
-	enumerable: true,
-	get: function() {
-		return AliasMessageEventSchema;
-	}
-});
-Object.defineProperty(exports, "AliasStartedEventSchema", {
-	enumerable: true,
-	get: function() {
-		return AliasStartedEventSchema;
-	}
-});

package/dist/alias-ipc-DkaozCo7.mjs

@@ -1,31 +0,0 @@
-import { o as defineSchema } from "./errors-Dcqq2MIW.mjs";
-import { z } from "zod";
-//#region src/schemas/alias-ipc.ts
-/**
-* The parent-to-child and child-to-parent IPC contract `AliasPool`'s Node adapter (`adapters/node/forked-alias-process.ts`) and worker (`adapters/node/alias-worker.ts`) exchange over `child_process.fork()`'s built-in channel. This is deliberately independent of the wire protocol schemas in `wire.ts`: it never touches a socket, it only carries commands and events between a pool and the real OS process backing one reply alias.
-*/
-const AliasStartCommandSchema = defineSchema(z.object({
-	type: z.literal("start"),
-	name: z.string().min(1),
-	homeDir: z.string().optional(),
-	socketDir: z.string().optional(),
-	sessionId: z.string().optional()
-}));
-const AliasStopCommandSchema = defineSchema(z.object({ type: z.literal("stop") }));
-const AliasCommandSchema = defineSchema(z.union([AliasStartCommandSchema, AliasStopCommandSchema]));
-/** Sent once the worker's own CcPeer is listening and registered. */
-const AliasStartedEventSchema = defineSchema(z.object({ type: z.literal("started") }));
-/** Mirrors CcPeer's own InboundMessage shape, carried over IPC instead of an EventEmitter within one process. */
-const AliasMessageEventSchema = defineSchema(z.object({
-	type: z.literal("message"),
-	from: z.string().optional(),
-	fromSession: z.string().optional(),
-	fromName: z.string().optional(),
-	fromMode: z.enum(["bypass", "prompting"]).optional(),
-	hopChain: z.array(z.string()).optional(),
-	body: z.string(),
-	msgId: z.string()
-}));
-defineSchema(z.union([AliasStartedEventSchema, AliasMessageEventSchema]));
-//#endregion
-export { AliasMessageEventSchema as n, AliasStartedEventSchema as r, AliasCommandSchema as t };