gesso-electrobun 0.6.6 → 0.6.7

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # gesso-electrobun
 
+## 0.6.7
+
+### Patch Changes
+
+- 4f622ec: Channels can now be served from another process without Electrobun. The bridge that carried a desktop window's channels to and from the main process has moved to `gesso-framework/remote`, under names that say what it is: `createRemoteBridge` in the page and `serveRemoteChannels` in the process that owns the data, with the frame format (`GessoFrame`, `frameData`, `FrameAssembler`, `isGessoFrame`, `DEFAULT_CHUNK_BYTES`) beside them. Neither half knows its transport; each takes a `send` function and has a `receive` method, so a web application whose data lives in a server on the person's machine can carry its channels over a WebSocket. The new page "Channels from another process" shows it end to end.
+
+  `gesso-electrobun` keeps every name it had: `createElectrobunBridge`, `serveChannelsToWindow`, `ChannelHost`, `ElectrobunBridge` and the frame exports are now re-exports of the same code, so a desktop application needs no change.
+
+- Updated dependencies [6493881]
+- Updated dependencies [4f622ec]
+  - gesso-framework@0.6.7
+
 ## 0.6.6
 
 ### Patch Changes

package/dist/desktop.d.ts

@@ -1,4 +1,4 @@
-import { r as GessoFrame } from "./frames-Bx7SnqWg.js";
+import { r as GessoFrame } from "./frames-CsYW_e7F.js";
 import { n as withWindowRoute } from "./route-CNeMnj_6.js";
 import { ChannelToken, ServedChannel } from "gesso-framework";
 import { Observable } from "rxjs";

package/dist/frames-CsYW_e7F.d.ts

@@ -0,0 +1,2 @@
+import { DEFAULT_CHUNK_BYTES, FrameAssembler, GessoFrame, frameData, isGessoFrame } from "gesso-framework/remote";
+export { isGessoFrame as a, frameData as i, FrameAssembler as n, GessoFrame as r, DEFAULT_CHUNK_BYTES as t };

package/dist/index.d.ts

@@ -1,2 +1,2 @@
-import { a as isGessoFrame, i as frameData, n as FrameAssembler, r as GessoFrame, t as DEFAULT_CHUNK_BYTES } from "./frames-Bx7SnqWg.js";
+import { a as isGessoFrame, i as frameData, n as FrameAssembler, r as GessoFrame, t as DEFAULT_CHUNK_BYTES } from "./frames-CsYW_e7F.js";
 export { DEFAULT_CHUNK_BYTES, FrameAssembler, type GessoFrame, frameData, isGessoFrame };

package/dist/index.js

@@ -1,2 +1,2 @@
-import { a as isGessoFrame, i as frameData, n as FrameAssembler, t as DEFAULT_CHUNK_BYTES } from "./frames-BQisaYy-.js";
+import { DEFAULT_CHUNK_BYTES, FrameAssembler, frameData, isGessoFrame } from "gesso-framework/remote";
 export { DEFAULT_CHUNK_BYTES, FrameAssembler, frameData, isGessoFrame };

package/dist/main.d.ts

@@ -1,54 +1,10 @@
-import { r as GessoFrame } from "./frames-Bx7SnqWg.js";
+import { RemoteChannelHost, RemoteChannelHostOptions } from "gesso-framework/remote";
 import { ServedChannel } from "gesso-framework";
 //#region src/main.d.ts
-interface ChannelHostOptions {
-  /**
-   * Sends one frame to the window, which is
-   * `window.webview.rpc.send.<name>`. One host per window: each keeps
-   * its own streams, and `provide` already keeps a separate record of
-   * what each client has seen, so two windows agree without anything
-   * here arranging it.
-   */
-  send: (frame: GessoFrame) => void;
-  /** Overrides `DEFAULT_CHUNK_BYTES`. Only a test should need to. */
-  chunkBytes?: number;
-  /**
-   * A url the window asked to have opened outside itself.
-   *
-   * `Utils.openExternal(url)` is what an Electrobun application passes
-   * here. It is not called for the application: opening something is
-   * an act, and which urls an application is willing to hand to the
-   * operating system is the application's decision.
-   */
-  onOpenUrl?: (url: string) => void;
-  /**
-   * One of the application's own urls the window asked to have opened
-   * in a new window: a Cmd-click on an in-app link, sent by the view
-   * bridge's `openRoute`.
-   *
-   * Not called for the application either. `createDesktopApp` answers
-   * it by opening a window at that route; a host built on this alone
-   * decides for itself.
-   */
-  onOpenRoute?: (url: string) => void;
-}
-interface ChannelHost {
-  /** Call from the RPC handler that receives frames from the window. */
-  receive(frame: GessoFrame): void;
-  /** Tells the window which appearance the platform is in. */
-  setColorScheme(scheme: 'light' | 'dark'): void;
-  /** Stops serving and disposes every channel this host provided. */
-  dispose(): void;
-}
-/**
- * Serves an application's channels to one window.
- *
- *   const host = serveChannelsToWindow(
- *     [{ token: Catalogue, source: { view: { … }, commands: { … } } }],
- *     { send: frame => window.webview.rpc.send.gessoFrame(frame) }
- *   );
- */
-declare function serveChannelsToWindow(channels: readonly ServedChannel[], options: ChannelHostOptions): ChannelHost;
+type ChannelHostOptions = RemoteChannelHostOptions;
+type ChannelHost = RemoteChannelHost;
+/** `serveRemoteChannels`, by the name the Electrobun template uses. */
+declare const serveChannelsToWindow: (channels: readonly ServedChannel[], options: ChannelHostOptions) => ChannelHost;
 //#endregion
 export { ChannelHost, ChannelHostOptions, serveChannelsToWindow };
 //# sourceMappingURL=main.d.ts.map

package/dist/main.js

@@ -1,106 +1,7 @@
-import { i as frameData, n as FrameAssembler, r as frameControl } from "./frames-BQisaYy-.js";
-import { serveChannels } from "gesso-framework";
+import { serveRemoteChannels } from "gesso-framework/remote";
 //#region src/main.ts
-/**
-* The main process's half of the bridge.
-*
-* `serveChannels` publishes an application's channels over a handshake
-* that arrives on a worker's global scope with a `MessagePort`
-* attached. No process boundary outside a worker can carry a port, so
-* this synthesises both: an `open` frame becomes the handshake, and
-* the port it hands over writes back as frames on the same stream.
-*
-* Nothing in `serveChannels`, `provide` or a view model changes for
-* this. That is the point of the seam: the application layer does not
-* learn it is talking to a window instead of a page.
-*/
-/**
-* Serves an application's channels to one window.
-*
-*   const host = serveChannelsToWindow(
-*     [{ token: Catalogue, source: { view: { … }, commands: { … } } }],
-*     { send: frame => window.webview.rpc.send.gessoFrame(frame) }
-*   );
-*/
-function serveChannelsToWindow(channels, options) {
-	const chunkBytes = options.chunkBytes ?? 1048576;
-	const assembler = new FrameAssembler();
-	/** The synthetic port each stream is served through. */
-	const ports = /* @__PURE__ */ new Map();
-	const host = { onmessage: null };
-	const stop = serveChannels(channels, host);
-	return {
-		setColorScheme(scheme) {
-			options.send(frameControl("colorScheme", { scheme }));
-		},
-		receive(frame) {
-			if (frame.kind === "control") {
-				if (frame.name === "openUrl" || frame.name === "openRoute") {
-					const payload = JSON.parse(frame.body);
-					if (typeof payload.url === "string") (frame.name === "openUrl" ? options.onOpenUrl : options.onOpenRoute)?.(payload.url);
-				}
-				return;
-			}
-			if (frame.kind === "open") {
-				const port = new StreamPort(frame.stream, options.send, chunkBytes);
-				ports.set(frame.stream, port);
-				host.onmessage?.({
-					data: {
-						type: "gesso:port",
-						key: frame.name
-					},
-					ports: [port]
-				});
-				return;
-			}
-			if (frame.kind === "close") {
-				assembler.forget(frame.stream);
-				ports.delete(frame.stream);
-				return;
-			}
-			const value = assembler.take(frame);
-			if (value === void 0) return;
-			const port = ports.get(frame.stream);
-			if (port === void 0) throw new Error(`A frame arrived for stream ${frame.stream}, which was never opened. The window and the main process disagree about what is running.`);
-			port.deliver(value);
-		},
-		dispose() {
-			for (const stream of ports.keys()) options.send({
-				kind: "close",
-				stream
-			});
-			ports.clear();
-			stop();
-			host.onmessage = null;
-		}
-	};
-}
-/**
-* One channel's port, as the application layer sees it.
-*
-* `provide` sets `onmessage` and calls `postMessage`, and that is the
-* entire surface it uses, which is why a channel can be served over
-* something that is not a `MessagePort` at all.
-*/
-var StreamPort = class {
-	stream;
-	send;
-	chunkBytes;
-	onmessage = null;
-	constructor(stream, send, chunkBytes) {
-		this.stream = stream;
-		this.send = send;
-		this.chunkBytes = chunkBytes;
-	}
-	postMessage(value) {
-		for (const frame of frameData(this.stream, value, this.chunkBytes)) this.send(frame);
-	}
-	deliver(value) {
-		this.onmessage?.({ data: value });
-	}
-	/** `provide` closes a port it is done with; there is nothing to close. */
-	close() {}
-};
+/** `serveRemoteChannels`, by the name the Electrobun template uses. */
+const serveChannelsToWindow = serveRemoteChannels;
 //#endregion
 export { serveChannelsToWindow };
 

package/dist/main.js.map

@@ -1 +1 @@
-{"version":3,"file":"main.js","names":[],"sources":["../src/main.ts"],"sourcesContent":["/**\n * The main process's half of the bridge.\n *\n * `serveChannels` publishes an application's channels over a handshake\n * that arrives on a worker's global scope with a `MessagePort`\n * attached. No process boundary outside a worker can carry a port, so\n * this synthesises both: an `open` frame becomes the handshake, and\n * the port it hands over writes back as frames on the same stream.\n *\n * Nothing in `serveChannels`, `provide` or a view model changes for\n * this. That is the point of the seam: the application layer does not\n * learn it is talking to a window instead of a page.\n */\nimport { serveChannels, type PortHost, type ServedChannel } from 'gesso-framework';\n\nimport { DEFAULT_CHUNK_BYTES, FrameAssembler, frameControl, frameData, type GessoFrame } from './frames';\n\nexport interface ChannelHostOptions {\n  /**\n   * Sends one frame to the window, which is\n   * `window.webview.rpc.send.<name>`. One host per window: each keeps\n   * its own streams, and `provide` already keeps a separate record of\n   * what each client has seen, so two windows agree without anything\n   * here arranging it.\n   */\n  send: (frame: GessoFrame) => void;\n  /** Overrides `DEFAULT_CHUNK_BYTES`. Only a test should need to. */\n  chunkBytes?: number;\n  /**\n   * A url the window asked to have opened outside itself.\n   *\n   * `Utils.openExternal(url)` is what an Electrobun application passes\n   * here. It is not called for the application: opening something is\n   * an act, and which urls an application is willing to hand to the\n   * operating system is the application's decision.\n   */\n  onOpenUrl?: (url: string) => void;\n  /**\n   * One of the application's own urls the window asked to have opened\n   * in a new window: a Cmd-click on an in-app link, sent by the view\n   * bridge's `openRoute`.\n   *\n   * Not called for the application either. `createDesktopApp` answers\n   * it by opening a window at that route; a host built on this alone\n   * decides for itself.\n   */\n  onOpenRoute?: (url: string) => void;\n}\n\nexport interface ChannelHost {\n  /** Call from the RPC handler that receives frames from the window. */\n  receive(frame: GessoFrame): void;\n  /** Tells the window which appearance the platform is in. */\n  setColorScheme(scheme: 'light' | 'dark'): void;\n  /** Stops serving and disposes every channel this host provided. */\n  dispose(): void;\n}\n\n/**\n * Serves an application's channels to one window.\n *\n *   const host = serveChannelsToWindow(\n *     [{ token: Catalogue, source: { view: { … }, commands: { … } } }],\n *     { send: frame => window.webview.rpc.send.gessoFrame(frame) }\n *   );\n */\nexport function serveChannelsToWindow(channels: readonly ServedChannel[], options: ChannelHostOptions): ChannelHost {\n  const chunkBytes = options.chunkBytes ?? DEFAULT_CHUNK_BYTES;\n  const assembler = new FrameAssembler();\n  /** The synthetic port each stream is served through. */\n  const ports = new Map<number, StreamPort>();\n\n  // `servePorts` installs its chain on this and answers handshakes\n  // delivered through `onmessage`. It is the whole of the shim: a\n  // worker's global scope, as far as anything downstream can tell.\n  const host: PortHost = { onmessage: null };\n  const stop = serveChannels(channels, host);\n\n  return {\n    setColorScheme(scheme: 'light' | 'dark'): void {\n      options.send(frameControl('colorScheme', { scheme }));\n    },\n    receive(frame: GessoFrame): void {\n      if (frame.kind === 'control') {\n        if (frame.name === 'openUrl' || frame.name === 'openRoute') {\n          const payload = JSON.parse(frame.body) as { url?: string };\n          if (typeof payload.url === 'string') {\n            (frame.name === 'openUrl' ? options.onOpenUrl : options.onOpenRoute)?.(payload.url);\n          }\n        }\n        return;\n      }\n      if (frame.kind === 'open') {\n        const port = new StreamPort(frame.stream, options.send, chunkBytes);\n        ports.set(frame.stream, port);\n        host.onmessage?.({\n          data: { type: 'gesso:port', key: frame.name },\n          // A `StreamPort` is a `MessagePort` in the two ways anything\n          // downstream uses one, and in no others. The cast is the\n          // seam; widening `PortHost` to admit a structural port would\n          // widen it for every worker as well.\n          ports: [port as unknown as MessagePort]\n        });\n        return;\n      }\n      if (frame.kind === 'close') {\n        assembler.forget(frame.stream);\n        ports.delete(frame.stream);\n        return;\n      }\n      const value = assembler.take(frame);\n      if (value === undefined) {\n        return;\n      }\n      const port = ports.get(frame.stream);\n      if (port === undefined) {\n        throw new Error(\n          `A frame arrived for stream ${frame.stream}, which was never opened. The window and the main process disagree about what is running.`\n        );\n      }\n      port.deliver(value);\n    },\n    dispose(): void {\n      for (const stream of ports.keys()) {\n        options.send({ kind: 'close', stream });\n      }\n      ports.clear();\n      stop();\n      host.onmessage = null;\n    }\n  };\n}\n\n/**\n * One channel's port, as the application layer sees it.\n *\n * `provide` sets `onmessage` and calls `postMessage`, and that is the\n * entire surface it uses, which is why a channel can be served over\n * something that is not a `MessagePort` at all.\n */\nclass StreamPort {\n  onmessage: ((event: { data: unknown }) => void) | null = null;\n\n  constructor(\n    private readonly stream: number,\n    private readonly send: (frame: GessoFrame) => void,\n    private readonly chunkBytes: number\n  ) {}\n\n  postMessage(value: unknown): void {\n    for (const frame of frameData(this.stream, value, this.chunkBytes)) {\n      this.send(frame);\n    }\n  }\n\n  deliver(value: unknown): void {\n    this.onmessage?.({ data: value });\n  }\n\n  /** `provide` closes a port it is done with; there is nothing to close. */\n  close(): void {}\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;AAkEA,SAAgB,sBAAsB,UAAoC,SAA0C;CAClH,MAAM,aAAa,QAAQ,cAAA;CAC3B,MAAM,YAAY,IAAI,eAAe;;CAErC,MAAM,wBAAQ,IAAI,IAAwB;CAK1C,MAAM,OAAiB,EAAE,WAAW,KAAK;CACzC,MAAM,OAAO,cAAc,UAAU,IAAI;CAEzC,OAAO;EACL,eAAe,QAAgC;GAC7C,QAAQ,KAAK,aAAa,eAAe,EAAE,OAAO,CAAC,CAAC;EACtD;EACA,QAAQ,OAAyB;GAC/B,IAAI,MAAM,SAAS,WAAW;IAC5B,IAAI,MAAM,SAAS,aAAa,MAAM,SAAS,aAAa;KAC1D,MAAM,UAAU,KAAK,MAAM,MAAM,IAAI;KACrC,IAAI,OAAO,QAAQ,QAAQ,UACzB,CAAC,MAAM,SAAS,YAAY,QAAQ,YAAY,QAAQ,YAAA,GAAe,QAAQ,GAAG;IAEtF;IACA;GACF;GACA,IAAI,MAAM,SAAS,QAAQ;IACzB,MAAM,OAAO,IAAI,WAAW,MAAM,QAAQ,QAAQ,MAAM,UAAU;IAClE,MAAM,IAAI,MAAM,QAAQ,IAAI;IAC5B,KAAK,YAAY;KACf,MAAM;MAAE,MAAM;MAAc,KAAK,MAAM;KAAK;KAK5C,OAAO,CAAC,IAA8B;IACxC,CAAC;IACD;GACF;GACA,IAAI,MAAM,SAAS,SAAS;IAC1B,UAAU,OAAO,MAAM,MAAM;IAC7B,MAAM,OAAO,MAAM,MAAM;IACzB;GACF;GACA,MAAM,QAAQ,UAAU,KAAK,KAAK;GAClC,IAAI,UAAU,KAAA,GACZ;GAEF,MAAM,OAAO,MAAM,IAAI,MAAM,MAAM;GACnC,IAAI,SAAS,KAAA,GACX,MAAM,IAAI,MACR,8BAA8B,MAAM,OAAO,0FAC7C;GAEF,KAAK,QAAQ,KAAK;EACpB;EACA,UAAgB;GACd,KAAK,MAAM,UAAU,MAAM,KAAK,GAC9B,QAAQ,KAAK;IAAE,MAAM;IAAS;GAAO,CAAC;GAExC,MAAM,MAAM;GACZ,KAAK;GACL,KAAK,YAAY;EACnB;CACF;AACF;;;;;;;;AASA,IAAM,aAAN,MAAiB;CAII;CACA;CACA;CALnB,YAAyD;CAEzD,YACE,QACA,MACA,YACA;EAHiB,KAAA,SAAA;EACA,KAAA,OAAA;EACA,KAAA,aAAA;CAChB;CAEH,YAAY,OAAsB;EAChC,KAAK,MAAM,SAAS,UAAU,KAAK,QAAQ,OAAO,KAAK,UAAU,GAC/D,KAAK,KAAK,KAAK;CAEnB;CAEA,QAAQ,OAAsB;EAC5B,KAAK,YAAY,EAAE,MAAM,MAAM,CAAC;CAClC;;CAGA,QAAc,CAAC;AACjB"}
+{"version":3,"file":"main.js","names":[],"sources":["../src/main.ts"],"sourcesContent":["/**\n * The main process's half of the bridge.\n *\n * The host is `serveRemoteChannels` from `gesso-framework/remote`,\n * which serves an application's channels to a page in another process\n * over any transport that can carry a string. In an Electrobun\n * application the page is a window and the transport is its RPC: pass\n * `window.webview.rpc.send.<name>` as `send`, and feed every frame the\n * window sends to `receive`. This entry keeps the names a desktop\n * application has always used for it.\n */\nimport type { ServedChannel } from 'gesso-framework';\nimport { serveRemoteChannels, type RemoteChannelHost, type RemoteChannelHostOptions } from 'gesso-framework/remote';\n\nexport type ChannelHostOptions = RemoteChannelHostOptions;\nexport type ChannelHost = RemoteChannelHost;\n\n/** `serveRemoteChannels`, by the name the Electrobun template uses. */\nexport const serveChannelsToWindow: (channels: readonly ServedChannel[], options: ChannelHostOptions) => ChannelHost =\n  serveRemoteChannels;\n"],"mappings":";;;AAkBA,MAAa,wBACX"}

package/dist/view.d.ts

@@ -1,64 +1,10 @@
-import { r as GessoFrame } from "./frames-Bx7SnqWg.js";
 import { t as windowRoute } from "./route-CNeMnj_6.js";
-import { AppLogicEndpoint } from "gesso-framework";
+import { RemoteBridge, RemoteBridgeOptions } from "gesso-framework/remote";
 //#region src/view.d.ts
-interface ElectrobunBridgeOptions {
-  /**
-   * Sends one frame to the main process, which is
-   * `view.rpc.send.<name>` for whichever message name the application
-   * declared. A function rather than the RPC object, so this package
-   * imports nothing from Electrobun's SDK and can be specified without
-   * a window.
-   */
-  send: (frame: GessoFrame) => void;
-  /** Overrides `DEFAULT_CHUNK_BYTES`. Only a test should need to. */
-  chunkBytes?: number;
-  /**
-   * The appearance the platform is in, as the main process reports it.
-   *
-   * Wire it to `app.setColorScheme`. It exists because
-   * `prefers-color-scheme` is not to be trusted in every webview: on
-   * WebKitGTK it reported light on a desktop that was in dark mode
-   *, and a shell that believes
-   * it is a browser gets the appearance wrong there.
-   */
-  onColorScheme?: (scheme: 'light' | 'dark') => void;
-}
-interface ElectrobunBridge {
-  /**
-   * Hand this to the shell as its application layer:
-   *
-   *   createApp({ renderWorker: …, appLogicWorker: bridge.endpoint })
-   *
-   * The shell wires it exactly as it wires a worker it was handed, and
-   * never closes it.
-   */
-  readonly endpoint: AppLogicEndpoint;
-  /** Call from the RPC handler that receives frames from the main process. */
-  receive(frame: GessoFrame): void;
-  /**
-   * Hands a url to the main process to open outside the window.
-   *
-   * Pass it as `onOpenUrl` to the shell: `window.open` in a webview
-   * opens another webview or nothing at all, and a link in a desktop
-   * application belongs in the person's browser.
-   */
-  openUrl(url: string): void;
-  /**
-   * Asks the main process to open this application at one of its own
-   * urls in a new window.
-   *
-   * Pass it as `onOpenRoute` to the shell. It is what a Cmd-click on an
-   * in-app link means in a desktop application: a window has no tabs,
-   * and a `window.open` here would open a bare webview the application
-   * does not serve. `createDesktopApp` opens the window, at that route,
-   * unless the application said otherwise.
-   */
-  openRoute(url: string): void;
-  /** Closes every stream and stops pumping. */
-  dispose(): void;
-}
-declare function createElectrobunBridge(options: ElectrobunBridgeOptions): ElectrobunBridge;
+type ElectrobunBridgeOptions = RemoteBridgeOptions;
+type ElectrobunBridge = RemoteBridge;
+/** `createRemoteBridge`, by the name the Electrobun template uses. */
+declare const createElectrobunBridge: (options: ElectrobunBridgeOptions) => ElectrobunBridge;
 //#endregion
 export { ElectrobunBridge, ElectrobunBridgeOptions, createElectrobunBridge, windowRoute };
 //# sourceMappingURL=view.d.ts.map

package/dist/view.js

@@ -1,111 +1,18 @@
-import { i as frameData, n as FrameAssembler, r as frameControl } from "./frames-BQisaYy-.js";
 import { t as windowRoute } from "./route-B2qU38dY.js";
-import { isHubMessage, isPortHandshake } from "gesso-framework";
+import { createRemoteBridge } from "gesso-framework/remote";
 //#region src/view.ts
 /**
 * The webview's half of the bridge.
 *
-* A Gesso render worker opens a named port per channel and expects the
-* application layer at the other end of it. In a desktop window the
-* application layer is in another process, reachable only from this
-* thread, so this stands in its place: it accepts the handshakes the
-* render worker sends and pumps each one over Electrobun's RPC as a
-* numbered stream.
-*
-* It is a transport and nothing else. It serializes a message it never
-* inspects, and it holds no channel, no token and no patch. Anything
-* that needs to understand a payload to route it belongs on the other
-* side of the bridge, and if that ever changes here, the wrong thing
-* is happening on the thread that must stay free for input.
+* The bridge is `createRemoteBridge` from `gesso-framework/remote`,
+* which carries a render worker's channels over any transport that
+* can carry a string. In a desktop window that transport is
+* Electrobun's RPC: pass `view.rpc.send.<name>` as `send`, and feed
+* every frame the main process sends to `receive`. This entry keeps the
+* names a desktop application has always used for it.
 */
-function createElectrobunBridge(options) {
-	const chunkBytes = options.chunkBytes ?? 1048576;
-	const assembler = new FrameAssembler();
-	/** The render worker's port for each stream this side opened. */
-	const ports = /* @__PURE__ */ new Map();
-	let hub = null;
-	let nextStream = 1;
-	let disposed = false;
-	const openStream = (name, port) => {
-		const stream = nextStream++;
-		ports.set(stream, port);
-		port.onmessage = (event) => {
-			for (const frame of frameData(stream, event.data, chunkBytes)) options.send(frame);
-		};
-		port.start?.();
-		options.send({
-			kind: "open",
-			stream,
-			name
-		});
-	};
-	return {
-		endpoint: {
-			postMessage(message, transfer) {
-				if (disposed) return;
-				if (isHubMessage(message)) {
-					const port = transfer?.[0];
-					if (port === void 0) throw new Error("The shell sent a hub message with no port attached.");
-					hub = port;
-					hub.onmessage = (event) => {
-						if (!isPortHandshake(event.data)) return;
-						const handshake = event.ports?.[0];
-						if (handshake === void 0) throw new Error(`Port handshake for '${event.data.key}' arrived with no port attached.`);
-						openStream(event.data.key, handshake);
-					};
-					hub.start?.();
-					return;
-				}
-			},
-			addEventListener() {},
-			removeEventListener() {}
-		},
-		openUrl(url) {
-			if (!disposed) options.send(frameControl("openUrl", { url }));
-		},
-		openRoute(url) {
-			if (!disposed) options.send(frameControl("openRoute", { url }));
-		},
-		receive(frame) {
-			if (disposed) return;
-			if (frame.kind === "control") {
-				if (frame.name === "colorScheme") {
-					const payload = JSON.parse(frame.body);
-					if (payload.scheme !== void 0) options.onColorScheme?.(payload.scheme);
-				}
-				return;
-			}
-			if (frame.kind === "close") {
-				assembler.forget(frame.stream);
-				ports.get(frame.stream)?.close();
-				ports.delete(frame.stream);
-				return;
-			}
-			if (frame.kind !== "data") throw new Error(`The main process opened stream ${frame.stream}, which only the window may do.`);
-			const value = assembler.take(frame);
-			if (value === void 0) return;
-			const port = ports.get(frame.stream);
-			if (port === void 0) return;
-			port.postMessage(value);
-		},
-		dispose() {
-			disposed = true;
-			for (const [stream, port] of ports) {
-				options.send({
-					kind: "close",
-					stream
-				});
-				port.close();
-			}
-			ports.clear();
-			if (hub !== null) {
-				hub.onmessage = null;
-				hub.close();
-				hub = null;
-			}
-		}
-	};
-}
+/** `createRemoteBridge`, by the name the Electrobun template uses. */
+const createElectrobunBridge = createRemoteBridge;
 //#endregion
 export { createElectrobunBridge, windowRoute };
 

package/dist/view.js.map

@@ -1 +1 @@
-{"version":3,"file":"view.js","names":[],"sources":["../src/view.ts"],"sourcesContent":["/**\n * The webview's half of the bridge.\n *\n * A Gesso render worker opens a named port per channel and expects the\n * application layer at the other end of it. In a desktop window the\n * application layer is in another process, reachable only from this\n * thread, so this stands in its place: it accepts the handshakes the\n * render worker sends and pumps each one over Electrobun's RPC as a\n * numbered stream.\n *\n * It is a transport and nothing else. It serializes a message it never\n * inspects, and it holds no channel, no token and no patch. Anything\n * that needs to understand a payload to route it belongs on the other\n * side of the bridge, and if that ever changes here, the wrong thing\n * is happening on the thread that must stay free for input.\n */\nimport { isHubMessage, isPortHandshake, type AppLogicEndpoint } from 'gesso-framework';\n\nimport { DEFAULT_CHUNK_BYTES, FrameAssembler, frameControl, frameData, type GessoFrame } from './frames';\n\nexport { windowRoute } from './route';\n\nexport interface ElectrobunBridgeOptions {\n  /**\n   * Sends one frame to the main process, which is\n   * `view.rpc.send.<name>` for whichever message name the application\n   * declared. A function rather than the RPC object, so this package\n   * imports nothing from Electrobun's SDK and can be specified without\n   * a window.\n   */\n  send: (frame: GessoFrame) => void;\n  /** Overrides `DEFAULT_CHUNK_BYTES`. Only a test should need to. */\n  chunkBytes?: number;\n  /**\n   * The appearance the platform is in, as the main process reports it.\n   *\n   * Wire it to `app.setColorScheme`. It exists because\n   * `prefers-color-scheme` is not to be trusted in every webview: on\n   * WebKitGTK it reported light on a desktop that was in dark mode\n   *, and a shell that believes\n   * it is a browser gets the appearance wrong there.\n   */\n  onColorScheme?: (scheme: 'light' | 'dark') => void;\n}\n\nexport interface ElectrobunBridge {\n  /**\n   * Hand this to the shell as its application layer:\n   *\n   *   createApp({ renderWorker: …, appLogicWorker: bridge.endpoint })\n   *\n   * The shell wires it exactly as it wires a worker it was handed, and\n   * never closes it.\n   */\n  readonly endpoint: AppLogicEndpoint;\n  /** Call from the RPC handler that receives frames from the main process. */\n  receive(frame: GessoFrame): void;\n  /**\n   * Hands a url to the main process to open outside the window.\n   *\n   * Pass it as `onOpenUrl` to the shell: `window.open` in a webview\n   * opens another webview or nothing at all, and a link in a desktop\n   * application belongs in the person's browser.\n   */\n  openUrl(url: string): void;\n  /**\n   * Asks the main process to open this application at one of its own\n   * urls in a new window.\n   *\n   * Pass it as `onOpenRoute` to the shell. It is what a Cmd-click on an\n   * in-app link means in a desktop application: a window has no tabs,\n   * and a `window.open` here would open a bare webview the application\n   * does not serve. `createDesktopApp` opens the window, at that route,\n   * unless the application said otherwise.\n   */\n  openRoute(url: string): void;\n  /** Closes every stream and stops pumping. */\n  dispose(): void;\n}\n\nexport function createElectrobunBridge(options: ElectrobunBridgeOptions): ElectrobunBridge {\n  const chunkBytes = options.chunkBytes ?? DEFAULT_CHUNK_BYTES;\n  const assembler = new FrameAssembler();\n  /** The render worker's port for each stream this side opened. */\n  const ports = new Map<number, MessagePort>();\n  let hub: MessagePort | null = null;\n  let nextStream = 1;\n  let disposed = false;\n\n  const openStream = (name: string, port: MessagePort): void => {\n    const stream = nextStream++;\n    ports.set(stream, port);\n    port.onmessage = event => {\n      for (const frame of frameData(stream, event.data, chunkBytes)) {\n        options.send(frame);\n      }\n    };\n    port.start?.();\n    options.send({ kind: 'open', stream, name });\n  };\n\n  const endpoint: AppLogicEndpoint = {\n    postMessage(message: unknown, transfer?: Transferable[]): void {\n      if (disposed) {\n        return;\n      }\n      if (isHubMessage(message)) {\n        const port = transfer?.[0] as MessagePort | undefined;\n        if (port === undefined) {\n          throw new Error('The shell sent a hub message with no port attached.');\n        }\n        hub = port;\n        hub.onmessage = event => {\n          if (!isPortHandshake(event.data)) {\n            return;\n          }\n          const handshake = event.ports?.[0];\n          if (handshake === undefined) {\n            throw new Error(`Port handshake for '${event.data.key}' arrived with no port attached.`);\n          }\n          openStream(event.data.key, handshake);\n        };\n        hub.start?.();\n        return;\n      }\n      // Everything else the shell sends an application worker is about\n      // a worker in this page: console forwarding, today. The\n      // application process's console is its own, and reaching it is\n      // E1.2's business rather than the transport's.\n    },\n    addEventListener(): void {\n      // The shell listens here for console entries from the\n      // application worker. There is no worker, and nothing on the\n      // other side of the bridge speaks that protocol yet, so a\n      // listener would never be called and is not kept.\n    },\n    removeEventListener(): void {}\n  };\n\n  return {\n    endpoint,\n    openUrl(url: string): void {\n      if (!disposed) {\n        options.send(frameControl('openUrl', { url }));\n      }\n    },\n    openRoute(url: string): void {\n      if (!disposed) {\n        options.send(frameControl('openRoute', { url }));\n      }\n    },\n    receive(frame: GessoFrame): void {\n      if (disposed) {\n        return;\n      }\n      if (frame.kind === 'control') {\n        if (frame.name === 'colorScheme') {\n          const payload = JSON.parse(frame.body) as { scheme?: 'light' | 'dark' };\n          if (payload.scheme !== undefined) {\n            options.onColorScheme?.(payload.scheme);\n          }\n        }\n        // An unknown control name is ignored rather than thrown on: the\n        // main process may be newer than the window, which is ordinary\n        // during a hot reload.\n        return;\n      }\n      if (frame.kind === 'close') {\n        assembler.forget(frame.stream);\n        ports.get(frame.stream)?.close();\n        ports.delete(frame.stream);\n        return;\n      }\n      if (frame.kind !== 'data') {\n        // `open` is this side's word. One arriving from the main\n        // process means the two ends disagree about who starts a\n        // stream, which is worth hearing about rather than ignoring.\n        throw new Error(`The main process opened stream ${frame.stream}, which only the window may do.`);\n      }\n      const value = assembler.take(frame);\n      if (value === undefined) {\n        return;\n      }\n      const port = ports.get(frame.stream);\n      if (port === undefined) {\n        // A frame for a stream this side has closed. Ordinary during\n        // teardown, because the far end may already have sent.\n        return;\n      }\n      port.postMessage(value);\n    },\n    dispose(): void {\n      disposed = true;\n      for (const [stream, port] of ports) {\n        options.send({ kind: 'close', stream });\n        port.close();\n      }\n      ports.clear();\n      if (hub !== null) {\n        hub.onmessage = null;\n        hub.close();\n        hub = null;\n      }\n    }\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAgFA,SAAgB,uBAAuB,SAAoD;CACzF,MAAM,aAAa,QAAQ,cAAA;CAC3B,MAAM,YAAY,IAAI,eAAe;;CAErC,MAAM,wBAAQ,IAAI,IAAyB;CAC3C,IAAI,MAA0B;CAC9B,IAAI,aAAa;CACjB,IAAI,WAAW;CAEf,MAAM,cAAc,MAAc,SAA4B;EAC5D,MAAM,SAAS;EACf,MAAM,IAAI,QAAQ,IAAI;EACtB,KAAK,aAAY,UAAS;GACxB,KAAK,MAAM,SAAS,UAAU,QAAQ,MAAM,MAAM,UAAU,GAC1D,QAAQ,KAAK,KAAK;EAEtB;EACA,KAAK,QAAQ;EACb,QAAQ,KAAK;GAAE,MAAM;GAAQ;GAAQ;EAAK,CAAC;CAC7C;CAwCA,OAAO;EACL,UAAA;GAtCA,YAAY,SAAkB,UAAiC;IAC7D,IAAI,UACF;IAEF,IAAI,aAAa,OAAO,GAAG;KACzB,MAAM,OAAO,WAAW;KACxB,IAAI,SAAS,KAAA,GACX,MAAM,IAAI,MAAM,qDAAqD;KAEvE,MAAM;KACN,IAAI,aAAY,UAAS;MACvB,IAAI,CAAC,gBAAgB,MAAM,IAAI,GAC7B;MAEF,MAAM,YAAY,MAAM,QAAQ;MAChC,IAAI,cAAc,KAAA,GAChB,MAAM,IAAI,MAAM,uBAAuB,MAAM,KAAK,IAAI,iCAAiC;MAEzF,WAAW,MAAM,KAAK,KAAK,SAAS;KACtC;KACA,IAAI,QAAQ;KACZ;IACF;GAKF;GACA,mBAAyB,CAKzB;GACA,sBAA4B,CAAC;EAItB;EACP,QAAQ,KAAmB;GACzB,IAAI,CAAC,UACH,QAAQ,KAAK,aAAa,WAAW,EAAE,IAAI,CAAC,CAAC;EAEjD;EACA,UAAU,KAAmB;GAC3B,IAAI,CAAC,UACH,QAAQ,KAAK,aAAa,aAAa,EAAE,IAAI,CAAC,CAAC;EAEnD;EACA,QAAQ,OAAyB;GAC/B,IAAI,UACF;GAEF,IAAI,MAAM,SAAS,WAAW;IAC5B,IAAI,MAAM,SAAS,eAAe;KAChC,MAAM,UAAU,KAAK,MAAM,MAAM,IAAI;KACrC,IAAI,QAAQ,WAAW,KAAA,GACrB,QAAQ,gBAAgB,QAAQ,MAAM;IAE1C;IAIA;GACF;GACA,IAAI,MAAM,SAAS,SAAS;IAC1B,UAAU,OAAO,MAAM,MAAM;IAC7B,MAAM,IAAI,MAAM,MAAM,CAAC,EAAE,MAAM;IAC/B,MAAM,OAAO,MAAM,MAAM;IACzB;GACF;GACA,IAAI,MAAM,SAAS,QAIjB,MAAM,IAAI,MAAM,kCAAkC,MAAM,OAAO,gCAAgC;GAEjG,MAAM,QAAQ,UAAU,KAAK,KAAK;GAClC,IAAI,UAAU,KAAA,GACZ;GAEF,MAAM,OAAO,MAAM,IAAI,MAAM,MAAM;GACnC,IAAI,SAAS,KAAA,GAGX;GAEF,KAAK,YAAY,KAAK;EACxB;EACA,UAAgB;GACd,WAAW;GACX,KAAK,MAAM,CAAC,QAAQ,SAAS,OAAO;IAClC,QAAQ,KAAK;KAAE,MAAM;KAAS;IAAO,CAAC;IACtC,KAAK,MAAM;GACb;GACA,MAAM,MAAM;GACZ,IAAI,QAAQ,MAAM;IAChB,IAAI,YAAY;IAChB,IAAI,MAAM;IACV,MAAM;GACR;EACF;CACF;AACF"}
+{"version":3,"file":"view.js","names":[],"sources":["../src/view.ts"],"sourcesContent":["/**\n * The webview's half of the bridge.\n *\n * The bridge is `createRemoteBridge` from `gesso-framework/remote`,\n * which carries a render worker's channels over any transport that\n * can carry a string. In a desktop window that transport is\n * Electrobun's RPC: pass `view.rpc.send.<name>` as `send`, and feed\n * every frame the main process sends to `receive`. This entry keeps the\n * names a desktop application has always used for it.\n */\nimport { createRemoteBridge, type RemoteBridge, type RemoteBridgeOptions } from 'gesso-framework/remote';\n\nexport { windowRoute } from './route';\n\nexport type ElectrobunBridgeOptions = RemoteBridgeOptions;\nexport type ElectrobunBridge = RemoteBridge;\n\n/** `createRemoteBridge`, by the name the Electrobun template uses. */\nexport const createElectrobunBridge: (options: ElectrobunBridgeOptions) => ElectrobunBridge = createRemoteBridge;\n"],"mappings":";;;;;;;;;;;;;;AAkBA,MAAa,yBAAiF"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gesso-electrobun",
-  "version": "0.6.6",
+  "version": "0.6.7",
   "description": "Run a Gesso application in an Electrobun window, with its stores in the main process.",
   "license": "MIT",
   "author": "Kevin Baker",
@@ -54,7 +54,7 @@
     "LICENSE"
   ],
   "dependencies": {
-    "gesso-framework": "^0.6.6"
+    "gesso-framework": "^0.6.7"
   },
   "peerDependencies": {
     "rxjs": "^7.8.2"

package/dist/frames-BQisaYy-.js

@@ -1,105 +0,0 @@
-//#region src/frames.ts
-/**
-* The whole wire format, which is deliberately smaller than the
-* channel protocol it carries.
-*
-* Three frames in each direction. `open` says a named channel wants a
-* stream, `data` carries one channel message, `close` ends a stream.
-* Nothing here knows what a channel is, what a patch is, or what a
-* command is: a frame's `body` is a string this module produced by
-* serializing a value it never looked inside. That restraint is the
-* rule the adapter states, and it is what keeps the
-* webview's main thread a transport rather than a router.
-*/
-/**
-* How much of a serialized message goes in one frame.
-*
-* Electrobun's transport fails above roughly 8 MiB in a single
-* message, and it fails badly: the main process throws while draining
-* and the sender sees only a timeout, so the real error is in a log
-* nobody is reading. A megabyte leaves eight times the headroom and
-* costs nothing at the measured rates.
-*/
-const DEFAULT_CHUNK_BYTES = 1048576;
-function isGessoFrame(value) {
-	const kind = value?.kind;
-	return kind === "open" || kind === "data" || kind === "close" || kind === "control";
-}
-/** Wraps one control message. Never split: these are small by construction. */
-function frameControl(name, payload) {
-	return {
-		kind: "control",
-		name,
-		body: JSON.stringify(payload ?? null) ?? "null"
-	};
-}
-/**
-* Serializes one channel message into the frames that carry it.
-*
-* JSON rather than structured clone, because the transport underneath
-* is JSON either way: `Electroview.createTransport` stringifies every
-* message before it encrypts it. That means `undefined` inside a value
-* does not survive, which is true of this transport with or without
-* this module, and which a view key cannot rely on anyway.
-*/
-function frameData(stream, value, chunkBytes = DEFAULT_CHUNK_BYTES) {
-	const body = JSON.stringify(value);
-	if (body === void 0) throw new Error(`A channel message for stream ${stream} could not be serialized. Only plain data crosses a channel; see requirePlainData.`);
-	if (body.length <= chunkBytes) return [{
-		kind: "data",
-		stream,
-		body
-	}];
-	const parts = Math.ceil(body.length / chunkBytes);
-	const frames = [];
-	for (let part = 0; part < parts; part++) frames.push({
-		kind: "data",
-		stream,
-		body: body.slice(part * chunkBytes, (part + 1) * chunkBytes),
-		part,
-		parts
-	});
-	return frames;
-}
-/**
-* Puts split messages back together.
-*
-* The transport delivers in order (`Electroview` dispatches through a
-* promise tail that preserves frame order), so a part that arrives out
-* of turn is a bug rather than a race, and it says so instead of
-* quietly assembling a corrupt message.
-*/
-var FrameAssembler = class {
-	partial = /* @__PURE__ */ new Map();
-	/**
-	* Returns the value a `data` frame completes, or `undefined` while
-	* more parts are still to come.
-	*/
-	take(frame) {
-		if (frame.parts === void 0) return JSON.parse(frame.body);
-		const held = this.partial.get(frame.stream) ?? {
-			parts: frame.parts,
-			chunks: []
-		};
-		const expected = held.chunks.length;
-		if (frame.part !== expected) {
-			this.partial.delete(frame.stream);
-			throw new Error(`Stream ${frame.stream} received part ${String(frame.part)} when part ${expected} was next. Frames are expected in order; a gap means the transport reordered or dropped one.`);
-		}
-		held.chunks.push(frame.body);
-		if (held.chunks.length < held.parts) {
-			this.partial.set(frame.stream, held);
-			return;
-		}
-		this.partial.delete(frame.stream);
-		return JSON.parse(held.chunks.join(""));
-	}
-	/** Drops anything half-received for a stream that has closed. */
-	forget(stream) {
-		this.partial.delete(stream);
-	}
-};
-//#endregion
-export { isGessoFrame as a, frameData as i, FrameAssembler as n, frameControl as r, DEFAULT_CHUNK_BYTES as t };
-
-//# sourceMappingURL=frames-BQisaYy-.js.map

package/dist/frames-BQisaYy-.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"frames-BQisaYy-.js","names":[],"sources":["../src/frames.ts"],"sourcesContent":["/**\n * The whole wire format, which is deliberately smaller than the\n * channel protocol it carries.\n *\n * Three frames in each direction. `open` says a named channel wants a\n * stream, `data` carries one channel message, `close` ends a stream.\n * Nothing here knows what a channel is, what a patch is, or what a\n * command is: a frame's `body` is a string this module produced by\n * serializing a value it never looked inside. That restraint is the\n * rule the adapter states, and it is what keeps the\n * webview's main thread a transport rather than a router.\n */\n\n/**\n * How much of a serialized message goes in one frame.\n *\n * Electrobun's transport fails above roughly 8 MiB in a single\n * message, and it fails badly: the main process throws while draining\n * and the sender sees only a timeout, so the real error is in a log\n * nobody is reading. A megabyte leaves eight times the headroom and\n * costs nothing at the measured rates.\n */\nexport const DEFAULT_CHUNK_BYTES = 1_048_576;\n\nexport type GessoFrame =\n  | { readonly kind: 'open'; readonly stream: number; readonly name: string }\n  | {\n      readonly kind: 'data';\n      readonly stream: number;\n      readonly body: string;\n      /** Absent unless the message was split; then 0-based. */\n      readonly part?: number;\n      /** Absent unless the message was split; then how many parts to expect. */\n      readonly parts?: number;\n    }\n  | { readonly kind: 'close'; readonly stream: number }\n  /**\n   * The adapter's own traffic, which is not a channel: the appearance\n   * the platform is in, a url the application wants opened outside the\n   * window, and one of its own routes it wants opened in a new window.\n   * It carries a name and a serialized payload for\n   * the same reason a `data` frame carries a body, and it is a\n   * separate kind so that nothing has to reserve a stream number.\n   */\n  | { readonly kind: 'control'; readonly name: string; readonly body: string };\n\nexport function isGessoFrame(value: unknown): value is GessoFrame {\n  const kind = (value as { kind?: unknown } | null)?.kind;\n  return kind === 'open' || kind === 'data' || kind === 'close' || kind === 'control';\n}\n\n/** Wraps one control message. Never split: these are small by construction. */\nexport function frameControl(name: string, payload: unknown): GessoFrame {\n  return { kind: 'control', name, body: JSON.stringify(payload ?? null) ?? 'null' };\n}\n\n/**\n * Serializes one channel message into the frames that carry it.\n *\n * JSON rather than structured clone, because the transport underneath\n * is JSON either way: `Electroview.createTransport` stringifies every\n * message before it encrypts it. That means `undefined` inside a value\n * does not survive, which is true of this transport with or without\n * this module, and which a view key cannot rely on anyway.\n */\nexport function frameData(stream: number, value: unknown, chunkBytes = DEFAULT_CHUNK_BYTES): GessoFrame[] {\n  const body = JSON.stringify(value);\n  if (body === undefined) {\n    throw new Error(\n      `A channel message for stream ${stream} could not be serialized. Only plain data crosses a channel; see requirePlainData.`\n    );\n  }\n  if (body.length <= chunkBytes) {\n    return [{ kind: 'data', stream, body }];\n  }\n  const parts = Math.ceil(body.length / chunkBytes);\n  const frames: GessoFrame[] = [];\n  for (let part = 0; part < parts; part++) {\n    frames.push({\n      kind: 'data',\n      stream,\n      body: body.slice(part * chunkBytes, (part + 1) * chunkBytes),\n      part,\n      parts\n    });\n  }\n  return frames;\n}\n\n/**\n * Puts split messages back together.\n *\n * The transport delivers in order (`Electroview` dispatches through a\n * promise tail that preserves frame order), so a part that arrives out\n * of turn is a bug rather than a race, and it says so instead of\n * quietly assembling a corrupt message.\n */\nexport class FrameAssembler {\n  private readonly partial = new Map<number, { parts: number; chunks: string[] }>();\n\n  /**\n   * Returns the value a `data` frame completes, or `undefined` while\n   * more parts are still to come.\n   */\n  take(frame: GessoFrame & { kind: 'data' }): unknown {\n    if (frame.parts === undefined) {\n      return JSON.parse(frame.body);\n    }\n    const held = this.partial.get(frame.stream) ?? { parts: frame.parts, chunks: [] };\n    const expected = held.chunks.length;\n    if (frame.part !== expected) {\n      this.partial.delete(frame.stream);\n      throw new Error(\n        `Stream ${frame.stream} received part ${String(frame.part)} when part ${expected} was next. ` +\n          'Frames are expected in order; a gap means the transport reordered or dropped one.'\n      );\n    }\n    held.chunks.push(frame.body);\n    if (held.chunks.length < held.parts) {\n      this.partial.set(frame.stream, held);\n      return undefined;\n    }\n    this.partial.delete(frame.stream);\n    return JSON.parse(held.chunks.join(''));\n  }\n\n  /** Drops anything half-received for a stream that has closed. */\n  forget(stream: number): void {\n    this.partial.delete(stream);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,sBAAsB;AAwBnC,SAAgB,aAAa,OAAqC;CAChE,MAAM,OAAQ,OAAqC;CACnD,OAAO,SAAS,UAAU,SAAS,UAAU,SAAS,WAAW,SAAS;AAC5E;;AAGA,SAAgB,aAAa,MAAc,SAA8B;CACvE,OAAO;EAAE,MAAM;EAAW;EAAM,MAAM,KAAK,UAAU,WAAW,IAAI,KAAK;CAAO;AAClF;;;;;;;;;;AAWA,SAAgB,UAAU,QAAgB,OAAgB,aAAa,qBAAmC;CACxG,MAAM,OAAO,KAAK,UAAU,KAAK;CACjC,IAAI,SAAS,KAAA,GACX,MAAM,IAAI,MACR,gCAAgC,OAAO,mFACzC;CAEF,IAAI,KAAK,UAAU,YACjB,OAAO,CAAC;EAAE,MAAM;EAAQ;EAAQ;CAAK,CAAC;CAExC,MAAM,QAAQ,KAAK,KAAK,KAAK,SAAS,UAAU;CAChD,MAAM,SAAuB,CAAC;CAC9B,KAAK,IAAI,OAAO,GAAG,OAAO,OAAO,QAC/B,OAAO,KAAK;EACV,MAAM;EACN;EACA,MAAM,KAAK,MAAM,OAAO,aAAa,OAAO,KAAK,UAAU;EAC3D;EACA;CACF,CAAC;CAEH,OAAO;AACT;;;;;;;;;AAUA,IAAa,iBAAb,MAA4B;CAC1B,0BAA2B,IAAI,IAAiD;;;;;CAMhF,KAAK,OAA+C;EAClD,IAAI,MAAM,UAAU,KAAA,GAClB,OAAO,KAAK,MAAM,MAAM,IAAI;EAE9B,MAAM,OAAO,KAAK,QAAQ,IAAI,MAAM,MAAM,KAAK;GAAE,OAAO,MAAM;GAAO,QAAQ,CAAC;EAAE;EAChF,MAAM,WAAW,KAAK,OAAO;EAC7B,IAAI,MAAM,SAAS,UAAU;GAC3B,KAAK,QAAQ,OAAO,MAAM,MAAM;GAChC,MAAM,IAAI,MACR,UAAU,MAAM,OAAO,iBAAiB,OAAO,MAAM,IAAI,EAAE,aAAa,SAAS,6FAEnF;EACF;EACA,KAAK,OAAO,KAAK,MAAM,IAAI;EAC3B,IAAI,KAAK,OAAO,SAAS,KAAK,OAAO;GACnC,KAAK,QAAQ,IAAI,MAAM,QAAQ,IAAI;GACnC;EACF;EACA,KAAK,QAAQ,OAAO,MAAM,MAAM;EAChC,OAAO,KAAK,MAAM,KAAK,OAAO,KAAK,EAAE,CAAC;CACxC;;CAGA,OAAO,QAAsB;EAC3B,KAAK,QAAQ,OAAO,MAAM;CAC5B;AACF"}

package/dist/frames-Bx7SnqWg.d.ts

@@ -1,86 +0,0 @@
-//#region src/frames.d.ts
-/**
- * The whole wire format, which is deliberately smaller than the
- * channel protocol it carries.
- *
- * Three frames in each direction. `open` says a named channel wants a
- * stream, `data` carries one channel message, `close` ends a stream.
- * Nothing here knows what a channel is, what a patch is, or what a
- * command is: a frame's `body` is a string this module produced by
- * serializing a value it never looked inside. That restraint is the
- * rule the adapter states, and it is what keeps the
- * webview's main thread a transport rather than a router.
- */
-/**
- * How much of a serialized message goes in one frame.
- *
- * Electrobun's transport fails above roughly 8 MiB in a single
- * message, and it fails badly: the main process throws while draining
- * and the sender sees only a timeout, so the real error is in a log
- * nobody is reading. A megabyte leaves eight times the headroom and
- * costs nothing at the measured rates.
- */
-declare const DEFAULT_CHUNK_BYTES = 1048576;
-type GessoFrame = {
-  readonly kind: 'open';
-  readonly stream: number;
-  readonly name: string;
-} | {
-  readonly kind: 'data';
-  readonly stream: number;
-  readonly body: string;
-  /** Absent unless the message was split; then 0-based. */
-  readonly part?: number;
-  /** Absent unless the message was split; then how many parts to expect. */
-  readonly parts?: number;
-} | {
-  readonly kind: 'close';
-  readonly stream: number;
-} |
-/**
- * The adapter's own traffic, which is not a channel: the appearance
- * the platform is in, a url the application wants opened outside the
- * window, and one of its own routes it wants opened in a new window.
- * It carries a name and a serialized payload for
- * the same reason a `data` frame carries a body, and it is a
- * separate kind so that nothing has to reserve a stream number.
- */
-{
-  readonly kind: 'control';
-  readonly name: string;
-  readonly body: string;
-};
-declare function isGessoFrame(value: unknown): value is GessoFrame;
-/**
- * Serializes one channel message into the frames that carry it.
- *
- * JSON rather than structured clone, because the transport underneath
- * is JSON either way: `Electroview.createTransport` stringifies every
- * message before it encrypts it. That means `undefined` inside a value
- * does not survive, which is true of this transport with or without
- * this module, and which a view key cannot rely on anyway.
- */
-declare function frameData(stream: number, value: unknown, chunkBytes?: number): GessoFrame[];
-/**
- * Puts split messages back together.
- *
- * The transport delivers in order (`Electroview` dispatches through a
- * promise tail that preserves frame order), so a part that arrives out
- * of turn is a bug rather than a race, and it says so instead of
- * quietly assembling a corrupt message.
- */
-declare class FrameAssembler {
-  private readonly partial;
-  /**
-   * Returns the value a `data` frame completes, or `undefined` while
-   * more parts are still to come.
-   */
-  take(frame: GessoFrame & {
-    kind: 'data';
-  }): unknown;
-  /** Drops anything half-received for a stream that has closed. */
-  forget(stream: number): void;
-}
-//#endregion
-export { isGessoFrame as a, frameData as i, FrameAssembler as n, GessoFrame as r, DEFAULT_CHUNK_BYTES as t };
-//# sourceMappingURL=frames-Bx7SnqWg.d.ts.map