@ekrooh/bare 0.4.0 → 0.6.0

package/dist/{plugins-1KweEBct.mjs → plugins-Ddp2AgOe.mjs}

@@ -1,9 +1,11 @@
-import { ErrorCode, definePlugin, err, ok } from "./index.mjs";
+import { g as ErrorCode, m as ok, p as err, r as definePlugin } from "./messages-CevD8qkV.mjs";
 import { discoverySpecs } from "./plugins-discovery-events.mjs";
 import { healthSpecs } from "./plugins-health-events.mjs";
+import { logsSpecs } from "./plugins-logs-events.mjs";
 import { mediaSpecs } from "./plugins-media-events.mjs";
 import { permissionSpecs } from "./plugins-permissions-events.mjs";
-//#region plugins/discovery/plugin.ts
+import crypto from "bare-crypto";
+// plugins/discovery/plugin.ts
 function mergeCapabilityRows(a, b) {
 	const map = /* @__PURE__ */ new Map();
 	for (const row of [...a, ...b]) {
@@ -40,8 +42,7 @@ function createDiscoveryPlugin(deps) {
 		} }
 	});
 }
-//#endregion
-//#region plugins/health/plugin.ts
+// plugins/health/plugin.ts
 function createHealthPlugin() {
 	return definePlugin("core.health", healthSpecs, {
 		capabilities: ["health"],
@@ -61,10 +62,32 @@ function createHealthPlugin() {
 		}
 	});
 }
-//#endregion
-//#region plugins/media/plugin.ts
+const LOGS_VIEW_DEFAULT_TAIL = 20;
+function createLogsPlugin(deps) {
+	return definePlugin("core.logs", logsSpecs, {
+		capabilities: ["logs"],
+		invoke: {
+			view: (args) => {
+				const tail = args?.tail === void 0 ? LOGS_VIEW_DEFAULT_TAIL : Math.max(0, Math.min(args.tail, 100));
+				return ok({ entries: deps.store.view({
+					tail,
+					level: args?.level,
+					source: args?.source
+				}) });
+			},
+			clear: () => ok({ cleared: deps.store.clear() })
+		}
+	});
+}
+// plugins/media/plugin.ts
+/** Most media mounts are consumed once and then linger. Cap how many stay
+* mounted at once and evict the least-recently-used so picked/captured files
+* do not accumulate on the loopback server for the whole session. */
+const MEDIA_MOUNT_CAP = 4;
+const MEDIA_KINDS = ["image", "video"];
 function newRequestId() {
-	return `${Date.now().toString(36)}-${Math.random().toString(36).slice(2, 10)}`;
+	const rand = crypto.randomBytes(16).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+	return `${Date.now().toString(36)}-${rand}`;
 }
 /**
 * `vendor.media` — reference plugin demonstrating out-of-band binary transfer.
@@ -74,25 +97,35 @@ function newRequestId() {
 * is identical on every runtime.
 */
 function createMediaPlugin(deps) {
+	const mounted = /* @__PURE__ */ new Map();
+	const mountMedia = (id, path) => {
+		deps.staticServer.mount(`/media/${id}`, path);
+		mounted.set(id, path);
+		while (mounted.size > MEDIA_MOUNT_CAP) {
+			const oldestId = mounted.keys().next().value;
+			const oldestPath = mounted.get(oldestId);
+			mounted.delete(oldestId);
+			if (oldestPath !== void 0) deps.staticServer.unmount(`/media/${oldestId}`);
+		}
+	};
 	const serve = async (event, args) => {
+		const kind = args?.kind;
+		if (kind !== void 0 && !MEDIA_KINDS.includes(kind)) return err(ErrorCode.PLUGIN_ERROR, `Unknown media kind for ${event}`);
 		const host = await deps.invokeOnHost({
 			type: "INVOKE_REQUEST",
 			pluginId: "vendor.media",
 			event,
 			requestId: newRequestId(),
-			args
+			args: kind === void 0 ? {} : { kind }
 		}, /* @__PURE__ */ new Uint8Array(0));
 		if (!host) return err(ErrorCode.HOST_ERROR, `Host did not answer ${event}`);
 		if (host.error) return err(host.error.code || ErrorCode.HOST_ERROR, host.error.message ?? `Host failed ${event}`);
 		const path = host.result?.path;
 		if (!path) return err(ErrorCode.HOST_ERROR, `Host returned no path for ${event}`);
-		const id = `${args?.kind ?? "media"}-${newRequestId()}`;
-		deps.staticServer.mount(`/media/${id}`, path);
+		const id = `${kind ?? "media"}-${newRequestId()}`;
+		mountMedia(id, path);
 		const url = await deps.staticServer.url(`/media/${id}`);
-		return ok({
-			url,
-			path
-		});
+		return ok({ url });
 	};
 	return definePlugin("vendor.media", mediaSpecs, {
 		capabilities: ["media"],
@@ -102,8 +135,7 @@ function createMediaPlugin(deps) {
 		}
 	});
 }
-//#endregion
-//#region plugins/permissions/plugin.ts
+// plugins/permissions/plugin.ts
 /**
 * Declares host-only permission events. Handlers are registered on the Android host
 * via {@code HostPluginRegistry}; the worklet delegates invokes here over IPC.
@@ -111,15 +143,14 @@ function createMediaPlugin(deps) {
 function createPermissionsPluginStub() {
 	return definePlugin("core.permissions", permissionSpecs, { capabilities: ["permissions"] });
 }
-//#endregion
-//#region plugins/index.ts
+// plugins/index.ts
 function createDefaultPlugins(deps) {
 	return [
 		createHealthPlugin(),
 		createDiscoveryPlugin(deps),
 		createPermissionsPluginStub(),
-		createMediaPlugin(deps)
+		createMediaPlugin(deps),
+		createLogsPlugin(deps)
 	];
 }
-//#endregion
 export { createDefaultPlugins as t };

package/dist/plugins-discovery-events.d.mts

@@ -1,10 +1,9 @@
-import { A as CapabilityDescriptor, B as InvokeEnvelope } from "./index-DjulYFJL.mjs";
-//#region plugins/discovery/events.d.ts
-type DiscoveryListResult = {
+import { F as CapabilityDescriptor, G as InvokeEnvelope } from "./index-BkwUzwVt.mjs";
+export type DiscoveryListResult = {
   schemaVersion: 1;
   capabilities: CapabilityDescriptor[];
 };
-declare const discoverySpecs: {
+export declare const discoverySpecs: {
   readonly list: {
     readonly pluginId: 'core.discovery';
     readonly name: 'discovery.list';
@@ -12,10 +11,8 @@ declare const discoverySpecs: {
     readonly result: DiscoveryListResult;
   };
 };
-declare const discoveryEvents: {
+export declare const discoveryEvents: {
   discovery: {
     list(): InvokeEnvelope<"discovery.list", Record<string, never>, DiscoveryListResult>;
   };
-};
-//#endregion
-export { DiscoveryListResult, discoveryEvents, discoverySpecs };
+};

package/dist/plugins-discovery-events.mjs

@@ -1,5 +1,5 @@
-import { invokeEvent } from "./index.mjs";
-//#region plugins/discovery/events.ts
+import { a as invokeEvent } from "./messages-CevD8qkV.mjs";
+// plugins/discovery/events.ts
 const discoverySpecs = { list: {
 	pluginId: "core.discovery",
 	name: "discovery.list",
@@ -9,5 +9,4 @@ const discoverySpecs = { list: {
 const discoveryEvents = { discovery: { list() {
 	return invokeEvent(discoverySpecs.list, {});
 } } };
-//#endregion
 export { discoveryEvents, discoverySpecs };

package/dist/plugins-health-events.d.mts

@@ -1,6 +1,5 @@
-import { B as InvokeEnvelope } from "./index-DjulYFJL.mjs";
-//#region plugins/health/events.d.ts
-declare const healthSpecs: {
+import { G as InvokeEnvelope } from "./index-BkwUzwVt.mjs";
+export declare const healthSpecs: {
   readonly ping: {
     readonly pluginId: 'core.health';
     readonly name: 'health.ping';
@@ -33,7 +32,7 @@ declare const healthSpecs: {
     };
   };
 };
-declare const healthEvents: {
+export declare const healthEvents: {
   health: {
     ping(message?: string): InvokeEnvelope<'health.ping', {
       message?: string;
@@ -52,6 +51,4 @@ declare const healthEvents: {
       ts: number;
     }>;
   };
-};
-//#endregion
-export { healthEvents, healthSpecs };
+};

package/dist/plugins-health-events.mjs

@@ -1,5 +1,5 @@
-import { invokeEvent } from "./index.mjs";
-//#region plugins/health/events.ts
+import { a as invokeEvent } from "./messages-CevD8qkV.mjs";
+// plugins/health/events.ts
 const healthSpecs = {
 	ping: {
 		pluginId: "core.health",
@@ -31,5 +31,4 @@ const healthEvents = { health: {
 		return invokeEvent(healthSpecs.roundtrip, {});
 	}
 } };
-//#endregion
 export { healthEvents, healthSpecs };

package/dist/plugins-logs-events.d.mts

@@ -0,0 +1,34 @@
+import { G as InvokeEnvelope, i as LogSource, n as LogEntry, r as LogLevel } from "./index-BkwUzwVt.mjs";
+export type LogsViewArgs = {
+  /** Most-recent N matching entries. Defaults to a small window. */
+  tail?: number;
+  level?: LogLevel;
+  source?: LogSource;
+};
+export type LogsViewResult = {
+  entries: LogEntry[];
+};
+export type LogsClearResult = {
+  cleared: number;
+};
+export declare const logsSpecs: {
+  readonly view: {
+    readonly pluginId: 'core.logs';
+    readonly name: 'logs.view';
+    readonly args: LogsViewArgs;
+    readonly result: LogsViewResult;
+  };
+  readonly clear: {
+    readonly pluginId: 'core.logs';
+    readonly name: 'logs.clear';
+    readonly args: Record<string, never>;
+    readonly result: LogsClearResult;
+  };
+};
+export declare const logEvents: {
+  logs: {
+    view(options?: LogsViewArgs): InvokeEnvelope<'logs.view', LogsViewArgs, LogsViewResult>;
+    clear(): InvokeEnvelope<'logs.clear', Record<string, never>, LogsClearResult>;
+  };
+};
+export type { LogEntry, LogLevel, LogSource };

package/dist/plugins-logs-events.mjs

@@ -0,0 +1,25 @@
+import { a as invokeEvent } from "./messages-CevD8qkV.mjs";
+// plugins/logs/events.ts
+const logsSpecs = {
+	view: {
+		pluginId: "core.logs",
+		name: "logs.view",
+		args: {},
+		result: {}
+	},
+	clear: {
+		pluginId: "core.logs",
+		name: "logs.clear",
+		args: {},
+		result: {}
+	}
+};
+const logEvents = { logs: {
+	view(options = {}) {
+		return invokeEvent(logsSpecs.view, options);
+	},
+	clear() {
+		return invokeEvent(logsSpecs.clear, {});
+	}
+} };
+export { logEvents, logsSpecs };

package/dist/plugins-media-events.d.mts

@@ -1,13 +1,10 @@
-import { B as InvokeEnvelope } from "./index-DjulYFJL.mjs";
-//#region plugins/media/events.d.ts
-type MediaKind = 'image' | 'video';
-type MediaResult = {
+import { G as InvokeEnvelope } from "./index-BkwUzwVt.mjs";
+export type MediaKind = 'image' | 'video';
+export type MediaResult = {
   /** URL served by the worklet's loopback HTTP server (no bytes on the wire). */
   url: string;
-  /** Absolute filesystem path of the picked file on the host. */
-  path: string;
 };
-declare const mediaSpecs: {
+export declare const mediaSpecs: {
   readonly pick: {
     readonly pluginId: 'vendor.media';
     readonly name: 'media.pick';
@@ -25,7 +22,7 @@ declare const mediaSpecs: {
     readonly result: MediaResult;
   };
 };
-declare const mediaEvents: {
+export declare const mediaEvents: {
   media: {
     pick(kind?: MediaKind): InvokeEnvelope<'media.pick', {
       kind?: MediaKind;
@@ -34,6 +31,4 @@ declare const mediaEvents: {
       kind?: MediaKind;
     }, MediaResult>;
   };
-};
-//#endregion
-export { MediaKind, MediaResult, mediaEvents, mediaSpecs };
+};

package/dist/plugins-media-events.mjs

@@ -1,5 +1,5 @@
-import { invokeEvent } from "./index.mjs";
-//#region plugins/media/events.ts
+import { a as invokeEvent } from "./messages-CevD8qkV.mjs";
+// plugins/media/events.ts
 const MEDIA_INVOKE_TIMEOUT_MS = 3e5;
 const mediaSpecs = {
 	pick: {
@@ -23,5 +23,4 @@ const mediaEvents = { media: {
 		return invokeEvent(mediaSpecs.capture, { kind }, null, MEDIA_INVOKE_TIMEOUT_MS);
 	}
 } };
-//#endregion
 export { mediaEvents, mediaSpecs };

package/dist/plugins-permissions-events.d.mts

@@ -1,13 +1,12 @@
-import { B as InvokeEnvelope } from "./index-DjulYFJL.mjs";
-//#region plugins/permissions/events.d.ts
+import { G as InvokeEnvelope } from "./index-BkwUzwVt.mjs";
 /** Canonical permission ids. Hosts map each to their platform equivalent. */
-type PermissionId = 'storage' | 'camera';
-type PermissionStatus = 'granted' | 'denied' | 'notDetermined' | 'unsupported';
-type PermissionResult = {
+export type PermissionId = 'storage' | 'camera';
+export type PermissionStatus = 'granted' | 'denied' | 'notDetermined' | 'unsupported';
+export type PermissionResult = {
   permission: PermissionId;
   status: PermissionStatus;
 };
-declare const permissionSpecs: {
+export declare const permissionSpecs: {
   readonly request: {
     readonly pluginId: 'core.permissions';
     readonly name: 'permissions.request';
@@ -25,7 +24,7 @@ declare const permissionSpecs: {
     readonly result: PermissionResult;
   };
 };
-declare const permissionEvents: {
+export declare const permissionEvents: {
   permissions: {
     request(permission: PermissionId): InvokeEnvelope<'permissions.request', {
       permission: PermissionId;
@@ -34,6 +33,4 @@ declare const permissionEvents: {
       permission: PermissionId;
     }, PermissionResult>;
   };
-};
-//#endregion
-export { PermissionId, PermissionResult, PermissionStatus, permissionEvents, permissionSpecs };
+};

package/dist/plugins-permissions-events.mjs

@@ -1,5 +1,5 @@
-import { invokeEvent } from "./index.mjs";
-//#region plugins/permissions/events.ts
+import { a as invokeEvent } from "./messages-CevD8qkV.mjs";
+// plugins/permissions/events.ts
 const permissionSpecs = {
 	request: {
 		pluginId: "core.permissions",
@@ -22,5 +22,4 @@ const permissionEvents = { permissions: {
 		return invokeEvent(permissionSpecs.status, { permission });
 	}
 } };
-//#endregion
 export { permissionEvents, permissionSpecs };

package/dist/plugins.d.mts

@@ -1,6 +1,5 @@
-import { A as CapabilityDescriptor, G as PluginInvokeRequestHeader, K as PluginInvokeResponseHeader, Y as RuntimeTarget, q as PluginManifest } from "./index-DjulYFJL.mjs";
-import { n as LoopbackServer } from "./static-file-server-DY9EKEVf.mjs";
-//#region plugins/discovery/plugin.d.ts
+import { F as CapabilityDescriptor, Q as PluginManifest, X as PluginInvokeRequestHeader, Z as PluginInvokeResponseHeader, a as LogStore, et as RuntimeTarget } from "./index-BkwUzwVt.mjs";
+import { n as LoopbackServer } from "./static-file-server-COxd-PFR.mjs";
 type DiscoveryPluginDeps = {
   listBareCapabilities: () => Array<{
     pluginId: string;
@@ -10,17 +9,16 @@ type DiscoveryPluginDeps = {
   }>;
   queryHostCapabilities: () => Promise<CapabilityDescriptor[]>;
 };
-//#endregion
-//#region plugins/media/plugin.d.ts
+type LogsPluginDeps = {
+  /** Shared ring buffer fed by the worklet capture seam and the ingest route. */
+  store: LogStore;
+};
 type MediaPluginDeps = {
   /** Worklet-side loopback server exposing picked files to the web layer. */
   staticServer: LoopbackServer;
   /** Delegates the native pick/capture to the host (`HOST_INVOKE_REQUEST`). */
   invokeOnHost: (header: PluginInvokeRequestHeader, payload: Uint8Array) => Promise<PluginInvokeResponseHeader | null>;
 };
-//#endregion
-//#region plugins/index.d.ts
-type DefaultPluginsDeps = DiscoveryPluginDeps & MediaPluginDeps;
-declare function createDefaultPlugins(deps: DefaultPluginsDeps): PluginManifest[];
-//#endregion
-export { DefaultPluginsDeps, type DiscoveryPluginDeps, type MediaPluginDeps, createDefaultPlugins };
+export type DefaultPluginsDeps = DiscoveryPluginDeps & MediaPluginDeps & LogsPluginDeps;
+export declare function createDefaultPlugins(deps: DefaultPluginsDeps): PluginManifest[];
+export type { DiscoveryPluginDeps, LogsPluginDeps, MediaPluginDeps };

package/dist/plugins.mjs

@@ -1,2 +1 @@
-import { t as createDefaultPlugins } from "./plugins-1KweEBct.mjs";
-export { createDefaultPlugins };
+export { t as createDefaultPlugins } from "./plugins-Ddp2AgOe.mjs";

package/dist/runtime.d.mts

@@ -1,75 +1,70 @@
-import { A as CapabilityDescriptor, G as PluginInvokeRequestHeader, K as PluginInvokeResponseHeader, V as MessageHeader, d as MessageProtocol, q as PluginManifest, t as BareRuntimeContext, v as createPluginRegistry, y as createPluginRouter } from "./index-DjulYFJL.mjs";
-import { i as createLoopbackServer, n as LoopbackServer, r as collectRequestBody, t as LoopbackRouteHandler } from "./static-file-server-DY9EKEVf.mjs";
-//#region core/messages/host-ipc.d.ts
+import { C as createPluginRegistry, F as CapabilityDescriptor, K as MessageHeader, Q as PluginManifest, X as PluginInvokeRequestHeader, Z as PluginInvokeResponseHeader, g as MessageProtocol, o as BareRuntimeContext, tt as WireMessage, w as createPluginRouter } from "./index-BkwUzwVt.mjs";
+import { i as createLoopbackServer, n as LoopbackServer, r as collectRequestBody, t as LoopbackRouteHandler } from "./static-file-server-COxd-PFR.mjs";
 type BareIpcLike = {
-  write(data: Uint8Array | Buffer | string): boolean;
+  write(data: Uint8Array | string): boolean;
 };
 declare function createHostIpcBridge(config: {
   ipc: BareIpcLike;
   protocol: MessageProtocol;
 }): {
-  tryConsumeDownstreamFromHost(raw: Uint8Array | ArrayBuffer | Buffer): boolean;
+  tryConsumeDownstream: (parsed: WireMessage) => boolean;
+  tryConsumeDownstreamFromHost(raw: Uint8Array | ArrayBuffer): boolean;
   queryCapabilities(timeoutMs?: number): Promise<CapabilityDescriptor[]>;
   invokeOnHost(header: PluginInvokeRequestHeader, payload: Uint8Array, timeoutMs?: number): Promise<PluginInvokeResponseHeader | null>;
 };
-//#endregion
-//#region core/server/websocket-server.d.ts
 /** Envelope encoder bound to a loopback server's connected protocol socket —
  * the server-initiated (backend → web) push seam. */
 type LoopbackPush = (header: MessageHeader, payload?: Uint8Array | ArrayBuffer | null) => boolean;
 /** Builds the push seam for the server's connected protocol socket: encodes a
  * `DISPATCH`-style envelope and writes it, mirroring how `attachWebSocketProtocol`
  * writes responses. Returns false when no socket is connected. */
-declare function createLoopbackPush(server: LoopbackServer, protocol: MessageProtocol): LoopbackPush;
+export declare function createLoopbackPush(server: LoopbackServer, protocol: MessageProtocol): LoopbackPush;
 /**
  * Attaches the framed-protocol socket to the unified loopback server. The
  * server owns the WebSocket upgrade (origin check, cookie/token auth, single
- * client, idle timeout); this layer only routes decoded envelopes through the
- * plugin router and writes responses back as raw frames.
+ * client, idle timeout); this layer runs one frame channel per socket. A peer
+ * that sends a malformed frame is not recoverable on that socket, so it is
+ * torn down and the client reconnects.
  */
-declare function attachWebSocketProtocol(server: LoopbackServer, context: BareRuntimeContext): void;
-//#endregion
-//#region core/lib/get-ipc.d.ts
+export declare function attachWebSocketProtocol(server: LoopbackServer, context: BareRuntimeContext): void;
 /**
  * @fileoverview Bare IPC provider for Android (BareKit) and Sidecar (Bare.IPC)
  */
 interface BareIPC extends NodeJS.EventEmitter {
   read(n?: number): Buffer | null;
-  write(data: Buffer | string): boolean;
+  write(data: Uint8Array | string): boolean;
   resume?(): void;
   pause?(): void;
 }
 /**
- * Returns the active IPC channel.
- * In BareKit (Android), it uses BareKit.IPC.
+ * Returns the active IPC channel, or null when there is no host.
+ * In BareKit (Android, iOS), it uses BareKit.IPC.
  * In Bare (Sidecar), it uses Bare.IPC.
  */
-declare function getIPC(): BareIPC;
-//#endregion
-//#region core/runtime.d.ts
+export declare function getIPC(): BareIPC | null;
 /** Resolves the host-provided worklet configuration from `start(...)`
  * arguments. On-device hosts pass `["<webAssets>", "<storage>", "<cache>"]`
- * (three existing directories, in that order), landing at `Bare.argv[0..2]`;
- * the Bare CLI (dev) passes the binary and the script path instead, so a
- * missing/absent config means dev mode (auth off, fixed port, no handoff
- * file). Falls back to the labeled CLI token syntax (see `resolveCliConfig`)
- * when the positional shape doesn't match, so the same entry works for both
- * device and dev runs. */
-declare function resolveWorkletConfig(): WorkletRuntimeOptions;
+ * (three existing directories, in that order), landing at `Bare.argv[0..2]`.
+ * Falls back to the labeled CLI token syntax (see `resolveCliConfig`) when the
+ * positional shape doesn't match, so the same entry works for device and dev
+ * runs. Nothing here turns auth off: the dev backend is selected only by an
+ * explicit `mode=dev` token. */
+export declare function resolveWorkletConfig(): WorkletRuntimeOptions;
 /**
- * Parses the dev/CLI labeled-token configuration from bare CLI arguments:
- * `webassets=<dir>`, `storage=<dir>`, `cache=<dir>`, `host=<addr>`,
- * `port=<n>`, `auth=<on|off|true|false|1|0>` — a single `key=value` separator.
- * Unknown labels (e.g. `bootstrap=127.0.0.1:49737`) are ignored and stay
- * consumer-owned.
+ * Parses labeled-token configuration from bare CLI arguments, one `key=value`
+ * per token: `webassets=<dir>`, `storage=<dir>`, `cache=<dir>`,
+ * `host=<addr>`, `port=<n>`, `auth=<on|off|true|false|1|0>`,
+ * `mode=<device|dev>` and `origin=<scheme://host[:port]>` (repeatable; an
+ * extra allowed page origin, e.g. the Vite dev server). Unknown labels (e.g.
+ * `bootstrap=127.0.0.1:49737`) are ignored and stay consumer-owned.
  *
- * Returns the equivalent `WorkletRuntimeOptions` in **dev mode**: `deviceMode:
- * false` (so a `storage=` token does not flip auth on or make the port
- * ephemeral), `auth: false`, `port: 8080`, each overridable by a token. When
- * no labeled tokens are present it returns `{}` (plain dev defaults).
+ * Without `mode=dev` the result keeps the secure device defaults (auth on, an
+ * ephemeral port), and `auth=off` is ignored with a warning. `mode=dev` selects the dev backend: `deviceMode: false`,
+ * `auth: false`, `port: 8080`, each overridable by a token. Returns `{}` when
+ * no labeled tokens are present.
  */
-declare function resolveCliConfig(argv?: readonly string[]): WorkletRuntimeOptions;
-type WorkletRuntimeOptions = {
+export declare function resolveCliConfig(argv?: readonly string[]): WorkletRuntimeOptions;
+export type WorkletRuntimeOptions = {
   /** Directory to serve at `/` (the built web app). */
   webAssets?: string;
   /** Durable app-sandbox directory: `handoff.json` + the p2p corestore. */
@@ -81,25 +76,59 @@ type WorkletRuntimeOptions = {
   /** Port to bind; `0` picks an ephemeral port (on-device). Defaults to an
    * ephemeral port in device mode, 8080 in dev mode. */
   port?: number;
-  /** Require the per-session token/cookie. Defaults to on in device mode. */
+  /** Require the per-session token/cookie. Defaults to on in device mode and
+   * off in dev mode. The origin check applies either way. */
   auth?: boolean;
-  /** Explicit device-mode override. Defaults to on whenever `storage` is set
-   * (the on-device 3-arg contract); `resolveCliConfig` resolves it to false so
-   * a dev backend keeps auth off + fixed port even with a storage dir. */
+  /** Extra page origins allowed to call the loopback server, e.g. the Vite dev
+   * server (`http://localhost:5173`). The bound origin and its loopback
+   * aliases are always allowed. */
+  allowedOrigins?: readonly string[];
+  /** Write `{ origin, port, bootstrap }` to `<storage>/handoff.json` for the
+   * host to read (auth on only; the session token is never written). Defaults
+   * to true; a host that receives them over its own channel (the desktop host
+   * reads them from a pipe) sets false so nothing touches disk. */
+  handoffFile?: boolean;
+  /** Device mode (the default): auth on, an ephemeral port, and the handoff
+   * file when `storage` is set. Pass `false` (or the `mode=dev` CLI token) for
+   * the dev backend: auth off and port 8080 unless set explicitly. */
   deviceMode?: boolean;
   /** Additional plugin manifests to register after the canonical defaults
    * (consumer product plugins, e.g. `app.photos`). */
   plugins?: PluginManifest[];
   /** Idle timeout (ms) after which an authenticated WebSocket is dropped. */
   wsIdleTimeoutMs?: number;
+  /** Dead-peer timeout (ms): a protocol socket that answers no ping within it
+   * is destroyed, freeing the slot. Defaults to 10s. */
+  wsDeadPeerTimeoutMs?: number;
+  /** Minimum gap (ms) before an accepted protocol socket may be replaced by a
+   * new authenticated one; an upgrade that arrives sooner is held until then.
+   * Defaults to 1s. */
+  wsReplaceMinIntervalMs?: number;
+  /** Bytes queued behind a protocol socket whose reader stopped reading before
+   * server pushes are dropped (newest first). Defaults to 2 MiB. */
+  wsMaxQueuedBytes?: number;
+  /** Ring capacity for the `core.logs` capture store (retention knob; the
+   * rotating file sink is a consumer/app decision). Defaults to 500. */
+  logsCapacity?: number;
+  /** Global cap on calls routed at once; calls over it fail with a
+   * `TRANSPORT_ERROR`. Defaults to 64. */
+  maxInflight?: number;
+  /** Plugin ids whose calls must run one at a time, in arrival order. All
+   * other plugins run concurrently, so one slow call never blocks the rest. */
+  serialPlugins?: readonly string[];
+  /** Lowest level the `core.logs` capture store records (`debug` | `info` |
+   * `warn` | `error`). Lower-level console calls still reach stdout. Defaults
+   * to `debug` (record everything); raise it to stop routine debug traces
+   * from evicting warnings out of a small ring. */
+  logsMinLevel?: 'debug' | 'info' | 'warn' | 'error';
 };
-type WorkletRuntimeConfig = {
+export type WorkletRuntimeConfig = {
   webAssets?: string;
   storage?: string;
   cache?: string;
   deviceMode: boolean;
 };
-interface WorkletRuntime {
+export interface WorkletRuntime {
   protocol: MessageProtocol;
   pluginRegistry: ReturnType<typeof createPluginRegistry>;
   pluginRouter: ReturnType<typeof createPluginRouter>;
@@ -112,6 +141,7 @@ interface WorkletRuntime {
     origin: string;
     port: number;
     token: string;
+    bootstrap: string;
   }>;
   close(cb?: (err?: Error | null) => void): void;
 }
@@ -121,6 +151,5 @@ interface WorkletRuntime {
  * N of them and a consumer worklet entry can be just "register plugins +
  * wire p2p". Mirrors the reference wiring in `core/main.core.ts`.
  */
-declare function createWorkletRuntime(options?: WorkletRuntimeOptions): WorkletRuntime;
-//#endregion
-export { type LoopbackPush, type LoopbackRouteHandler, type LoopbackServer, WorkletRuntime, WorkletRuntimeConfig, WorkletRuntimeOptions, attachWebSocketProtocol, collectRequestBody, createLoopbackPush, createLoopbackServer, createWorkletRuntime, getIPC, resolveCliConfig, resolveWorkletConfig };
+export declare function createWorkletRuntime(options?: WorkletRuntimeOptions): WorkletRuntime;
+export { type LoopbackPush, type LoopbackRouteHandler, type LoopbackServer, collectRequestBody, createLoopbackServer };