posipaki 0.35.2 → 0.37.1

package/dist/json1-DYq9g7im.js

@@ -0,0 +1,1124 @@
+import { r as makeWaiter } from "./util-Brtfgv68.js";
+import { i as isProcess, t as defineActor } from "./define-actor-CZysIKH4.js";
+import { s as stopPropagation } from "./hooks-CgXhmY4r.js";
+//#region src/remote/process-ref.ts
+/** The key that marks a process reference inside an otherwise JSON value. */
+const PROCESS_REF = "$p";
+/**
+* The id a side gives its own root: the first id of its parity.  The two ends of a
+* connection therefore number their roots differently, and an id says whose root it is
+* as it says who holds every other process.  A side hands out its next id from two
+* steps further on, the one in between belonging to the root of the side it talks to.
+*/
+function rootIdFor(parity) {
+	return parity === "odd" ? 1 : 0;
+}
+/** What a served root is called when the client states no name for it.  A client that
+*  states one — and the library's own does, in `$init` — is served under that name instead:
+*  the process across the seam is the one its proxy was forked as, and it should be called
+*  the same on both sides.  This is the name for a connection that says nothing. */
+const SERVED_ROOT_NAME = "remote";
+/**
+* The processes one connection knows, by the ids that name them.  One table per
+* connection, because an id means nothing on any other one, and it lives exactly
+* as long as the connection that owns it.
+*
+* It holds two sets, told apart by parity rather than kept apart by a rule: the
+* processes this side holds — the root, and anything it hands over — and the ones
+* the far side holds, which this side knows as handles.  A frame's address is
+* looked up in both, and exactly one can answer.
+*/
+var ProcessTable = class {
+	constructor(parity, onCrossed) {
+		this.pvtMine = /* @__PURE__ */ new Map();
+		this.pvtMineIds = /* @__PURE__ */ new Map();
+		this.pvtTheirs = /* @__PURE__ */ new Map();
+		this.pvtRootId = rootIdFor(parity);
+		this.pvtFarRootId = rootIdFor(parity === "odd" ? "even" : "odd");
+		this.pvtNext = this.pvtRootId + 2;
+		this.pvtOnCrossed = onCrossed;
+	}
+	/** The id of this side's own end of the connection. */
+	rootId() {
+		return this.pvtRootId;
+	}
+	/** The id the far side knows its own end by: the root this side reaches as a handle,
+	*  and the one it never hands out for anything of its own. */
+	farRootId() {
+		return this.pvtFarRootId;
+	}
+	/** Bind this side's own end of the connection — the root — to its id. */
+	bindRoot(proc) {
+		const bound = this.pvtMine.get(this.pvtRootId);
+		if (bound !== void 0 && bound !== proc) throw new Error("ProcessTable: the root is already bound");
+		this.pvtMine.set(this.pvtRootId, proc);
+		this.pvtMineIds.set(proc, this.pvtRootId);
+	}
+	/** The id this side gives a process it holds, allocating one the first time. */
+	handleFor(proc) {
+		const known = this.pvtMineIds.get(proc);
+		if (known !== void 0) return known;
+		const id = this.pvtNext;
+		this.pvtNext += 2;
+		this.pvtMine.set(id, proc);
+		this.pvtMineIds.set(proc, id);
+		this.pvtOnCrossed?.(proc, id);
+		return id;
+	}
+	/** A process this side holds, by the id it gave it. */
+	processFor(id) {
+		return this.pvtMine.get(id);
+	}
+	/**
+	* Register a process the far side holds — a handle — under the id it arrived
+	* with.  A root is one of these as much as anything else: both ends hold one at 0,
+	* so the far side's root is a handle here, and the one this side has of itself
+	* stays what it was.
+	*/
+	bindFar(id, proc) {
+		this.pvtTheirs.set(id, proc);
+	}
+	/** A process the far side holds, by the id it gave it. */
+	farHandleFor(id) {
+		return this.pvtTheirs.get(id);
+	}
+	/**
+	* Whatever this connection knows `id` to mean: a process this side holds, or a
+	* handle on one the far side holds.  Only one of the two can answer, because
+	* the two sides take their ids from different halves of the space — so what
+	* comes back does not depend on which way the frame was going.
+	*/
+	resolve(id) {
+		return this.pvtMine.get(id) ?? this.pvtTheirs.get(id);
+	}
+	/**
+	* Let go of an id: the process behind it is not this connection's business any
+	* more, so it is no longer known by it.  Both sides' ids go the same way — the
+	* side that lets a handle go names the far side's id, the side that is asked to
+	* forget names its own — and an id let go is never handed out again, so nothing
+	* that still names it can come to mean another process.
+	*
+	* Neither root is let go of: one is this side's own end of the connection, and the
+	*  other is what this side is talking to.
+	*/
+	release(id) {
+		if (id === this.pvtRootId || id === this.pvtFarRootId) return void 0;
+		const mine = this.pvtMine.get(id);
+		if (mine !== void 0) {
+			this.pvtMine.delete(id);
+			this.pvtMineIds.delete(mine);
+			return mine;
+		}
+		const theirs = this.pvtTheirs.get(id);
+		if (theirs !== void 0) this.pvtTheirs.delete(id);
+		return theirs;
+	}
+	/** Every handle this side holds on a process of the far side. */
+	handles() {
+		return [...this.pvtTheirs.values()];
+	}
+};
+function isPlainObject(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const proto = Object.getPrototypeOf(value);
+	return proto === Object.prototype || proto === null;
+}
+/** Whether `value` is the wire form of a reference. */
+function asProcessRef(value) {
+	if (typeof value !== "object" || value === null) return null;
+	const ref = value["$p"];
+	if (typeof ref !== "object" || ref === null) return null;
+	const { id, pname } = ref;
+	if (typeof id !== "number" || typeof pname !== "string") return null;
+	return {
+		id,
+		pname
+	};
+}
+/** Whether `value` has the shape of a handle on a far-side process.  Judged by
+*  what it holds rather than by `instanceof`, for the reason a process is: one
+*  build can hold two copies of the class. */
+function isRemoteProcess(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const candidate = value;
+	return typeof candidate.pname === "string" && typeof candidate.id === "symbol" && typeof candidate.send === "function" && asProcessRef({ ["$p"]: candidate.ref }) !== null;
+}
+/**
+* Replace every process in `value` with the reference this connection uses for
+* it, so what is left is JSON that says which processes the answer is about.
+*
+* A handle goes back as the reference it came with, id and all: that id is the
+* far side's own, the one it will be read by.
+*
+* Containers are copied rather than rewritten: the objects belong to the actor
+* that returned them, and a state it is still running on is not ours to edit.  A
+* node already seen is left where it is — a cycle is the encoder's to report, not
+* something to walk forever.
+*/
+function encodeProcessRefs(value, table, seen = /* @__PURE__ */ new Set()) {
+	if (isRemoteProcess(value)) return { ["$p"]: {
+		id: value.ref.id,
+		pname: value.ref.pname
+	} };
+	if (isProcess(value)) return { ["$p"]: {
+		id: table.handleFor(value),
+		pname: value.pname
+	} };
+	if (Array.isArray(value)) {
+		if (seen.has(value)) return value;
+		seen.add(value);
+		return value.map((item) => encodeProcessRefs(item, table, seen));
+	}
+	if (isPlainObject(value)) {
+		if (seen.has(value)) return value;
+		seen.add(value);
+		const copy = {};
+		for (const [key, item] of Object.entries(value)) copy[key] = encodeProcessRefs(item, table, seen);
+		return copy;
+	}
+	return value;
+}
+/** Replace every reference in `value` with what `resolve` makes of it. */
+function decodeProcessRefs(value, resolve, seen = /* @__PURE__ */ new Set()) {
+	const ref = asProcessRef(value);
+	if (ref) return resolve(ref);
+	if (Array.isArray(value)) {
+		if (seen.has(value)) return value;
+		seen.add(value);
+		return value.map((item) => decodeProcessRefs(item, resolve, seen));
+	}
+	if (isPlainObject(value)) {
+		if (seen.has(value)) return value;
+		seen.add(value);
+		const copy = {};
+		for (const [key, item] of Object.entries(value)) copy[key] = decodeProcessRefs(item, resolve, seen);
+		return copy;
+	}
+	return value;
+}
+//#endregion
+//#region src/remote/channel.ts
+/** The id a frame addresses, or null when it names no process. */
+function frameTo(frame) {
+	const to = frame.to;
+	return typeof to === "number" ? to : null;
+}
+/**
+* A frame on its way out: every process in it becomes the reference this
+* connection uses for that process, and the process the frame addresses is
+* written down as `to`.
+*/
+function encodeFrame(frame, table, to) {
+	return {
+		...encodeProcessRefs(frame, table),
+		to
+	};
+}
+/**
+* A frame just read: every reference in it becomes a handle on that process — or
+* the handle this side already made for it, since the same process handed over
+* twice is one process.
+*/
+function decodeFrame(frame, resolve) {
+	return decodeProcessRefs(frame, resolve);
+}
+function isProto(msg) {
+	return "$proto" in msg;
+}
+function isInit(msg) {
+	return "$init" in msg;
+}
+function isState(msg) {
+	return "$state" in msg;
+}
+function isMsg(msg) {
+	return "$msg" in msg;
+}
+function isExit(msg) {
+	return "$exit" in msg;
+}
+/** The three, in the one order they are ever named in — the order a tune frame
+*  carries them in, so two ways of asking for the same thing look the same. */
+const STREAM_KINDS = [
+	"message",
+	"state",
+	"exit"
+];
+function isStreamKind(value) {
+	return typeof value === "string" && STREAM_KINDS.includes(value);
+}
+function isStop(msg) {
+	return "$stop" in msg;
+}
+function isPause(msg) {
+	return "$pause" in msg;
+}
+function isResume(msg) {
+	return "$resume" in msg;
+}
+function isRelease(msg) {
+	return "$release" in msg;
+}
+function isTune(msg) {
+	return "$tune" in msg;
+}
+/**
+* The categories a tune frame asks for, in the order they are named in — or null
+* when the frame says something this vocabulary has no word for, which is a frame
+* to ignore rather than to guess at.
+*/
+function tuneFrame(frame) {
+	const body = frame.$tune;
+	if (typeof body !== "object" || body === null) return null;
+	const streams = body.streams;
+	if (!Array.isArray(streams)) return null;
+	if (!streams.every(isStreamKind)) return null;
+	return STREAM_KINDS.filter((kind) => streams.includes(kind));
+}
+const REFLECT_METHODS = "$r.methods";
+const REFLECT_CALL = "$r.call.";
+const REFLECT_RESULT = "$r.result.";
+function isReflectionMethods(msg) {
+	const names = msg[REFLECT_METHODS];
+	return Array.isArray(names) && names.every((name) => typeof name === "string");
+}
+function reflectionBody(frame, prefix) {
+	for (const key of Object.keys(frame)) {
+		if (!key.startsWith(prefix) || key.length === prefix.length) continue;
+		const body = frame[key];
+		if (typeof body !== "object" || body === null) return null;
+		return {
+			name: key.slice(prefix.length),
+			body
+		};
+	}
+	return null;
+}
+/** A call frame, or null — a malformed one is not worth an answer. */
+function asReflectionCall(frame) {
+	const parsed = reflectionBody(frame, REFLECT_CALL);
+	if (!parsed || typeof parsed.body.seq !== "number") return null;
+	const args = parsed.body.args;
+	return {
+		name: parsed.name,
+		seq: parsed.body.seq,
+		args: Array.isArray(args) ? args : []
+	};
+}
+/** An answer frame, or null.  `error` present means the call was refused. */
+function asReflectionResult(frame) {
+	const parsed = reflectionBody(frame, REFLECT_RESULT);
+	if (!parsed || typeof parsed.body.seq !== "number") return null;
+	const { seq, value, error } = parsed.body;
+	return typeof error === "string" ? {
+		name: parsed.name,
+		seq,
+		error
+	} : {
+		name: parsed.name,
+		seq,
+		value
+	};
+}
+/**
+* Why a value cannot cross a frame, or null when it can.  Only JSON data
+* crosses: a function, a symbol or a bigint cannot be written down at all, and
+* a value with a cycle or a bigint inside it makes the encoder throw.  What
+* JSON itself would quietly drop — a function stored inside an object — is the
+* caller's business, not something to invent a policy for here.
+*/
+function jsonProblem(value) {
+	const kind = typeof value;
+	if (kind === "function" || kind === "symbol" || kind === "bigint") return `a ${kind}`;
+	if (kind !== "object" || value === null) return null;
+	try {
+		JSON.stringify(value);
+	} catch (err) {
+		return err instanceof Error ? err.message : String(err);
+	}
+	return null;
+}
+//#endregion
+//#region src/remote/remote-process.ts
+var RemoteProcess = class {
+	constructor(ref, send, fromName, letGo) {
+		this.state = null;
+		this.$reflection = {};
+		this.pvtConnected = true;
+		this.pvtReleased = false;
+		this.pvtExit = null;
+		this.pvtExitWaiter = null;
+		this.pvtMessageSubs = [];
+		this.pvtStateSubs = [];
+		this.pvtWanted = /* @__PURE__ */ new Set();
+		this.ref = ref;
+		this.pname = ref.pname;
+		this.id = Symbol(ref.pname);
+		this.pvtSend = send;
+		this.pvtFromName = fromName;
+		this.pvtLetGo = letGo;
+	}
+	/**
+	* Whether the process this handle names can still be reached: the wire is there, and
+	* this side has not let the handle go.
+	*
+	* Reaching it is not the same as it being alive.  A process that has ended is still
+	* one this side has a handle on — it is what the handle points at, and what it left
+	* behind is here — so an end does not put it out of reach; `hasEnded()` is that
+	* answer, and the two are asked separately.  From the two ways out there is no coming
+	* back: no reconnect, and no way to un-release.
+	*/
+	isConnected() {
+		return this.pvtConnected && !this.pvtReleased;
+	}
+	/**
+	* The connection is gone.  Every handle this side holds goes out of reach with it,
+	* and says so: there is no reconnect to wait for, so a send fails here and now
+	* rather than disappearing into nothing.
+	*/
+	disconnect() {
+		if (!this.pvtConnected) return;
+		this.pvtConnected = false;
+		this.pvtStateSubs.forEach((fn) => fn());
+		this.pvtExitWaiter?.reject(/* @__PURE__ */ new Error(`${this.pname} cannot be reached: the connection is closed`));
+	}
+	/** Whether the process it names has ended, as far as this side has been told. */
+	hasEnded() {
+		return this.pvtExit !== null;
+	}
+	/** Why nothing can be asked *of the process* — let go, ended, or out of reach — or
+	*  nothing when something can.  Those are not one thing said three ways: an ended
+	*  process is still reached, it simply has nothing left to receive. */
+	pvtWhyNotAskable() {
+		if (this.pvtReleased) return `${this.pname} was released`;
+		if (this.pvtExit !== null) return `${this.pname} has ended`;
+		if (!this.pvtConnected) return `${this.pname} cannot be reached: the connection is closed`;
+		return null;
+	}
+	pvtRequireAskable() {
+		const why = this.pvtWhyNotAskable();
+		if (why !== null) throw new Error(why);
+	}
+	/**
+	* Wait for the process to end.  Its exit crosses back like everything else it
+	* does, and what it left behind is the answer.
+	*
+	* A handle whose connection is gone rejects instead: what is left to wait for
+	* after that is nothing, and a process that keeps running is not something this
+	* side can tell from one that died with the wire.
+	*/
+	wait() {
+		if (this.pvtExit !== null) return Promise.resolve(this.pvtExit);
+		const why = this.pvtWhyNotAskable();
+		if (why !== null) return Promise.reject(new Error(why));
+		this.pvtWant("exit");
+		this.pvtExitWaiter ??= makeWaiter();
+		return this.pvtExitWaiter.promise;
+	}
+	/**
+	* Ask the far side to stop it.  Stops the way it always does there, and this
+	* resolves when its exit has crossed back — which is all this side can know.
+	* There is no deadline, so a process that refuses to stop leaves this pending.
+	*/
+	stop() {
+		this.pvtRequireAskable();
+		this.pvtWant("exit");
+		this.pvtSend({ $stop: {} }, this.ref.id);
+		return this.wait().then(() => void 0);
+	}
+	/**
+	* Let it go: the far side forgets this id and stops telling this side anything
+	* about the process behind it.  The process itself is untouched — it runs on, it
+	* is simply nobody's here any more — and this handle is done: nothing reaches it,
+	* nothing is waited for, and what arrives for it later is not news.
+	*/
+	release() {
+		this.pvtRequireAskable();
+		this.pvtReleased = true;
+		this.pvtLetGo?.(this.ref.id);
+		this.pvtSend({ $release: {} }, this.ref.id);
+	}
+	/** Stop feeding it messages.  It is still there: `send` still reaches it. */
+	pause() {
+		this.pvtRequireAskable();
+		this.pvtSend({ $pause: {} }, this.ref.id);
+	}
+	/** Feed it messages again. */
+	resume() {
+		this.pvtRequireAskable();
+		this.pvtSend({ $resume: {} }, this.ref.id);
+	}
+	/**
+	* What to be told about it from now on: any of `message`, `state` and `exit`,
+	* or `"silent"` for none of it.
+	*
+	* A process that crossed is silent to begin with, so this is how a handle asks
+	* to hear anything at all — and what is heard is only ever what was asked for.
+	* An exit nobody asked for is not sent: silence is silence, which makes this the
+	* one way to leave a handle that will not answer a `wait()`, and the far side's
+	* books the one place an end can go unrecorded.
+	*/
+	tune(kinds) {
+		this.pvtRequireAskable();
+		this.pvtTune(kinds === "silent" ? [] : kinds);
+	}
+	/** Ask the far side to say exactly this much, and nothing when it is already
+	*  saying it.  The list goes in the order the three are named in, so asking for
+	*  the same thing twice sends the same frame twice. */
+	pvtTune(wanted) {
+		const kinds = STREAM_KINDS.filter((kind) => wanted.includes(kind));
+		if (kinds.length === this.pvtWanted.size && kinds.every((kind) => this.pvtWanted.has(kind))) return;
+		this.pvtWanted = new Set(kinds);
+		this.pvtSend({ $tune: { streams: kinds } }, this.ref.id);
+	}
+	/** Ask for one more category, because something here now wants it.  A handle
+	*  that is gone asks nothing: there is no far side left to hear it, and nothing
+	*  was asked for, so what was wanted stays what it was. */
+	pvtWant(kind) {
+		if (this.pvtWanted.has(kind)) return;
+		if (!this.pvtConnected || this.pvtReleased) return;
+		this.pvtTune([...this.pvtWanted, kind]);
+	}
+	/** Hand the far process a message. */
+	send(msg) {
+		this.pvtRequireAskable();
+		this.pvtSend({ $msg: {
+			fromName: this.pvtFromName,
+			body: msg
+		} }, this.ref.id);
+	}
+	subscribe(channel, cb) {
+		if (channel === "message") {
+			const fn = cb;
+			this.pvtMessageSubs.push(fn);
+			this.pvtWant("message");
+			return () => this.pvtUnsubscribe(this.pvtMessageSubs, fn);
+		}
+		const fn = cb;
+		this.pvtStateSubs.push(fn);
+		this.pvtWant("state");
+		return () => this.pvtUnsubscribe(this.pvtStateSubs, fn);
+	}
+	pvtUnsubscribe(list, fn) {
+		const idx = list.indexOf(fn);
+		if (idx >= 0) list.splice(idx, 1);
+	}
+	/** Its state, as the far side just published it. */
+	receiveState(state) {
+		if (this.pvtReleased) return;
+		this.state = Object.assign(this.state ?? {}, state);
+		this.pvtStateSubs.forEach((fn) => fn());
+	}
+	/** A message it emitted. */
+	receiveMessage(msg, fromName) {
+		if (this.pvtReleased) return;
+		this.pvtMessageSubs.forEach((fn) => fn(msg, fromName));
+	}
+	/** It has ended, and this is what it left behind.  The last thing said about a
+	*  process: nothing crosses about it after its exit, though the handle still
+	*  reaches it for what it left. */
+	receiveExit(exit) {
+		if (this.pvtExit !== null || this.pvtReleased) return;
+		this.pvtExit = exit;
+		this.pvtExitWaiter?.resolve(exit);
+	}
+	/** The methods it can answer, as functions that ask it for an answer.  `call`
+	*  is the connection's own: a handle knows what to ask for, not how a call is
+	*  made or paired with its answer. */
+	receiveMethods(names, call) {
+		for (const name of names) this.$reflection[name] = (...args) => call(name, args);
+	}
+};
+//#endregion
+//#region src/remote/process-streams.ts
+/** What a process can be asked over the wire: the functions on its reflection
+*  surface, read once.  On the side that serves it the list *is* the dispatch
+*  table, so a name that was never on it can never be reached. */
+const pvtReflectionNames = /* @__PURE__ */ new WeakMap();
+function reflectionNames(target) {
+	const known = pvtReflectionNames.get(target);
+	if (known) return known;
+	const surface = target.$reflection ?? {};
+	const names = Object.keys(surface).filter((name) => typeof surface[name] === "function");
+	pvtReflectionNames.set(target, names);
+	return names;
+}
+var ProcessStreams = class {
+	constructor(sink, rootId) {
+		this.pvtPending = [];
+		this.pvtRecords = /* @__PURE__ */ new Map();
+		this.pvtFlushing = false;
+		this.pvtSink = sink;
+		this.pvtRootId = rootId;
+	}
+	/** A process was numbered: it is about to cross.  Anything that is not a
+	*  process — a handle travelling back to the side that holds it — crosses as
+	*  the reference it came with and is nobody's to stream. */
+	crossed(proc, id) {
+		if (!isProcess(proc)) return;
+		this.pvtPending.push([proc, id]);
+	}
+	/** Say what there is to say about whatever crossed while a frame was written. */
+	flush() {
+		if (this.pvtFlushing) return;
+		this.pvtFlushing = true;
+		try {
+			while (this.pvtPending.length > 0) {
+				const next = this.pvtPending.shift();
+				if (next) this.pvtStream(next[0], next[1]);
+			}
+		} finally {
+			this.pvtFlushing = false;
+		}
+	}
+	/**
+	* What to say about it from now on: the categories named, and none of the
+	* others.  Asking for its state says it there and then — a handle that has just
+	* asked what it holds should not have to wait for it to change.
+	*
+	* An id with no stream here is not this side's to tune, and the frame is
+	* dropped: both sides tune only what they hold, so an id names a stream on the
+	* side that numbered it.
+	*/
+	tune(id, kinds) {
+		const record = this.pvtRecords.get(id);
+		if (!record) return;
+		const wanted = new Set(kinds);
+		for (const kind of STREAM_KINDS) {
+			const isOn = record.kinds.has(kind);
+			const want = wanted.has(kind);
+			if (want === isOn) continue;
+			if (want) {
+				record.kinds.add(kind);
+				this.pvtArm(record, id, kind);
+			} else {
+				record.kinds.delete(kind);
+				this.pvtDisarm(record, kind);
+			}
+		}
+	}
+	/**
+	* Say nothing more about this one.  It is not that the process ended — the far
+	* side asked to be left out of it, so its exit is nobody's news over here, and
+	* dropping the subscription is what keeps it from being sent.
+	*/
+	stop(id) {
+		const record = this.pvtRecords.get(id);
+		if (!record) return;
+		for (const stop of record.stops.values()) stop();
+		this.pvtRecords.delete(id);
+	}
+	/** Nothing more is said about any of them: the connection is done. */
+	stopAll() {
+		for (const id of [...this.pvtRecords.keys()]) this.stop(id);
+		this.pvtPending.length = 0;
+	}
+	pvtStream(target, id) {
+		const record = {
+			target,
+			kinds: /* @__PURE__ */ new Set(),
+			stops: /* @__PURE__ */ new Map()
+		};
+		this.pvtRecords.set(id, record);
+		this.pvtSink({ [REFLECT_METHODS]: reflectionNames(target) }, id);
+		for (const kind of record.kinds) this.pvtArm(record, id, kind);
+		if (id !== this.pvtRootId) target.wait().then(() => void this.sayEnded(id, 0), () => void this.sayEnded(id, 1));
+	}
+	/** Start saying this much about it, and say what there is to say now. */
+	pvtArm(record, id, kind) {
+		if (kind === "message") {
+			record.stops.set("message", record.target.subscribe("message", (msg, sender) => {
+				this.pvtSink({ $msg: {
+					fromName: sender.fromName,
+					body: msg
+				} }, id);
+			}));
+			return;
+		}
+		if (kind === "state") {
+			record.stops.set("state", record.target.subscribe("state", () => {
+				this.pvtSink({ $state: record.target.state }, id);
+			}));
+			this.pvtSink({ $state: record.target.state }, id);
+		}
+	}
+	pvtDisarm(record, kind) {
+		const stop = record.stops.get(kind);
+		if (!stop) return;
+		stop();
+		record.stops.delete(kind);
+	}
+	/**
+	* It has ended: say so once, if that is among the categories asked for, and say
+	* nothing more about it either way.  Awaited by whoever has to have the frame out
+	* before the wire closes, which is the root's end and nobody else's — no other
+	* process can end after this side has stopped saying anything about it.
+	*/
+	async sayEnded(id, code) {
+		const record = this.pvtRecords.get(id);
+		if (!record) return;
+		const told = record.kinds.has("exit");
+		const state = record.target.state;
+		this.stop(id);
+		if (told) await this.pvtSink({ $exit: {
+			code,
+			state
+		} }, id);
+	}
+};
+//#endregion
+//#region src/remote/sender.ts
+function makeSender(fromName, parentName, parentId) {
+	if (parentId && fromName === parentName) return {
+		fromName,
+		fromId: parentId
+	};
+	return {
+		fromName,
+		fromId: Symbol()
+	};
+}
+//#endregion
+//#region src/remote/call-side.ts
+var CallSide = class {
+	constructor(write, table) {
+		this.pvtCalls = 0;
+		this.pvtWaiting = /* @__PURE__ */ new Map();
+		this.pvtWrite = write;
+		this.pvtTable = table;
+	}
+	/**
+	* Ask a process on the far side for one of its methods.  Processes among the
+	* arguments become references first — this side's own, with ids from its table, or
+	* the far side's coming back — and what is left has to be JSON, or nothing is sent
+	* at all.
+	*/
+	call(method, callArgs, to) {
+		return new Promise((resolve, reject) => {
+			const seq = ++this.pvtCalls;
+			const frame = encodeFrame({ [`${REFLECT_CALL}${method}`]: {
+				seq,
+				args: callArgs
+			} }, this.pvtTable, to);
+			const problem = jsonProblem(frame);
+			if (problem !== null) {
+				reject(/* @__PURE__ */ new Error(`cannot send ${problem} to ${method}`));
+				return;
+			}
+			this.pvtWaiting.set(seq, {
+				name: method,
+				resolve,
+				reject
+			});
+			this.pvtWrite(frame).catch((error) => {
+				this.pvtWaiting.delete(seq);
+				reject(error instanceof Error ? error : new Error(String(error)));
+			});
+		});
+	}
+	/** One function per announced name, on the surface whoever calls reads. */
+	install(surface, methods, to) {
+		for (const method of methods) surface[method] = (...callArgs) => this.call(method, callArgs, to);
+	}
+	/**
+	* An answer to a call this side made: the call waiting under that `seq` is settled
+	* by it, and the frame says whether it was one at all.  An answer is about the call
+	* and not about a process, so a dispatcher reads it before it looks anything up.
+	*/
+	settle(frame) {
+		const result = asReflectionResult(frame);
+		if (!result) return false;
+		const waiting = this.pvtWaiting.get(result.seq);
+		if (waiting) {
+			this.pvtWaiting.delete(result.seq);
+			if (result.error === void 0) waiting.resolve(result.value);
+			else waiting.reject(/* @__PURE__ */ new Error(`${waiting.name}: ${result.error}`));
+		}
+		return true;
+	}
+	/** A call that was in flight when the wire went has no answer coming; it fails
+	*  here rather than hanging for ever. */
+	rejectAll() {
+		for (const waiting of this.pvtWaiting.values()) waiting.reject(/* @__PURE__ */ new Error(`connection closed before ${waiting.name} answered`));
+		this.pvtWaiting.clear();
+	}
+};
+/**
+* Answer one call with what the process said, or why it could not.  A method may be
+* written for a call that answers later; the wire has no opinion about that, it just
+* waits for the frame.
+*/
+async function answerCall(call, target, write, table) {
+	const reply = (body) => write(encodeFrame({ [`${REFLECT_RESULT}${call.name}`]: body }, table, table.farRootId()));
+	if (!isProcess(target)) {
+		await reply({
+			seq: call.seq,
+			error: "no process with that id on this connection"
+		});
+		return;
+	}
+	const names = reflectionNames(target);
+	const surface = target.$reflection;
+	const method = names.includes(call.name) ? surface[call.name] : void 0;
+	if (typeof method !== "function") {
+		await reply({
+			seq: call.seq,
+			error: `no reflection method named ${call.name}`
+		});
+		return;
+	}
+	try {
+		const value = encodeProcessRefs(await method(...call.args), table);
+		const problem = jsonProblem(value);
+		if (problem !== null) {
+			await reply({
+				seq: call.seq,
+				error: `${call.name} returned ${problem}, which cannot cross a frame`
+			});
+			return;
+		}
+		await reply({
+			seq: call.seq,
+			value
+		});
+	} catch (err) {
+		await reply({
+			seq: call.seq,
+			error: err instanceof Error ? err.message : String(err)
+		});
+	}
+}
+//#endregion
+//#region src/remote/server.ts
+/** The name the served actor is spawned under, and the one it answers to as a sender when
+*  it talks to a process of the far side's: what the client states in `$init`, since the
+*  process being served is the one its proxy was forked as over there.  The fallback is for
+*  a connection that states none — an older client, or a hand-written `$init` — where the
+*  far side's name for its own end is all there is to go on. */
+let rootName = SERVED_ROOT_NAME;
+async function serveRemoteActor(actor, spawner) {
+	const channel = await spawner();
+	const table = new ProcessTable("even", (proc, id) => streams.crossed(proc, id));
+	/** Put an encoded frame on the wire, and then say what it numbered.  A frame that
+	*  carried a reference has to be out before anything about that process is. */
+	const write = async (frame) => {
+		await channel.send(frame);
+		streams.flush();
+	};
+	const sendToFrame = (frame, to) => write(encodeFrame(frame, table, to));
+	/** Every frame leaves this way.  The answer is handed back, since the one frame that
+	*  has to be out before the wire closes is awaited by the side that owns the wire. */
+	const sendTo = (frame, to) => sendToFrame(frame, to).catch((e) => {
+		console.error("Error sending out the frame", e);
+	});
+	const streams = new ProcessStreams(sendTo, table.rootId());
+	const calls = new CallSide(write, table);
+	/** The handle for a reference that arrived: the same one every time, and the process
+	*  itself when the reference names a process of this side's own.  The roots are
+	*  numbered apart, so a reference to the far side's root is a reference to a process
+	*  of theirs, and a handle like any of those. */
+	const handleFor = (ref) => {
+		const held = table.processFor(ref.id);
+		if (held) return held;
+		const known = table.farHandleFor(ref.id);
+		if (isRemoteProcess(known)) return known;
+		const handle = new RemoteProcess(ref, sendTo, rootName, (id) => table.release(id));
+		table.bindFar(ref.id, handle);
+		return handle;
+	};
+	const waiting = [];
+	await new Promise((resolve) => {
+		channel.onMessage((frame) => {
+			waiting.push(frame);
+			resolve();
+		});
+	});
+	channel.removeHandler();
+	const initFrame = decodeFrame(waiting.shift(), handleFor);
+	if (!isInit(initFrame)) throw new Error("serveRemoteActor: expected $init");
+	const init = initFrame.$init;
+	const stated = init.rootName;
+	if (typeof stated === "string" && stated !== "") rootName = stated;
+	const parentName = init.parentName ?? null;
+	const parentIdName = init.parentIdName ?? null;
+	const parentId = parentIdName ? Symbol.for(parentIdName) : null;
+	const { parentName: _pn, parentIdName: _pid, ...initArgs } = init;
+	const proc = await actor.spawn(initArgs, {
+		name: rootName,
+		parentName,
+		parentId
+	});
+	table.bindRoot(proc);
+	await proc.ready();
+	streams.crossed(proc, table.rootId());
+	streams.flush();
+	function dispatch(raw) {
+		const frame = decodeFrame(raw, handleFor);
+		if (calls.settle(frame)) return;
+		const to = frameTo(frame);
+		if (to === null) return;
+		const news = table.farHandleFor(to);
+		const mine = table.processFor(to);
+		if (isRelease(frame)) {
+			if (mine !== void 0) {
+				streams.stop(to);
+				table.release(to);
+			}
+			return;
+		}
+		if (isTune(frame)) {
+			if (mine !== void 0) {
+				const kinds = tuneFrame(frame);
+				if (kinds !== null) streams.tune(to, kinds);
+			}
+			return;
+		}
+		if (isReflectionMethods(frame)) {
+			if (isRemoteProcess(news)) news.receiveMethods(frame[REFLECT_METHODS], (method, args) => calls.call(method, args, to));
+			return;
+		}
+		if (isState(frame)) {
+			if (isRemoteProcess(news)) news.receiveState(frame.$state);
+			return;
+		}
+		if (isExit(frame)) {
+			if (isRemoteProcess(news)) news.receiveExit(frame.$exit);
+			return;
+		}
+		if (isStop(frame) || isPause(frame) || isResume(frame)) {
+			if (isProcess(mine)) {
+				const sender = makeSender(rootName, parentName, parentId);
+				if (isStop(frame)) mine.stop({ from: sender });
+				else if (isPause(frame)) mine.pause();
+				else mine.resume();
+			}
+			return;
+		}
+		if (isMsg(frame)) {
+			const { fromName, body } = frame.$msg;
+			if (isProcess(mine)) mine.send(body, makeSender(fromName, parentName, parentId));
+			else if (isRemoteProcess(news)) news.receiveMessage(body, fromName);
+			return;
+		}
+		const call = asReflectionCall(frame);
+		if (call) answerCall(call, mine, write, table);
+	}
+	channel.removeHandler();
+	channel.onMessage(dispatch);
+	for (const frame of waiting.splice(0)) dispatch(frame);
+	let code = 0;
+	try {
+		await proc.wait();
+	} catch (err) {
+		console.error("server actor error:", err);
+		code = 1;
+	}
+	await streams.sayEnded(table.rootId(), code);
+	streams.stopAll();
+	calls.rejectAll();
+	await channel.close();
+}
+//#endregion
+//#region src/remote/client.ts
+function remoteClient(name, spawner) {
+	return defineActor({
+		name,
+		handlers: {},
+		async setup(args) {
+			const table = new ProcessTable("odd", (proc, id) => streams.crossed(proc, id));
+			const root = this.ctx;
+			table.bindRoot(root);
+			const channel = await spawner(args);
+			const fromName = this.ctx.pname;
+			const parentName = this.ctx.parentName ?? this.ctx.pname;
+			const streams = new ProcessStreams((frame, to) => sendTo(frame, to), table.rootId());
+			/** Put an encoded frame on the wire, and then say what it numbered.  A frame that
+			*  carried a reference has to be out first, or the far side hears about a process
+			*  it cannot name yet. */
+			const write = (frame) => Promise.resolve(channel.send(frame)).then(() => streams.flush());
+			/** Every frame leaves this way: the processes in it become references, and
+			*  what the frame is addressed to becomes the id the far side knows. */
+			const sendTo = (frame, to) => {
+				write(encodeFrame(frame, table, to)).catch((error) => {
+					console.error("Error sending out the frame", error);
+				});
+			};
+			sendTo({ $init: {
+				...args,
+				rootName: fromName,
+				parentName,
+				parentIdName: parentName
+			} }, table.farRootId());
+			let currentState = {};
+			const calls = new CallSide(write, table);
+			/**
+			* The handle for a reference that arrived.  A process handed over twice is one
+			* process, so a reference that names one this side already knows gives back the
+			* handle it gave last time, and one that names a process of this side's own —
+			* handed back to its owner — gives back that process.
+			*
+			* The roots are numbered apart, so the numbers say what belongs to whom: 1 is this
+			* side's own end, and 0 is the far side's root, which is a handle like any of the
+			* processes they hold.
+			*/
+			const handleFor = (ref) => {
+				const held = table.processFor(ref.id);
+				if (held) return held;
+				const known = table.farHandleFor(ref.id);
+				if (isRemoteProcess(known)) return known;
+				const handle = new RemoteProcess(ref, sendTo, fromName, (id) => table.release(id));
+				table.bindFar(ref.id, handle);
+				return handle;
+			};
+			/**
+			* The far side's root, which is what this proxy stands in for.  It is bound here
+			* like any other reference the far side sends: what it holds, what it says, when
+			* it is over and what it can answer reach it as they reach any handle.
+			*/
+			const farRoot = new RemoteProcess({
+				id: table.farRootId(),
+				pname: fromName
+			}, sendTo, fromName, (id) => table.release(id));
+			table.bindFar(table.farRootId(), farRoot);
+			let started = null;
+			const start = new Promise((resolve) => {
+				started = resolve;
+			});
+			farRoot.tune([
+				"message",
+				"state",
+				"exit"
+			]);
+			farRoot.subscribe("state", () => {
+				Object.assign(currentState, farRoot.state ?? {});
+				root.notify();
+				started?.();
+				started = null;
+			});
+			farRoot.subscribe("message", (msg) => {
+				this.emit(msg);
+			});
+			const exitPromise = farRoot.wait().then((exit) => ({
+				code: exit.code,
+				state: exit.state
+			}), () => ({
+				code: null,
+				state: currentState
+			}));
+			channel.onMessage((raw) => {
+				const frame = decodeFrame(raw, handleFor);
+				if (calls.settle(frame)) return;
+				const to = frameTo(frame);
+				if (to === null) return;
+				const news = table.farHandleFor(to);
+				const mine = table.processFor(to);
+				if (isRelease(frame)) {
+					if (mine !== void 0) {
+						streams.stop(to);
+						table.release(to);
+					}
+					return;
+				}
+				if (isReflectionMethods(frame)) {
+					if (isRemoteProcess(news)) {
+						news.receiveMethods(frame[REFLECT_METHODS], (method, callArgs) => calls.call(method, callArgs, to));
+						if (to === table.farRootId()) calls.install(this.reflection, frame[REFLECT_METHODS], table.farRootId());
+					}
+					return;
+				}
+				if (isState(frame)) {
+					if (isRemoteProcess(news)) news.receiveState(frame.$state);
+					return;
+				}
+				if (isExit(frame)) {
+					if (isRemoteProcess(news)) news.receiveExit(frame.$exit);
+					return;
+				}
+				if (isMsg(frame)) {
+					if (isProcess(mine)) mine.send(frame.$msg.body, makeSender(frame.$msg.fromName, null, null));
+					else if (isRemoteProcess(news)) news.receiveMessage(frame.$msg.body, frame.$msg.fromName);
+					return;
+				}
+				if (isTune(frame)) {
+					if (mine !== void 0) {
+						const kinds = tuneFrame(frame);
+						if (kinds !== null) streams.tune(to, kinds);
+					}
+					return;
+				}
+				if (isStop(frame) || isPause(frame) || isResume(frame)) {
+					if (isProcess(mine)) {
+						if (isStop(frame)) mine.stop({ from: makeSender(fromName, null, null) });
+						else if (isPause(frame)) mine.pause();
+						else mine.resume();
+					}
+					return;
+				}
+				const call = asReflectionCall(frame);
+				if (call) answerCall(call, mine, write, table);
+			});
+			channel.onClose(() => {
+				calls.rejectAll();
+				for (const held of table.handles()) if (isRemoteProcess(held)) held.disconnect();
+				streams.stopAll();
+			});
+			await start;
+			return {
+				public: currentState,
+				private: {
+					channel,
+					farRoot,
+					exitPromise
+				}
+			};
+		},
+		async onMessage(msg) {
+			const { farRoot } = this.state.private;
+			if (farRoot.isConnected()) farRoot.send(msg);
+			return stopPropagation();
+		},
+		async onStopRequested() {
+			const { channel, farRoot, exitPromise } = this.state.private;
+			if (channel) {
+				if (farRoot.isConnected() && !farRoot.hasEnded()) farRoot.stop().catch(() => void 0);
+				await exitPromise;
+			}
+			this.agreeToStop();
+		},
+		async afterEnd() {
+			if (this.state.private.channel) await this.state.private.channel.close();
+		}
+	});
+}
+//#endregion
+//#region src/remote/protocols/json1.ts
+const VERSION = "json.v1";
+function encode(frame) {
+	return JSON.stringify(frame);
+}
+function decode(str) {
+	return JSON.parse(str);
+}
+function json1Channel(transport) {
+	return {
+		send(frame) {
+			return transport.send(encode(frame));
+		},
+		onMessage(handler) {
+			transport.onMessage((str) => handler(decode(str)));
+		},
+		removeHandler() {
+			transport.removeHandler();
+		},
+		onClose(handler) {
+			transport.onClose(handler);
+		},
+		close() {
+			return transport.close();
+		}
+	};
+}
+//#endregion
+export { isStop as _, remoteClient as a, rootIdFor as b, RemoteProcess as c, isMsg as d, isPause as f, isState as g, isResume as h, json1Channel as i, isExit as l, isRelease as m, decode as n, serveRemoteActor as o, isProto as p, encode as r, makeSender as s, VERSION as t, isInit as u, PROCESS_REF as v, isRemoteProcess as y };
+
+//# sourceMappingURL=json1-DYq9g7im.js.map