@riebeckite/runtime 0.0.0-stage → 0.0.36

package/dist/client.js

@@ -0,0 +1,1343 @@
+// src/core/errors.ts
+var RuntimeError = class extends Error {
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RuntimeError";
+  }
+};
+var RuntimeStateError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeStateError";
+  }
+};
+var RuntimeFailureError = class extends RuntimeStateError {
+  constructor(message, options) {
+    super(message);
+    this.name = "RuntimeFailureError";
+    if (options?.cause !== void 0) this.cause = options.cause;
+  }
+};
+var RuntimeAbortError = class extends RuntimeError {
+  constructor(message = "Interactive runtime operation was aborted.") {
+    super(message);
+    this.name = "RuntimeAbortError";
+  }
+};
+var RuntimeTimeoutError = class extends RuntimeError {
+  constructor(message = "Interactive runtime operation timed out.") {
+    super(message);
+    this.name = "RuntimeTimeoutError";
+  }
+};
+var RuntimePayloadError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimePayloadError";
+  }
+};
+var RuntimeConcurrencyError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeConcurrencyError";
+  }
+};
+var RuntimeWorkerError = class extends RuntimeError {
+  remoteName;
+  remoteKind;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RuntimeWorkerError";
+    this.remoteName = options?.remoteName;
+    this.remoteKind = options?.remoteKind;
+  }
+};
+var RuntimeWasmError = class extends RuntimeError {
+  trap;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RuntimeWasmError";
+    this.trap = options?.trap ?? false;
+  }
+};
+var RuntimeIframeError = class extends RuntimeError {
+  remoteKind;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RuntimeIframeError";
+    this.remoteKind = options?.remoteKind;
+  }
+};
+var RuntimeUnsupportedError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeUnsupportedError";
+  }
+};
+
+// src/core/abort.ts
+var knownReasonTypes = [
+  RuntimeAbortError,
+  RuntimeTimeoutError,
+  RuntimeWasmError,
+  RuntimeWorkerError,
+  RuntimeIframeError,
+  RuntimeFailureError
+];
+function abortReasonToError(signal) {
+  const reason = signal.reason;
+  if (reason instanceof Error) {
+    for (const type of knownReasonTypes) {
+      if (reason instanceof type) return reason;
+    }
+    if (reason.message) return new RuntimeAbortError(reason.message);
+  }
+  return new RuntimeAbortError();
+}
+
+// src/core/outcome.ts
+var RuntimeTransfer = class {
+  constructor(value, transfer = []) {
+    this.value = value;
+    this.transfer = transfer;
+  }
+  value;
+  transfer;
+};
+function transferOutput(value, transfer = []) {
+  return new RuntimeTransfer(value, transfer);
+}
+function isRuntimeTransfer(value) {
+  return value instanceof RuntimeTransfer;
+}
+
+// src/core/payload.ts
+var MAX_DEPTH = 16;
+var MAX_ENTRIES = 1e5;
+var encoder = new TextEncoder();
+function estimatePayloadSize(value) {
+  return estimate(value, 0, { entries: 0 }, /* @__PURE__ */ new WeakSet());
+}
+function assertPayloadSize(value, limit, label) {
+  if (limit <= 0) return;
+  const size = estimatePayloadSize(value);
+  if (size > limit) {
+    throw new RuntimePayloadError(
+      `${label} is ${size} bytes, exceeding the ${limit} byte runtime limit.`
+    );
+  }
+}
+function estimate(value, depth, counter, ancestors) {
+  counter.entries += 1;
+  if (counter.entries > MAX_ENTRIES) {
+    throw new RuntimePayloadError(
+      "Runtime payload contains too many entries to measure."
+    );
+  }
+  if (value === void 0 || value === null) return 0;
+  if (typeof value === "string") return encoder.encode(value).byteLength;
+  if (typeof value === "number") return 8;
+  if (typeof value === "boolean") return 1;
+  if (typeof value === "bigint") return 16;
+  if (typeof value === "function" || typeof value === "symbol") {
+    throw new RuntimePayloadError(
+      "Runtime payload is not structured-cloneable."
+    );
+  }
+  if (value instanceof ArrayBuffer) return value.byteLength;
+  if (ArrayBuffer.isView(value)) return value.byteLength;
+  if (value instanceof Date) return 8;
+  if (depth >= MAX_DEPTH) {
+    throw new RuntimePayloadError("Runtime payload is nested too deeply.");
+  }
+  const objectValue = value;
+  if (ancestors.has(objectValue)) {
+    throw new RuntimePayloadError("Runtime payload must not contain cycles.");
+  }
+  ancestors.add(objectValue);
+  let total = 0;
+  if (value instanceof Map) {
+    for (const [key, item] of value) {
+      total += estimate(key, depth + 1, counter, ancestors);
+      total += estimate(item, depth + 1, counter, ancestors);
+    }
+  } else if (value instanceof Set) {
+    for (const item of value) {
+      total += estimate(item, depth + 1, counter, ancestors);
+    }
+  } else if (Array.isArray(value)) {
+    for (const item of value) {
+      total += estimate(item, depth + 1, counter, ancestors);
+    }
+  } else {
+    for (const key of Object.keys(value)) {
+      total += encoder.encode(key).byteLength;
+      total += estimate(
+        value[key],
+        depth + 1,
+        counter,
+        ancestors
+      );
+    }
+  }
+  ancestors.delete(objectValue);
+  return total;
+}
+
+// src/core/instance.ts
+var instanceCounter = 0;
+var RuntimeInstance = class {
+  id;
+  instanceId;
+  kind;
+  capabilities;
+  driver;
+  controller = new AbortController();
+  listeners = /* @__PURE__ */ new Set();
+  active = /* @__PURE__ */ new Set();
+  limits;
+  onError;
+  currentState = "created";
+  requestCount = 0;
+  mountPromise;
+  disposePromise;
+  stopPromise;
+  failure;
+  constructor(definition, options) {
+    this.id = definition.id;
+    this.instanceId = createInstanceId(definition.id);
+    this.kind = definition.kind;
+    this.capabilities = definition.capabilities;
+    this.limits = resolveLimits(definition.limits);
+    this.onError = options.onError ?? defaultErrorReporter;
+    this.driver = definition.create({
+      instanceId: this.instanceId,
+      signal: this.controller.signal,
+      limits: this.limits,
+      root: options.root
+    });
+    if (options.signal?.aborted) {
+      void this.dispose();
+    } else {
+      options.signal?.addEventListener("abort", () => void this.dispose(), {
+        once: true
+      });
+    }
+  }
+  get state() {
+    return this.currentState;
+  }
+  get signal() {
+    return this.controller.signal;
+  }
+  onStateChange(listener) {
+    this.listeners.add(listener);
+    return () => this.listeners.delete(listener);
+  }
+  mount() {
+    if (this.disposePromise) {
+      return Promise.reject(this.disposedError());
+    }
+    if (this.mountPromise) return this.mountPromise;
+    if (this.currentState !== "created") {
+      return Promise.reject(
+        new RuntimeStateError(
+          `Cannot mount runtime "${this.id}" from state "${this.currentState}".`
+        )
+      );
+    }
+    this.mountPromise = this.runStart();
+    return this.mountPromise;
+  }
+  async invoke(input, options = {}) {
+    if (this.currentState === "failed") {
+      throw new RuntimeFailureError(
+        `Runtime "${this.id}" failed and cannot be reused; create a new instance.`,
+        { cause: this.failure }
+      );
+    }
+    if (this.currentState !== "ready" && this.currentState !== "running") {
+      throw new RuntimeStateError(
+        `Cannot invoke runtime "${this.id}" from state "${this.currentState}".`
+      );
+    }
+    if (this.active.size >= this.limits.maxConcurrent) {
+      throw new RuntimeConcurrencyError(
+        `Runtime "${this.id}" rejected an invocation: ${this.active.size} requests are already in flight.`
+      );
+    }
+    if (options.signal?.aborted) throw abortReasonToError(options.signal);
+    if (options.capability && !this.capabilities.includes(options.capability)) {
+      throw new RuntimeStateError(
+        `Runtime "${this.id}" does not declare the "${options.capability}" capability.`
+      );
+    }
+    assertPayloadSize(input, this.limits.maxInputBytes, "Runtime input");
+    const requestId = ++this.requestCount;
+    const call = new AbortController();
+    const unlinkInstance = linkSignal(this.controller.signal, call);
+    const unlinkExternal = options.signal ? linkSignal(options.signal, call) : () => {
+    };
+    const timeoutMs = options.timeoutMs ?? this.limits.invokeTimeoutMs;
+    const timer = timeoutMs > 0 ? setTimeout(
+      () => call.abort(
+        new RuntimeTimeoutError(
+          `Runtime "${this.id}" invocation timed out after ${timeoutMs}ms.`
+        )
+      ),
+      timeoutMs
+    ) : void 0;
+    this.active.add(requestId);
+    this.transition("running");
+    try {
+      const pending = Promise.resolve(
+        this.driver.invoke(input, {
+          signal: call.signal,
+          requestId,
+          capability: options.capability,
+          transfer: options.transfer
+        })
+      );
+      const raw = await awaitWithSignal(pending, call.signal);
+      const output = isRuntimeTransfer(raw) ? raw.value : raw;
+      assertPayloadSize(output, this.limits.maxOutputBytes, "Runtime output");
+      return output;
+    } catch (error) {
+      if (error instanceof RuntimeFailureError) {
+        this.failure = error;
+        if (this.currentState === "running") this.transition("failed");
+        this.report(error, "invoke");
+      }
+      throw error;
+    } finally {
+      if (timer !== void 0) clearTimeout(timer);
+      unlinkExternal();
+      unlinkInstance();
+      this.active.delete(requestId);
+      if (this.active.size === 0 && this.currentState === "running") {
+        this.transition("ready");
+      }
+    }
+  }
+  dispose() {
+    if (this.disposePromise) return this.disposePromise;
+    if (this.currentState === "disposed") return Promise.resolve();
+    this.disposePromise = this.runStop();
+    return this.disposePromise;
+  }
+  async runStart() {
+    this.transition("starting");
+    try {
+      const start = Promise.resolve(this.driver.start());
+      await awaitWithSignal(
+        withTimeout(
+          start,
+          this.limits.startTimeoutMs,
+          `Runtime "${this.id}" start timed out.`
+        ),
+        this.controller.signal
+      );
+      if (this.currentState !== "starting") {
+        throw this.disposedError();
+      }
+      this.transition("ready");
+    } catch (error) {
+      this.failure = error;
+      if (this.currentState === "starting") this.transition("failed");
+      this.report(error, "start");
+      await this.stopDriver();
+      throw error;
+    }
+  }
+  async runStop() {
+    if (this.currentState !== "disposed") this.transition("stopping");
+    this.controller.abort(new RuntimeAbortError("Runtime was disposed."));
+    await this.mountPromise?.catch(() => {
+    });
+    await this.stopDriver();
+    if (this.currentState !== "disposed") this.transition("disposed");
+    this.listeners.clear();
+  }
+  stopDriver() {
+    this.stopPromise ??= (async () => {
+      try {
+        await this.driver.stop();
+      } catch (error) {
+        this.report(error, "stop");
+      }
+    })();
+    return this.stopPromise;
+  }
+  disposedError() {
+    return new RuntimeAbortError(`Runtime "${this.id}" was disposed.`);
+  }
+  transition(state) {
+    const previous = this.currentState;
+    if (previous === state) return;
+    this.currentState = state;
+    const change = { previous, state };
+    for (const listener of this.listeners) {
+      try {
+        listener(change);
+      } catch (error) {
+        this.report(error, "state-change");
+      }
+    }
+  }
+  report(error, phase) {
+    try {
+      this.onError(error, phase);
+    } catch {
+      return;
+    }
+  }
+};
+function resolveLimits(limits) {
+  return {
+    maxInputBytes: limits.maxInputBytes ?? 4 * 1024 * 1024,
+    maxOutputBytes: limits.maxOutputBytes ?? 16 * 1024 * 1024,
+    maxConcurrent: limits.maxConcurrent ?? 16,
+    invokeTimeoutMs: limits.invokeTimeoutMs ?? 0,
+    startTimeoutMs: limits.startTimeoutMs ?? 15e3
+  };
+}
+function createInstanceId(id) {
+  const random = globalThis.crypto?.randomUUID?.();
+  if (random) return `${id}#${random}`;
+  instanceCounter += 1;
+  return `${id}#${Date.now().toString(36)}-${instanceCounter}`;
+}
+function linkSignal(parent, child) {
+  if (parent.aborted) {
+    child.abort(parent.reason);
+    return () => {
+    };
+  }
+  const listener = () => child.abort(parent.reason);
+  parent.addEventListener("abort", listener, { once: true });
+  return () => parent.removeEventListener("abort", listener);
+}
+function abortFrom(signal) {
+  return abortReasonToError(signal);
+}
+function awaitWithSignal(promise, signal) {
+  if (signal.aborted) {
+    void promise.catch(() => {
+    });
+    return Promise.reject(abortFrom(signal));
+  }
+  return new Promise((resolve, reject) => {
+    const onAbort = () => {
+      cleanup();
+      reject(abortFrom(signal));
+    };
+    const cleanup = () => signal.removeEventListener("abort", onAbort);
+    signal.addEventListener("abort", onAbort, { once: true });
+    promise.then(
+      (value) => {
+        cleanup();
+        resolve(value);
+      },
+      (error) => {
+        cleanup();
+        reject(error);
+      }
+    );
+  });
+}
+function withTimeout(promise, timeoutMs, message) {
+  if (timeoutMs <= 0) return promise;
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(
+      () => reject(new RuntimeTimeoutError(message)),
+      timeoutMs
+    );
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (error) => {
+        clearTimeout(timer);
+        reject(error);
+      }
+    );
+  });
+}
+function defaultErrorReporter(error, phase) {
+  if (error instanceof RuntimeAbortError) return;
+  console.error(`[riebeckite] Interactive runtime ${phase} failed.`, error);
+}
+
+// src/core/protocol.ts
+var RUNTIME_PROTOCOL = "riebeckite:runtime";
+var RUNTIME_PROTOCOL_VERSION = 1;
+var RUNTIME_MESSAGE_KINDS = [
+  "init",
+  "invoke",
+  "cancel",
+  "ready",
+  "result",
+  "error",
+  "fatal",
+  "dispose"
+];
+function isRuntimeMessage(value) {
+  if (!value || typeof value !== "object") return false;
+  const message = value;
+  if (message.protocol !== RUNTIME_PROTOCOL) return false;
+  if (message.version !== RUNTIME_PROTOCOL_VERSION) return false;
+  if (typeof message.instanceId !== "string") return false;
+  return RUNTIME_MESSAGE_KINDS.includes(message.kind);
+}
+function serializeRuntimeError(error) {
+  if (error instanceof Error) {
+    const details = error;
+    return {
+      name: error.name,
+      message: error.message,
+      kind: typeof details.kind === "string" ? details.kind : void 0,
+      trap: details.trap === true,
+      stack: error.stack
+    };
+  }
+  return {
+    name: "Error",
+    message: typeof error === "string" ? error : "Unknown runtime error."
+  };
+}
+
+// src/core/registry.ts
+var InteractiveRuntimeRegistry = class {
+  definitions = /* @__PURE__ */ new Map();
+  register(definition) {
+    if (this.definitions.has(definition.id)) {
+      throw new RuntimeStateError(
+        `Interactive runtime "${definition.id}" is already registered.`
+      );
+    }
+    this.definitions.set(
+      definition.id,
+      definition
+    );
+  }
+  has(id) {
+    return this.definitions.has(id);
+  }
+  get(id) {
+    const definition = this.definitions.get(id);
+    if (!definition) {
+      throw new RuntimeStateError(
+        `Interactive runtime "${id}" is not registered.`
+      );
+    }
+    return definition;
+  }
+  get ids() {
+    return [...this.definitions.keys()];
+  }
+  create(id, options = {}) {
+    return new RuntimeInstance(this.get(id), options);
+  }
+};
+function defineInteractiveRuntime(definition) {
+  if (!definition.id.trim()) {
+    throw new RuntimeStateError("Interactive runtime id must not be empty.");
+  }
+  const capabilities = [...definition.capabilities ?? []];
+  if (new Set(capabilities).size !== capabilities.length) {
+    throw new RuntimeStateError(
+      `Interactive runtime "${definition.id}" declares duplicate capabilities.`
+    );
+  }
+  return Object.freeze({
+    id: definition.id,
+    kind: definition.kind,
+    capabilities: Object.freeze(capabilities),
+    limits: Object.freeze({ ...definition.limits ?? {} }),
+    create: definition.create
+  });
+}
+function createInteractiveRuntime(definition, options = {}) {
+  return new RuntimeInstance(definition, options);
+}
+
+// src/core/types.ts
+var RUNTIME_KINDS = [
+  "main",
+  "worker",
+  "wasm-worker",
+  "iframe"
+];
+var RUNTIME_STATES = [
+  "created",
+  "starting",
+  "ready",
+  "running",
+  "stopping",
+  "disposed",
+  "failed"
+];
+var RUNTIME_CAPABILITIES = [
+  "dom",
+  "worker",
+  "wasm",
+  "network",
+  "message"
+];
+
+// src/client/errors.ts
+function runtimeErrorFromWire(error, fallbackMessage) {
+  if (!error) return new RuntimeWorkerError(fallbackMessage);
+  const message = error.message || fallbackMessage;
+  switch (error.name) {
+    case "RuntimeAbortError":
+      return new RuntimeAbortError(message);
+    case "RuntimeTimeoutError":
+      return new RuntimeTimeoutError(message);
+    case "RuntimePayloadError":
+      return new RuntimePayloadError(message);
+    case "RuntimeConcurrencyError":
+      return new RuntimeConcurrencyError(message);
+    case "RuntimeUnsupportedError":
+      return new RuntimeUnsupportedError(message);
+    case "RuntimeWasmError":
+      return new RuntimeWasmError(message, { trap: error.trap === true });
+    case "RuntimeFailureError":
+      return new RuntimeFailureError(message);
+    case "RuntimeStateError":
+      return new RuntimeStateError(message);
+    case "RuntimeIframeError":
+      return new RuntimeIframeError(message, { remoteKind: error.kind });
+    default:
+      return new RuntimeWorkerError(message, {
+        remoteName: error.name,
+        remoteKind: error.kind
+      });
+  }
+}
+
+// src/client/fallback.ts
+var FALLBACK_SELECTOR = "[data-runtime-fallback]";
+var LOADING_SELECTOR = "[data-runtime-loading]";
+var ERROR_SELECTOR = "[data-runtime-error]";
+function createRuntimeFallback(root) {
+  if (typeof Element === "undefined" || !(root instanceof Element)) {
+    throw new RuntimeUnsupportedError(
+      "A runtime fallback requires a DOM element and must not be created during SSR."
+    );
+  }
+  const fallback = root.querySelector(FALLBACK_SELECTOR);
+  const loading = root.querySelector(LOADING_SELECTOR);
+  const error = root.querySelector(ERROR_SELECTOR);
+  const setBusy = (busy) => {
+    if (busy) {
+      root.setAttribute("aria-busy", "true");
+    } else {
+      root.removeAttribute("aria-busy");
+    }
+  };
+  return {
+    showLoading() {
+      if (fallback) fallback.hidden = true;
+      if (loading) loading.hidden = false;
+      if (error) error.hidden = true;
+      setBusy(true);
+    },
+    showReady() {
+      if (fallback) fallback.hidden = true;
+      if (loading) loading.hidden = true;
+      if (error) error.hidden = true;
+      setBusy(false);
+    },
+    showError(cause) {
+      if (fallback) fallback.hidden = false;
+      if (loading) loading.hidden = true;
+      if (error) {
+        error.hidden = false;
+        error.textContent = cause instanceof Error ? cause.message : String(cause);
+      }
+      setBusy(false);
+    },
+    reset() {
+      if (fallback) fallback.hidden = false;
+      if (loading) loading.hidden = true;
+      if (error) {
+        error.hidden = true;
+        error.textContent = "";
+      }
+      setBusy(false);
+    }
+  };
+}
+
+// src/client/host.ts
+function createClientRuntimeHost(options) {
+  const instances = /* @__PURE__ */ new Set();
+  let disposed = false;
+  return {
+    has(id) {
+      return options.registry.has(id);
+    },
+    ids() {
+      return options.registry.ids;
+    },
+    create(id, createOptions = {}) {
+      if (disposed) {
+        throw new RuntimeStateError(
+          `Client runtime host is disposed; cannot create "${id}".`
+        );
+      }
+      const instance = options.registry.create(id, {
+        root: createOptions.root ?? options.root,
+        signal: createOptions.signal ?? options.signal,
+        onError: options.onError
+      });
+      instances.add(instance);
+      return instance;
+    },
+    async dispose() {
+      if (disposed) return;
+      disposed = true;
+      await Promise.allSettled(
+        [...instances].map((instance) => instance.dispose())
+      );
+      instances.clear();
+    }
+  };
+}
+
+// src/client/iframe.ts
+var IFRAME_PROTOCOL = "riebeckite:iframe";
+var IFRAME_PROTOCOL_VERSION = 1;
+var MAX_ACTIVE_IFRAMES = 4;
+var DEFAULT_CSP = "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; img-src data: blob:; media-src data: blob:; font-src data:; connect-src 'none'; form-action 'none'; base-uri 'none'";
+var ALLOWED_SANDBOX_TOKENS = /* @__PURE__ */ new Set(["allow-scripts", "allow-forms"]);
+var activeIframes = 0;
+function createIframeRuntime(options) {
+  return defineInteractiveRuntime({
+    id: options.id,
+    kind: "iframe",
+    capabilities: options.capabilities ?? ["message"],
+    limits: {
+      ...options.limits,
+      invokeTimeoutMs: options.limits?.invokeTimeoutMs ?? 1e4
+    },
+    create(context) {
+      let iframe;
+      let sessionId;
+      let readySeen = false;
+      let readyResolve;
+      let readyReject;
+      let started = false;
+      let stopped = false;
+      let failed;
+      let counted = false;
+      const pending = /* @__PURE__ */ new Map();
+      const expectedOrigin = options.expectedOrigin ?? "null";
+      const targetOrigin = expectedOrigin === "null" ? "*" : expectedOrigin;
+      const fail = (error, message) => {
+        const failure = error instanceof RuntimeFailureError ? error : new RuntimeFailureError(message, { cause: error });
+        failed = failure;
+        readyReject?.(failure);
+        for (const request of pending.values()) {
+          request.unlink();
+          request.reject(failure);
+        }
+        pending.clear();
+        cleanup();
+      };
+      const takePending2 = (requestId) => {
+        if (requestId === void 0) return void 0;
+        const request = pending.get(requestId);
+        if (!request) return void 0;
+        pending.delete(requestId);
+        request.unlink();
+        return request;
+      };
+      const onMessage = (event) => {
+        if (!iframe || event.source !== iframe.contentWindow) return;
+        if (event.origin !== expectedOrigin) return;
+        const message = event.data;
+        if (!message || typeof message !== "object") return;
+        if (message.protocol !== IFRAME_PROTOCOL) return;
+        if (message.version !== IFRAME_PROTOCOL_VERSION) return;
+        if (!sessionId || message.sessionId !== sessionId) return;
+        switch (message.kind) {
+          case "ready":
+            if (!readySeen) {
+              readySeen = true;
+              readyResolve?.();
+            }
+            break;
+          case "result": {
+            const request = takePending2(message.requestId);
+            if (!request) return;
+            const transfer = message.transfer;
+            request.resolve(
+              transfer && transfer.length > 0 ? transferOutput(message.payload, transfer) : message.payload
+            );
+            break;
+          }
+          case "error": {
+            const request = takePending2(message.requestId);
+            if (!request) return;
+            request.reject(
+              runtimeErrorFromWire(
+                message.error,
+                `Iframe runtime "${options.id}" request failed.`
+              )
+            );
+            break;
+          }
+          default:
+            return;
+        }
+      };
+      const onLoad = () => {
+        if (!iframe) return;
+        if (readySeen) {
+          fail(
+            new RuntimeIframeError(
+              `Iframe runtime "${options.id}" navigated unexpectedly.`
+            ),
+            `Iframe runtime "${options.id}" navigated unexpectedly.`
+          );
+          return;
+        }
+        if (!sessionId) return;
+        iframe.contentWindow?.postMessage(
+          {
+            protocol: IFRAME_PROTOCOL,
+            version: IFRAME_PROTOCOL_VERSION,
+            sessionId,
+            kind: "init"
+          },
+          targetOrigin
+        );
+      };
+      const start = () => {
+        if (typeof document === "undefined" || typeof window === "undefined") {
+          throw new RuntimeUnsupportedError(
+            `Iframe runtime "${options.id}" requires a browser DOM.`
+          );
+        }
+        if (activeIframes >= MAX_ACTIVE_IFRAMES) {
+          throw new RuntimeConcurrencyError(
+            `Iframe runtime "${options.id}" cannot start: ${MAX_ACTIVE_IFRAMES} iframe runtimes are already active.`
+          );
+        }
+        const sandbox = resolveSandbox(options.sandbox, options.id);
+        const container = resolveContainer(options.container, context.root);
+        if (!container) {
+          throw new RuntimeUnsupportedError(
+            `Iframe runtime "${options.id}" has no document body to mount into.`
+          );
+        }
+        const ready = new Promise((resolve, reject) => {
+          readyResolve = resolve;
+          readyReject = reject;
+        });
+        sessionId = createSessionId();
+        iframe = document.createElement("iframe");
+        iframe.setAttribute("sandbox", sandbox.join(" "));
+        iframe.setAttribute("referrerpolicy", "no-referrer");
+        iframe.setAttribute("title", options.title ?? "Interactive runtime");
+        iframe.setAttribute(
+          "style",
+          "width:100%;height:100%;border:0;display:block"
+        );
+        iframe.srcdoc = buildDocument({
+          html: options.html,
+          title: options.title ?? "Interactive runtime",
+          csp: options.csp ?? DEFAULT_CSP,
+          sessionId
+        });
+        iframe.addEventListener("load", onLoad);
+        window.addEventListener("message", onMessage);
+        activeIframes += 1;
+        counted = true;
+        try {
+          container.appendChild(iframe);
+        } catch (error) {
+          cleanup();
+          throw error;
+        }
+        started = true;
+        return ready;
+      };
+      const invoke = (input, requestContext) => {
+        if (failed) return Promise.reject(failed);
+        if (stopped) {
+          return Promise.reject(
+            new RuntimeAbortError(
+              `Iframe runtime "${options.id}" was disposed.`
+            )
+          );
+        }
+        if (!started || !iframe) {
+          return Promise.reject(
+            new RuntimeStateError(
+              `Iframe runtime "${options.id}" is not started.`
+            )
+          );
+        }
+        const { signal, requestId } = requestContext;
+        if (signal.aborted) {
+          return Promise.reject(abortReasonToError(signal));
+        }
+        return new Promise(
+          (resolve, reject) => {
+            const onAbort = () => {
+              post({ kind: "cancel", requestId });
+              takePending2(requestId);
+              reject(abortReasonToError(signal));
+            };
+            const unlink = () => signal.removeEventListener("abort", onAbort);
+            pending.set(requestId, { resolve, reject, unlink });
+            signal.addEventListener("abort", onAbort, { once: true });
+            try {
+              post(
+                {
+                  kind: "invoke",
+                  requestId,
+                  capability: requestContext.capability,
+                  payload: input
+                },
+                requestContext.transfer
+              );
+            } catch (error) {
+              takePending2(requestId);
+              reject(error);
+            }
+          }
+        );
+      };
+      const post = (message, transfer) => {
+        if (!iframe?.contentWindow || !sessionId) return;
+        iframe.contentWindow.postMessage(
+          {
+            protocol: IFRAME_PROTOCOL,
+            version: IFRAME_PROTOCOL_VERSION,
+            sessionId,
+            ...message
+          },
+          targetOrigin,
+          transfer ? [...transfer] : void 0
+        );
+      };
+      const cleanup = () => {
+        window.removeEventListener("message", onMessage);
+        if (iframe) {
+          iframe.removeEventListener("load", onLoad);
+          iframe.remove();
+          iframe = void 0;
+        }
+        if (counted) {
+          counted = false;
+          activeIframes = Math.max(0, activeIframes - 1);
+        }
+      };
+      const stop = () => {
+        if (stopped) return;
+        stopped = true;
+        const error = new RuntimeAbortError(
+          `Iframe runtime "${options.id}" was disposed.`
+        );
+        for (const request of pending.values()) {
+          request.unlink();
+          request.reject(error);
+        }
+        pending.clear();
+        readyReject?.(error);
+        cleanup();
+        started = false;
+      };
+      return { start, invoke, stop };
+    }
+  });
+}
+function resolveSandbox(tokens, id) {
+  const sandbox = [...tokens ?? ["allow-scripts"]];
+  if (!sandbox.includes("allow-scripts")) {
+    throw new RuntimeIframeError(
+      `Iframe runtime "${id}" requires the "allow-scripts" sandbox token.`
+    );
+  }
+  for (const token of sandbox) {
+    if (!ALLOWED_SANDBOX_TOKENS.has(token)) {
+      throw new RuntimeIframeError(
+        `Iframe runtime "${id}" rejects the "${token}" sandbox token.`
+      );
+    }
+  }
+  if (sandbox.includes("allow-scripts") && sandbox.includes("allow-same-origin")) {
+    throw new RuntimeIframeError(
+      `Iframe runtime "${id}" must not combine "allow-scripts" with "allow-same-origin".`
+    );
+  }
+  return sandbox;
+}
+function resolveContainer(container, root) {
+  if (typeof container === "function") return container();
+  if (typeof container === "string") {
+    return document.querySelector(container);
+  }
+  if (container) return container;
+  if (root instanceof Element) return root;
+  return document.body;
+}
+function createSessionId() {
+  const random = globalThis.crypto?.randomUUID?.();
+  if (random) return random;
+  return `iframe-${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+}
+function buildDocument(options) {
+  return `<!doctype html><html><head><meta charset="utf-8"><meta http-equiv="Content-Security-Policy" content="${escapeAttribute(options.csp)}"><meta name="referrer" content="no-referrer"><title>${escapeHtml(options.title)}</title></head><body>${options.html}<script>${bridgeScript(options.sessionId)}</script></body></html>`;
+}
+function bridgeScript(sessionId) {
+  return `(function(){
+var session=${JSON.stringify(sessionId)};
+function send(message,transfer){
+message.protocol="riebeckite:iframe";message.version=1;message.sessionId=session;
+if(transfer&&transfer.length){window.parent.postMessage(message,"*",transfer);}
+else{window.parent.postMessage(message,"*");}
+}
+window.addEventListener("message",function(event){
+if(event.source!==window.parent)return;
+var data=event.data;
+if(!data||data.protocol!=="riebeckite:iframe"||data.version!==1||data.sessionId!==session)return;
+if(data.kind==="init"){
+window.dispatchEvent(new CustomEvent("riebeckite:iframe-init",{detail:data.payload}));
+send({kind:"ready"});
+}else if(data.kind==="invoke"){
+window.dispatchEvent(new CustomEvent("riebeckite:iframe-invoke",{detail:{requestId:data.requestId,payload:data.payload,capability:data.capability}}));
+}else if(data.kind==="cancel"){
+window.dispatchEvent(new CustomEvent("riebeckite:iframe-cancel",{detail:{requestId:data.requestId}}));
+}
+});
+window.riebeckiteIframe={
+result:function(requestId,payload){send({kind:"result",requestId:requestId,payload:payload});},
+transfer:function(requestId,payload,transfer){send({kind:"result",requestId:requestId,payload:payload,transfer:transfer},transfer);},
+error:function(requestId,error){send({kind:"error",requestId:requestId,error:{name:"RuntimeIframeError",message:String(error&&error.message?error.message:error)}});}
+};
+})();`;
+}
+function escapeAttribute(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;");
+}
+function escapeHtml(value) {
+  return escapeAttribute(value).replaceAll(">", "&gt;");
+}
+
+// src/client/main.ts
+function createMainRuntime(options) {
+  return defineInteractiveRuntime({
+    id: options.id,
+    kind: "main",
+    capabilities: options.capabilities ?? ["dom"],
+    limits: options.limits ?? {},
+    create(context) {
+      const runtimeContext = {
+        instanceId: context.instanceId,
+        signal: context.signal,
+        limits: context.limits,
+        root: context.root
+      };
+      return {
+        start: () => options.start?.(runtimeContext),
+        invoke: (input, invokeContext) => options.invoke(input, {
+          ...runtimeContext,
+          requestId: invokeContext.requestId,
+          capability: invokeContext.capability
+        }),
+        stop: () => options.stop?.(runtimeContext)
+      };
+    }
+  });
+}
+
+// src/client/worker.ts
+var MAX_ACTIVE_WORKERS = 8;
+var activeWorkers = 0;
+function createWorkerRuntime(options) {
+  return defineInteractiveRuntime({
+    id: options.id,
+    kind: options.kind ?? "worker",
+    capabilities: options.capabilities ?? ["worker", "message"],
+    limits: {
+      ...options.limits,
+      invokeTimeoutMs: options.limits?.invokeTimeoutMs ?? 3e4
+    },
+    create(context) {
+      let worker;
+      let readyResolve;
+      let readyReject;
+      let failed;
+      let stopped = false;
+      let counted = false;
+      const pending = /* @__PURE__ */ new Map();
+      const post = (message, transfer) => {
+        worker?.postMessage(message, transfer);
+      };
+      const base = {
+        protocol: RUNTIME_PROTOCOL,
+        version: RUNTIME_PROTOCOL_VERSION,
+        instanceId: context.instanceId
+      };
+      const fail = (error, message) => {
+        if (stopped) return;
+        const specific = error instanceof Error ? error : new RuntimeWorkerError(message);
+        const failure = specific instanceof RuntimeFailureError ? specific : new RuntimeFailureError(message, { cause: specific });
+        failed = failure;
+        readyReject?.(specific);
+        for (const request of pending.values()) {
+          request.unlink();
+          request.reject(failure);
+        }
+        pending.clear();
+        worker?.terminate();
+        worker = void 0;
+        if (counted) {
+          counted = false;
+          activeWorkers = Math.max(0, activeWorkers - 1);
+        }
+      };
+      const onMessage = (event) => {
+        const message = event.data;
+        if (!isRuntimeMessage(message)) return;
+        if (message.instanceId !== context.instanceId) return;
+        switch (message.kind) {
+          case "ready":
+            readyResolve?.();
+            break;
+          case "result": {
+            const request = takePending(pending, message.requestId);
+            if (!request) return;
+            try {
+              const value = options.mapResult ? options.mapResult(message.payload) : message.payload;
+              const transfer = message.transfer;
+              request.resolve(
+                transfer && transfer.length > 0 ? transferOutput(value, transfer) : value
+              );
+            } catch (error) {
+              request.reject(error);
+            }
+            break;
+          }
+          case "error": {
+            const request = takePending(pending, message.requestId);
+            const error = runtimeErrorFromWire(
+              message.error,
+              `Worker runtime "${options.id}" request failed.`
+            );
+            if (request) request.reject(error);
+            else if (error instanceof RuntimeFailureError)
+              fail(error, error.message);
+            break;
+          }
+          case "fatal": {
+            const error = runtimeErrorFromWire(
+              message.error,
+              `Worker runtime "${options.id}" failed.`
+            );
+            fail(error, error.message);
+            break;
+          }
+          default:
+            return;
+        }
+      };
+      const onError = (event) => {
+        const message = event.error instanceof Error ? event.error.message : event.message || `Worker runtime "${options.id}" crashed.`;
+        fail(event.error, message);
+      };
+      const onMessageError = () => {
+        fail(
+          void 0,
+          `Worker runtime "${options.id}" received an uncloneable message.`
+        );
+      };
+      const start = () => {
+        if (activeWorkers >= MAX_ACTIVE_WORKERS) {
+          throw new RuntimeConcurrencyError(
+            `Worker runtime "${options.id}" cannot start: ${MAX_ACTIVE_WORKERS} worker runtimes are already active.`
+          );
+        }
+        const ready = new Promise((resolve, reject) => {
+          readyResolve = resolve;
+          readyReject = reject;
+        });
+        worker = options.createWorker();
+        counted = true;
+        activeWorkers += 1;
+        worker.addEventListener("message", onMessage);
+        worker.addEventListener("error", onError);
+        worker.addEventListener("messageerror", onMessageError);
+        post(
+          {
+            ...base,
+            kind: "init",
+            payload: options.init,
+            limits: context.limits
+          },
+          options.initTransfer ? [...options.initTransfer] : void 0
+        );
+        return ready;
+      };
+      const invoke = (input, requestContext) => {
+        if (failed) return Promise.reject(failed);
+        if (stopped) {
+          return Promise.reject(
+            new RuntimeAbortError(
+              `Worker runtime "${options.id}" was disposed.`
+            )
+          );
+        }
+        if (!worker) {
+          return Promise.reject(
+            new RuntimeWorkerError(
+              `Worker runtime "${options.id}" is not started.`
+            )
+          );
+        }
+        const { signal, requestId } = requestContext;
+        if (signal.aborted) {
+          return Promise.reject(abortReasonToError(signal));
+        }
+        return new Promise(
+          (resolve, reject) => {
+            const onAbort = () => {
+              post({ ...base, kind: "cancel", requestId });
+              takePending(pending, requestId);
+              reject(abortReasonToError(signal));
+            };
+            const unlink = () => signal.removeEventListener("abort", onAbort);
+            pending.set(requestId, { resolve, reject, unlink });
+            signal.addEventListener("abort", onAbort, { once: true });
+            try {
+              post(
+                {
+                  ...base,
+                  kind: "invoke",
+                  requestId,
+                  capability: requestContext.capability,
+                  payload: options.invokePayload ? options.invokePayload(input) : input
+                },
+                requestContext.transfer ? [...requestContext.transfer] : void 0
+              );
+            } catch (error) {
+              takePending(pending, requestId);
+              reject(error);
+            }
+          }
+        );
+      };
+      const stop = () => {
+        if (stopped) return;
+        stopped = true;
+        const error = new RuntimeAbortError(
+          `Worker runtime "${options.id}" was disposed.`
+        );
+        for (const request of pending.values()) {
+          request.unlink();
+          request.reject(error);
+        }
+        pending.clear();
+        readyReject?.(error);
+        if (worker) {
+          try {
+            post({ ...base, kind: "dispose" });
+          } catch {
+          }
+          worker.removeEventListener("message", onMessage);
+          worker.removeEventListener("error", onError);
+          worker.removeEventListener("messageerror", onMessageError);
+          worker.terminate();
+          worker = void 0;
+          if (counted) {
+            counted = false;
+            activeWorkers = Math.max(0, activeWorkers - 1);
+          }
+        }
+      };
+      return {
+        start,
+        invoke,
+        stop
+      };
+    }
+  });
+}
+function takePending(pending, requestId) {
+  if (requestId === void 0) return void 0;
+  const request = pending.get(requestId);
+  if (!request) return void 0;
+  pending.delete(requestId);
+  request.unlink();
+  return request;
+}
+
+// src/client/wasm_worker.ts
+function createWasmWorkerRuntime(options) {
+  const capabilities = /* @__PURE__ */ new Set([
+    "worker",
+    "wasm",
+    "message",
+    ...options.capabilities ?? []
+  ]);
+  return createWorkerRuntime({
+    id: options.id,
+    kind: "wasm-worker",
+    capabilities: [...capabilities],
+    limits: options.limits,
+    createWorker: options.createWorker,
+    init: {
+      wasmUrl: options.wasmUrl,
+      exportName: options.exportName
+    },
+    invokePayload: (input) => input,
+    mapResult: (payload) => options.mapOutput ? options.mapOutput(payload) : payload
+  });
+}
+export {
+  IFRAME_PROTOCOL,
+  IFRAME_PROTOCOL_VERSION,
+  InteractiveRuntimeRegistry,
+  MAX_ACTIVE_IFRAMES,
+  MAX_ACTIVE_WORKERS,
+  RUNTIME_CAPABILITIES,
+  RUNTIME_KINDS,
+  RUNTIME_MESSAGE_KINDS,
+  RUNTIME_PROTOCOL,
+  RUNTIME_PROTOCOL_VERSION,
+  RUNTIME_STATES,
+  RuntimeAbortError,
+  RuntimeConcurrencyError,
+  RuntimeError,
+  RuntimeFailureError,
+  RuntimeIframeError,
+  RuntimeInstance,
+  RuntimePayloadError,
+  RuntimeStateError,
+  RuntimeTimeoutError,
+  RuntimeTransfer,
+  RuntimeUnsupportedError,
+  RuntimeWasmError,
+  RuntimeWorkerError,
+  assertPayloadSize,
+  createClientRuntimeHost,
+  createIframeRuntime,
+  createInteractiveRuntime,
+  createMainRuntime,
+  createRuntimeFallback,
+  createWasmWorkerRuntime,
+  createWorkerRuntime,
+  defineInteractiveRuntime,
+  estimatePayloadSize,
+  isRuntimeMessage,
+  isRuntimeTransfer,
+  runtimeErrorFromWire,
+  serializeRuntimeError,
+  transferOutput
+};