arcane-os 0.5.7 → 0.5.9

package/browser-runtime/ai/speech-worker-runtime.mjs

@@ -6,7 +6,6 @@ const SPEECH_WORKER_ERROR_PROTOCOL = "arcane-ai-speech-worker-error/1";
 
 const ARTIFACT_GRAPH_MODULE_GRAPH =
   "browser-speech-authenticated-artifact-graph";
-const GRAPH_GUARD_NAME = "__arcaneBrowserSpeechArtifactGraphGuardsV1";
 const MODULE_ROUTER_NAME = "__arcaneBrowserSpeechModuleRouterV1";
 const NESTED_WORKER_PROTOCOL =
   "arcane-ai-browser-speech-artifact-module-worker/1";
@@ -18,10 +17,6 @@ const ONNX_NAMESPACES = completeValue({
   stt: "transformers-env-backends-onnx-wasm",
   tts: "kokoro-env-wasm-paths",
 });
-const ARTIFACT_GRAPH_TRANSFORM_KINDS = new Set([
-  "function-return-this-to-global-this",
-  "typed-array-constructor",
-]);
 const PUBLIC_WORKER_OPERATIONS = completeValue([
   "load",
   "use",
@@ -40,14 +35,12 @@ const STATUS_OPERATION = completeValue(["status"]);
 const UNLOAD_OPERATION = completeValue(["unload"]);
 const DISPOSE_OPERATION = completeValue(["dispose"]);
 const UNLOAD_OR_DISPOSE_OPERATIONS = completeValue(["unload", "dispose"]);
-const LOAD_OR_USE_OPERATIONS = completeValue(["load", "use"]);
 const SDK_WORKER_ERRORS = new WeakSet();
 const WORKER_ERROR_MESSAGES = completeValue({
   ARCANE_AI_REQUEST_ABORTED: "The speech worker operation was cancelled.",
   ARCANE_AI_NOT_READY: "The speech worker is not loaded.",
   ARCANE_AI_INVALID_REQUEST: "The speech worker request was rejected.",
   ARCANE_AI_INVALID_PROVIDER_RESULT: "The speech engine result was rejected.",
-  ARCANE_AI_UNDECLARED_ARTIFACT: "The speech engine requested an undeclared artifact.",
   ARCANE_AI_PROVIDER_UNAVAILABLE: "The selected speech engine is unavailable.",
   ARCANE_AI_PROVIDER_DISPOSED: "The speech worker is disposed.",
   ARCANE_AI_PROVIDER_REQUEST_FAILED: "The speech engine operation was rejected.",
@@ -55,16 +48,6 @@ const WORKER_ERROR_MESSAGES = completeValue({
   ARCANE_AI_WORKER_MESSAGE_ERROR: "The speech Worker message was rejected.",
   ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID:
     "The authenticated artifact graph Worker configuration was rejected.",
-  ARCANE_AI_ARTIFACT_GRAPH_FETCH_EDGE_UNDECLARED:
-    "The runtime used an undeclared artifact graph fetch edge.",
-  ARCANE_AI_ARTIFACT_GRAPH_IMPORT_EDGE_UNDECLARED:
-    "The runtime used an undeclared artifact graph import edge.",
-  ARCANE_AI_ARTIFACT_GRAPH_CACHE_EDGE_UNDECLARED:
-    "The runtime used an undeclared artifact graph cache edge.",
-  ARCANE_AI_ARTIFACT_GRAPH_WORKER_EDGE_UNDECLARED:
-    "The runtime used an undeclared artifact graph module Worker edge.",
-  ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE:
-    "The Worker cannot install the authenticated artifact graph isolation boundary.",
 });
 const WORKER_ERROR_REASON_ADMISSIONS = new Map();
 
@@ -160,6 +143,7 @@ registerWorkerErrorReasons("ARCANE_AI_INVALID_REQUEST", BOTH_WORKER_ROLES, LOAD_
   "speech-runtime-entrypoint-not-materialized",
   "speech-worker-configuration-missing",
   "speech-worker-materialized-files-missing",
+  "speech-worker-execution-configuration-mismatch",
   "speech-worker-model-dtype-empty",
   "speech-worker-model-id-empty",
   "speech-worker-model-repository-empty",
@@ -188,19 +172,6 @@ registerWorkerErrorReasons("ARCANE_AI_INVALID_PROVIDER_RESULT", ["tts"], USE_OPE
   "tts-synthesis-pcm-sample-non-finite",
   "tts-synthesis-result-sample-rate-mismatch",
 ]);
-registerWorkerErrorReasons(
-  "ARCANE_AI_UNDECLARED_ARTIFACT",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  [
-  "artifact-graph-cache-write-rejected",
-  "artifact-graph-runtime-request-url-malformed",
-  "speech-worker-artifact-request-method-rejected",
-  "speech-worker-artifact-request-undeclared",
-  "speech-worker-cache-match-rejected",
-  "speech-worker-cache-open-rejected",
-  ],
-);
 registerWorkerErrorReasons("ARCANE_AI_PROVIDER_DISPOSED", ["stt"], LOAD_OPERATION, [
   "stt-load-rejected-after-dispose",
 ]);
@@ -214,19 +185,9 @@ registerWorkerErrorReasons("ARCANE_AI_NOT_READY", ["tts"], USE_OPERATION, [
   "tts-synthesis-rejected-before-load",
 ]);
 registerWorkerErrorReasons("ARCANE_AI_PROVIDER_UNAVAILABLE", BOTH_WORKER_ROLES, LOAD_OPERATION, [
-  "artifact-graph-fetch-constructor-unavailable",
   "artifact-graph-onnx-wasm-pair-not-materialized",
   "speech-worker-fetch-unavailable",
 ]);
-registerWorkerErrorReasons(
-  "ARCANE_AI_PROVIDER_UNAVAILABLE",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  [
-  "artifact-graph-module-worker-constructor-unavailable",
-  "artifact-graph-negative-response-constructor-unavailable",
-  ],
-);
 registerWorkerErrorReasons("ARCANE_AI_PROVIDER_UNAVAILABLE", ["tts"], LOAD_OPERATION, [
   "kokoro-env-wasm-paths-assignment-rejected",
   "kokoro-env-wasm-paths-unavailable",
@@ -265,23 +226,9 @@ registerWorkerErrorReasons(
   [
   "artifact-graph-kokoro-voice-inventory-missing",
   "artifact-graph-module-worker-target-not-materialized",
-  "artifact-graph-negative-request-routes-not-array",
   "artifact-graph-onnx-wasm-configuration-mismatch",
-  "artifact-graph-runtime-request-route-ambiguous",
-  "artifact-graph-transform-identity-ambiguous",
-  "artifact-graph-transform-kind-not-admitted",
-  "artifact-graph-transform-module-path-empty",
-  "artifact-graph-transform-occurrence-not-positive-safe-integer",
-  "artifact-graph-transformers-cache-edge-ambiguous",
-  "artifact-graph-worker-configuration-incomplete",
   ],
 );
-registerWorkerErrorReasons(
-  "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  ["artifact-graph-typed-array-constructor-transform-undeclared"],
-);
 registerWorkerErrorReasons(
   "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
   ["tts"],
@@ -298,138 +245,6 @@ registerWorkerErrorReasons(
   "transformers-env-num-threads-not-positive-safe-integer",
   ],
 );
-for (const label of ["cache-open", "dynamic-import", "fetch", "module-worker"]) {
-  registerWorkerErrorReasons(
-    "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-    BOTH_WORKER_ROLES,
-    LOAD_OPERATION,
-    [
-    `artifact-graph-${label}-edges-not-array`,
-    `artifact-graph-${label}-edge-not-object`,
-    `artifact-graph-${label}-edge-module-path-empty`,
-    `artifact-graph-${label}-edge-occurrence-not-positive-safe-integer`,
-    `artifact-graph-${label}-edge-policy-not-admitted`,
-    `artifact-graph-${label}-edge-identity-ambiguous`,
-    ],
-  );
-}
-registerWorkerErrorReasons(
-  "ARCANE_AI_ARTIFACT_GRAPH_IMPORT_EDGE_UNDECLARED",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  [
-  "artifact-graph-dynamic-import-edge-undeclared",
-  "artifact-graph-dynamic-import-edge-undeclared-inactive-runtime-branch-entered",
-  "artifact-graph-dynamic-import-target-undeclared",
-  ],
-);
-registerWorkerErrorReasons(
-  "ARCANE_AI_ARTIFACT_GRAPH_FETCH_EDGE_UNDECLARED",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  [
-  "artifact-graph-fetch-edge-undeclared",
-  "artifact-graph-fetch-edge-undeclared-inactive-runtime-branch-entered",
-  "artifact-graph-fetch-guard-bypassed",
-  "artifact-graph-fetch-method-undeclared",
-  "artifact-graph-fetch-target-undeclared",
-  ],
-);
-registerWorkerErrorReasons(
-  "ARCANE_AI_ARTIFACT_GRAPH_CACHE_EDGE_UNDECLARED",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  [
-  "artifact-graph-cache-match-guard-bypassed",
-  "artifact-graph-cache-name-mismatch",
-  "artifact-graph-cache-open-edge-undeclared",
-  "artifact-graph-cache-open-edge-undeclared-inactive-runtime-branch-entered",
-  "artifact-graph-cache-open-guard-bypassed",
-  "artifact-graph-cache-read-target-undeclared",
-  ],
-);
-registerWorkerErrorReasons(
-  "ARCANE_AI_ARTIFACT_GRAPH_WORKER_EDGE_UNDECLARED",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  [
-  "artifact-graph-module-worker-edge-undeclared",
-  "artifact-graph-module-worker-edge-undeclared-inactive-runtime-branch-entered",
-  "artifact-graph-module-worker-target-undeclared",
-  "artifact-graph-module-worker-type-mismatch",
-  ],
-);
-registerWorkerErrorReasons(
-  "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-  BOTH_WORKER_ROLES,
-  LOAD_OPERATION,
-  [
-  "artifact-graph-cache-isolation-unavailable",
-  "artifact-graph-dynamic-code-constructor-isolation-unavailable",
-  "artifact-graph-fetch-isolation-unavailable",
-  "artifact-graph-guard-global-collision",
-  "artifact-graph-guard-global-definition-rejected",
-  "artifact-graph-indexeddb-isolation-unavailable",
-  "artifact-graph-opfs-isolation-unavailable",
-  "artifact-graph-private-message-port-missing",
-  "artifact-graph-setinterval-isolation-unavailable",
-  "artifact-graph-settimeout-isolation-unavailable",
-  "artifact-graph-typed-array-validation-unavailable",
-  "speech-worker-cache-isolation-unavailable",
-  "speech-worker-fetch-isolation-unavailable",
-  ],
-);
-registerWorkerErrorReasons(
-  "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  [
-  "artifact-graph-dynamic-code-constructor-rejected",
-  "artifact-graph-guard-capability-mismatch",
-  "artifact-graph-setinterval-string-callback-rejected",
-  "artifact-graph-settimeout-string-callback-rejected",
-  "artifact-graph-typed-array-constructor-intrinsic-mismatch",
-  "artifact-graph-typed-array-constructor-receiver-not-typed-array",
-  ],
-);
-for (const name of [
-  "broadcastchannel",
-  "eventsource",
-  "function",
-  "rtcpeerconnection",
-  "shadowrealm",
-  "sharedworker",
-  "websocket",
-  "websocketstream",
-  "webtransport",
-  "worker",
-  "xmlhttprequest",
-  "eval",
-  "importscripts",
-]) {
-  registerWorkerErrorReasons(
-    "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-    BOTH_WORKER_ROLES,
-    LOAD_OR_USE_OPERATIONS,
-    [`artifact-graph-${name}-capability-undeclared`],
-  );
-  registerWorkerErrorReasons(
-    "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-    BOTH_WORKER_ROLES,
-    LOAD_OPERATION,
-    [`artifact-graph-${name}-isolation-unavailable`],
-  );
-}
-registerWorkerErrorReasons(
-  "ARCANE_AI_WORKER_MESSAGE_ERROR",
-  BOTH_WORKER_ROLES,
-  LOAD_OR_USE_OPERATIONS,
-  [
-  "artifact-graph-module-worker-error-envelope-rejected",
-  "artifact-graph-module-worker-initialization-message-rejected",
-  ],
-);
-
 function operationFailureReason(role, op) {
   if (op === "load") return `${role}-worker-model-load-rejected`;
   if (op === "use") {
@@ -890,6 +705,49 @@ function validateConfiguration(configuration, role) {
   requiredText(configuration.model?.repository, "Speech model repository", "speech-worker-model-repository-empty");
   requiredText(configuration.model?.revision, "Speech model revision", "speech-worker-model-revision-empty");
   requiredText(configuration.runtime?.entry, "Speech runtime entry", "speech-worker-runtime-entry-empty");
+  const execution = configuration.execution;
+  if (execution !== undefined) {
+    if (!execution || typeof execution !== "object" || Array.isArray(execution)) {
+      throw workerError(
+        "ARCANE_AI_INVALID_REQUEST",
+        "Speech worker execution must be a plain data record.",
+        undefined,
+        "speech-worker-execution-configuration-mismatch",
+      );
+    }
+    const prototype = Object.getPrototypeOf(execution);
+    if (prototype !== Object.prototype && prototype !== null) {
+      throw workerError(
+        "ARCANE_AI_INVALID_REQUEST",
+        "Speech worker execution must be a plain data record.",
+        undefined,
+        "speech-worker-execution-configuration-mismatch",
+      );
+    }
+    const descriptors = Object.getOwnPropertyDescriptors(execution);
+    let descriptorMismatch = false;
+    for (const key of Reflect.ownKeys(descriptors)) {
+      if (key !== "device" || !Object.hasOwn(descriptors[key], "value")) {
+        descriptorMismatch = true;
+        break;
+      }
+    }
+    if (
+      descriptorMismatch
+      || !Object.hasOwn(descriptors, "device")
+      || (role === "stt" && descriptors.device.value !== "wasm")
+      || (role === "tts"
+        && descriptors.device.value !== "wasm"
+        && descriptors.device.value !== "webgpu")
+    ) {
+      throw workerError(
+        "ARCANE_AI_INVALID_REQUEST",
+        "Speech worker execution device does not match the selected role.",
+        undefined,
+        "speech-worker-execution-configuration-mismatch",
+      );
+    }
+  }
   if (!Array.isArray(configuration.runtime?.files) || !Array.isArray(configuration.model?.files)) {
     throw workerError(
       "ARCANE_AI_INVALID_REQUEST",
@@ -981,496 +839,6 @@ function validateConfiguration(configuration, role) {
   return configuration;
 }
 
-function absoluteRequestUrl(value, scope) {
-  const input = typeof value === "string" || value instanceof URL
-    ? String(value)
-    : value?.url;
-  try {
-    return new URL(input, scope.location?.href).href;
-  } catch {
-    throw workerError(
-      "ARCANE_AI_UNDECLARED_ARTIFACT",
-      "The speech engine requested a malformed artifact URL.",
-      undefined,
-      "artifact-graph-runtime-request-url-malformed",
-    );
-  }
-}
-
-// Dormant hardening retained for future review only. The closed route reader,
-// cache admission, and legacy fetch isolation below are not used by ordinary
-// execution and must not be enabled without explicit user review.
-function createArtifactRoutes(scope, configuration) {
-  const positive = new Map();
-  const negative = new Set();
-  const files = [
-    ...configuration.runtime.files,
-    ...configuration.model.files,
-  ];
-
-  function addPositive(route, file) {
-    const absolute = absoluteRequestUrl(route, scope);
-    const existing = positive.get(absolute);
-    if (existing && existing.path !== file.path) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        "An artifact graph runtime request route names more than one file.",
-        undefined,
-        "artifact-graph-runtime-request-route-ambiguous",
-      );
-    }
-    positive.set(absolute, file);
-  }
-
-  for (const file of files) {
-    addPositive(file.sourceUrl, file);
-    addPositive(file.moduleUrl, file);
-    for (const route of file.runtimeRequestUrls ?? []) addPositive(route, file);
-  }
-  for (const route of configuration.runtime.negativeRuntimeRequestUrls ?? []) {
-    const absolute = absoluteRequestUrl(route, scope);
-    if (positive.has(absolute) || negative.has(absolute)) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        "Artifact graph positive and negative runtime request routes overlap.",
-        undefined,
-        "artifact-graph-runtime-request-route-ambiguous",
-      );
-    }
-    negative.add(absolute);
-  }
-  return completeValue({ files, positive, negative });
-}
-
-function requestMethod(input, init, scope) {
-  const RequestConstructor = scope.Request ?? globalThis.Request;
-  const inherited = typeof RequestConstructor === "function" && input instanceof RequestConstructor
-    ? input.method
-    : "GET";
-  return String(init?.method ?? inherited ?? "GET").toUpperCase();
-}
-
-function installScopeValue(scope, name, value, reason) {
-  const descriptor = Object.getOwnPropertyDescriptor(scope, name);
-  if (descriptor?.configurable === false && descriptor.writable !== true) {
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-      `The speech Worker cannot isolate globalThis.${name}.`,
-      undefined,
-      reason,
-    );
-  }
-  try {
-    if (descriptor?.configurable === false) {
-      scope[name] = value;
-    } else {
-      Object.defineProperty(scope, name, {
-        configurable: true,
-        enumerable: descriptor?.enumerable ?? true,
-        writable: false,
-        value,
-      });
-    }
-  } catch (error) {
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-      `The speech Worker could not isolate globalThis.${name}.`,
-      error,
-      reason,
-    );
-  }
-  return function restoreScopeValue() {
-    if (descriptor) Object.defineProperty(scope, name, descriptor);
-    else delete scope[name];
-  };
-}
-
-function restoreScopeValues(restores) {
-  for (const restore of restores.splice(0).reverse()) {
-    try {
-      restore();
-    } catch {
-      // Terminating the owning Worker remains the final isolation boundary.
-    }
-  }
-}
-
-function installObjectValue(object, name, value, label, reason) {
-  const descriptor = Object.getOwnPropertyDescriptor(object, name);
-  if (descriptor?.configurable === false && descriptor.writable !== true) {
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-      `The speech Worker cannot isolate ${label}.`,
-      undefined,
-      reason,
-    );
-  }
-  try {
-    Object.defineProperty(object, name, {
-      configurable: true,
-      enumerable: descriptor?.enumerable ?? true,
-      writable: false,
-      value,
-    });
-  } catch (error) {
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-      `The speech Worker could not isolate ${label}.`,
-      error,
-      reason,
-    );
-  }
-  return function restoreObjectValue() {
-    if (descriptor) Object.defineProperty(object, name, descriptor);
-    else delete object[name];
-  };
-}
-
-function createRouteReader(scope, configuration, originalFetch) {
-  const routes = createArtifactRoutes(scope, configuration);
-  const ResponseConstructor = scope.Response ?? globalThis.Response;
-
-  async function responseFor(resolution, signal) {
-    if (resolution.kind === "negative") {
-      if (typeof ResponseConstructor !== "function") {
-        throw workerError(
-          "ARCANE_AI_PROVIDER_UNAVAILABLE",
-          "Browser Response is unavailable in the speech Worker.",
-          undefined,
-          "artifact-graph-negative-response-constructor-unavailable",
-        );
-      }
-      return new ResponseConstructor(null, {
-        status: 404,
-        statusText: "Not Found",
-        headers: { "cache-control": "no-store" },
-      });
-    }
-    return originalFetch(resolution.file.moduleUrl, {
-      method: "GET",
-      credentials: "omit",
-      redirect: "error",
-      signal,
-    });
-  }
-
-  function resolve(input) {
-    const absolute = absoluteRequestUrl(input, scope);
-    const file = routes.positive.get(absolute);
-    if (file) return completeValue({ kind: "file", absolute, file });
-    if (routes.negative.has(absolute)) {
-      return completeValue({ kind: "negative", absolute, file: null });
-    }
-    return null;
-  }
-
-  function cacheForPaths(targetPaths) {
-    const admittedPaths = new Set(targetPaths);
-    return completeValue({
-      async match(input) {
-        const resolution = resolve(input);
-        if (
-          !resolution
-          || resolution.kind !== "file"
-          || !admittedPaths.has(resolution.file.path)
-        ) {
-          throw workerError(
-            "ARCANE_AI_ARTIFACT_GRAPH_CACHE_EDGE_UNDECLARED",
-            "The runtime cache read target is outside its admitted artifact graph edge.",
-            undefined,
-            "artifact-graph-cache-read-target-undeclared",
-          );
-        }
-        return responseFor(resolution);
-      },
-      async put() {
-        throw workerError(
-          "ARCANE_AI_UNDECLARED_ARTIFACT",
-          "Speech runtime cache writes are disabled; DBOPFS is the sole durable artifact store.",
-          undefined,
-          "artifact-graph-cache-write-rejected",
-        );
-      },
-      async add() {
-        throw workerError(
-          "ARCANE_AI_UNDECLARED_ARTIFACT",
-          "Speech runtime cache writes are disabled; DBOPFS is the sole durable artifact store.",
-          undefined,
-          "artifact-graph-cache-write-rejected",
-        );
-      },
-      async addAll() {
-        throw workerError(
-          "ARCANE_AI_UNDECLARED_ARTIFACT",
-          "Speech runtime cache writes are disabled; DBOPFS is the sole durable artifact store.",
-          undefined,
-          "artifact-graph-cache-write-rejected",
-        );
-      },
-      async delete() {
-        return false;
-      },
-      async keys() {
-        return completeValue([]);
-      },
-    });
-  }
-
-  const cache = cacheForPaths(routes.files.map((file) => file.path));
-  return completeValue({ cache, cacheForPaths, resolve, responseFor, routes });
-}
-
-function installLegacyAuthorizedFetch(scope, configuration) {
-  const original = scope.fetch?.bind(scope);
-  if (typeof original !== "function") {
-    throw workerError(
-      "ARCANE_AI_PROVIDER_UNAVAILABLE",
-      "Browser fetch is unavailable in the speech Worker.",
-      undefined,
-      "speech-worker-fetch-unavailable",
-    );
-  }
-  const reader = createRouteReader(scope, configuration, original);
-  const authorized = async function fetchAuthorizedSpeechArtifact(input, init) {
-    if (requestMethod(input, init, scope) !== "GET") {
-      throw workerError(
-        "ARCANE_AI_UNDECLARED_ARTIFACT",
-        "Legacy speech artifacts admit only GET requests.",
-        undefined,
-        "speech-worker-artifact-request-method-rejected",
-      );
-    }
-    const resolution = reader.resolve(input);
-    if (!resolution) {
-      throw workerError(
-        "ARCANE_AI_UNDECLARED_ARTIFACT",
-        "The speech engine requested an artifact outside its admitted file map.",
-        undefined,
-        "speech-worker-artifact-request-undeclared",
-      );
-    }
-    return reader.responseFor(resolution, init?.signal);
-  };
-  const restore = installScopeValue(
-    scope,
-    "fetch",
-    authorized,
-    "speech-worker-fetch-isolation-unavailable",
-  );
-  return completeValue({ cache: null, cleanup: restore });
-}
-
-function installDeniedCacheIsolation(scope) {
-  const denied = completeValue({
-    async open() {
-      throw workerError(
-        "ARCANE_AI_UNDECLARED_ARTIFACT",
-        "Speech runtime cache access is disabled; DBOPFS admission is the sole artifact source.",
-        undefined,
-        "speech-worker-cache-open-rejected",
-      );
-    },
-    async match() {
-      throw workerError(
-        "ARCANE_AI_UNDECLARED_ARTIFACT",
-        "Speech runtime cache access is disabled; DBOPFS admission is the sole artifact source.",
-        undefined,
-        "speech-worker-cache-match-rejected",
-      );
-    },
-    async has() {
-      return false;
-    },
-    async keys() {
-      return completeValue([]);
-    },
-    async delete() {
-      return false;
-    },
-  });
-  return installScopeValue(
-    scope,
-    "caches",
-    denied,
-    "speech-worker-cache-isolation-unavailable",
-  );
-}
-
-function edgeKey(modulePath, occurrence) {
-  return `${modulePath}\u0000${String(occurrence)}`;
-}
-
-function edgeMap(edges, label) {
-  if (!Array.isArray(edges)) {
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-      `Artifact graph ${label} edges must be an array.`,
-      undefined,
-      `artifact-graph-${label}-edges-not-array`,
-    );
-  }
-  const map = new Map();
-  for (const edge of edges) {
-    if (!edge || typeof edge !== "object" || Array.isArray(edge)) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        `Artifact graph ${label} edge must be an object.`,
-        undefined,
-        `artifact-graph-${label}-edge-not-object`,
-      );
-    }
-    if (typeof edge.modulePath !== "string" || !edge.modulePath) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        `Artifact graph ${label} edge modulePath must be nonempty.`,
-        undefined,
-        `artifact-graph-${label}-edge-module-path-empty`,
-      );
-    }
-    if (!Number.isSafeInteger(edge.occurrence) || edge.occurrence < 1) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        `Artifact graph ${label} edge occurrence must be a positive safe integer.`,
-        undefined,
-        `artifact-graph-${label}-edge-occurrence-not-positive-safe-integer`,
-      );
-    }
-    if (edge.edgePolicy !== "artifact-targets-admitted"
-      && edge.edgePolicy !== "inactive-runtime-branch-rejected") {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        `Artifact graph ${label} edge policy is not admitted.`,
-        undefined,
-        `artifact-graph-${label}-edge-policy-not-admitted`,
-      );
-    }
-    const key = edgeKey(edge.modulePath, edge.occurrence);
-    if (map.has(key)) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        `Artifact graph ${label} edge identity is ambiguous.`,
-        undefined,
-        `artifact-graph-${label}-edge-identity-ambiguous`,
-      );
-    }
-    map.set(key, edge);
-  }
-  return map;
-}
-
-function transformSet(transforms, kind) {
-  const result = new Set();
-  for (const transform of transforms) {
-    if (!ARTIFACT_GRAPH_TRANSFORM_KINDS.has(transform?.kind)) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        "Artifact graph Worker configuration contains a transform kind that is not admitted.",
-        undefined,
-        "artifact-graph-transform-kind-not-admitted",
-      );
-    }
-    if (transform?.kind !== kind) continue;
-    if (typeof transform.modulePath !== "string" || !transform.modulePath) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        `Artifact graph ${kind} transform modulePath must be nonempty.`,
-        undefined,
-        "artifact-graph-transform-module-path-empty",
-      );
-    }
-    if (!Number.isSafeInteger(transform.occurrence) || transform.occurrence < 1) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        `Artifact graph ${kind} transform occurrence must be a positive safe integer.`,
-        undefined,
-        "artifact-graph-transform-occurrence-not-positive-safe-integer",
-      );
-    }
-    const key = edgeKey(transform.modulePath, transform.occurrence);
-    if (result.has(key)) {
-      throw workerError(
-        "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-        `Artifact graph ${kind} transform identity is ambiguous.`,
-        undefined,
-        "artifact-graph-transform-identity-ambiguous",
-      );
-    }
-    result.add(key);
-  }
-  return result;
-}
-
-function typedArrayIntrinsics(scope) {
-  const constructors = new Map();
-  for (const name of [
-    "BigInt64Array",
-    "BigUint64Array",
-    "Float32Array",
-    "Float64Array",
-    "Int8Array",
-    "Int16Array",
-    "Int32Array",
-    "Uint8Array",
-    "Uint8ClampedArray",
-    "Uint16Array",
-    "Uint32Array",
-  ]) {
-    const Constructor = scope[name] ?? globalThis[name];
-    if (typeof Constructor === "function" && Constructor.prototype) {
-      constructors.set(Constructor.prototype, Constructor);
-    }
-  }
-  const ArrayBufferConstructor = scope.ArrayBuffer ?? globalThis.ArrayBuffer;
-  const DataViewConstructor = scope.DataView ?? globalThis.DataView;
-  if (typeof ArrayBufferConstructor?.isView !== "function") {
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-      "Authenticated artifact graph typed-array validation is unavailable.",
-      undefined,
-      "artifact-graph-typed-array-validation-unavailable",
-    );
-  }
-  return completeValue({
-    constructors,
-    dataViewPrototype: DataViewConstructor?.prototype ?? null,
-    getPrototypeOf: Object.getPrototypeOf,
-    hasOwn: Object.hasOwn,
-    isView: ArrayBufferConstructor.isView.bind(ArrayBufferConstructor),
-  });
-}
-
-function runtimeFileMap(configuration) {
-  return new Map(configuration.runtime.files.map((file) => [file.path, file]));
-}
-
-function targetRecords(edge) {
-  if (Array.isArray(edge.targets)) return edge.targets;
-  if (Array.isArray(edge.targetPaths)) {
-    return edge.targetPaths.map((targetPath) => ({ targetPath }));
-  }
-  return [];
-}
-
-function targetForRequest(edge, requested, files, sourceFile) {
-  const value = String(requested);
-  for (const target of targetRecords(edge)) {
-    const file = files.get(target?.targetPath);
-    if (!file) continue;
-    if (target.match === "exact-runtime-specifier") {
-      if (value === target.exactSpecifier) return file;
-      continue;
-    }
-    if (target.match === "self-module-url") {
-      if (file.path === sourceFile?.path && value === sourceFile.moduleUrl) return file;
-      continue;
-    }
-    if (target.match === "materialized-module-url" && value === file.moduleUrl) {
-      return file;
-    }
-  }
-  return null;
-}
-
 function nestedWorkerUrl(role) {
   const url = new URL(
     role === "stt"
@@ -1500,401 +868,6 @@ function nestedWorkerFailureEvent(scope, error) {
   return event;
 }
 
-// Dormant hardening retained for future review only. Ordinary speech execution
-// never installs this guard, its declared-edge admission, or its isolation
-// controls. Do not enable it for secure mode without explicit user review.
-function createArtifactGraphGuard(scope, configuration, role, reader, originalWorker) {
-  const files = runtimeFileMap(configuration);
-  const edges = configuration.runtime.edges;
-  const imports = edgeMap(edges.dynamicImports ?? [], "dynamic-import");
-  const fetches = edgeMap(edges.fetches ?? [], "fetch");
-  const workers = edgeMap(edges.moduleWorkers ?? [], "module-worker");
-  const cacheOpens = edgeMap(edges.cacheOpens ?? [], "cache-open");
-  const typedArrayConstructors = transformSet(
-    configuration.runtime.transforms,
-    "typed-array-constructor",
-  );
-  transformSet(configuration.runtime.transforms, "function-return-this-to-global-this");
-  const typedArrays = typedArrayIntrinsics(scope);
-  const guardCapability = configuration.runtime.guardCapability;
-  const nestedWorkers = new Set();
-
-  function assertGuardCapability(candidate) {
-    if (candidate === guardCapability) return;
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-      "Authenticated artifact graph runtime guard capability did not match.",
-      undefined,
-      "artifact-graph-guard-capability-mismatch",
-    );
-  }
-
-  function declaredEdge(map, modulePath, occurrence, code, reason) {
-    const edge = map.get(edgeKey(modulePath, occurrence));
-    if (edge?.edgePolicy === "artifact-targets-admitted") return edge;
-    if (edge?.edgePolicy === "inactive-runtime-branch-rejected") {
-      throw workerError(
-        code,
-        "The runtime entered an artifact graph branch declared inactive.",
-        undefined,
-        `${reason}-inactive-runtime-branch-entered`,
-      );
-    }
-    throw workerError(
-      code,
-      "The runtime used an undeclared authenticated artifact graph edge.",
-      undefined,
-      reason,
-    );
-  }
-
-  function fetchEdgeAllows(edge, resolution) {
-    if (resolution.kind === "negative") {
-      return (edge.negativeRuntimeRequestUrls ?? [])
-        .map((route) => absoluteRequestUrl(route, scope))
-        .includes(resolution.absolute);
-    }
-    const paths = new Set([
-      ...(edge.targetPaths ?? []),
-      ...targetRecords(edge).map((target) => target?.targetPath),
-    ]);
-    if (!paths.has(resolution.file.path)) return false;
-    if (resolution.absolute === absoluteRequestUrl(resolution.file.moduleUrl, scope)) {
-      return edge.allowMaterializedUrls === true;
-    }
-    return true;
-  }
-
-  const guard = completeValue({
-    protocol: "arcane-ai-browser-speech-artifact-graph-runtime/1",
-
-    async dynamicImport(capability, modulePath, occurrence, specifier) {
-      assertGuardCapability(capability);
-      const edge = declaredEdge(
-        imports,
-        modulePath,
-        occurrence,
-        "ARCANE_AI_ARTIFACT_GRAPH_IMPORT_EDGE_UNDECLARED",
-        "artifact-graph-dynamic-import-edge-undeclared",
-      );
-      const sourceFile = files.get(modulePath);
-      const target = targetForRequest(edge, specifier, files, sourceFile);
-      if (!target) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_IMPORT_EDGE_UNDECLARED",
-          "The runtime dynamic import target is outside its admitted artifact graph edge.",
-          undefined,
-          "artifact-graph-dynamic-import-target-undeclared",
-        );
-      }
-      return import(target.moduleUrl);
-    },
-
-    async fetch(capability, modulePath, occurrence, input, init) {
-      assertGuardCapability(capability);
-      const edge = declaredEdge(
-        fetches,
-        modulePath,
-        occurrence,
-        "ARCANE_AI_ARTIFACT_GRAPH_FETCH_EDGE_UNDECLARED",
-        "artifact-graph-fetch-edge-undeclared",
-      );
-      const method = requestMethod(input, init, scope);
-      if (!(edge.methods ?? ["GET"]).includes(method)) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_FETCH_EDGE_UNDECLARED",
-          "The runtime fetch method is outside its admitted artifact graph edge.",
-          undefined,
-          "artifact-graph-fetch-method-undeclared",
-        );
-      }
-      const resolution = reader.resolve(input);
-      if (!resolution || !fetchEdgeAllows(edge, resolution)) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_FETCH_EDGE_UNDECLARED",
-          "The runtime fetch target is outside its admitted artifact graph edge.",
-          undefined,
-          "artifact-graph-fetch-target-undeclared",
-        );
-      }
-      return reader.responseFor(resolution, init?.signal);
-    },
-
-    async openCache(capability, modulePath, occurrence, cacheName) {
-      assertGuardCapability(capability);
-      const edge = declaredEdge(
-        cacheOpens,
-        modulePath,
-        occurrence,
-        "ARCANE_AI_ARTIFACT_GRAPH_CACHE_EDGE_UNDECLARED",
-        "artifact-graph-cache-open-edge-undeclared",
-      );
-      if (cacheName !== edge.cacheName) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_CACHE_EDGE_UNDECLARED",
-          "The runtime cache name is outside its admitted artifact graph edge.",
-          undefined,
-          "artifact-graph-cache-name-mismatch",
-        );
-      }
-      return reader.cacheForPaths(edge.targetPaths);
-    },
-
-    createWorker(capability, modulePath, occurrence, specifier, options = {}) {
-      assertGuardCapability(capability);
-      const edge = declaredEdge(
-        workers,
-        modulePath,
-        occurrence,
-        "ARCANE_AI_ARTIFACT_GRAPH_WORKER_EDGE_UNDECLARED",
-        "artifact-graph-module-worker-edge-undeclared",
-      );
-      const sourceFile = files.get(modulePath);
-      const target = targetForRequest(edge, specifier, files, sourceFile);
-      if (!target) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_WORKER_EDGE_UNDECLARED",
-          "The runtime module Worker target is outside its admitted artifact graph edge.",
-          undefined,
-          "artifact-graph-module-worker-target-undeclared",
-        );
-      }
-      if (options?.type !== "module") {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_WORKER_EDGE_UNDECLARED",
-          "Authenticated artifact graph child Workers must be module Workers.",
-          undefined,
-          "artifact-graph-module-worker-type-mismatch",
-        );
-      }
-      if (typeof originalWorker !== "function") {
-        throw workerError(
-          "ARCANE_AI_PROVIDER_UNAVAILABLE",
-          "Nested browser module Workers are unavailable.",
-          undefined,
-          "artifact-graph-module-worker-constructor-unavailable",
-        );
-      }
-      const worker = new originalWorker(nestedWorkerUrl(role), {
-        type: "module",
-        name: typeof options.name === "string" ? options.name : "arcane-speech-artifact-module",
-      });
-      nestedWorkers.add(worker);
-      const onBootstrapMessage = (event) => {
-        if (event.data?.protocol !== NESTED_WORKER_PROTOCOL
-          || event.data?.event !== "artifact-module-worker-bootstrap-rejected") return;
-        event.stopImmediatePropagation?.();
-        const admitted = normalizeSpeechWorkerErrorEnvelope(event.data.error, role, "load");
-        const failure = admitted
-          ? workerError(admitted.code, admitted.message, admitted.cause, admitted.reason)
-          : workerError(
-            "ARCANE_AI_WORKER_MESSAGE_ERROR",
-            "The authenticated artifact module Worker error envelope was rejected.",
-            undefined,
-            "artifact-graph-module-worker-error-envelope-rejected",
-          );
-        worker.dispatchEvent?.(nestedWorkerFailureEvent(scope, failure));
-      };
-      worker.addEventListener?.("message", onBootstrapMessage);
-      try {
-        worker.postMessage({
-          protocol: NESTED_WORKER_PROTOCOL,
-          op: "initialize-authenticated-artifact-module-worker",
-          role,
-          targetPath: target.path,
-          configuration,
-        });
-      } catch (error) {
-        nestedWorkers.delete(worker);
-        worker.terminate();
-        throw workerError(
-          "ARCANE_AI_WORKER_MESSAGE_ERROR",
-          "The authenticated artifact module Worker initialization message was rejected.",
-          error,
-          "artifact-graph-module-worker-initialization-message-rejected",
-        );
-      }
-      return worker;
-    },
-
-    typedArrayConstructor(capability, modulePath, occurrence, receiver) {
-      assertGuardCapability(capability);
-      if (!typedArrayConstructors.has(edgeKey(modulePath, occurrence))) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-          "The runtime used an undeclared typed-array constructor transform.",
-          undefined,
-          "artifact-graph-typed-array-constructor-transform-undeclared",
-        );
-      }
-      if (
-        !typedArrays.isView(receiver)
-        || typedArrays.getPrototypeOf(receiver) === typedArrays.dataViewPrototype
-        || typedArrays.hasOwn(receiver, "constructor")
-      ) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-          "The typed-array constructor transform received an unauthenticated receiver.",
-          undefined,
-          "artifact-graph-typed-array-constructor-receiver-not-typed-array",
-        );
-      }
-      const Constructor = typedArrays.constructors.get(
-        typedArrays.getPrototypeOf(receiver),
-      );
-      if (typeof Constructor !== "function") {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-          "The typed-array constructor transform receiver does not use an intrinsic prototype.",
-          undefined,
-          "artifact-graph-typed-array-constructor-intrinsic-mismatch",
-        );
-      }
-      return Constructor;
-    },
-  });
-
-  return completeValue({
-    guard,
-    transformersCache: (() => {
-      const edgesForTransformers = [...cacheOpens.values()].filter((edge) =>
-        edge.edgePolicy === "artifact-targets-admitted"
-        && edge.cacheName === "transformers-cache");
-      if (edgesForTransformers.length === 0) return null;
-      if (edgesForTransformers.length !== 1) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_CONFIGURATION_INVALID",
-          "The Transformers custom cache edge is ambiguous.",
-          undefined,
-          "artifact-graph-transformers-cache-edge-ambiguous",
-        );
-      }
-      return reader.cacheForPaths(edgesForTransformers[0].targetPaths);
-    })(),
-    cleanup() {
-      for (const worker of nestedWorkers) {
-        try {
-          worker.terminate();
-        } catch {
-          // The owning speech Worker is already being torn down.
-        }
-      }
-      nestedWorkers.clear();
-    },
-  });
-}
-
-function installDynamicCodeConstructorIsolation() {
-  const rejectingConstructor = function rejectArtifactGraphDynamicCodeConstructor() {
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-      "Authenticated artifact graph runtime code cannot construct executable strings.",
-      undefined,
-      "artifact-graph-dynamic-code-constructor-rejected",
-    );
-  };
-  const prototypes = new Set([
-    Object.getPrototypeOf(function artifactGraphFunctionProbe() {}),
-    Object.getPrototypeOf(async function artifactGraphAsyncFunctionProbe() {}),
-    Object.getPrototypeOf(function* artifactGraphGeneratorFunctionProbe() {}),
-    Object.getPrototypeOf(async function* artifactGraphAsyncGeneratorFunctionProbe() {}),
-  ]);
-  const restores = [];
-  try {
-    for (const prototype of prototypes) {
-      const descriptor = Object.getOwnPropertyDescriptor(prototype, "constructor");
-      if (!descriptor || (descriptor.configurable === false && descriptor.writable !== true)) {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-          "The Worker cannot isolate a dynamic-code constructor prototype.",
-          undefined,
-          "artifact-graph-dynamic-code-constructor-isolation-unavailable",
-        );
-      }
-      Object.defineProperty(prototype, "constructor", {
-        ...descriptor,
-        value: rejectingConstructor,
-      });
-      restores.push(() => Object.defineProperty(prototype, "constructor", descriptor));
-    }
-  } catch (error) {
-    restoreScopeValues(restores);
-    throw error;
-  }
-  return () => restoreScopeValues(restores);
-}
-
-function installStringTimerIsolation(scope, name) {
-  const original = scope[name];
-  if (typeof original !== "function") return () => undefined;
-  const invoke = original.bind(scope);
-  return installScopeValue(
-    scope,
-    name,
-    function authenticatedArtifactGraphTimer(callback, ...arguments_) {
-      if (typeof callback !== "function") {
-        throw workerError(
-          "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-          `Authenticated artifact graph ${name} requires a function callback.`,
-          undefined,
-          `artifact-graph-${name.toLowerCase()}-string-callback-rejected`,
-        );
-      }
-      return invoke(callback, ...arguments_);
-    },
-    `artifact-graph-${name.toLowerCase()}-isolation-unavailable`,
-  );
-}
-
-function installArtifactGraphEnvironment(scope, configuration, role) {
-  const originalFetch = scope.fetch?.bind(scope);
-  const originalWorker = scope.Worker;
-  if (typeof originalFetch !== "function") {
-    throw workerError(
-      "ARCANE_AI_PROVIDER_UNAVAILABLE",
-      "Browser fetch is unavailable in the speech Worker.",
-      undefined,
-      "artifact-graph-fetch-constructor-unavailable",
-    );
-  }
-  if (GRAPH_GUARD_NAME in scope) {
-    throw workerError(
-      "ARCANE_AI_ARTIFACT_GRAPH_ISOLATION_UNAVAILABLE",
-      "The authenticated artifact graph guard global already exists.",
-      undefined,
-      "artifact-graph-guard-global-collision",
-    );
-  }
-  const reader = createRouteReader(scope, configuration, originalFetch);
-  const graphGuard = createArtifactGraphGuard(
-    scope,
-    configuration,
-    role,
-    reader,
-    originalWorker,
-  );
-  const restores = [];
-  try {
-    restores.push(installScopeValue(
-      scope,
-      GRAPH_GUARD_NAME,
-      graphGuard.guard,
-      "artifact-graph-guard-global-definition-rejected",
-    ));
-  } catch (error) {
-    restoreScopeValues(restores);
-    graphGuard.cleanup();
-    throw error;
-  }
-  return completeValue({
-    cache: graphGuard.transformersCache,
-    cleanup() {
-      graphGuard.cleanup();
-      restoreScopeValues(restores);
-    },
-  });
-}
-
 function ordinaryRequestUrl(value, scope, base = scope.location?.href) {
   const input = typeof value === "string" || value instanceof URL
     ? String(value)
@@ -2431,7 +1404,7 @@ async function createKokoroEngine(namespace, configuration, signal, report) {
   const synthesizer = await namespace.KokoroTTS.from_pretrained(
     configuration.model.repository,
     {
-      device: "wasm",
+      device: configuration.execution?.device ?? "wasm",
       dtype: configuration.model.dtype ?? "q8",
       revision: configuration.model.revision,
       progress_callback: report,