posipaki 0.44.0 → 0.45.0

package/dist/remote/index.d.ts

@@ -1,233 +1,5 @@
-import { a as Message, c as SenderInfo } from "../types-CuabnerI.js";
-import { A as OutputFd, B as isInit, C as Init, D as BAD_PREFIX_LIMIT, E as Spawner, F as errorFrame, G as isResume, H as isPause, I as errorReason, J as outputFrame, K as isState, L as isBad, M as StringTransport, N as badFrame, O as Channel, P as badReason, R as isError, S as serveRemoteActor, T as ServedProcess, U as isProto, V as isMsg, W as isRelease, Y as outputOf, _ as ServedConnection, b as oneConnection, c as ClientContext, d as remoteClient, f as AnyActorDefinition, g as ReactorOptions, h as Reactor, i as OutputSink, j as StreamKind, k as Frame, l as ClientSpawner, m as Listener, n as WebSocketLike, o as withOutput, p as Connection, q as isStop, r as WebSocketTransport, s as CHANNEL_LOST, t as WS_OPEN, u as RemoteClientOptions, v as Session, w as Served, x as reactor, y as SessionFactory, z as isExit } from "../websocket-sGQcEDbm.js";
-//#region src/remote/remote-process.d.ts
-interface RemoteExit {
-  code: number;
-  state: unknown;
-}
-/** How a handle gets a frame onto the connection it belongs to, addressed to a
- *  process the far side holds.  The answer is handed back when a caller has to know
- *  the frame is out — the root's end is said that way, just before the wire closes. */
-type FrameSink = (frame: Record<string, unknown>, to: number) => void | Promise<void>;
-/** What a side does when it lets go of a handle: stop knowing the id, so nothing
- *  arriving for it can land here again. */
-type ReleaseHook = (id: number) => void;
-/** An out-message of the far process, and the name it came with. */
-type RemoteMessage<OutMsg extends Message = Message> = (msg: OutMsg, fromName: string) => void;
-declare class RemoteProcess<InMsg extends Message = Message, OutMsg extends Message = Message> {
-  /** The name the far side knows it by. */
-  readonly pname: string;
-  /** The id this connection knows it by — the far side's own, since it is the
-   *  side that holds the process. */
-  readonly ref: ProcessRef;
-  /** A symbol of this side's own, so a handle can be told apart from any other
-   *  the way a process is: by holding one. */
-  readonly id: symbol;
-  /** What the far side has said about its state so far. */
-  state: Record<string, unknown> | null;
-  /** The methods the far side announced it can answer. */
-  readonly $reflection: Record<string, (...args: unknown[]) => Promise<unknown>>;
-  private pvtSend;
-  private pvtFromName;
-  private pvtConnected;
-  /** This side let it go: nothing more is asked of it, and nothing arriving for it
-   *  is news any more.  Not the same as ending, and not the same as the connection
-   *  going: in all three the handle is dead, and only the reason differs. */
-  private pvtReleased;
-  private pvtLetGo;
-  /** What the far side said when it ended, or null while it is running. */
-  private pvtExit;
-  private pvtExitWaiter;
-  private pvtMessageSubs;
-  private pvtStateSubs;
-  /** Whoever is waiting to hear what it holds, settled by the first word of it. */
-  private pvtReadyWaiters;
-  /** How many times this reference has been kept.  Nothing is heard about a process
-   *  nothing here keeps, so the count is what makes a handle usable rather than a name. */
-  private pvtRefCount;
-  /** The handles this one keeps because they sit in what it holds.  Counted, and given
-   *  back when this one is let go of: the thing holding them is here. */
-  private pvtOwnedRefs;
-  /** The handles that arrived here on their way somewhere else, in a message or an answer.
-   *  Not counted — nobody here asked for them, and whoever receives them is the one to deal
-   *  with them — but remembered, so that one nobody ever keeps is let go of after all. */
-  private pvtTransientRefs;
-  /** What this side has asked to be told about it.  A process that crosses is
-   *  silent, so a handle starts out having asked for nothing and hears nothing
-   *  until something here wants it — which is the same rule the far side holds,
-   *  written from the other end. */
-  private pvtWanted;
-  constructor(ref: ProcessRef, send: FrameSink, fromName: string, letGo?: ReleaseHook);
-  /**
-   * 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(): boolean;
-  /**
-   * 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(): void;
-  /** Whether the process it names has ended, as far as this side has been told. */
-  hasEnded(): boolean;
-  /** 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. */
-  private pvtWhyNotAskable;
-  private pvtRequireAskable;
-  /**
-   * Keep this reference: from here it is counted, which is what lets anything be asked of
-   * it.  It returns the handle, so what is kept is written in one line —
-   * `this.pvtRemoteRefsHeld.push(ref.holdRef())` — and a table of them reads as what it is.
-   */
-  holdRef(): this;
-  /**
-   * Give the count back.  Whoever gives the last one back lets the reference go, which is
-   * what tells the far side that nothing here wants to hear about the process again.  A
-   * reference nobody ever kept is let go of by this too, which is how whoever receives one
-   * they do not want is rid of it.
-   */
-  releaseRef(): void;
-  /** Let go of the binding here without asking the far side for anything: what the process
-   *  was is over, or the wire that carried it is. */
-  private pvtDropBinding;
-  /** How many times this reference has been kept. */
-  refCount(): number;
-  /**
-   * What this is, in JSON: the same reference the wire would carry, or the unstable thing
-   * it is when nothing keeps it.  Written so that an unheld reference cannot be mistaken
-   * for a process that merely looks odd in a state, and so that one that is kept reads as
-   * the reference it is rather than as whatever fields it happens to have.
-   */
-  toJSON(): unknown;
-  /**
-   * Remember the references inside a value that arrived here to be passed on.  They are not
-   * counted — the receiver is the one to deal with them — and this is what keeps one from
-   * being nobody's for ever: when this handle is let go of, they are dropped with it.
-   */
-  markTransient(value: unknown): void;
-  /** Stop treating a reference as one that was only passing through. */
-  private pvtDropTransient;
-  /**
-   * Keep the references sitting in what this process holds.  What it holds is here, so the
-   * thing keeping those references alive is this handle, and it holds them until it is let
-   * go of itself.
-   */
-  private pvtHoldOwned;
-  /** Nothing is heard about a process nothing here keeps.  A subscription, a tuning and a
-   *  wait for the state are all ways of hearing, so they are where a reference has to have
-   *  been kept first — and where the mistake says what to do about it. */
-  private pvtRequireHeld;
-  /**
-   * Wait until what it holds is here.
-   *
-   * A handle starts out knowing nothing about the process: the far side says what a
-   * process holds when something over here asks to hear it, so the asking and the waiting
-   * are one act, and this is both.  It settles with whatever has arrived when nothing more
-   * can: a process that has ended has said its last, and a connection that has gone has
-   * nothing left to say.  Asking twice is asking about what is already here.
-   */
-  ready(): Promise<void>;
-  /** Everyone waiting for what it holds has heard it, or never will. */
-  private pvtSettleReady;
-  /**
-   * 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(): Promise<RemoteExit>;
-  /**
-   * 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(): Promise<void>;
-  /**
-   * 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(): void;
-  /** Stop feeding it messages.  It is still there: `send` still reaches it. */
-  pause(): void;
-  /** Feed it messages again. */
-  resume(): void;
-  /**
-   * 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: StreamKind[] | "silent"): void;
-  /** 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. */
-  private pvtTune;
-  /** 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. */
-  private pvtWant;
-  /** Hand the far process a message. */
-  send(msg: InMsg): void;
-  /** Subscribe to what it says, or to what it holds.  Asking here is asking the far
-   *  side: a subscription is the first thing that wants the category, so it is what
-   *  turns it on, and unsubscribing leaves it on — the far side is not told to stop
-   *  saying something that another subscriber may still want. */
-  subscribe(channel: "message", cb: RemoteMessage<OutMsg>): () => void;
-  subscribe(channel: "state", cb: () => void): () => void;
-  private pvtUnsubscribe;
-  /** Its state, as the far side just published it. */
-  receiveState(state: Record<string, unknown>): void;
-  /** A message it emitted. */
-  receiveMessage(msg: OutMsg, fromName: string): void;
-  /** 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: RemoteExit): void;
-  /** 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: string[], call: (name: string, args: unknown[]) => Promise<unknown>): void;
-}
-//#endregion
-//#region src/remote/process-ref.d.ts
-/** The key that marks a process reference inside an otherwise JSON value. */
-declare 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.
- */
-declare function rootIdFor(parity: IdParity): number;
-/** What crosses the wire in place of a process. */
-interface ProcessRef {
-  id: number;
-  pname: string;
-}
-/** Which ids a side hands out: the client takes the odd ones, the server the
- *  even ones, so one number can never name a process on both sides at once. */
-type IdParity = "odd" | "even";
-/** 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. */
-declare function isRemoteProcess(value: unknown): value is RemoteProcess;
-//#endregion
+import { c as SenderInfo } from "../types-U3NvKgpg.js";
+import { $ as isInit, A as BlobSource, B as isBytesRef, C as Init, D as Blob, E as Spawner, F as Stream, G as StringTransport, H as BAD_PREFIX_LIMIT, I as StreamRef, J as errorFrame, K as badFrame, L as StreamStore, M as RemoteBlob, N as RemoteBytes, O as BlobFacts, P as RemoteStream, Q as isExit, R as StreamStoreOptions, S as serveRemoteActor, T as ServedProcess, U as Channel, V as isStreamRef, W as Frame, X as isBad, Y as errorReason, Z as isError, _ as ServedConnection, a as ClientContext, at as isState, b as oneConnection, c as remoteClient, ct as ProcessRef, d as stderrSink, dt as FrameSink, et as isMsg, f as AnyActorDefinition, ft as RemoteMessage, g as ReactorOptions, h as Reactor, i as CHANNEL_LOST, it as isResume, j as BytesRef, k as BlobRef, l as OutputSink, lt as isRemoteProcess, m as Listener, n as WebSocketLike, nt as isProto, o as ClientSpawner, ot as isStop, p as Connection, pt as RemoteProcess, q as badReason, r as WebSocketTransport, rt as isRelease, s as RemoteClientOptions, st as PROCESS_REF, t as WS_OPEN, tt as isPause, u as pumpOutput, ut as rootIdFor, v as Session, w as Served, x as reactor, y as SessionFactory, z as isBlobRef } from "../websocket-DT8zKD34.js";
 //#region src/remote/sender.d.ts
 declare function makeSender(fromName: string, parentName: string | null, parentId: symbol | null): SenderInfo;
 //#endregion
@@ -309,7 +81,7 @@ declare function wsServerSpawner(ws: WebSocketLike): Spawner;
  * properties on the socket, so the consumer routes them onto the adapter.
  */
 interface BunServerWebSocketLike {
-  send(data: string): void;
+  send(data: string | Uint8Array): void;
   close(code?: number, reason?: string): void;
   readonly readyState: number;
   data?: unknown;
@@ -342,5 +114,5 @@ declare function workerClientSpawner<Args = unknown>(url: string | ((args: Args)
 //#region src/remote/spawners/worker-self.d.ts
 declare function workerSelfSpawner(selfScope?: WorkerLike): Spawner;
 //#endregion
-export { type AnyActorDefinition, BAD_PREFIX_LIMIT, type BunServerWebSocketLike, CHANNEL_LOST, type Channel, type ClientContext, type ClientSpawner, type Connection, type Frame, type FrameSink, type Init, type Listener, type OpenedWebSocket, type OutputFd, type OutputSink, PROCESS_REF, type ProcessRef, type Reactor, type ReactorOptions, type RemoteClientOptions, type RemoteMessage, RemoteProcess, type Served, type ServedConnection, type ServedProcess, type Session, type SessionFactory, type Spawner, type StringTransport, VERSION, WORKER_VERSION, WS_OPEN, type WebSocketClientOptions, type WebSocketCtor, type WebSocketLike, type WebSocketOpener, WebSocketTransport, type WorkerCtor, type WorkerLike, WorkerTransport, badFrame, badReason, bunServerWebSocket, decode, encode, errorFrame, errorReason, isBad, isError, isExit, isInit, isMsg, isPause, isProto, isRelease, isRemoteProcess, isResume, isState, isStop, json1Channel, makeSender, oneConnection, outputFrame, outputOf, reactor, readFrame, remoteClient, rootIdFor, serveRemoteActor, withOutput, workerClientSpawner, workerSelfSpawner, wsClientSpawner, wsServerSpawner };
+export { type AnyActorDefinition, BAD_PREFIX_LIMIT, type Blob, type BlobFacts, type BlobRef, type BlobSource, type BunServerWebSocketLike, type BytesRef, CHANNEL_LOST, type Channel, type ClientContext, type ClientSpawner, type Connection, type Frame, type FrameSink, type Init, type Listener, type OpenedWebSocket, type OutputSink, PROCESS_REF, type ProcessRef, type Reactor, type ReactorOptions, RemoteBlob, RemoteBytes, type RemoteClientOptions, type RemoteMessage, RemoteProcess, RemoteStream, type Served, type ServedConnection, type ServedProcess, type Session, type SessionFactory, type Spawner, type Stream, type StreamRef, StreamStore, type StreamStoreOptions, type StringTransport, VERSION, WORKER_VERSION, WS_OPEN, type WebSocketClientOptions, type WebSocketCtor, type WebSocketLike, type WebSocketOpener, WebSocketTransport, type WorkerCtor, type WorkerLike, WorkerTransport, badFrame, badReason, bunServerWebSocket, decode, encode, errorFrame, errorReason, isBad, isBlobRef, isBytesRef, isError, isExit, isInit, isMsg, isPause, isProto, isRelease, isRemoteProcess, isResume, isState, isStop, isStreamRef, json1Channel, makeSender, oneConnection, pumpOutput, reactor, readFrame, remoteClient, rootIdFor, serveRemoteActor, stderrSink, workerClientSpawner, workerSelfSpawner, wsClientSpawner, wsServerSpawner };
 //# sourceMappingURL=index.d.ts.map

package/dist/remote/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/remote/remote-process.ts","../../src/remote/process-ref.ts","../../src/remote/sender.ts","../../src/remote/protocols/json1.ts","../../src/remote/transports/worker.ts","../../src/remote/spawners/ws-client.ts","../../src/remote/spawners/ws-server.ts","../../src/remote/spawners/worker-client.ts","../../src/remote/spawners/worker-self.ts"],"mappings":";;;UAyDiB;EACf;EACA;;;;;KAMU,aAAa,OAAO,yBAAyB,sBAAsB;;;KAInE,eAAe;;KAGf,cAAc,eAAe,UAAU,YAAY,KAAK,QAAQ;cAE/D,cAAc,cAAc,UAAU,SAAS,eAAe,UAAU;;WAE1E;;;WAGA,KAAK;;;WAGL;;EAET,OAAO;;WAEE,aAAa,mBAAmB,oBAAoB;UAErD;UACA;UACA;;;;UAIA;UACA;;UAEA;UACA;UACA;UACA;;UAEA;;;UAGA;;;UAGA;;;;UAIA;;;;;UAKA;EAER,YAAY,KAAK,YAAY,MAAM,WAAW,kBAAkB,QAAQ;;;;;;;;;;;EAmBxE;;;;;;EASA;;EAUA;;;;UAOQ;UAOA;;;;;;EAUR;;;;;;;EAWA;;;UAgBQ;;EAQR;;;;;;;EAkBA;;;;;;EAUA,cAAc;;UAUN;;;;;;UAUA;;;;UAYA;;;;;;;;;;EAiBR,SAAS;;UAQD;;;;;;;;;EAcR,QAAQ,QAAQ;;;;;;EAgBhB,QAAQ;;;;;;;EAgBR;;EAqBA;;EAMA;;;;;;;;;;;EAeA,KAAK,OAAO;;;;UASJ;;;;UAYA;;EAOR,KAAK,KAAK;;;;;EASV,UAAU,oBAAoB,IAAI,cAAc;EAChD,UAAU,kBAAkB;UAepB;;EAUR,aAAa,OAAO;;EASpB,eAAe,KAAK,QAAQ;;;;EAU5B,YAAY,MAAM;;;;EAYlB,eAAe,iBAAiB,OAAO,cAAc,oBAAoB;;;;;cCvc9D;;;;;;;iBAQG,UAAU,QAAQ;;UAWjB;EACf;EACA;;;;KAYU;;;;iBAoJI,gBAAgB,iBAAiB,SAAS;;;iBCvM1C,WACd,kBACA,2BACA,0BACC;;;cCMU;iBAMG,OAAO,OAAO;;;iBAMd,OAAO,cAAc;;;iBAMrB,UAAU,cAAc;iBAmBxB,aAAa,WAAW,kBAAkB;;;;cC9C7C;;;;;;UAOI;EACf,YAAY;EACZ,aAAa;IAAS;;EACtB,YAAY;EACZ;;cAGW,2BAA2B;UAC9B;UACA;UACA;UACA;UACA;EAER,YAAY,QAAQ;MAgBhB;EAIJ,UAAU,UAAU,OAAO;EAU3B,QAAQ;MAIJ;EAIE,KAAK,OAAO,0BAA0B;EAKtC,SAAS;;;;;KCzDL;WACD;EACT,KAAK;EACL,MAAM,eAAe;EACrB;EACA,WAAW;EACX,aAAa;IAAS;;EACtB;;KAGU,qBAAqB,gBAAgB;;;;;;;KAQrC,gBAAgB,mBAAmB,aAAa,MAAM,SAAS;UAE1D,uBAAuB;;EAEtC,OAAO,gBAAgB;;iBA6BT,gBAAgB,gBAC9B,gBAAgB,MAAM,kBACtB,gBAAe,eACf,OAAM,uBAAuB,QAC5B,cAAc;;;iBC/DD,gBAAgB,IAAI,gBAAgB;;;;;;;UAcnC;EACf,KAAK;EACL,MAAM,eAAe;WACZ;EACT;;;;;;;;;;;;;;;;;;;;;iBAsBc,mBAAmB,IAAI,yBAAyB;;;KCxCpD,kBAAkB,gBAAgB;iBAI9B,oBAAoB,gBAClC,gBAAgB,MAAM,kBACtB,aAAY,aACX,cAAc;;;iBCRD,kBAAkB,YAAW,aAAmD"}
+{"version":3,"file":"index.d.ts","names":[],"sources":["../../src/remote/sender.ts","../../src/remote/protocols/json1.ts","../../src/remote/transports/worker.ts","../../src/remote/spawners/ws-client.ts","../../src/remote/spawners/ws-server.ts","../../src/remote/spawners/worker-client.ts","../../src/remote/spawners/worker-self.ts"],"mappings":";;;iBAUgB,WACd,kBACA,2BACA,0BACC;;;cCMU;iBAMG,OAAO,OAAO;;;iBAMd,OAAO,cAAc;;;iBAMrB,UAAU,cAAc;iBAiCxB,aAAa,WAAW,kBAAkB;;;;cC5D7C;;;;;;UAOI;EACf,YAAY;EACZ,aAAa;IAAS;;EACtB,YAAY;EACZ;;cAGW,2BAA2B;UAC9B;UACA;UACA;UACA;UACA;EAER,YAAY,QAAQ;MAgBhB;EAIJ,UAAU,UAAU,OAAO;EAU3B,QAAQ;MAIJ;EAIE,KAAK,OAAO,0BAA0B;EAKtC,SAAS;;;;;KCzDL;WACD;EACT,KAAK;EACL,MAAM,eAAe;EACrB;EACA,WAAW;EACX,aAAa;IAAS;;EACtB;;KAGU,qBAAqB,gBAAgB;;;;;;;KAQrC,gBAAgB,mBAAmB,aAAa,MAAM,SAAS;UAE1D,uBAAuB;;EAEtC,OAAO,gBAAgB;;iBA6BT,gBAAgB,gBAC9B,gBAAgB,MAAM,kBACtB,gBAAe,eACf,OAAM,uBAAuB,QAC5B,cAAc;;;iBC/DD,gBAAgB,IAAI,gBAAgB;;;;;;;UAcnC;EACf,KAAK,eAAe;EACpB,MAAM,eAAe;WACZ;EACT;;;;;;;;;;;;;;;;;;;;;iBAsBc,mBAAmB,IAAI,yBAAyB;;;KCxCpD,kBAAkB,gBAAgB;iBAI9B,oBAAoB,gBAClC,gBAAgB,MAAM,kBACtB,aAAY,aACX,cAAc;;;iBCRD,kBAAkB,YAAW,aAAmD"}

package/dist/remote/index.js

@@ -1,4 +1,4 @@
-import { A as isRelease, C as isBad, D as isMsg, E as isInit, F as outputOf, I as PROCESS_REF, L as isRemoteProcess, M as isState, N as isStop, O as isPause, P as outputFrame, R as rootIdFor, S as frameReaders, T as isExit, _ as BAD_PREFIX_LIMIT, a as CHANNEL_LOST, b as errorFrame, c as reactor, d as RemoteProcess, f as VERSION, g as readFrame, h as json1Channel, i as withOutput, j as isResume, k as isProto, l as serveRemoteActor, m as encode, n as WebSocketTransport, o as remoteClient, p as decode, s as oneConnection, t as WS_OPEN, u as makeSender, v as badFrame, w as isError, x as errorReason, y as badReason } from "../websocket-DecgMfb3.js";
+import { A as errorReason, B as isResume, C as json1Channel, D as badReason, E as badFrame, F as isInit, H as isStop, I as isMsg, K as rootIdFor, L as isPause, M as isBad, N as isError, P as isExit, R as isProto, S as encode, T as BAD_PREFIX_LIMIT, U as PROCESS_REF, V as isState, W as isRemoteProcess, _ as isStreamRef, a as remoteClient, b as VERSION, c as oneConnection, d as RemoteBlob, f as RemoteBytes, g as isBytesRef, h as isBlobRef, i as CHANNEL_LOST, j as frameReaders, k as errorFrame, l as reactor, m as StreamStore, n as WebSocketTransport, o as pumpOutput, p as RemoteStream, s as stderrSink, t as WS_OPEN, u as serveRemoteActor, v as makeSender, w as readFrame, x as decode, y as RemoteProcess, z as isRelease } from "../websocket-DkDAHMFm.js";
 //#region src/remote/transports/worker.ts
 /** The worker encoding: native structured clone (no JSON). */
 const WORKER_VERSION = "clone.v1";
@@ -152,6 +152,6 @@ function workerSelfSpawner(selfScope = globalThis) {
 	};
 }
 //#endregion
-export { BAD_PREFIX_LIMIT, CHANNEL_LOST, PROCESS_REF, RemoteProcess, VERSION, WORKER_VERSION, WS_OPEN, WebSocketTransport, WorkerTransport, badFrame, badReason, bunServerWebSocket, decode, encode, errorFrame, errorReason, isBad, isError, isExit, isInit, isMsg, isPause, isProto, isRelease, isRemoteProcess, isResume, isState, isStop, json1Channel, makeSender, oneConnection, outputFrame, outputOf, reactor, readFrame, remoteClient, rootIdFor, serveRemoteActor, withOutput, workerClientSpawner, workerSelfSpawner, wsClientSpawner, wsServerSpawner };
+export { BAD_PREFIX_LIMIT, CHANNEL_LOST, PROCESS_REF, RemoteBlob, RemoteBytes, RemoteProcess, RemoteStream, StreamStore, VERSION, WORKER_VERSION, WS_OPEN, WebSocketTransport, WorkerTransport, badFrame, badReason, bunServerWebSocket, decode, encode, errorFrame, errorReason, isBad, isBlobRef, isBytesRef, isError, isExit, isInit, isMsg, isPause, isProto, isRelease, isRemoteProcess, isResume, isState, isStop, isStreamRef, json1Channel, makeSender, oneConnection, pumpOutput, reactor, readFrame, remoteClient, rootIdFor, serveRemoteActor, stderrSink, workerClientSpawner, workerSelfSpawner, wsClientSpawner, wsServerSpawner };
 
 //# sourceMappingURL=index.js.map

package/dist/remote/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../src/remote/transports/worker.ts","../../src/remote/spawners/ws-client.ts","../../src/remote/spawners/ws-server.ts","../../src/remote/spawners/worker-client.ts","../../src/remote/spawners/worker-self.ts"],"sourcesContent":["/* eslint-disable unicorn/prefer-add-event-listener, unicorn/require-post-message-target-origin */\n// ── Worker transport ────────────────────────────────────────────────────────────\n//\n// Moves frame objects directly over postMessage.  postMessage structured-clones\n// the frame object, so there is no JSON encode/decode — this transport implements\n// Channel directly (not StringTransport).  Structured clone is the worker's\n// native encoding, named by WORKER_VERSION.\n\nimport { frameReaders, type Channel } from \"../channel.js\";\n\n/** The worker encoding: native structured clone (no JSON). */\nexport const WORKER_VERSION = \"clone.v1\";\n\n/**\n * The subset of a worker the transport needs.  The main-thread `Worker` and the\n * worker-global `self` both satisfy it; `terminate` is present only on the\n * main-thread side.\n */\nexport interface WorkerLike {\n  postMessage(data: unknown): void;\n  onmessage: ((event: { data: unknown }) => void) | null;\n  onerror?: ((event: unknown) => void) | null;\n  terminate?(): void;\n}\n\nexport class WorkerTransport implements Channel {\n  private worker: WorkerLike;\n  private pvtOnMessage: ((frame: Record<string, unknown>) => void) | null = null;\n  private pvtSubscribe: ((handler: (frame: Record<string, unknown>) => void) => () => void) | null = null;\n  private pvtOnClose: (() => void) | null = null;\n  private closed = false;\n\n  constructor(worker: WorkerLike) {\n    this.worker = worker;\n    worker.onmessage = (event) => {\n      if (this.pvtOnMessage && !this.closed) {\n        this.pvtOnMessage(event.data as Record<string, unknown>);\n      }\n    };\n    // An uncaught error in the worker is the closest thing to an abrupt drop.\n    if (\"onerror\" in worker) {\n      worker.onerror = () => {\n        this.closed = true;\n        this.pvtOnClose?.();\n      };\n    }\n  }\n\n  get canSend(): boolean {\n    return !this.closed;\n  }\n\n  onMessage(handler: (frame: Record<string, unknown>) => void): () => void {\n    if (this.closed) throw new Error(\"WorkerTransport: closed\");\n    // This transport moves frame objects itself, so it is a channel and not a transport: readers are kept\n    // the way any channel keeps them, over the one handler the worker's own event needs.\n    this.pvtSubscribe ??= frameReaders((deliver) => {\n      this.pvtOnMessage = deliver;\n    });\n    return this.pvtSubscribe(handler);\n  }\n\n  onClose(handler: () => void): void {\n    this.pvtOnClose = handler;\n  }\n\n  get hasHandler(): boolean {\n    return this.pvtOnMessage !== null;\n  }\n\n  async send(frame: Record<string, unknown>): Promise<void> {\n    if (this.closed) throw new Error(\"WorkerTransport: closed\");\n    this.worker.postMessage(frame);\n  }\n\n  async close(): Promise<void> {\n    if (this.closed) return;\n    this.closed = true;\n    this.worker.terminate?.();\n  }\n}\n","/* eslint-disable unicorn/prefer-add-event-listener */\n// ── WebSocket client spawner ────────────────────────────────────────────────────\n//\n// Environment-specific: connects to a `ws://` URL with the WHATWG WebSocket,\n// wraps it in a WebSocketTransport, and returns a frame Channel with the $proto\n// handshake already validated.\n//\n// How the socket is opened is the caller's.  The second parameter constructs one from a URL, which is\n// what a runtime's own client takes; an opener replaces it with a function of the connection, which is\n// where a header belongs — a token in a URL is a token in every log the URL passes through — and the\n// only place a value that varies per spawn can be attached at all.\n\nimport { WebSocketTransport } from \"../transports/websocket.js\";\nimport { json1Channel, VERSION } from \"../protocols/json1.js\";\nimport { isProto } from \"../channel.js\";\nimport type { ClientSpawner } from \"../client.js\";\n\n/** The socket the spawner needs: what the transport reads and writes, and the open/error slots. */\nexport type OpenedWebSocket = {\n  readonly readyState: number;\n  send(data: string): void;\n  close(code?: number, reason?: string): void;\n  onopen: (() => void) | null;\n  onerror: ((err: unknown) => void) | null;\n  onmessage: ((event: { data: unknown }) => void) | null;\n  onclose: (() => void) | null;\n};\n\nexport type WebSocketCtor = new (url: string) => OpenedWebSocket;\n\n/**\n * How a socket is opened when a constructor is not enough: the URL to open, and the arguments this\n * spawn was called with.  A per-tenant header, a bearer token, an authority the machine does not\n * already know — each of them is a fact about the connection, and each of them is the caller's to\n * express in its own runtime's shape rather than in one posipaki was taught.\n */\nexport type WebSocketOpener<Args = unknown> = (url: string, args: Args) => OpenedWebSocket;\n\nexport interface WebSocketClientOptions<Args = unknown> {\n  /** Opens the socket.  Given, it replaces the constructor. */\n  open?: WebSocketOpener<Args>;\n}\n\nconst defaultWebSocket = (globalThis as { WebSocket?: WebSocketCtor }).WebSocket;\n\n/** What a socket failure says about itself.\n *\n * A WHATWG WebSocket reports an open failure as an ErrorEvent, and `String(event)` is\n * `[object ErrorEvent]`: its type, its message and the underlying error are all in its\n * own fields, so read those rather than stringify the event that carries them.\n */\nfunction describeSocketError(err: unknown): string {\n  if (typeof err !== \"object\" || err === null) return String(err);\n  const event = err as { type?: unknown; message?: unknown; error?: unknown };\n  const cause = event.error instanceof Error ? event.error.message : event.error;\n  const parts = [event.type, event.message, cause].filter(\n    (part): part is string => typeof part === \"string\" && part.length > 0,\n  );\n  return parts.length > 0 ? parts.join(\": \") : String(err);\n}\n\nfunction openWebSocket(ws: { readonly readyState: number; onopen: (() => void) | null; onerror: ((err: unknown) => void) | null }): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (ws.readyState === 1 /* OPEN */) return resolve();\n    ws.onopen = () => resolve();\n    ws.onerror = (err) => reject(new Error(`websocket failed to open: ${describeSocketError(err)}`));\n  });\n}\n\nexport function wsClientSpawner<Args = unknown>(\n  url: string | ((args: Args) => string),\n  WebSocketImpl: WebSocketCtor = defaultWebSocket as WebSocketCtor,\n  opts: WebSocketClientOptions<Args> = {},\n): ClientSpawner<Args> {\n  // The constructor is the default opener, so the socket is opened one way either way.\n  const open: WebSocketOpener<Args> = opts.open ?? ((target) => new WebSocketImpl(target));\n  return async (args) => {\n    const target = typeof url === \"function\" ? url(args) : url;\n    const ws = open(target, args);\n    const transport = new WebSocketTransport(ws);\n    const channel = json1Channel(transport);\n\n    // Set the $proto waiter before awaiting open so a fast server's handshake\n    // frame is not dropped.\n    const protoPromise = new Promise<Record<string, unknown>>((resolve) => {\n      const off = channel.onMessage((frame) => {\n        off();\n        resolve(frame);\n      });\n    });\n    await openWebSocket(ws);\n    const protoFrame = await protoPromise;\n\n    if (!isProto(protoFrame) || protoFrame.$proto !== VERSION) {\n      throw new Error(`unsupported protocol: ${JSON.stringify(protoFrame).slice(0, 50)}`);\n    }\n    return channel;\n  };\n}\n","// ── WebSocket server spawner ────────────────────────────────────────────────────\n//\n// Environment-specific: serves an already-upgraded WebSocket connection.  The\n// consumer's HTTP server does the upgrade and hands us the socket; we wrap it in\n// a WebSocketTransport, send $proto, and return the frame Channel.\n\nimport { WebSocketTransport, type WebSocketLike } from \"../transports/websocket.js\";\nimport { json1Channel, VERSION } from \"../protocols/json1.js\";\nimport type { Spawner } from \"../server.js\";\n\nexport function wsServerSpawner(ws: WebSocketLike): Spawner {\n  return async () => {\n    const channel = json1Channel(new WebSocketTransport(ws));\n    await channel.send({ $proto: VERSION });\n    return channel;\n  };\n}\n\n/**\n * A minimal Bun `ServerWebSocket` — `send`/`close`/`readyState` plus the data\n * slot the server uses to stash per-connection state.  Bun delivers message and\n * close events through the `Bun.serve` websocket config callbacks, not through\n * properties on the socket, so the consumer routes them onto the adapter.\n */\nexport interface BunServerWebSocketLike {\n  send(data: string): void;\n  close(code?: number, reason?: string): void;\n  readonly readyState: number;\n  data?: unknown;\n}\n\n/**\n * Adapt a Bun server socket to the `WebSocketLike` the transport consumes.  The\n * returned adapter owns settable `onmessage`/`onclose` slots; the consumer\n * routes Bun's `message`/`close` config callbacks into them, e.g.:\n *\n * ```ts\n * Bun.serve({\n *   websocket: {\n *     open(ws) {\n *       const adapter = bunServerWebSocket(ws);\n *       ws.data = adapter;\n *       serveRemoteActor(actor, wsServerSpawner(adapter));\n *     },\n *     message(ws, msg) { (ws.data as WebSocketLike).onmessage?.({ data: msg }); },\n *     close(ws) { (ws.data as WebSocketLike).onclose?.(); },\n *   },\n * });\n * ```\n */\nexport function bunServerWebSocket(ws: BunServerWebSocketLike): WebSocketLike {\n  return {\n    send: (data) => ws.send(data),\n    close: (code, reason) => ws.close(code, reason),\n    readyState: ws.readyState,\n    onmessage: null,\n    onclose: null,\n  };\n}\n","// ── Worker client spawner (command) ─────────────────────────────────────────────\n//\n// Environment-specific: spawns a Worker with the WHATWG `new Worker(url)` API,\n// wraps it in a WorkerTransport, and returns a frame Channel with the $proto\n// handshake already validated.\n\nimport { WorkerTransport, WORKER_VERSION, type WorkerLike } from \"../transports/worker.js\";\nimport { isProto } from \"../channel.js\";\nimport type { ClientSpawner } from \"../client.js\";\n\nexport type WorkerCtor = new (url: string) => WorkerLike;\n\nconst defaultWorker = (globalThis as { Worker?: WorkerCtor }).Worker;\n\nexport function workerClientSpawner<Args = unknown>(\n  url: string | ((args: Args) => string),\n  WorkerImpl: WorkerCtor = defaultWorker as WorkerCtor,\n): ClientSpawner<Args> {\n  return async (args) => {\n    const target = typeof url === \"function\" ? url(args) : url;\n    const channel = new WorkerTransport(new WorkerImpl(target));\n\n    const protoFrame = await new Promise<Record<string, unknown>>((resolve) => {\n      const off = channel.onMessage((frame) => {\n        off();\n        resolve(frame);\n      });\n    });\n\n    if (!isProto(protoFrame) || protoFrame.$proto !== WORKER_VERSION) {\n      throw new Error(`unsupported protocol: ${JSON.stringify(protoFrame).slice(0, 50)}`);\n    }\n    return channel;\n  };\n}\n","// ── Worker server spawner (self) ────────────────────────────────────────────────\n//\n// Environment-specific: serves the worker-global scope (`self`) as a frame\n// Channel with the $proto handshake already sent.  The worker entry script calls\n// `serveRemoteActor(actor, workerSelfSpawner())`.\n\nimport { WorkerTransport, WORKER_VERSION, type WorkerLike } from \"../transports/worker.js\";\nimport type { Spawner } from \"../server.js\";\n\nexport function workerSelfSpawner(selfScope: WorkerLike = globalThis as unknown as WorkerLike): Spawner {\n  return async () => {\n    const channel = new WorkerTransport(selfScope);\n    await channel.send({ $proto: WORKER_VERSION });\n    return channel;\n  };\n}\n"],"mappings":"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"}
+{"version":3,"file":"index.js","names":[],"sources":["../../src/remote/transports/worker.ts","../../src/remote/spawners/ws-client.ts","../../src/remote/spawners/ws-server.ts","../../src/remote/spawners/worker-client.ts","../../src/remote/spawners/worker-self.ts"],"sourcesContent":["/* eslint-disable unicorn/prefer-add-event-listener, unicorn/require-post-message-target-origin */\n// ── Worker transport ────────────────────────────────────────────────────────────\n//\n// Moves frame objects directly over postMessage.  postMessage structured-clones\n// the frame object, so there is no JSON encode/decode — this transport implements\n// Channel directly (not StringTransport).  Structured clone is the worker's\n// native encoding, named by WORKER_VERSION.\n\nimport { frameReaders, type Channel } from \"../channel.js\";\n\n/** The worker encoding: native structured clone (no JSON). */\nexport const WORKER_VERSION = \"clone.v1\";\n\n/**\n * The subset of a worker the transport needs.  The main-thread `Worker` and the\n * worker-global `self` both satisfy it; `terminate` is present only on the\n * main-thread side.\n */\nexport interface WorkerLike {\n  postMessage(data: unknown): void;\n  onmessage: ((event: { data: unknown }) => void) | null;\n  onerror?: ((event: unknown) => void) | null;\n  terminate?(): void;\n}\n\nexport class WorkerTransport implements Channel {\n  private worker: WorkerLike;\n  private pvtOnMessage: ((frame: Record<string, unknown>) => void) | null = null;\n  private pvtSubscribe: ((handler: (frame: Record<string, unknown>) => void) => () => void) | null = null;\n  private pvtOnClose: (() => void) | null = null;\n  private closed = false;\n\n  constructor(worker: WorkerLike) {\n    this.worker = worker;\n    worker.onmessage = (event) => {\n      if (this.pvtOnMessage && !this.closed) {\n        this.pvtOnMessage(event.data as Record<string, unknown>);\n      }\n    };\n    // An uncaught error in the worker is the closest thing to an abrupt drop.\n    if (\"onerror\" in worker) {\n      worker.onerror = () => {\n        this.closed = true;\n        this.pvtOnClose?.();\n      };\n    }\n  }\n\n  get canSend(): boolean {\n    return !this.closed;\n  }\n\n  onMessage(handler: (frame: Record<string, unknown>) => void): () => void {\n    if (this.closed) throw new Error(\"WorkerTransport: closed\");\n    // This transport moves frame objects itself, so it is a channel and not a transport: readers are kept\n    // the way any channel keeps them, over the one handler the worker's own event needs.\n    this.pvtSubscribe ??= frameReaders((deliver) => {\n      this.pvtOnMessage = deliver;\n    });\n    return this.pvtSubscribe(handler);\n  }\n\n  onClose(handler: () => void): void {\n    this.pvtOnClose = handler;\n  }\n\n  get hasHandler(): boolean {\n    return this.pvtOnMessage !== null;\n  }\n\n  async send(frame: Record<string, unknown>): Promise<void> {\n    if (this.closed) throw new Error(\"WorkerTransport: closed\");\n    this.worker.postMessage(frame);\n  }\n\n  async close(): Promise<void> {\n    if (this.closed) return;\n    this.closed = true;\n    this.worker.terminate?.();\n  }\n}\n","/* eslint-disable unicorn/prefer-add-event-listener */\n// ── WebSocket client spawner ────────────────────────────────────────────────────\n//\n// Environment-specific: connects to a `ws://` URL with the WHATWG WebSocket,\n// wraps it in a WebSocketTransport, and returns a frame Channel with the $proto\n// handshake already validated.\n//\n// How the socket is opened is the caller's.  The second parameter constructs one from a URL, which is\n// what a runtime's own client takes; an opener replaces it with a function of the connection, which is\n// where a header belongs — a token in a URL is a token in every log the URL passes through — and the\n// only place a value that varies per spawn can be attached at all.\n\nimport { WebSocketTransport } from \"../transports/websocket.js\";\nimport { json1Channel, VERSION } from \"../protocols/json1.js\";\nimport { isProto } from \"../channel.js\";\nimport type { ClientSpawner } from \"../client.js\";\n\n/** The socket the spawner needs: what the transport reads and writes, and the open/error slots. */\nexport type OpenedWebSocket = {\n  readonly readyState: number;\n  send(data: string): void;\n  close(code?: number, reason?: string): void;\n  onopen: (() => void) | null;\n  onerror: ((err: unknown) => void) | null;\n  onmessage: ((event: { data: unknown }) => void) | null;\n  onclose: (() => void) | null;\n};\n\nexport type WebSocketCtor = new (url: string) => OpenedWebSocket;\n\n/**\n * How a socket is opened when a constructor is not enough: the URL to open, and the arguments this\n * spawn was called with.  A per-tenant header, a bearer token, an authority the machine does not\n * already know — each of them is a fact about the connection, and each of them is the caller's to\n * express in its own runtime's shape rather than in one posipaki was taught.\n */\nexport type WebSocketOpener<Args = unknown> = (url: string, args: Args) => OpenedWebSocket;\n\nexport interface WebSocketClientOptions<Args = unknown> {\n  /** Opens the socket.  Given, it replaces the constructor. */\n  open?: WebSocketOpener<Args>;\n}\n\nconst defaultWebSocket = (globalThis as { WebSocket?: WebSocketCtor }).WebSocket;\n\n/** What a socket failure says about itself.\n *\n * A WHATWG WebSocket reports an open failure as an ErrorEvent, and `String(event)` is\n * `[object ErrorEvent]`: its type, its message and the underlying error are all in its\n * own fields, so read those rather than stringify the event that carries them.\n */\nfunction describeSocketError(err: unknown): string {\n  if (typeof err !== \"object\" || err === null) return String(err);\n  const event = err as { type?: unknown; message?: unknown; error?: unknown };\n  const cause = event.error instanceof Error ? event.error.message : event.error;\n  const parts = [event.type, event.message, cause].filter(\n    (part): part is string => typeof part === \"string\" && part.length > 0,\n  );\n  return parts.length > 0 ? parts.join(\": \") : String(err);\n}\n\nfunction openWebSocket(ws: { readonly readyState: number; onopen: (() => void) | null; onerror: ((err: unknown) => void) | null }): Promise<void> {\n  return new Promise((resolve, reject) => {\n    if (ws.readyState === 1 /* OPEN */) return resolve();\n    ws.onopen = () => resolve();\n    ws.onerror = (err) => reject(new Error(`websocket failed to open: ${describeSocketError(err)}`));\n  });\n}\n\nexport function wsClientSpawner<Args = unknown>(\n  url: string | ((args: Args) => string),\n  WebSocketImpl: WebSocketCtor = defaultWebSocket as WebSocketCtor,\n  opts: WebSocketClientOptions<Args> = {},\n): ClientSpawner<Args> {\n  // The constructor is the default opener, so the socket is opened one way either way.\n  const open: WebSocketOpener<Args> = opts.open ?? ((target) => new WebSocketImpl(target));\n  return async (args) => {\n    const target = typeof url === \"function\" ? url(args) : url;\n    const ws = open(target, args);\n    const transport = new WebSocketTransport(ws);\n    const channel = json1Channel(transport);\n\n    // Set the $proto waiter before awaiting open so a fast server's handshake\n    // frame is not dropped.\n    const protoPromise = new Promise<Record<string, unknown>>((resolve) => {\n      const off = channel.onMessage((frame) => {\n        off();\n        resolve(frame);\n      });\n    });\n    await openWebSocket(ws);\n    const protoFrame = await protoPromise;\n\n    if (!isProto(protoFrame) || protoFrame.$proto !== VERSION) {\n      throw new Error(`unsupported protocol: ${JSON.stringify(protoFrame).slice(0, 50)}`);\n    }\n    return channel;\n  };\n}\n","// ── WebSocket server spawner ────────────────────────────────────────────────────\n//\n// Environment-specific: serves an already-upgraded WebSocket connection.  The\n// consumer's HTTP server does the upgrade and hands us the socket; we wrap it in\n// a WebSocketTransport, send $proto, and return the frame Channel.\n\nimport { WebSocketTransport, type WebSocketLike } from \"../transports/websocket.js\";\nimport { json1Channel, VERSION } from \"../protocols/json1.js\";\nimport type { Spawner } from \"../server.js\";\n\nexport function wsServerSpawner(ws: WebSocketLike): Spawner {\n  return async () => {\n    const channel = json1Channel(new WebSocketTransport(ws));\n    await channel.send({ $proto: VERSION });\n    return channel;\n  };\n}\n\n/**\n * A minimal Bun `ServerWebSocket` — `send`/`close`/`readyState` plus the data\n * slot the server uses to stash per-connection state.  Bun delivers message and\n * close events through the `Bun.serve` websocket config callbacks, not through\n * properties on the socket, so the consumer routes them onto the adapter.\n */\nexport interface BunServerWebSocketLike {\n  send(data: string | Uint8Array): void;\n  close(code?: number, reason?: string): void;\n  readonly readyState: number;\n  data?: unknown;\n}\n\n/**\n * Adapt a Bun server socket to the `WebSocketLike` the transport consumes.  The\n * returned adapter owns settable `onmessage`/`onclose` slots; the consumer\n * routes Bun's `message`/`close` config callbacks into them, e.g.:\n *\n * ```ts\n * Bun.serve({\n *   websocket: {\n *     open(ws) {\n *       const adapter = bunServerWebSocket(ws);\n *       ws.data = adapter;\n *       serveRemoteActor(actor, wsServerSpawner(adapter));\n *     },\n *     message(ws, msg) { (ws.data as WebSocketLike).onmessage?.({ data: msg }); },\n *     close(ws) { (ws.data as WebSocketLike).onclose?.(); },\n *   },\n * });\n * ```\n */\nexport function bunServerWebSocket(ws: BunServerWebSocketLike): WebSocketLike {\n  return {\n    send: (data) => ws.send(data),\n    close: (code, reason) => ws.close(code, reason),\n    readyState: ws.readyState,\n    onmessage: null,\n    onclose: null,\n  };\n}\n","// ── Worker client spawner (command) ─────────────────────────────────────────────\n//\n// Environment-specific: spawns a Worker with the WHATWG `new Worker(url)` API,\n// wraps it in a WorkerTransport, and returns a frame Channel with the $proto\n// handshake already validated.\n\nimport { WorkerTransport, WORKER_VERSION, type WorkerLike } from \"../transports/worker.js\";\nimport { isProto } from \"../channel.js\";\nimport type { ClientSpawner } from \"../client.js\";\n\nexport type WorkerCtor = new (url: string) => WorkerLike;\n\nconst defaultWorker = (globalThis as { Worker?: WorkerCtor }).Worker;\n\nexport function workerClientSpawner<Args = unknown>(\n  url: string | ((args: Args) => string),\n  WorkerImpl: WorkerCtor = defaultWorker as WorkerCtor,\n): ClientSpawner<Args> {\n  return async (args) => {\n    const target = typeof url === \"function\" ? url(args) : url;\n    const channel = new WorkerTransport(new WorkerImpl(target));\n\n    const protoFrame = await new Promise<Record<string, unknown>>((resolve) => {\n      const off = channel.onMessage((frame) => {\n        off();\n        resolve(frame);\n      });\n    });\n\n    if (!isProto(protoFrame) || protoFrame.$proto !== WORKER_VERSION) {\n      throw new Error(`unsupported protocol: ${JSON.stringify(protoFrame).slice(0, 50)}`);\n    }\n    return channel;\n  };\n}\n","// ── Worker server spawner (self) ────────────────────────────────────────────────\n//\n// Environment-specific: serves the worker-global scope (`self`) as a frame\n// Channel with the $proto handshake already sent.  The worker entry script calls\n// `serveRemoteActor(actor, workerSelfSpawner())`.\n\nimport { WorkerTransport, WORKER_VERSION, type WorkerLike } from \"../transports/worker.js\";\nimport type { Spawner } from \"../server.js\";\n\nexport function workerSelfSpawner(selfScope: WorkerLike = globalThis as unknown as WorkerLike): Spawner {\n  return async () => {\n    const channel = new WorkerTransport(selfScope);\n    await channel.send({ $proto: WORKER_VERSION });\n    return channel;\n  };\n}\n"],"mappings":";;;AAWA,MAAa,iBAAiB;AAc9B,IAAa,kBAAb,MAAgD;CAO9C,YAAY,QAAoB;EAL0C,KAAA,eAAA;EACyB,KAAA,eAAA;EACzD,KAAA,aAAA;EACzB,KAAA,SAAA;EAGf,KAAK,SAAS;EACd,OAAO,aAAa,UAAU;GAC5B,IAAI,KAAK,gBAAgB,CAAC,KAAK,QAC7B,KAAK,aAAa,MAAM,IAA+B;EAE3D;EAEA,IAAI,aAAa,QACf,OAAO,gBAAgB;GACrB,KAAK,SAAS;GACd,KAAK,aAAa;EACpB;CAEJ;CAEA,IAAI,UAAmB;EACrB,OAAO,CAAC,KAAK;CACf;CAEA,UAAU,SAA+D;EACvE,IAAI,KAAK,QAAQ,MAAM,IAAI,MAAM,yBAAyB;EAG1D,KAAK,iBAAiB,cAAc,YAAY;GAC9C,KAAK,eAAe;EACtB,CAAC;EACD,OAAO,KAAK,aAAa,OAAO;CAClC;CAEA,QAAQ,SAA2B;EACjC,KAAK,aAAa;CACpB;CAEA,IAAI,aAAsB;EACxB,OAAO,KAAK,iBAAiB;CAC/B;CAEA,MAAM,KAAK,OAA+C;EACxD,IAAI,KAAK,QAAQ,MAAM,IAAI,MAAM,yBAAyB;EAC1D,KAAK,OAAO,YAAY,KAAK;CAC/B;CAEA,MAAM,QAAuB;EAC3B,IAAI,KAAK,QAAQ;EACjB,KAAK,SAAS;EACd,KAAK,OAAO,YAAY;CAC1B;AACF;;;ACrCA,MAAM,mBAAoB,WAA6C;;;;;;;AAQvE,SAAS,oBAAoB,KAAsB;CACjD,IAAI,OAAO,QAAQ,YAAY,QAAQ,MAAM,OAAO,OAAO,GAAG;CAC9D,MAAM,QAAQ;CACd,MAAM,QAAQ,MAAM,iBAAiB,QAAQ,MAAM,MAAM,UAAU,MAAM;CACzE,MAAM,QAAQ;EAAC,MAAM;EAAM,MAAM;EAAS;CAAK,CAAC,CAAC,QAC9C,SAAyB,OAAO,SAAS,YAAY,KAAK,SAAS,CACtE;CACA,OAAO,MAAM,SAAS,IAAI,MAAM,KAAK,IAAI,IAAI,OAAO,GAAG;AACzD;AAEA,SAAS,cAAc,IAA2H;CAChJ,OAAO,IAAI,SAAS,SAAS,WAAW;EACtC,IAAI,GAAG,eAAe,GAAc,OAAO,QAAQ;EACnD,GAAG,eAAe,QAAQ;EAC1B,GAAG,WAAW,QAAQ,uBAAO,IAAI,MAAM,6BAA6B,oBAAoB,GAAG,GAAG,CAAC;CACjG,CAAC;AACH;AAEA,SAAgB,gBACd,KACA,gBAA+B,kBAC/B,OAAqC,CAAC,GACjB;CAErB,MAAM,OAA8B,KAAK,UAAU,WAAW,IAAI,cAAc,MAAM;CACtF,OAAO,OAAO,SAAS;EACrB,MAAM,SAAS,OAAO,QAAQ,aAAa,IAAI,IAAI,IAAI;EACvD,MAAM,KAAK,KAAK,QAAQ,IAAI;EAC5B,MAAM,YAAY,IAAI,mBAAmB,EAAE;EAC3C,MAAM,UAAU,aAAa,SAAS;EAItC,MAAM,eAAe,IAAI,SAAkC,YAAY;GACrE,MAAM,MAAM,QAAQ,WAAW,UAAU;IACvC,IAAI;IACJ,QAAQ,KAAK;GACf,CAAC;EACH,CAAC;EACD,MAAM,cAAc,EAAE;EACtB,MAAM,aAAa,MAAM;EAEzB,IAAI,CAAC,QAAQ,UAAU,KAAK,WAAW,WAAA,WACrC,MAAM,IAAI,MAAM,yBAAyB,KAAK,UAAU,UAAU,CAAC,CAAC,MAAM,GAAG,EAAE,GAAG;EAEpF,OAAO;CACT;AACF;;;ACxFA,SAAgB,gBAAgB,IAA4B;CAC1D,OAAO,YAAY;EACjB,MAAM,UAAU,aAAa,IAAI,mBAAmB,EAAE,CAAC;EACvD,MAAM,QAAQ,KAAK,EAAE,QAAQ,QAAQ,CAAC;EACtC,OAAO;CACT;AACF;;;;;;;;;;;;;;;;;;;;AAkCA,SAAgB,mBAAmB,IAA2C;CAC5E,OAAO;EACL,OAAO,SAAS,GAAG,KAAK,IAAI;EAC5B,QAAQ,MAAM,WAAW,GAAG,MAAM,MAAM,MAAM;EAC9C,YAAY,GAAG;EACf,WAAW;EACX,SAAS;CACX;AACF;;;AC9CA,MAAM,gBAAiB,WAAuC;AAE9D,SAAgB,oBACd,KACA,aAAyB,eACJ;CACrB,OAAO,OAAO,SAAS;EAErB,MAAM,UAAU,IAAI,gBAAgB,IAAI,WADzB,OAAO,QAAQ,aAAa,IAAI,IAAI,IAAI,GACE,CAAC;EAE1D,MAAM,aAAa,MAAM,IAAI,SAAkC,YAAY;GACzE,MAAM,MAAM,QAAQ,WAAW,UAAU;IACvC,IAAI;IACJ,QAAQ,KAAK;GACf,CAAC;EACH,CAAC;EAED,IAAI,CAAC,QAAQ,UAAU,KAAK,WAAW,WAAA,YACrC,MAAM,IAAI,MAAM,yBAAyB,KAAK,UAAU,UAAU,CAAC,CAAC,MAAM,GAAG,EAAE,GAAG;EAEpF,OAAO;CACT;AACF;;;ACzBA,SAAgB,kBAAkB,YAAwB,YAA8C;CACtG,OAAO,YAAY;EACjB,MAAM,UAAU,IAAI,gBAAgB,SAAS;EAC7C,MAAM,QAAQ,KAAK,EAAE,QAAQ,eAAe,CAAC;EAC7C,OAAO;CACT;AACF"}

package/dist/remote/node.d.ts

@@ -1,6 +1,6 @@
-import { a as Message } from "../types-CuabnerI.js";
-import { h as MethodOptions, l as ActorDefinition, p as HandlerOptions, v as ReflectionOptions } from "../hooks-Dpbe39oa.js";
-import { A as OutputFd, M as StringTransport, O as Channel, a as stderrSink, i as OutputSink, l as ClientSpawner, m as Listener, n as WebSocketLike, o as withOutput } from "../websocket-sGQcEDbm.js";
+import { a as Message } from "../types-U3NvKgpg.js";
+import { h as MethodOptions, l as ActorDefinition, p as HandlerOptions, v as ReflectionOptions } from "../hooks-DO-efRM_.js";
+import { G as StringTransport, U as Channel, d as stderrSink, l as OutputSink, m as Listener, n as WebSocketLike, o as ClientSpawner, u as pumpOutput } from "../websocket-DT8zKD34.js";
 import { FileHandle } from "node:fs/promises";
 import { ChildProcess, StdioOptions } from "node:child_process";
 import { Duplex, Readable, Writable } from "node:stream";
@@ -9,10 +9,11 @@ import { IncomingMessage } from "node:http";
 declare class FifoUtf8NlineTransport implements StringTransport {
   private readFd;
   private writeFd;
-  private rl;
+  private reader;
   private rs;
   private ws;
   private pvtOnMessage;
+  private pvtOnBytes;
   private pvtOnClose;
   private closed;
   private closingPromise;
@@ -47,12 +48,14 @@ declare class FifoUtf8NlineTransport implements StringTransport {
    */
   static connect(readPath: string, writePath: string): Promise<FifoUtf8NlineTransport>;
   get canSend(): boolean;
-  onMessage(handler: (line: string) => void): void;
-  removeHandler(): ((line: string) => void) | null;
+  onBytes(handler: (bytes: Uint8Array) => void): void;
+  onMessage(handler: (line: string) => number | void): void;
+  removeHandler(): ((line: string) => number | void) | null;
   onClose(handler: () => void): void;
   get hasHandler(): boolean;
   get lastError(): Error | null;
   send(line: string): Promise<void>;
+  sendBytes(bytes: Uint8Array): Promise<void>;
   close(): Promise<void>;
   private pvtClose;
 }
@@ -237,31 +240,35 @@ declare function errorReason(frame: Record<string, unknown>): string | null;
 declare class LineTransport implements StringTransport {
   private readonly streams;
   private pvtOnMessage;
+  private pvtOnBytes;
   private pvtOnClose;
   private pvtClosed;
   private pvtClosing;
   constructor(streams: LineStreams);
   get closed(): boolean;
   get hasHandler(): boolean;
-  onMessage(handler: (line: string) => void): void;
-  removeHandler(): ((line: string) => void) | null;
+  onMessage(handler: (line: string) => number | void): void;
+  onBytes(handler: (bytes: Uint8Array) => void): void;
+  removeHandler(): ((line: string) => number | void) | null;
   onClose(handler: () => void): void;
   send(frame: string): Promise<void>;
+  sendBytes(bytes: Uint8Array): Promise<void>;
+  private pvtWrite;
   close(): Promise<void>;
   private pvtClose;
 }
 /** Streams over two fds of *our own* process — the child side of an fd wire. */
 declare function fdStreams(readFd: number, writeFd: number): LineStreams;
 interface ClientChannelOptions {
-  /** Where the far end's own output goes.  Defaults to our stderr. */
-  onOutput?: OutputSink;
   /** How long to wait for the peer's protocol frame.  Defaults to {@link HANDSHAKE_TIMEOUT_MS}. */
   timeoutMs?: number;
 }
 /**
- * The client end of the connection: hand the streams to the seam and wait for the peer's `$proto`,
- * with the far end's own output going to `onOutput` (our stderr by default) as it arrives.  A
- * first stage reports a failed start as an `$error` frame instead.
+ * The client end of the connection: hand the streams to the seam and wait for the peer's `$proto`.
+ * A first stage reports a failed start as an `$error` frame instead.
+ *
+ * What the far end prints is not here: it arrives as a stream the far end announces under a name,
+ * and whoever wants it reads it by that name.
  */
 declare function clientChannel(streams: LineStreams, opts?: ClientChannelOptions): Promise<Channel>;
 /** The server end of the wire — a payload speaking stdio itself. */
@@ -277,44 +284,13 @@ interface LineLog {
   info(message: string, ...args: unknown[]): void;
   warn(message: string, ...args: unknown[]): void;
 }
-/** One stream of a connection: what the other end's root says on it, and what this end's root says. */
-interface FdStream {
-  /** The other end's root, printing on this stream of its own. */
-  readonly read: Readable;
-  /** This end's root, printing on this stream; the other end reads it. */
-  readonly write: Writable;
-}
-/** The three streams of a connection, and the one way to let them go. */
-interface FdSet {
-  readonly stdin: FdStream;
-  readonly stdout: FdStream;
-  readonly stderr: FdStream;
-  /** Stop reading the connection, and end every stream of it. */
-  close(): void;
-}
-/** Where a frame goes: a connection's own `send`, or a transport's, encoded. */
-type OutputSender = (frame: Record<string, unknown>) => void | Promise<void>;
 /**
- * A writable that writes what is written to it as output frames of one fd: one chunk is one frame.
- *
- * The shape of an output frame lives here rather than at each caller — the gateway relays a payload's
- * own output and holds no channel — and a send that fails is the stream's error, not a lost line.
- */
-declare function fdWriter(send: OutputSender, fd: OutputFd): Writable;
-/**
- * The byte streams of a connection: what each end's root prints, and what it reads.
- *
- * The frames are the connection's, so anyone may also read them directly (`Channel.onMessage`); what
- * this adds is the shape a program outside the seam already speaks.
- */
-declare function connectionFds(channel: Channel): FdSet;
-/**
- * A writable that turns what is written to it into log lines: fd 1 arrives as `info` and fd 2 as
- * `warn`, and the tail is held until a newline (or the end) so a chunk boundary is not a line
- * boundary.
+ * A writable that turns what is written to it into log lines: `stderr` arrives as `warn` and every
+ * other name as `info`, and the tail is held until a newline (or the end) so a chunk boundary is not
+ * a line boundary.
  */
 declare function logStream(log: LineLog, opts?: {
-  fd?: OutputFd;
+  name?: string;
 }): Writable;
 //#endregion
 //#region src/remote/gateway.d.ts
@@ -346,6 +322,8 @@ interface GatewayBoot {
 declare function gatewayArgs(boot: GatewayBoot): string[];
 /** The boot a gateway was started with, or the reason it cannot start. */
 declare function gatewayBoot(argv: string[]): GatewayBoot;
+/** Everything a payload printed into its pipes, up to the point they end: what a start that dies
+ *  before its channel says about itself.  A stream cannot carry it — there is no connection yet. */
 /**
  * Serve one environment over stdin/stdout.  Returns the exit code; the caller
  * turns it into `process.exitCode`.
@@ -488,11 +466,8 @@ declare function unixSocketListener<Meta = unknown>(options: UnixSocketListenerO
 declare function connectUnixSocket(path: string, options?: UnixSocketClientOptions): Promise<LineTransport>;
 //#endregion
 //#region src/remote/spawners/socket-client.d.ts
-/** What a socket client needs: how to reach it, and where the far end's own output goes. */
-interface SocketClientSpawnerOptions extends UnixSocketClientOptions {
-  /** Where the far end's own output goes.  Defaults to our stderr. */
-  onOutput?: OutputSink;
-}
+/** What a socket client needs: how to reach it. */
+interface SocketClientSpawnerOptions extends UnixSocketClientOptions {}
 declare function socketClientSpawner<Args = unknown>(path: string | ((args: Args) => string), options?: SocketClientSpawnerOptions): ClientSpawner<Args>;
 //#endregion
 //#region src/remote/fifo.d.ts
@@ -576,5 +551,5 @@ interface WebSocketListenerOptions<Meta = unknown> {
  */
 declare function webSocketListener<Meta = unknown>(options: WebSocketListenerOptions<Meta>): Listener<Meta>;
 //#endregion
-export { type BootstrapReport, type ClientChannelOptions, DEFAULT_KIT_PARENT, DEFAULT_RUNTIMES, type FdSet, type FdStream, type FifoListenerOptions, type FifoPair, FifoUtf8NlineTransport, GATEWAY_ARTIFACT, GATEWAY_ENTRY, GATEWAY_FAILED, type GatewayBoot, HANDSHAKE_TIMEOUT_MS, type HostProgram, type HostResult, type HostRun, type HostVersion, HostVersionError, type HostVersionVerdict, KIT_LAYOUT, type Kit, type KitApp, type KitFile, type LineLog, type LineStreams, LineTransport, type MakeKitOptions, type OutputFd, type OutputSender, type OutputSink, PAYLOAD_ARTIFACT, PAYLOAD_REFUSED, type RemoteSpec, RemoteSpecError, type RemoteWayIn, type SocketClientSpawnerOptions, type SpawnChild, StdioWireError, type SubprocessActorBundle, type SubprocessActorOptions, type UnixSocketClientOptions, type UnixSocketListenerOptions, type UnixSocketPeer, type UpgradeSource, type WebSocketListenerOptions, type WebSocketUpgrade, bootstrapScript, clientChannel, commandSpawner, connectUnixSocket, connectionFds, defineSubprocessActor, errorFrame, errorReason, fdStreams, fdWriter, fifoArgvSpawner, fifoClientSpawner, fifoListener, gatewayArgs, gatewayBoot, gatewayClient, hostRemote, hostVersion, hostVersionAccepts, kitVersion, logStream, makeFifoPair, makeKit, parseBootstrapReport, parseHostVersion, runGateway, runHost, sameHostVersion, serverChannel, sha256Hex, socketClientSpawner, spawnChild, stderrSink, unixSocketListener, webSocketListener, withOutput };
+export { type BootstrapReport, type ClientChannelOptions, DEFAULT_KIT_PARENT, DEFAULT_RUNTIMES, type FifoListenerOptions, type FifoPair, FifoUtf8NlineTransport, GATEWAY_ARTIFACT, GATEWAY_ENTRY, GATEWAY_FAILED, type GatewayBoot, HANDSHAKE_TIMEOUT_MS, type HostProgram, type HostResult, type HostRun, type HostVersion, HostVersionError, type HostVersionVerdict, KIT_LAYOUT, type Kit, type KitApp, type KitFile, type LineLog, type LineStreams, LineTransport, type MakeKitOptions, type OutputSink, PAYLOAD_ARTIFACT, PAYLOAD_REFUSED, type RemoteSpec, RemoteSpecError, type RemoteWayIn, type SocketClientSpawnerOptions, type SpawnChild, StdioWireError, type SubprocessActorBundle, type SubprocessActorOptions, type UnixSocketClientOptions, type UnixSocketListenerOptions, type UnixSocketPeer, type UpgradeSource, type WebSocketListenerOptions, type WebSocketUpgrade, bootstrapScript, clientChannel, commandSpawner, connectUnixSocket, defineSubprocessActor, errorFrame, errorReason, fdStreams, fifoArgvSpawner, fifoClientSpawner, fifoListener, gatewayArgs, gatewayBoot, gatewayClient, hostRemote, hostVersion, hostVersionAccepts, kitVersion, logStream, makeFifoPair, makeKit, parseBootstrapReport, parseHostVersion, pumpOutput, runGateway, runHost, sameHostVersion, serverChannel, sha256Hex, socketClientSpawner, spawnChild, stderrSink, unixSocketListener, webSocketListener };
 //# sourceMappingURL=node.d.ts.map

package/dist/remote/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","names":[],"sources":["../../src/remote/transports/fifo.ts","../../src/remote/spawners/fifo-command.ts","../../src/remote/spawners/fifo-argv.ts","../../src/remote/kit.ts","../../src/remote/define-subprocess.ts","../../src/remote/stdio.ts","../../src/remote/streams.ts","../../src/remote/gateway.ts","../../src/remote/host.ts","../../src/remote/gateway-client.ts","../../src/remote/socket.ts","../../src/remote/spawners/socket-client.ts","../../src/remote/fifo.ts","../../src/remote/websocket.ts"],"mappings":"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"}
+{"version":3,"file":"node.d.ts","names":[],"sources":["../../src/remote/transports/fifo.ts","../../src/remote/spawners/fifo-command.ts","../../src/remote/spawners/fifo-argv.ts","../../src/remote/kit.ts","../../src/remote/define-subprocess.ts","../../src/remote/stdio.ts","../../src/remote/streams.ts","../../src/remote/gateway.ts","../../src/remote/host.ts","../../src/remote/gateway-client.ts","../../src/remote/socket.ts","../../src/remote/spawners/socket-client.ts","../../src/remote/fifo.ts","../../src/remote/websocket.ts"],"mappings":"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"}