@riebeckite/runtime 0.0.0-stage → 0.0.37

package/dist/worker.js

@@ -0,0 +1,438 @@
+// 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 RuntimePayloadError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimePayloadError";
+  }
+};
+var RuntimeConcurrencyError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeConcurrencyError";
+  }
+};
+var RuntimeWasmError = class extends RuntimeError {
+  trap;
+  constructor(message, options) {
+    super(message, options);
+    this.name = "RuntimeWasmError";
+    this.trap = options?.trap ?? false;
+  }
+};
+var RuntimeUnsupportedError = class extends RuntimeError {
+  constructor(message) {
+    super(message);
+    this.name = "RuntimeUnsupportedError";
+  }
+};
+
+// src/core/outcome.ts
+var RuntimeTransfer = class {
+  constructor(value, transfer = []) {
+    this.value = value;
+    this.transfer = transfer;
+  }
+  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/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."
+  };
+}
+
+// worker.ts
+function serveWorkerRuntime(scope, handler) {
+  let instanceId;
+  let initialized = false;
+  let failed = false;
+  let disposed = false;
+  let limits = {};
+  const active = /* @__PURE__ */ new Map();
+  const post = (message, transfer) => {
+    scope.postMessage(message, transfer);
+  };
+  const fatal = (error) => {
+    failed = true;
+    post({
+      protocol: RUNTIME_PROTOCOL,
+      version: RUNTIME_PROTOCOL_VERSION,
+      instanceId: instanceId ?? "",
+      kind: "fatal",
+      error: serializeRuntimeError(error)
+    });
+  };
+  const onMessage = (event) => {
+    const message = event.data;
+    if (!isRuntimeMessage(message)) return;
+    if (disposed || failed) return;
+    if (message.kind === "init") {
+      if (initialized) return;
+      if (!message.instanceId) return;
+      instanceId = message.instanceId;
+      limits = message.limits ?? {};
+      void initialize(message).catch(fatal);
+      return;
+    }
+    if (!initialized || message.instanceId !== instanceId) return;
+    switch (message.kind) {
+      case "invoke":
+        void invokeMessage(message);
+        break;
+      case "cancel": {
+        if (message.requestId === void 0) return;
+        active.get(message.requestId)?.abort(
+          new RuntimeAbortError("Worker runtime request was cancelled.")
+        );
+        break;
+      }
+      case "dispose":
+        void dispose();
+        break;
+      default:
+        return;
+    }
+  };
+  const initialize = async (message) => {
+    try {
+      await handler.initialize?.(message.payload, {
+        instanceId: message.instanceId,
+        signal: new AbortController().signal
+      });
+      initialized = true;
+      post({
+        protocol: RUNTIME_PROTOCOL,
+        version: RUNTIME_PROTOCOL_VERSION,
+        instanceId: message.instanceId,
+        kind: "ready"
+      });
+    } catch (error) {
+      fatal(error);
+    }
+  };
+  const invokeMessage = async (message) => {
+    const requestId = message.requestId;
+    if (requestId === void 0 || active.has(requestId)) return;
+    const maxConcurrent = limits.maxConcurrent ?? 16;
+    if (active.size >= maxConcurrent) {
+      post({
+        protocol: RUNTIME_PROTOCOL,
+        version: RUNTIME_PROTOCOL_VERSION,
+        instanceId: instanceId ?? "",
+        kind: "error",
+        requestId,
+        error: serializeRuntimeError(
+          new RuntimeConcurrencyError(
+            `Worker runtime rejected a request: ${active.size} requests are already in flight.`
+          )
+        )
+      });
+      return;
+    }
+    const controller = new AbortController();
+    active.set(requestId, controller);
+    try {
+      const result = await handler.invoke(message.payload, {
+        instanceId: instanceId ?? "",
+        requestId,
+        signal: controller.signal,
+        capability: message.capability
+      });
+      if (controller.signal.aborted) return;
+      const value = isRuntimeTransfer(result) ? result.value : result;
+      assertPayloadSize(
+        value,
+        limits.maxOutputBytes ?? 16 * 1024 * 1024,
+        "Worker runtime output"
+      );
+      const transfer = isRuntimeTransfer(result) ? result.transfer : [];
+      post(
+        {
+          protocol: RUNTIME_PROTOCOL,
+          version: RUNTIME_PROTOCOL_VERSION,
+          instanceId: instanceId ?? "",
+          kind: "result",
+          requestId,
+          payload: value,
+          transfer: transfer.length > 0 ? transfer : void 0
+        },
+        transfer.length > 0 ? [...transfer] : void 0
+      );
+    } catch (error) {
+      if (controller.signal.aborted) return;
+      if (error instanceof RuntimeFailureError) {
+        fatal(error);
+        return;
+      }
+      post({
+        protocol: RUNTIME_PROTOCOL,
+        version: RUNTIME_PROTOCOL_VERSION,
+        instanceId: instanceId ?? "",
+        kind: "error",
+        requestId,
+        error: serializeRuntimeError(error)
+      });
+    } finally {
+      active.delete(requestId);
+    }
+  };
+  const abortAll = () => {
+    for (const controller of active.values()) {
+      controller.abort(new RuntimeAbortError("Worker runtime was disposed."));
+    }
+    active.clear();
+  };
+  const dispose = async () => {
+    if (disposed) return;
+    disposed = true;
+    abortAll();
+    try {
+      await handler.dispose?.();
+    } catch {
+      return;
+    } finally {
+      scope.removeEventListener("message", onMessage);
+      scope.close?.();
+    }
+  };
+  scope.addEventListener("message", onMessage);
+  return () => {
+    void dispose();
+  };
+}
+function serveWasmWorkerRuntime(scope, options = {}) {
+  let exportFunction;
+  let instance;
+  return serveWorkerRuntime(scope, {
+    async initialize(init) {
+      const config = parseWasmInit(init);
+      if (typeof WebAssembly === "undefined") {
+        throw new RuntimeUnsupportedError(
+          "This browser does not support WebAssembly."
+        );
+      }
+      const base = globalThis.location?.href ?? "http://localhost/";
+      const url = new URL(config.wasmUrl, base);
+      if (!options.allowCrossOrigin && url.origin !== new URL(base).origin) {
+        throw new RuntimeWasmError(
+          `WASM asset "${config.wasmUrl}" must be served from the same origin.`
+        );
+      }
+      const loaded = await loadWasm(url, options);
+      instance = loaded.instance;
+      const candidate = instance.exports[config.exportName];
+      if (typeof candidate !== "function") {
+        throw new RuntimeWasmError(
+          `WASM module does not export the "${config.exportName}" function.`
+        );
+      }
+      exportFunction = candidate;
+    },
+    invoke(input) {
+      if (!exportFunction) {
+        throw new RuntimeWasmError("WASM module is not initialized.");
+      }
+      const args = Array.isArray(input) ? input : [input];
+      try {
+        return Reflect.apply(exportFunction, void 0, args);
+      } catch (error) {
+        if (isWasmTrap(error)) {
+          throw new RuntimeWasmError("WASM module trapped during execution.", {
+            trap: true,
+            cause: error
+          });
+        }
+        throw error;
+      }
+    },
+    dispose() {
+      exportFunction = void 0;
+      instance = void 0;
+    }
+  });
+}
+async function loadWasm(url, options) {
+  const fetcher = options.fetch ?? globalThis.fetch;
+  if (!fetcher) {
+    throw new RuntimeUnsupportedError(
+      "Fetch is unavailable; the WASM asset cannot be loaded."
+    );
+  }
+  const imports = options.imports ?? {};
+  const response = await fetcher(url);
+  if (!response.ok) {
+    throw new RuntimeWasmError(
+      `WASM asset "${url.pathname}" responded with ${response.status}.`
+    );
+  }
+  if (options.streaming !== false && typeof WebAssembly.instantiateStreaming === "function") {
+    try {
+      return await WebAssembly.instantiateStreaming(response.clone(), imports);
+    } catch {
+    }
+  }
+  const bytes = await response.arrayBuffer();
+  try {
+    return await WebAssembly.instantiate(bytes, imports);
+  } catch (error) {
+    throw new RuntimeWasmError(
+      "WASM module could not be compiled; check the content type and CSP.",
+      { cause: error }
+    );
+  }
+}
+function parseWasmInit(init) {
+  if (!init || typeof init !== "object") {
+    throw new RuntimeWasmError("WASM runtime init payload is missing.");
+  }
+  const config = init;
+  if (typeof config.wasmUrl !== "string" || !config.wasmUrl) {
+    throw new RuntimeWasmError("WASM runtime init requires a wasmUrl.");
+  }
+  if (typeof config.exportName !== "string" || !config.exportName) {
+    throw new RuntimeWasmError("WASM runtime init requires an exportName.");
+  }
+  return { wasmUrl: config.wasmUrl, exportName: config.exportName };
+}
+function isWasmTrap(error) {
+  if (error instanceof Error && error.name === "RuntimeError") return true;
+  return typeof WebAssembly !== "undefined" && typeof WebAssembly.RuntimeError === "function" && error instanceof WebAssembly.RuntimeError;
+}
+export {
+  serveWasmWorkerRuntime,
+  serveWorkerRuntime
+};

package/package.json

@@ -1,6 +1,69 @@
 {
   "name": "@riebeckite/runtime",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.0.37",
+  "license": "Apache-2.0",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "source": "./index.ts",
+      "default": "./dist/index.js"
+    },
+    "./client": {
+      "types": "./dist/client.d.ts",
+      "import": "./dist/client.js",
+      "source": "./client.ts",
+      "default": "./dist/client.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js",
+      "source": "./worker.ts",
+      "default": "./dist/worker.js"
+    },
+    "./package.json": "./package.json"
+  },
+  "files": [
+    "LICENSE",
+    "README.md",
+    "README_ja.md",
+    "dist"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "@riebeckite/core": "0.0.37"
+  },
+  "devDependencies": {
+    "tsx": "^4.22.4"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Rerurate514/riebeckite.git",
+    "directory": "packages/runtime"
+  },
+  "homepage": "https://github.com/Rerurate514/riebeckite#readme",
+  "bugs": {
+    "url": "https://github.com/Rerurate514/riebeckite/issues"
+  },
+  "description": "Typed interactive runtime contracts for Riebeckite main-thread, worker, WASM worker, and sandboxed iframe execution.",
+  "keywords": [
+    "riebeckite",
+    "runtime",
+    "web-worker",
+    "wasm",
+    "sandbox"
+  ],
+  "engines": {
+    "node": "^20.19.0 || >=22.12.0"
+  },
+  "sideEffects": false,
+  "scripts": {
+    "build": "node ../../scripts/build_package.mjs",
+    "test": "node --import tsx --test \"test/*.test.ts\""
+  }
 }