@forgeax/engine-devkit 0.1.7 → 0.1.19

package/dist/index.mjs

@@ -1,11 +1,11 @@
 import { deflateRawSync } from 'zlib';
 import { createHash, randomUUID } from 'crypto';
-import { readFile, writeFile, access, readdir, stat, realpath, rm, mkdir, copyFile, mkdtemp, cp, rename, symlink, unlink, lstat, readlink, rmdir } from 'fs/promises';
-import { resolve, relative, sep, isAbsolute, extname, dirname, basename, join } from 'path';
+import { readFile, writeFile, access, readdir, stat, realpath, rm, mkdir, mkdtemp, rename, copyFile, cp, symlink, unlink, lstat, readlink, rmdir } from 'fs/promises';
+import { resolve, relative, sep, isAbsolute, dirname, basename, extname, join } from 'path';
 import { GameProjectSchema } from '@forgeax/engine-project';
 import { existsSync } from 'fs';
 import { createRequire } from 'module';
-import { fileURLToPath } from 'url';
+import { pathToFileURL, fileURLToPath } from 'url';
 import { audioImporter } from '@forgeax/engine-audio-webaudio/audio-importer';
 import { fbxImporter } from '@forgeax/engine-fbx';
 import { fontImporter } from '@forgeax/engine-font/font-importer';
@@ -13,21 +13,23 @@ import { gltfImporter } from '@forgeax/engine-gltf';
 import { imageImporter } from '@forgeax/engine-image/image-importer';
 import { BUILTIN_MESH_ASSETS } from '@forgeax/engine-pack/builtin';
 import { scanInventory } from '@forgeax/engine-pack/scanner';
-import { validatePreviewArtifactManifest, createMaterialPreviewContribution, createMeshPreviewContribution, createVfxPreviewContribution, createTexturePreviewContribution, validateCanonicalKitReceipt, describeResourcePreviewFailure } from '@forgeax/engine-preview';
+import { validatePreviewArtifactManifest, RESOURCE_PREVIEW_DEFAULT_SIZE, createNativePreviewHost, validateCanonicalKitReceipt, bindPreviewHost, createResourcePreviewReport, describeResourcePreviewFailure } from '@forgeax/engine-preview';
 import { createMaterialPackCooker } from '@forgeax/engine-shader-compiler';
 import { createStandaloneRuntimeAssetBinding, err, ok } from '@forgeax/engine-types';
 import { createParticleCodeNativeCookerFromRoots } from '@forgeax/engine-vfx-compiler';
 import { pluginPack, reloadAssetHost } from '@forgeax/engine-vite-plugin-pack';
+import { vitePluginRhiDebug } from '@forgeax/engine-vite-plugin-rhi-debug';
 import { forgeaxShader } from '@forgeax/engine-vite-plugin-shader';
+import { tmpdir } from 'os';
+import { parse } from 'parse5';
+import { build, preview, createServer as createServer$2, parseAst, Visitor } from 'vite';
 import { runCliGltf } from '@forgeax/engine-gltf/cli-gltf';
 import { scanEntries } from '@forgeax/engine-pack/cli-asset';
 import { AssetGuid } from '@forgeax/engine-pack/guid';
 import { execFile, spawn } from 'child_process';
-import { tmpdir } from 'os';
 import { promisify } from 'util';
 import { replayDeviceRequest, createRhiDebugError, decodeTape, openReplay, buildFrameModel } from '@forgeax/engine-rhi-debug';
 import { rhi, createShaderModule } from '@forgeax/engine-rhi-webgpu';
-import { build, preview, createServer as createServer$2 } from 'vite';
 import { createServer as createServer$1 } from 'net';
 import { createToolPreviewRecipe, createToolPreviewHost, FORGEAX_FRAME_SUBMITTED_DATASET } from '@forgeax/engine-app';
 import { parseImage } from '@forgeax/engine-image/parse-image';
@@ -37,10 +39,10 @@ import materialPreviewPlugin from '@forgeax/engine-preview/material';
 import meshPreviewPlugin from '@forgeax/engine-preview/mesh';
 import texturePreviewPlugin from '@forgeax/engine-preview/texture';
 import vfxPreviewPlugin from '@forgeax/engine-preview/vfx';
-import { validateArtifactManifest, defineTool, createToolRuntime, validateRealmBootstrapPayload, createCarrierStateMachine, capabilityUnavailableError, createServiceCapability, cancellationError, disconnectedError, domainFailureError, createAuthenticatedLoopbackTransport, createPreviewArtifactManifest, validatePreviewArtifactManifest as validatePreviewArtifactManifest$1 } from '@forgeax/engine-tool-runtime';
+import { defineTool, validateArtifactManifest, createToolRuntime, validateRealmBootstrapPayload, createCarrierStateMachine, capabilityUnavailableError, createServiceCapability, cancellationError, disconnectedError, domainFailureError, createAuthenticatedLoopbackTransport, createPreviewArtifactManifest, validatePreviewArtifactManifest as validatePreviewArtifactManifest$1 } from '@forgeax/engine-tool-runtime';
 export { createAuthenticatedLoopbackTransport, createCapabilityToken, createMigrationRecipe, createRealmCapabilityMatrix, createServiceCapability, probeMigrationTarget } from '@forgeax/engine-tool-runtime';
 import { Context, isToolPlugin } from '@forgeax/engine-plugin';
-import { installCatalogLoader, projectPluginEntries, bootstrapCatalogLoader } from '@forgeax/engine-plugin/loader';
+import { installCatalogLoader, projectPluginEntries, createContextCapabilityResolver, bootstrapCatalogLoader } from '@forgeax/engine-plugin/loader';
 import { createServer } from 'http';
 
 var __defProp = Object.defineProperty;
@@ -149,6 +151,20 @@ function mediaType(path) {
   if (path.endsWith(".wasm")) return "application/wasm";
   if (path.endsWith(".png")) return "image/png";
   if (path.endsWith(".jpg") || path.endsWith(".jpeg")) return "image/jpeg";
+  if (path.endsWith(".css")) return "text/css";
+  if (path.endsWith(".svg")) return "image/svg+xml";
+  if (path.endsWith(".webp")) return "image/webp";
+  if (path.endsWith(".gif")) return "image/gif";
+  if (path.endsWith(".mp3")) return "audio/mpeg";
+  if (path.endsWith(".wav")) return "audio/wav";
+  if (path.endsWith(".ogg")) return "audio/ogg";
+  if (path.endsWith(".mp4")) return "video/mp4";
+  if (path.endsWith(".webm")) return "video/webm";
+  if (path.endsWith(".woff")) return "font/woff";
+  if (path.endsWith(".woff2")) return "font/woff2";
+  if (path.endsWith(".ttf")) return "font/ttf";
+  if (path.endsWith(".otf")) return "font/otf";
+  if (path.endsWith(".wgsl") || path.endsWith(".glsl")) return "text/plain";
   return "application/octet-stream";
 }
 async function filesUnder(root, directory = root) {
@@ -840,6 +856,7 @@ var init_engine_binding = __esm({
 // src/host.ts
 var host_exports = {};
 __export(host_exports, {
+  createEngineWorkspaceResolverForProject: () => createEngineWorkspaceResolverForProject,
   createViteConfig: () => createViteConfig,
   devKitDdcRoots: () => devKitDdcRoots,
   ignoreDevKitCatalogPath: () => ignoreDevKitCatalogPath
@@ -1010,6 +1027,9 @@ async function createEngineWorkspaceResolver(projectRoot) {
     }
   };
 }
+async function createEngineWorkspaceResolverForProject(projectRoot) {
+  return createEngineWorkspaceResolver(projectRoot);
+}
 async function consumerEngineAliases(projectRoot) {
   const root = resolve(projectRoot, "node_modules", ".pnpm", "node_modules", "@forgeax");
   try {
@@ -1326,6 +1346,44 @@ async function previewOwnerFacts(assets, resource, payload) {
   return undefined;
 }
 
+const gameProjectionDefinitions = new Map();
+function registerGameProjection(kind, definition) {
+  if (gameProjectionDefinitions.has(definition.id)) {
+    throw new Error('forgeax: duplicate game projection id ' + definition.id);
+  }
+  const entry = { kind, definition };
+  gameProjectionDefinitions.set(definition.id, entry);
+  return () => {
+    if (gameProjectionDefinitions.get(definition.id) === entry) {
+      gameProjectionDefinitions.delete(definition.id);
+    }
+  };
+}
+const gameProjection = {
+  registerAction: (definition) => registerGameProjection('action', definition),
+  registerRead: (definition) => registerGameProjection('read', definition),
+};
+function exposeGameInspection(app) {
+  globalThis.__forgeaxGameInspection = {
+    list() {
+      return {
+        reads: Array.from(gameProjectionDefinitions.entries())
+          .filter(([, entry]) => entry.kind === 'read')
+          .map(([id]) => id),
+      };
+    },
+    async read(id) {
+      const entry = gameProjectionDefinitions.get(id);
+      if (entry?.kind !== 'read') throw new Error('forgeax: game read projection not found ' + id);
+      return entry.definition.read();
+    },
+    renderer() {
+      const inspection = app.renderer.inspect();
+      return { state: inspection.state, frameId: inspection.frame.frameId };
+    },
+  };
+}
+
 async function prepareProject(app) {
 await prepareAssetRegistry(app.assets);
 previewWorld = app.world;
@@ -1510,6 +1568,7 @@ await app.pluginContext.plugin(gameHostPlugin({
   ...(defaultSceneRoot === undefined ? {} : { defaultSceneRoot }),
   uiRoot: uiRoot instanceof HTMLElement ? uiRoot : document.body,
   setPointerLockAllowed: (allowed) => app.input?.setPointerLockAllowed?.(allowed),
+  ...(import.meta.env.DEV ? { gameProjection } : {}),
 }));
 const { loader: pluginLoader } = await installCatalogLoader(app.pluginContext, pluginCatalog, 'engine');
 await pluginLoader.root.update(projectPluginEntries(pluginEntries, 'engine'));
@@ -1546,7 +1605,10 @@ if (query.has('forgeax-tool-replay')) {
       if (current === undefined) return current;
       if (resource?.kind !== 'vfx') {
         if (resource?.kind === 'material' || resource?.kind === 'mesh' || resource?.kind === 'texture') {
-          if (app.renderer.drawCalls <= 0) return current;
+          const subjectDrawn = resource.kind === 'texture'
+            ? app.renderer.drawCalls > 0
+            : app.renderer.drawCalls > 2;
+          if (!subjectDrawn) return current;
           if (resource.kind === 'mesh') {
             const asset = current.asset;
             const aabb = asset?.aabb;
@@ -1656,6 +1718,7 @@ if (query.has('forgeax-tool-replay')) {
   );
   if (!result.ok) throw result.error;
   const app = result.value;
+  if (import.meta.env.DEV) exposeGameInspection(app);
   await prepareProject(app);
 ${bootstrapPlugin}
   app.start().unwrap();
@@ -1800,6 +1863,7 @@ async function createViteConfig(facts, command, base = "/", options = {}) {
   const consumerAliases = await consumerEngineAliases(facts.root);
   const plugins = [
     ...engineWorkspaceResolver === void 0 ? [] : [engineWorkspaceResolver],
+    ...command === "serve" && process.env.FORGEAX_ENGINE_RHI_DEBUG === "1" ? [vitePluginRhiDebug({ rootDir: facts.root })] : [],
     forgeaxShader(),
     pluginPack({
       roots,
@@ -1844,6 +1908,737 @@ var init_host = __esm({
     hostRequire = createRequire(import.meta.url);
   }
 });
+function errorResult(code, expected, hint, detail = {}) {
+  return { ok: false, error: new SingleHtmlError(code, expected, hint, detail) };
+}
+function toErrorResult(cause, code, expected, hint) {
+  if (cause instanceof SingleHtmlError) return { ok: false, error: cause };
+  return errorResult(code, expected, hint, {
+    reason: cause instanceof Error ? cause.message : String(cause)
+  });
+}
+function normalizePath(value) {
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value.split(/[?#]/, 1)[0] ?? value);
+  } catch {
+    return void 0;
+  }
+  const normalized = decoded.replace(/\\/g, "/").replace(/^\.\//, "").replace(/^\/+/, "");
+  const segments = normalized.split("/");
+  if (normalized.length === 0 || segments.some((segment) => segment.length === 0 || segment === "." || segment === "..")) {
+    return void 0;
+  }
+  return normalized;
+}
+function safeScriptText(value) {
+  return value.replace(/<\/script/gi, "<\\/script");
+}
+function hashBytes(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function contentTypeForDataUri(value) {
+  const semicolon = value.indexOf(";");
+  return semicolon < 0 ? value : value.slice(0, semicolon);
+}
+function dataUri(bytes, type) {
+  return `data:${contentTypeForDataUri(type)};base64,${Buffer.from(bytes).toString("base64")}`;
+}
+function attributeValueRange(source, location) {
+  const raw = source.slice(location.startOffset, location.endOffset);
+  const equals = raw.indexOf("=");
+  if (equals < 0) return void 0;
+  let cursor = equals + 1;
+  while (/\s/.test(raw[cursor] ?? "")) cursor += 1;
+  const quote = raw[cursor] === '"' || raw[cursor] === "'" ? raw[cursor] : void 0;
+  if (quote !== void 0) {
+    const start = cursor + 1;
+    const end = raw.lastIndexOf(quote);
+    return end <= start ? void 0 : { startOffset: location.startOffset + start, endOffset: location.startOffset + end };
+  }
+  return {
+    startOffset: location.startOffset + cursor,
+    endOffset: location.endOffset
+  };
+}
+function scanHtmlElements(source) {
+  const document2 = parse(source, { sourceCodeLocationInfo: true });
+  const elements = [];
+  const visit = (node) => {
+    if (node.nodeName === "#document" || node.nodeName === "#document-fragment") {
+      for (const child of node.childNodes) visit(child);
+      return;
+    }
+    if (node.nodeName === "#text" || node.nodeName === "#comment" || node.nodeName === "#documentType") {
+      return;
+    }
+    const element = node;
+    const location = element.sourceCodeLocation;
+    if (location?.startTag === void 0) {
+      for (const child of element.childNodes) visit(child);
+      return;
+    }
+    const name = element.tagName.toLowerCase();
+    const attributes = element.attrs.map(({ name: attributeName, value }) => ({
+      name: attributeName.toLowerCase(),
+      value
+    }));
+    const attributeLocations = {};
+    for (const attribute2 of attributes) {
+      const attributeLocation = location.attrs?.[attribute2.name];
+      if (attributeLocation !== void 0) attributeLocations[attribute2.name] = attributeLocation;
+    }
+    elements.push({
+      name,
+      start: location.startTag.startOffset,
+      openEnd: location.startTag.endOffset,
+      end: location.endTag?.endOffset ?? location.startTag.endOffset,
+      ...name === "script" || name === "style" ? {
+        contentStart: location.startTag.endOffset,
+        contentEnd: location.endTag?.startOffset ?? location.startTag.endOffset
+      } : {},
+      attributes,
+      attributeLocations
+    });
+    for (const child of element.childNodes) visit(child);
+  };
+  visit(document2);
+  return elements;
+}
+function attribute(element, name) {
+  return element.attributes.find((candidate) => candidate.name === name);
+}
+function attributeValue(element, name) {
+  return attribute(element, name)?.value;
+}
+function isModuleScript(element) {
+  return element.name === "script" && attributeValue(element, "type")?.toLowerCase() === "module";
+}
+function isStylesheet(element) {
+  return element.name === "link" && attributeValue(element, "rel")?.toLowerCase().split(/\s+/).includes("stylesheet") === true;
+}
+function isModulePreload(element) {
+  return element.name === "link" && attributeValue(element, "rel")?.toLowerCase().split(/\s+/).includes("modulepreload") === true;
+}
+function resourceForPath(path, resources) {
+  const normalized = normalizePath(path);
+  if (normalized === void 0) return void 0;
+  const direct = resources.get(normalized);
+  if (direct !== void 0) return direct;
+  const suffix = [...resources.entries()].filter(
+    ([candidate]) => candidate.endsWith(`/${normalized}`)
+  );
+  return suffix.length === 1 ? suffix[0]?.[1] : void 0;
+}
+function resourcePath(reference, basePath) {
+  try {
+    return normalizePath(new URL(reference, `https://forgeax.invalid/${basePath}`).pathname);
+  } catch {
+    return void 0;
+  }
+}
+function applyReplacements(source, replacements) {
+  const unique = /* @__PURE__ */ new Map();
+  for (const replacement of replacements) {
+    unique.set(`${replacement.start}:${replacement.end}`, replacement);
+  }
+  const ordered = [...unique.values()].sort((left, right) => left.start - right.start);
+  for (let index = 1; index < ordered.length; index += 1) {
+    const previous = ordered[index - 1];
+    const current = ordered[index];
+    if (previous !== void 0 && current !== void 0 && previous.end > current.start) {
+      throw new Error(
+        `single-html AST replacements overlap (${previous.start}:${previous.end} and ${current.start}:${current.end})`
+      );
+    }
+  }
+  return ordered.reverse().reduce(
+    (value, replacement) => value.slice(0, replacement.start) + replacement.value + value.slice(replacement.end),
+    source
+  );
+}
+function inlineCss(css, cssPath, resources) {
+  const replacements = [];
+  const pattern = /url\(\s*(["']?)(.*?)\1\s*\)/gi;
+  for (; ; ) {
+    const match = pattern.exec(css);
+    if (match === null) break;
+    const reference = match[2]?.trim();
+    if (reference === void 0 || reference.length === 0 || reference.startsWith("data:") || reference.startsWith("#")) {
+      continue;
+    }
+    if (/^(?:https?:|blob:)/i.test(reference)) {
+      return errorResult(
+        "single-html-css-external-resource",
+        "CSS URL references to be embedded or data/blob URLs",
+        "Move the CSS resource into the verified dist closure before packaging.",
+        { cssPath, reference }
+      );
+    }
+    const path = resourcePath(reference, cssPath);
+    const resource = path === void 0 ? void 0 : resourceForPath(path, resources);
+    if (resource === void 0) {
+      return errorResult(
+        "single-html-css-asset-missing",
+        "every local CSS URL to resolve to an embedded dist artifact",
+        "Add the referenced asset to the project asset closure and rebuild.",
+        { cssPath, reference, path: path ?? null }
+      );
+    }
+    replacements.push({
+      start: match.index,
+      end: match.index + match[0].length,
+      value: `url(${dataUri(resource.bytes, resource.mediaType)})`
+    });
+  }
+  return { ok: true, value: applyReplacements(css, replacements) };
+}
+function collectEntrySource(html) {
+  const entries2 = scanHtmlElements(html).filter((element2) => isModuleScript(element2));
+  const external = entries2.filter((element2) => attributeValue(element2, "src") !== void 0);
+  const inline = entries2.filter((element2) => attributeValue(element2, "src") === void 0);
+  if (external.length === 0 && inline.length === 0) {
+    return errorResult(
+      "single-html-entry-missing",
+      "production index.html to contain one module entry",
+      "Rebuild the game with a module entry in its generated host."
+    );
+  }
+  if (external.length > 1 || inline.length > 1) {
+    return errorResult(
+      "single-html-entry-ambiguous",
+      "production index.html to contain exactly one module entry",
+      "Converge the generated host to one ForgeaX module entry before packaging.",
+      { external: external.length, inline: inline.length }
+    );
+  }
+  const element = external[0] ?? inline[0];
+  if (element === void 0) throw new Error("single-html entry selection was unexpectedly empty");
+  const src = attributeValue(element, "src");
+  if (src === void 0 && element.contentStart !== void 0 && element.contentEnd !== void 0) {
+    return { ok: true, value: html.slice(element.contentStart, element.contentEnd) };
+  }
+  if (src === void 0) {
+    return errorResult(
+      "single-html-entry-missing",
+      "a module entry source",
+      "Add a module entry to index.html."
+    );
+  }
+  if (/^(?:https?:|file:|data:|blob:)/i.test(src)) {
+    return errorResult(
+      "single-html-entry-external",
+      "the module entry to be a project-local dist artifact",
+      "Rebuild the game so the generated host points at a local production module.",
+      { src }
+    );
+  }
+  return { ok: true, value: src };
+}
+async function filesUnder2(root, directory = root) {
+  const result = [];
+  for (const name of (await readdir(directory)).sort()) {
+    const path = resolve(directory, name);
+    const info = await stat(path);
+    if (info.isDirectory()) result.push(...await filesUnder2(root, path));
+    else if (info.isFile()) result.push(path);
+  }
+  return result;
+}
+function isPreloadHelperSource(value) {
+  if (typeof value !== "string") return false;
+  const path = value.split(/[?#]/, 1)[0] ?? value;
+  const name = path.slice(path.lastIndexOf("/") + 1);
+  return name.startsWith("preload-helper-") && name.endsWith(".js");
+}
+function isStaticImportSource(source) {
+  return source.type === "Literal" || source.type === "StringLiteral" || source.type === "TemplateLiteral" && source.expressions?.length === 0;
+}
+function programReplacements(program) {
+  const replacements = [];
+  const preloadBindings = /* @__PURE__ */ new Set();
+  new Visitor({
+    ImportDeclaration(node) {
+      if (!isPreloadHelperSource(node.source.value)) return;
+      for (const specifier of node.specifiers) {
+        if (specifier.type === "ImportSpecifier") preloadBindings.add(specifier.local.name);
+      }
+    },
+    CallExpression(node) {
+      if (node.callee.type !== "Identifier" || !preloadBindings.has(node.callee.name) || node.arguments.length < 2) {
+        return;
+      }
+      const dependencies = node.arguments[1];
+      if (dependencies !== void 0) {
+        replacements.push({ start: dependencies.start, end: dependencies.end, value: "void 0" });
+      }
+    },
+    ImportExpression(node) {
+      if (isStaticImportSource(node.source)) return;
+      replacements.push({
+        start: node.start,
+        end: node.start + "import".length,
+        value: "globalThis.__forgeaxImport"
+      });
+    }
+  }).visit(program);
+  return replacements;
+}
+function outputReplacements(program) {
+  const replacements = [];
+  new Visitor({
+    ImportExpression(node) {
+      replacements.push({
+        start: node.start,
+        end: node.start + "import".length,
+        value: "globalThis.__forgeaxImport"
+      });
+    }
+  }).visit(program);
+  return replacements;
+}
+function rewriteOutputJavaScript(code) {
+  const program = parseAst(code);
+  return applyReplacements(code, outputReplacements(program));
+}
+function residualImportStart(code) {
+  let residualStart;
+  new Visitor({
+    ImportExpression(node) {
+      residualStart ??= node.start;
+    }
+  }).visit(parseAst(code));
+  return residualStart;
+}
+function isJavaScriptOutputAsset(fileName) {
+  return /\.(?:c?js|mjs)$/i.test(fileName);
+}
+function singleHtmlBundlePlugin() {
+  const plugin = {
+    name: "forgeax-single-html-bundle-runtime",
+    enforce: "post",
+    transform: {
+      order: "post",
+      handler(code, _id, meta) {
+        let program = meta?.ast;
+        if (program === void 0) {
+          try {
+            program = parseAst(code);
+          } catch {
+            return null;
+          }
+        }
+        const replacements = programReplacements(program);
+        if (replacements.length === 0) return null;
+        if (meta?.magicString !== void 0) {
+          for (const replacement of replacements) {
+            meta.magicString.overwrite(replacement.start, replacement.end, replacement.value);
+          }
+          return meta.magicString.hasChanged() ? meta.magicString : null;
+        }
+        return applyReplacements(code, replacements);
+      }
+    },
+    generateBundle(_outputOptions, bundle) {
+      for (const output of Object.values(bundle)) {
+        if (output.type === "chunk") {
+          output.code = rewriteOutputJavaScript(output.code);
+        } else if (isJavaScriptOutputAsset(output.fileName) && output.source !== void 0) {
+          const source = typeof output.source === "string" ? output.source : Buffer.from(output.source).toString("utf8");
+          output.source = rewriteOutputJavaScript(source);
+        } else {
+          continue;
+        }
+        const code = output.type === "chunk" ? output.code : String(output.source);
+        const residualStart = residualImportStart(code);
+        if (residualStart !== void 0) {
+          this.error(
+            `single-html bundle left a native dynamic import in ${output.fileName} at ${residualStart}`
+          );
+        }
+      }
+    },
+    resolveFileUrl: ({ fileName }) => JSON.stringify(`${GENERATED_PREFIX}${fileName}`)
+  };
+  return plugin;
+}
+async function bundleSingleHtmlEntry(distRootInput, indexHtml, projectRoot) {
+  const distRoot = resolve(distRootInput);
+  const selected = collectEntrySource(indexHtml);
+  if (!selected.ok) return selected;
+  const source = selected.value;
+  const entryPath = normalizePath(source);
+  const temporaryRoot = await mkdtemp(resolve(tmpdir(), "forgeax-single-html-bundle-"));
+  try {
+    let inputPath;
+    if (entryPath !== void 0) {
+      const candidate = resolve(distRoot, entryPath);
+      try {
+        const candidateInfo = await stat(candidate);
+        if (candidateInfo.isFile()) inputPath = candidate;
+      } catch {
+      }
+    }
+    if (inputPath === void 0) {
+      inputPath = resolve(temporaryRoot, "inline-entry.mjs");
+      await writeFile(inputPath, source, "utf8");
+    }
+    const outputRoot = resolve(temporaryRoot, "dist");
+    const resolver = projectRoot === void 0 ? void 0 : await createEngineWorkspaceResolverForProject(projectRoot);
+    await build({
+      configFile: false,
+      root: distRoot,
+      base: "./",
+      logLevel: "error",
+      plugins: [singleHtmlBundlePlugin(), ...resolver === void 0 ? [] : [resolver]],
+      experimental: {
+        renderBuiltUrl: (filename) => `forgeax-resource:///${GENERATED_PREFIX}${filename}`
+      },
+      build: {
+        outDir: outputRoot,
+        emptyOutDir: true,
+        target: "esnext",
+        minify: false,
+        sourcemap: false,
+        assetsInlineLimit: 0,
+        modulePreload: false,
+        rolldownOptions: {
+          input: inputPath,
+          output: {
+            codeSplitting: false,
+            entryFileNames: "entry.mjs",
+            chunkFileNames: "assets/[name]-[hash].mjs",
+            assetFileNames: "assets/[name]-[hash][extname]"
+          },
+          experimental: { nativeMagicString: true }
+        }
+      }
+    });
+    const paths = (await filesUnder2(outputRoot)).map(
+      (path) => relative(outputRoot, path).split(sep).join("/")
+    );
+    const entry = paths.find((path) => path === "entry.mjs");
+    if (entry === void 0) {
+      return errorResult(
+        "single-html-bundle-entry-missing",
+        "Vite to emit exactly one entry.mjs",
+        "Inspect the production entry and the single-html bundler output.",
+        { outputRoot, paths }
+      );
+    }
+    const generatedPaths = paths.filter((path) => path !== entry);
+    const artifacts = [];
+    for (const path of generatedPaths) {
+      const bytes = await readFile(resolve(outputRoot, path));
+      artifacts.push({
+        path: `${GENERATED_PREFIX}${path}`,
+        bytes,
+        mediaType: mediaType(path)
+      });
+    }
+    const entryBytes = await readFile(resolve(outputRoot, entry));
+    return {
+      ok: true,
+      value: {
+        entrySource: entryBytes.toString("utf8"),
+        artifacts
+      }
+    };
+  } catch (cause) {
+    return toErrorResult(
+      cause,
+      "single-html-bundle-failed",
+      "the production module entry to converge into one executable bundle",
+      "Repair the production entry or inspect the Vite/Rolldown diagnostic before packaging."
+    );
+  } finally {
+    await rm(temporaryRoot, { recursive: true, force: true });
+  }
+}
+function workerPrelude(resources) {
+  const payload = resources.map((resource) => ({
+    path: resource.path,
+    mime: resource.mediaType,
+    data: Buffer.from(resource.bytes).toString("base64")
+  }));
+  const template = `globalThis.process??={env:{},versions:{node:'0.0.0'},platform:'browser',argv:[]};
+const __forgeaxWorkerPayload=${JSON.stringify(payload)};
+const __forgeaxSourcePath=__FORGEAX_SOURCE_PATH__;
+const __forgeaxNativeURL=globalThis.URL;
+const __forgeaxNativeFetch=globalThis.fetch?.bind(globalThis);
+const __forgeaxNativePostMessage=globalThis.postMessage?.bind(globalThis);
+const __forgeaxOwnedUrls=new Set();
+const __forgeaxBytes=(value)=>{const binary=atob(value);const bytes=new Uint8Array(binary.length);for(let index=0;index<binary.length;index+=1)bytes[index]=binary.charCodeAt(index);return bytes;};
+const __forgeaxDataURL=(source)=>{const bytes=new TextEncoder().encode(source);let binary='';for(const byte of bytes)binary+=String.fromCharCode(byte);return 'data:text/javascript;base64,'+btoa(binary);};
+const __forgeaxWorkerURL=(source)=>{if(/^(?:file:|data:|about:)/i.test(String(globalThis.location?.protocol??'')))return __forgeaxDataURL(source);const blob=__forgeaxNativeURL.createObjectURL(new Blob([source],{type:'text/javascript'}));__forgeaxOwnedUrls.add(blob);return blob;};
+const __forgeaxNormalize=(value)=>{try{return decodeURIComponent(String(value).split(/[?#]/,1)[0]).replaceAll('\\\\','/').replace(/^\\/+/, '');}catch{return undefined;}};
+const __forgeaxWithoutBundle=(value)=>String(value).replace(/^__forgeax-bundle\\//,'');
+const __forgeaxLookup=(value)=>{let url;try{url=value instanceof __forgeaxNativeURL?value:new __forgeaxNativeURL(String(value),'https://forgeax.invalid/'+__forgeaxSourcePath);}catch{return undefined;}const path=__forgeaxNormalize(url.pathname);if(path===undefined)return undefined;const normalized=__forgeaxWithoutBundle(path);const exact=__forgeaxWorkerPayload.find((entry)=>entry.path===path||__forgeaxWithoutBundle(entry.path)===normalized);if(exact!==undefined)return exact;const suffix=__forgeaxWorkerPayload.filter((entry)=>normalized.endsWith('/'+__forgeaxWithoutBundle(entry.path)));if(suffix.length===1)return suffix[0];const name=normalized.slice(normalized.lastIndexOf('/')+1);const matches=__forgeaxWorkerPayload.filter((entry)=>__forgeaxWithoutBundle(entry.path).slice(__forgeaxWithoutBundle(entry.path).lastIndexOf('/')+1)===name);return matches.length===1?matches[0]:undefined;};
+const __forgeaxResourceURL=(value)=>{const raw=String(value);try{const url=new __forgeaxNativeURL(raw,'https://forgeax.invalid/'+__forgeaxSourcePath);if(url.protocol!=='http:'&&url.protocol!=='https:')return url;const path=__forgeaxNormalize(url.pathname);return path===undefined?url:new __forgeaxNativeURL('forgeax-resource:///'+__forgeaxWithoutBundle(path));}catch{return new __forgeaxNativeURL(raw,'https://forgeax.invalid/'+__forgeaxSourcePath);}};
+globalThis.__forgeaxURL=__forgeaxResourceURL;
+class __ForgeaxURL extends __forgeaxNativeURL{constructor(input,base){if(base!==undefined&&/^blob:/i.test(String(base))&&!/^[a-z][a-z0-9+.-]*:/i.test(String(input))){super(__forgeaxResourceURL(input));return;}super(input,base);}}
+globalThis.URL=__ForgeaxURL;
+const __forgeaxNote=(kind,specifier)=>{const value={kind,specifier:String(specifier)};try{__forgeaxNativePostMessage?.({__forgeaxResourceMiss:value});}catch{}};
+const __forgeaxNoteHit=()=>{try{__forgeaxNativePostMessage?.({__forgeaxResourceHit:1});}catch{}};
+const __forgeaxNoteExternal=(kind,specifier)=>{const value={kind,specifier:String(specifier)};try{__forgeaxNativePostMessage?.({__forgeaxExternalRequest:value});}catch{}};
+const __forgeaxResponse=(entry)=>{__forgeaxNoteHit();return new Response(__forgeaxBytes(entry.data),{status:200,headers:{'Content-Type':entry.mime}});};
+const __forgeaxImportUrls=new Map();
+const __forgeaxImport=async(value)=>{const entry=__forgeaxLookup(value);if(entry===undefined){__forgeaxNote('import',value);throw new TypeError('forgeax single-html worker resource miss');}let url=__forgeaxImportUrls.get(entry.path);if(url===undefined){url=__forgeaxNativeURL.createObjectURL(new Blob([__forgeaxBytes(entry.data)],{type:'text/javascript'}));__forgeaxOwnedUrls.add(url);__forgeaxImportUrls.set(entry.path,url);}__forgeaxNoteHit();return import(url);};
+globalThis.__forgeaxImport=__forgeaxImport;
+if(typeof __forgeaxNativeFetch==='function')globalThis.fetch=(input,init)=>{const entry=__forgeaxLookup(input);if(entry!==undefined)return Promise.resolve(__forgeaxResponse(entry));const text=String(input);if(/^(?:data:|blob:)/i.test(text))return __forgeaxNativeFetch(input,init);if(/^https?:/i.test(text)){__forgeaxNoteExternal('fetch',input);}else{__forgeaxNote('fetch',input);}return Promise.reject(new TypeError('forgeax single-html worker resource miss'));};
+const __forgeaxWorkerPrelude=__FORGEAX_WORKER_FACTORY__;
+const __forgeaxNativeWorker=globalThis.Worker;
+if(typeof __forgeaxNativeWorker==='function')globalThis.Worker=class extends __forgeaxNativeWorker{constructor(input,options){const entry=__forgeaxLookup(input);if(entry===undefined){__forgeaxNote('worker',input);throw new TypeError('forgeax single-html worker resource miss');}const source=new TextDecoder().decode(__forgeaxBytes(entry.data));super(__forgeaxWorkerURL(__forgeaxWorkerPrelude(entry.path)+source),options);}};
+globalThis.addEventListener?.('message',(event)=>{if(event.data?.__forgeaxResourceMiss||event.data?.__forgeaxResourceHit||event.data?.__forgeaxExternalRequest){try{__forgeaxNativePostMessage?.(event.data);}catch{}event.stopImmediatePropagation?.();}});
+globalThis.addEventListener?.('unload',()=>{for(const url of __forgeaxOwnedUrls)__forgeaxNativeURL.revokeObjectURL(url);__forgeaxOwnedUrls.clear();});`;
+  const factoryToken = "__FORGEAX_WORKER_FACTORY__";
+  const recursiveTemplate = template;
+  const factorySource = `(sourcePath)=>{const source=${JSON.stringify(recursiveTemplate)};return source.replace(${JSON.stringify(factoryToken)},()=> '('+__forgeaxWorkerPrelude.toString()+')').replace('__FORGEAX_SOURCE_PATH__',()=>JSON.stringify(sourcePath));}`;
+  return `const __forgeaxWorkerPrelude=${factorySource};`;
+}
+function runtimeBootstrap(resources) {
+  const workerFactory = workerPrelude(resources);
+  return `(() => {
+  globalThis.process ??= { env: {}, versions: { node: '0.0.0' }, platform: 'browser', argv: [] };
+  const nativeURL = globalThis.URL;
+  const nativeFetch = globalThis.fetch?.bind(globalThis);
+  const nodes = [...document.querySelectorAll('script[data-forgeax-asset]')];
+  const entries = nodes.map((node) => ({ path: node.getAttribute('data-path'), mime: node.getAttribute('data-mime') || 'application/octet-stream', data: (node.textContent || '').trim() })).filter((entry) => typeof entry.path === 'string');
+  const decode = (value) => { const binary = atob(value); const bytes = new Uint8Array(binary.length); for (let index = 0; index < binary.length; index += 1) bytes[index] = binary.charCodeAt(index); return bytes; };
+  const normalize = (value) => { try { return decodeURIComponent(String(value).split(/[?#]/, 1)[0]).replaceAll('\\\\', '/').replace(/^\\/+/, ''); } catch { return undefined; } };
+  const withoutBundle = (value) => String(value).replace(/^__forgeax-bundle\\//, '');
+  const lookup = (input) => { let url; try { url = input instanceof nativeURL ? input : new nativeURL(String(input), document.baseURI); } catch { return undefined; } if (url.protocol === 'data:' || url.protocol === 'blob:') return undefined; const path = normalize(url.pathname); if (path === undefined) return undefined; const normalized = withoutBundle(path); const exact = entries.find((entry) => entry.path === path || withoutBundle(entry.path) === normalized); if (exact !== undefined) return exact; const suffix = entries.filter((entry) => normalized.endsWith('/' + withoutBundle(entry.path))); if (suffix.length === 1) return suffix[0]; const name = normalized.slice(normalized.lastIndexOf('/') + 1); const matches = entries.filter((entry) => withoutBundle(entry.path).slice(withoutBundle(entry.path).lastIndexOf('/') + 1) === name); return matches.length === 1 ? matches[0] : undefined; };
+  const resourceMisses = [];
+  const externalRequests = [];
+  let resourceHits = 0;
+  const noteMiss = (kind, specifier) => { resourceMisses.push({ kind, specifier: String(specifier), realm: 'main' }); };
+  const noteExternal = (kind, specifier) => { externalRequests.push({ kind, specifier: String(specifier), realm: 'main' }); };
+  const response = (entry) => { resourceHits += 1; return new Response(decode(entry.data), { status: 200, headers: { 'Content-Type': entry.mime } }); };
+  const ownedBlobUrls = new Set();
+  const makeBlobUrl = (entry) => { const url = nativeURL.createObjectURL(new Blob([decode(entry.data)], { type: entry.mime })); ownedBlobUrls.add(url); return url; };
+  const dataUrl = (source) => { const bytes = new TextEncoder().encode(source); let binary = ''; for (const byte of bytes) binary += String.fromCharCode(byte); return 'data:text/javascript;base64,' + btoa(binary); };
+  const workerUrl = (source) => { if (/^(?:file:|data:|about:)/i.test(String(globalThis.location?.protocol ?? ''))) return dataUrl(source); const url = nativeURL.createObjectURL(new Blob([source], { type: 'text/javascript' })); ownedBlobUrls.add(url); return url; };
+  const importUrls = new Map();
+  const forgeaxImport = async (specifier) => { const entry = lookup(specifier); if (entry === undefined) { const text = String(specifier); if (/^(?:https?:)/i.test(text)) noteExternal('import', text); else noteMiss('import', text); throw new TypeError('forgeax single-html resource miss'); } let url = importUrls.get(entry.path); if (url === undefined) { url = makeBlobUrl(entry); importUrls.set(entry.path, url); } resourceHits += 1; return import(url); };
+  globalThis.__forgeaxImport = forgeaxImport;
+  const external = (input) => { try { const url = input instanceof nativeURL ? input : new nativeURL(String(input), document.baseURI); return url.protocol === 'http:' || url.protocol === 'https:'; } catch { return false; } };
+  if (typeof nativeFetch === 'function') globalThis.fetch = (input, init) => { const entry = lookup(input); if (entry !== undefined) return Promise.resolve(response(entry)); if (/^(?:data:|blob:)/i.test(String(input))) return nativeFetch(input, init); if (external(input)) { noteExternal('fetch', input); return Promise.reject(new TypeError('forgeax single-html blocked an external request')); } noteMiss('fetch', input); return Promise.reject(new TypeError('forgeax single-html resource miss')); };
+  ${workerFactory}
+  const nativeWorker = globalThis.Worker;
+  const attachWorker = (worker) => { worker.addEventListener('message', (event) => { const miss = event.data?.__forgeaxResourceMiss; if (miss !== undefined) { resourceMisses.push({ ...miss, realm: 'worker' }); event.stopImmediatePropagation?.(); } const externalRequest = event.data?.__forgeaxExternalRequest; if (externalRequest !== undefined) { externalRequests.push({ ...externalRequest, realm: 'worker' }); event.stopImmediatePropagation?.(); } const hit = event.data?.__forgeaxResourceHit; if (typeof hit === 'number' && Number.isFinite(hit)) resourceHits += hit; }); return worker; };
+  if (typeof nativeWorker === 'function') globalThis.Worker = class extends nativeWorker { constructor(input, options) { const entry = lookup(input); if (entry === undefined) { const text = String(input); if (external(input)) noteExternal('worker', text); else noteMiss('worker', text); throw new TypeError('forgeax single-html worker resource miss'); } const source = new TextDecoder().decode(decode(entry.data)); super(workerUrl(__forgeaxWorkerPrelude(entry.path) + source), options); attachWorker(this); } };
+  const witness = () => ({ ready: document.documentElement.dataset.forgeaxSingleHtmlReady === 'true', resourceHits, resourceMisses: resourceMisses.slice(), externalRequests: externalRequests.slice() });
+  globalThis.__forgeaxSingleHtml = { lookup, entries: entries.map(({ path, mime }) => ({ path, mime })), witness };
+  globalThis.addEventListener('pagehide', () => { for (const url of ownedBlobUrls) nativeURL.revokeObjectURL(url); ownedBlobUrls.clear(); }, { once: true });
+  document.documentElement.dataset.forgeaxSingleHtmlReady = 'true';
+})();`;
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+function distResources(distRoot, manifest) {
+  const rows = [
+    ...manifest.artifacts,
+    { path: "forgeax-dist.json" }
+  ];
+  return Promise.all(
+    rows.filter((artifact) => artifact.path !== "index.html").map(async (artifact) => ({
+      path: artifact.path,
+      bytes: await readFile(resolve(distRoot, artifact.path)),
+      mediaType: "mediaType" in artifact ? artifact.mediaType : mediaType(artifact.path)
+    }))
+  );
+}
+function buildHtml(indexHtml, distArtifacts, bundle) {
+  const resources = /* @__PURE__ */ new Map();
+  for (const resource of [...distArtifacts, ...bundle.artifacts]) {
+    if (resources.has(resource.path)) {
+      return errorResult(
+        "single-html-asset-duplicate",
+        "embedded resource paths to be unique",
+        "Repair the generated bundle path collision before packaging.",
+        { path: resource.path }
+      );
+    }
+    resources.set(resource.path, resource);
+  }
+  const replacements = [];
+  for (const element of scanHtmlElements(indexHtml)) {
+    if (isModuleScript(element) || isModulePreload(element)) {
+      replacements.push({ start: element.start, end: element.end, value: "" });
+      continue;
+    }
+    if (isStylesheet(element)) {
+      const href = attributeValue(element, "href");
+      if (href === void 0) {
+        return errorResult(
+          "single-html-stylesheet-missing",
+          "stylesheet link to contain href",
+          "Repair the generated HTML stylesheet link."
+        );
+      }
+      const path = resourcePath(href, "index.html");
+      const stylesheet = path === void 0 ? void 0 : resourceForPath(path, resources);
+      if (stylesheet === void 0) {
+        return errorResult(
+          "single-html-css-asset-missing",
+          "stylesheet link to resolve to an embedded artifact",
+          "Add the stylesheet to the dist closure and rebuild.",
+          { href, path: path ?? null }
+        );
+      }
+      const css = inlineCss(
+        Buffer.from(stylesheet.bytes).toString("utf8"),
+        stylesheet.path,
+        resources
+      );
+      if (!css.ok) return css;
+      replacements.push({
+        start: element.start,
+        end: element.end,
+        value: `<style data-forgeax-inline-css>${css.value}</style>`
+      });
+      continue;
+    }
+    if (element.name === "style" && element.contentStart !== void 0 && element.contentEnd !== void 0) {
+      const css = inlineCss(
+        indexHtml.slice(element.contentStart, element.contentEnd),
+        "index.html",
+        resources
+      );
+      if (!css.ok) return css;
+      replacements.push({ start: element.contentStart, end: element.contentEnd, value: css.value });
+      continue;
+    }
+    const resourceAttribute = element.name === "img" || element.name === "source" || element.name === "video" || element.name === "audio" || element.name === "link" ? element.attributes.find((candidate) => ["src", "poster", "href"].includes(candidate.name)) : void 0;
+    const resourceAttributeLocation = resourceAttribute === void 0 ? void 0 : element.attributeLocations[resourceAttribute.name];
+    const resourceAttributeRange = resourceAttribute === void 0 || resourceAttributeLocation === void 0 ? void 0 : attributeValueRange(indexHtml, resourceAttributeLocation);
+    if (resourceAttribute?.value !== void 0 && resourceAttributeRange !== void 0 && !/^(?:data:|blob:|#)/i.test(resourceAttribute.value)) {
+      const path = resourcePath(resourceAttribute.value, "index.html");
+      const embedded = path === void 0 ? void 0 : resourceForPath(path, resources);
+      if (embedded === void 0) {
+        return errorResult(
+          "single-html-asset-missing",
+          "every local HTML resource to resolve to an embedded dist artifact",
+          "Add the referenced asset to the project closure and rebuild.",
+          { value: resourceAttribute.value, path: path ?? null }
+        );
+      }
+      replacements.push({
+        start: resourceAttributeRange.startOffset,
+        end: resourceAttributeRange.endOffset,
+        value: dataUri(embedded.bytes, embedded.mediaType)
+      });
+      continue;
+    }
+    if (element.name === "script" && attributeValue(element, "src") !== void 0) {
+      return errorResult(
+        "single-html-script-external",
+        "non-module script sources to be absent from the generated host",
+        "Move the script into the production module entry before packaging.",
+        { src: attributeValue(element, "src") }
+      );
+    }
+  }
+  const assetNodes = [...resources.values()].sort((left, right) => left.path.localeCompare(right.path)).map(
+    (resource, index) => `<script type="application/octet-stream" id="forgeax-asset-${index}" data-forgeax-asset data-path="${escapeAttribute(resource.path)}" data-mime="${escapeAttribute(resource.mediaType)}">${Buffer.from(resource.bytes).toString("base64")}</script>`
+  ).join("");
+  const bootstrap = `<script type="application/javascript">${safeScriptText(runtimeBootstrap([...resources.values()]))}</script>`;
+  const entry = `<script type="module">${safeScriptText(bundle.entrySource)}</script>`;
+  const withResources = applyReplacements(indexHtml, replacements);
+  const body = `${assetNodes}${bootstrap}${entry}`;
+  const html = withResources.includes("</body>") ? withResources.replace(/<\/body>/i, () => `${body}</body>`) : `${withResources}${body}`;
+  return { ok: true, value: { html, embeddedAssets: resources.size } };
+}
+async function writeSingleHtml(options) {
+  const distRoot = resolve(options.distRoot);
+  const output = resolve(options.output);
+  const checksumPath = `${output}.sha256`;
+  const temporary = `${output}.partial-${process.pid}`;
+  const temporaryChecksum = `${checksumPath}.partial-${process.pid}`;
+  try {
+    const indexHtml = await readFile(resolve(distRoot, "index.html"), "utf8");
+    const resources = await distResources(distRoot, options.manifest);
+    const built = buildHtml(indexHtml, resources, options.bundle);
+    if (!built.ok) return built;
+    const bytes = Buffer.from(built.value.html, "utf8");
+    const sha2562 = hashBytes(bytes);
+    const manifestBytes = await readFile(resolve(distRoot, "forgeax-dist.json"));
+    await mkdir(dirname(output), { recursive: true });
+    await writeFile(temporary, bytes);
+    await writeFile(temporaryChecksum, `${sha2562}  ${basename(output)}
+`, "utf8");
+    await rename(temporaryChecksum, checksumPath);
+    await rename(temporary, output);
+    return {
+      ok: true,
+      value: {
+        schemaVersion: "1.0.0",
+        format: SINGLE_HTML_FORMAT,
+        target: "file",
+        project: options.manifest.project,
+        base: options.manifest.base,
+        html: { path: output, bytes: bytes.byteLength, sha256: sha2562 },
+        checksumPath,
+        distManifestSha256: hashBytes(manifestBytes),
+        embeddedAssets: built.value.embeddedAssets,
+        run: {
+          local: pathToFileURL(output).href,
+          shared: "send the HTML file and open it in a desktop Chrome with WebGPU support"
+        }
+      }
+    };
+  } catch (cause) {
+    return toErrorResult(
+      cause,
+      "single-html-write-failed",
+      "the single HTML candidate and adjacent SHA-256 to be written atomically",
+      "Repair the dist closure or output directory, then retry packaging."
+    );
+  } finally {
+    await Promise.all([rm(temporary, { force: true }), rm(temporaryChecksum, { force: true })]);
+  }
+}
+function packageFormatError(format) {
+  return errorResult(
+    "package-format-unsupported",
+    "package format to be web-zip or single-html",
+    "Use web-zip for HTTPS hosting or single-html for a self-contained file:// delivery.",
+    { format }
+  );
+}
+function packageOutputError(output, format) {
+  const expectedSuffix = format === "single-html" ? ".html" : ".zip";
+  return errorResult(
+    "package-output-suffix-mismatch",
+    `package output to end with ${expectedSuffix}`,
+    `Use a ${expectedSuffix} output path for ${format}.`,
+    { output, format }
+  );
+}
+var SINGLE_HTML_FORMAT, GENERATED_PREFIX, SingleHtmlError;
+var init_single_html = __esm({
+  "src/single-html.ts"() {
+    init_dist();
+    init_host();
+    SINGLE_HTML_FORMAT = "forgeax-single-html-game";
+    GENERATED_PREFIX = "__forgeax-bundle/";
+    SingleHtmlError = class extends Error {
+      constructor(code, expected, hint, detail) {
+        super(`${code}: ${hint}`);
+        this.code = code;
+        this.expected = expected;
+        this.hint = hint;
+        this.detail = detail;
+        this.name = "SingleHtmlError";
+      }
+      code;
+      expected;
+      hint;
+      detail;
+    };
+  }
+});
 
 // src/types.ts
 function resolveProjectPort(port) {
@@ -2106,11 +2901,13 @@ var init_package = __esm({
         "@forgeax/engine-types": "workspace:*",
         "@forgeax/engine-vfx-compiler": "workspace:*",
         "@forgeax/engine-vite-plugin-pack": "workspace:*",
+        "@forgeax/engine-vite-plugin-rhi-debug": "workspace:*",
         "@forgeax/engine-vite-plugin-shader": "workspace:*",
         jiti: "1.21.7",
+        parse5: "7.3.0",
         playwright: "1.60.0",
         vite: "8.0.10",
-        vitest: "4.0.18",
+        vitest: "4.1.11",
         webgpu: "^0.4.0"
       },
       devDependencies: {
@@ -2285,7 +3082,7 @@ var init_init = __esm({
       "@webgpu/types": "0.1.71",
       tsx: "4.23.1",
       typescript: "6.0.3",
-      vitest: "4.0.18"
+      vitest: "4.1.11"
     };
   }
 });
@@ -2307,15 +3104,12 @@ async function findSdkContext() {
       const templates = new Map(
         manifest.templates.map((template) => [template.id, resolve(cursor, template.root)])
       );
-      const defaultTemplate = manifest.templates.find((template) => template.default);
-      if (defaultTemplate === void 0) throw new Error("sdk-default-template-missing");
       const store = resolve(cursor, "store", "pnpm");
       return {
         root: cursor,
         manifest,
         ...await readable(store) ? { store } : {},
-        templates,
-        defaultTemplate: defaultTemplate.id
+        templates
       };
     }
     const parent = dirname(cursor);
@@ -2335,10 +3129,14 @@ function agentOnboarding(sdk, projectRoot) {
       resolve(root, "skills", "forgeax-engine-sdk", "SKILL.md"),
       resolve(root, "skills", "forgeax-engine-sdk", "references", "feature-catalog.md")
     ],
-    next: projectRoot === void 0 ? {
-      cwd: root,
-      argv: ["node", "./bin/forgeax.mjs", "new", "../my-game"]
-    } : { cwd: root, argv: ["pnpm", "exec", "forgeax", "list", "--json"] }
+    ...projectRoot === void 0 ? {
+      templateSelection: {
+        required: true,
+        game3d: "game-3d",
+        otherwise: "empty"
+      }
+    } : {},
+    ...projectRoot === void 0 ? {} : { next: { cwd: root, argv: ["pnpm", "exec", "forgeax", "list", "--json"] } }
   };
 }
 function sdkInitPath(sdk) {
@@ -2420,8 +3218,8 @@ async function requireSdkInitialization(sdk) {
   return { ok: true, value: state };
 }
 async function copyBootstrapInputs(sdk, root) {
-  const template = sdk.templates.get(sdk.defaultTemplate);
-  if (template === void 0) throw new Error("sdk-default-template-missing");
+  const template = sdk.templates.get("empty");
+  if (template === void 0) throw new Error("sdk-bootstrap-template-missing");
   for (const name of ["package.json", "pnpm-lock.yaml", "pnpm-workspace.yaml"]) {
     await cp(resolve(template, name), resolve(root, name));
   }
@@ -2613,13 +3411,13 @@ async function pathKind(path) {
     throw cause;
   }
 }
-async function filesUnder2(root, directory = root) {
+async function filesUnder3(root, directory = root) {
   const files = [];
   for (const name of (await readdir(directory)).sort()) {
     const path = resolve(directory, name);
     const info = await lstat(path);
     if (info.isSymbolicLink()) throw new Error(`skill-source-symlink: ${path}`);
-    if (info.isDirectory()) files.push(...await filesUnder2(root, path));
+    if (info.isDirectory()) files.push(...await filesUnder3(root, path));
     else if (info.isFile()) files.push(path);
   }
   return files;
@@ -2631,7 +3429,7 @@ async function skillRow(sourceRoot, id) {
   if (await pathKind(resolve(root, "SKILL.md")) !== "file") {
     throw new Error(`skill-entry-missing: ${id}/SKILL.md`);
   }
-  const files = await filesUnder2(root);
+  const files = await filesUnder3(root);
   return {
     id,
     root: `skills/${id}`,
@@ -2648,8 +3446,8 @@ async function discoverProjectSkills(root) {
   return Promise.all(ids.map((id) => skillRow(sourceRoot, id)));
 }
 async function sameFiles(leftRoot, rightRoot) {
-  const left = await filesUnder2(leftRoot);
-  const right = await filesUnder2(rightRoot);
+  const left = await filesUnder3(leftRoot);
+  const right = await filesUnder3(rightRoot);
   const leftNames = left.map((path) => slash(relative(leftRoot, path)));
   const rightNames = right.map((path) => slash(relative(rightRoot, path)));
   if (JSON.stringify(leftNames) !== JSON.stringify(rightNames)) return false;
@@ -3073,8 +3871,8 @@ async function initCommand(options = {}) {
     const applied = await applyInitPlan(facts.value, plan.value, options);
     if (!applied.ok || options.dryRun === true) return applied;
     if (sdk !== void 0) {
-      const template = sdk.templates.get(sdk.defaultTemplate);
-      if (template === void 0) throw new Error("sdk-default-template-missing");
+      const template = sdk.templates.get("empty");
+      if (template === void 0) throw new Error("sdk-bootstrap-template-missing");
       await copyFile(
         resolve(template, "pnpm-lock.yaml"),
         resolve(facts.value.root, "pnpm-lock.yaml")
@@ -3142,7 +3940,18 @@ async function newCommand(options = {}) {
         }
       };
     }
-    const templateId = options.template ?? sdk.defaultTemplate;
+    if (options.template === void 0) {
+      return {
+        ok: false,
+        error: {
+          code: "sdk-template-required",
+          expected: "forgeax new to select exactly one template with --template",
+          hint: "Use --template game-3d for a 3D game; otherwise use --template empty.",
+          detail: { templates: [...sdk.templates.keys()].sort() }
+        }
+      };
+    }
+    const templateId = options.template;
     const template = sdk.templates.get(templateId);
     if (template === void 0) {
       return {
@@ -4060,28 +4869,32 @@ function observedBackend(runtime) {
   return isSoftwareAdapter(runtime) ? "software" : "hardware";
 }
 async function resolveBrowserExecutable(requested) {
+  if (requested !== void 0 && requested.length > 0) {
+    return await pathExists2(requested) ? requested : void 0;
+  }
   const candidates = [
-    requested,
     process.env.FORGEAX_BROWSER_EXECUTABLE,
     "/opt/google/chrome-beta/chrome",
     "/usr/bin/google-chrome",
     "/usr/bin/google-chrome-stable",
     "/usr/bin/chromium",
-    "/usr/bin/chromium-browser"
+    "/usr/bin/chromium-browser",
+    typeof chromium.executablePath === "function" ? chromium.executablePath() : void 0
   ].filter((candidate) => candidate !== void 0 && candidate.length > 0);
   for (const candidate of candidates) {
     if (await pathExists2(candidate)) return candidate;
   }
   return void 0;
 }
-function browserLaunchArgs(backend) {
-  const common = [
-    "--enable-unsafe-webgpu",
-    "--ignore-gpu-blocklist",
-    "--disable-gpu-driver-bug-workarounds",
-    "--force-color-profile=srgb",
-    "--force-device-scale-factor=1"
-  ];
+function browserLaunchArgs(backend, profile) {
+  const common = ["--force-color-profile=srgb", "--force-device-scale-factor=1"];
+  if (profile === "development") {
+    common.unshift(
+      "--enable-unsafe-webgpu",
+      "--ignore-gpu-blocklist",
+      "--disable-gpu-driver-bug-workarounds"
+    );
+  }
   if (backend !== "software") return common;
   return [
     ...common,
@@ -4172,6 +4985,7 @@ async function runtimeWitness(page) {
       adapterError = String(cause);
     }
     const frameId = Number(document.documentElement.dataset[datasetKey]);
+    const singleHtmlState = globalThis.__forgeaxSingleHtml;
     return {
       title: document.title,
       canvas: canvas instanceof HTMLCanvasElement ? { width: canvas.width, height: canvas.height } : null,
@@ -4184,6 +4998,7 @@ async function runtimeWitness(page) {
       adapterError,
       engineFrameId: Number.isSafeInteger(frameId) && frameId > 0 ? frameId : null,
       captureReady: document.documentElement.dataset.forgeaxCaptureReady ?? null,
+      singleHtml: singleHtmlState?.witness?.() ?? null,
       userAgent: navigator.userAgent
     };
   }, FORGEAX_FRAME_SUBMITTED_DATASET);
@@ -4199,8 +5014,81 @@ async function writeRunReport(report) {
   await writeFile(report.report, `${JSON.stringify(report, null, 2)}
 `, "utf8");
 }
+function requestProtocol(url) {
+  try {
+    return new URL(url).protocol;
+  } catch {
+    return void 0;
+  }
+}
+function requestRecord(request, target, candidateUrl) {
+  const url = request.url();
+  const protocol = requestProtocol(url);
+  const requestDocument = url.split(/[?#]/, 1)[0];
+  const candidateDocument = candidateUrl.split(/[?#]/, 1)[0];
+  return {
+    url,
+    resourceType: request.resourceType(),
+    status: null,
+    failed: false,
+    failure: null,
+    resourceMiss: target.kind === "single-html" && protocol === "file:" && requestDocument !== candidateDocument
+  };
+}
+function summarizeRequests(records) {
+  return {
+    documents: records.filter((record) => record.resourceType === "document").length,
+    http: records.filter((record) => requestProtocol(record.url) === "http:").length,
+    https: records.filter((record) => requestProtocol(record.url) === "https:").length,
+    failed: records.filter((record) => record.failed).length,
+    resourceMisses: records.filter((record) => record.resourceMiss).length,
+    entries: records.map((record) => ({ ...record }))
+  };
+}
+function singleHtmlRuntimeClean(target, runtime, requests) {
+  if (target.kind !== "single-html") return true;
+  const singleHtml = runtime?.singleHtml;
+  return singleHtml?.ready === true && singleHtml.resourceMisses.length === 0 && singleHtml.externalRequests.length === 0 && requests.http === 0 && requests.https === 0 && requests.failed === 0 && requests.resourceMisses === 0;
+}
+function markResponse(records, response) {
+  const record = records.get(response.request());
+  if (record === void 0) return;
+  record.status = response.status();
+  if (record.status >= 400) record.resourceMiss = true;
+}
+function markFailed(records, request) {
+  const record = records.get(request);
+  if (record === void 0) return;
+  record.failed = true;
+  record.failure = request.failure()?.errorText ?? "request failed";
+  record.resourceMiss = true;
+}
 async function openBrowserCaptureSession(root, options) {
   const backend = options.backend ?? (options.software === true ? "software" : "auto");
+  const launchProfile = options.launchProfile ?? "development";
+  const requestedTarget = options.target ?? { kind: "project" };
+  const target = requestedTarget.kind === "single-html" ? { kind: "single-html", path: resolve(requestedTarget.path) } : { kind: "project" };
+  if (target.kind === "single-html") {
+    if (!target.path.toLowerCase().endsWith(".html")) {
+      fail(
+        "browser-capture-target-invalid",
+        "single-html target path to end with .html",
+        "Pass the exact forgeax package --format single-html candidate.",
+        { path: target.path }
+      );
+    }
+    try {
+      const info = await stat(target.path);
+      if (!info.isFile()) throw new Error("target is not a regular file");
+    } catch (cause) {
+      fail(
+        "browser-capture-target-missing",
+        "single-html target path to exist",
+        "Package the game first, then pass its candidate HTML path.",
+        { path: target.path, reason: cause instanceof Error ? cause.message : String(cause) }
+      );
+    }
+  }
   if (options.software === true && options.backend !== void 0 && options.backend !== "software") {
     fail(
       "browser-capture-option-conflict",
@@ -4238,27 +5126,32 @@ async function openBrowserCaptureSession(root, options) {
     facts.value.root,
     options.report ?? resolve(outputDirectory, "run.json")
   );
-  const port = options.port === void 0 || options.port === 0 ? await reservePort() : options.port;
+  const port = target.kind === "project" ? options.port === void 0 || options.port === 0 ? await reservePort() : options.port : void 0;
   let server;
   let browser;
   let page;
   let display;
   try {
-    const { createServer: createServer5 } = await import('vite');
-    server = await createServer5(
-      await createViteConfig(facts.value, "serve", "/", {
-        server: { port, strictPort: true }
-      })
-    );
-    await server.listen(port);
+    if (target.kind === "project") {
+      const { createServer: createServer5 } = await import('vite');
+      if (port === void 0) throw new Error("project capture did not reserve a port");
+      server = await createServer5(
+        await createViteConfig(facts.value, "serve", "/", {
+          server: { port, strictPort: true }
+        })
+      );
+      await server.listen(port);
+    }
     display = await startVirtualDisplay(width, height);
     const captureDisplay = display;
     const icd = await lavapipeIcd();
     const consoleErrors = [];
     const pageErrors = [];
+    const requestRecords = [];
+    const requestByObject = /* @__PURE__ */ new Map();
     const hasDisplay = display.value !== void 0;
     const headless = options.headless ?? (!hasDisplay && process.platform !== "linux");
-    const baseUrl = new URL(server.resolvedUrls?.local[0] ?? `http://127.0.0.1:${port}/`);
+    const baseUrl = target.kind === "project" ? new URL(server?.resolvedUrls?.local[0] ?? `http://127.0.0.1:${port ?? 0}/`) : void 0;
     const openPage = async (launchBackend) => {
       const browserEnvironment = {
         ...Object.fromEntries(
@@ -4272,7 +5165,7 @@ async function openBrowserCaptureSession(root, options) {
       const launchOptions = {
         headless,
         env: browserEnvironment,
-        args: browserLaunchArgs(launchBackend),
+        args: browserLaunchArgs(launchBackend, launchProfile),
         ...browserPath === void 0 ? {} : { executablePath: browserPath }
       };
       browser = await chromium.launch(launchOptions);
@@ -4289,7 +5182,14 @@ async function openBrowserCaptureSession(root, options) {
         if (message.type() === "error") consoleErrors.push(message.text());
       });
       page.on("pageerror", (error) => pageErrors.push(String(error)));
-      const captureUrl2 = new URL(baseUrl.href);
+      const captureUrl2 = target.kind === "single-html" ? new URL(pathToFileURL(target.path).href) : new URL(baseUrl?.href ?? "http://127.0.0.1/");
+      page.on("request", (request) => {
+        const record = requestRecord(request, target, captureUrl2.href);
+        requestRecords.push(record);
+        requestByObject.set(request, record);
+      });
+      page.on("response", (response) => markResponse(requestByObject, response));
+      page.on("requestfailed", (request) => markFailed(requestByObject, request));
       if (options.deterministic === true) captureUrl2.searchParams.set("forgeaxCapture", "1");
       await page.goto(captureUrl2.href, { waitUntil: "domcontentloaded", timeout: 12e4 });
       await page.waitForFunction(
@@ -4315,10 +5215,12 @@ async function openBrowserCaptureSession(root, options) {
       page = void 0;
       consoleErrors.length = 0;
       pageErrors.length = 0;
+      requestRecords.length = 0;
+      requestByObject.clear();
       runtime = await openPage("software");
       observed = observedBackend(runtime);
     }
-    const captureUrl = new URL(baseUrl.href);
+    const captureUrl = target.kind === "single-html" ? new URL(pathToFileURL(target.path).href) : new URL(baseUrl?.href ?? "http://127.0.0.1/");
     if (options.deterministic === true) captureUrl.searchParams.set("forgeaxCapture", "1");
     if (page === void 0 || browser === void 0) {
       fail(
@@ -4328,6 +5230,7 @@ async function openBrowserCaptureSession(root, options) {
       );
     }
     const captures = [];
+    let latestRuntime = runtime;
     let closed = false;
     const report = {
       schemaVersion: "2.0.0",
@@ -4336,6 +5239,8 @@ async function openBrowserCaptureSession(root, options) {
       mode: "browser-compositor",
       root: facts.value.root,
       url: captureUrl.href,
+      target,
+      launchProfile,
       report: reportPath,
       backendRequested: backend,
       backend: observed,
@@ -4354,14 +5259,19 @@ async function openBrowserCaptureSession(root, options) {
       display: display.value ?? null,
       lavapipeIcd: icd ?? null,
       captures,
+      requests: summarizeRequests(requestRecords),
+      singleHtml: runtime.singleHtml,
       consoleErrors,
       pageErrors,
       boundary: "Browser-compositor capture is visual iteration evidence, not physical-GPU performance, HDR-display output, or release acceptance."
     };
     await writeRunReport(report);
     const updateReport = async () => {
+      const requests = summarizeRequests(requestRecords);
       Object.assign(report, {
-        ok: captures.length > 0 && captures.every((capture) => capture.ok) && consoleErrors.length === 0 && pageErrors.length === 0
+        requests,
+        singleHtml: latestRuntime?.singleHtml ?? null,
+        ok: captures.length > 0 && captures.every((capture) => capture.ok) && consoleErrors.length === 0 && pageErrors.length === 0 && singleHtmlRuntimeClean(target, latestRuntime, requests)
       });
       await writeRunReport(report);
     };
@@ -4426,12 +5336,14 @@ async function openBrowserCaptureSession(root, options) {
           }
         }
         const runtime2 = await runtimeWitness(activePage);
+        latestRuntime = runtime2;
+        const requestSummary = summarizeRequests(requestRecords);
         const uiPresent = runtime2.domUi.rootChildren > 0;
         const requireUi = captureOptions.requireUi ?? options.requireUi ?? false;
         const captureBackend = observedBackend(runtime2);
         if (captureBackend !== "unknown") Object.assign(report, { backend: captureBackend });
         const backendMatches = backend === "auto" || captureBackend === backend;
-        const ok2 = runtime2.canvas !== null && captured.pixels.rendered && backendMatches && runtime2.engineFrameId !== null && consoleErrors.length === 0 && pageErrors.length === 0 && (expectedReady === void 0 || runtime2.captureReady === expectedReady) && (!requireUi || uiPresent);
+        const ok2 = runtime2.canvas !== null && captured.pixels.rendered && backendMatches && runtime2.engineFrameId !== null && consoleErrors.length === 0 && pageErrors.length === 0 && singleHtmlRuntimeClean(target, runtime2, requestSummary) && (expectedReady === void 0 || runtime2.captureReady === expectedReady) && (!requireUi || uiPresent);
         const index = captures.length + 1;
         const output = resolve(
           facts.value.root,
@@ -4646,31 +5558,47 @@ function releaseSlug(name) {
 async function packageCommand(options = {}) {
   const facts = await readProjectFacts(options.root);
   if (!facts.ok) return facts;
-  const built = await buildCommand({
-    root: facts.value.root,
-    base: "./",
-    ...options.json === void 0 ? {} : { json: options.json }
-  });
-  if (!built.ok) return built;
+  const format = options.format ?? "web-zip";
+  if (format !== "web-zip" && format !== "single-html") return packageFormatError(String(format));
+  const defaultOutput = format === "single-html" ? `release/${releaseSlug(facts.value.name)}-offline.html` : `release/${releaseSlug(facts.value.name)}-web.zip`;
+  const output = resolve(facts.value.root, options.output ?? defaultOutput);
+  const expectedSuffix = format === "single-html" ? ".html" : ".zip";
+  if (!output.toLowerCase().endsWith(expectedSuffix)) {
+    return packageOutputError(output, format);
+  }
   const distRoot = resolve(facts.value.root, "dist");
-  const verified = await verifyDist(distRoot);
-  if (!verified.ok) return verified;
-  const archive = resolve(
-    facts.value.root,
-    options.output ?? `release/${releaseSlug(facts.value.name)}-web.zip`
-  );
-  const archiveRelativeToDist = relative(distRoot, archive);
-  if (archiveRelativeToDist === "" || !archiveRelativeToDist.startsWith("..")) {
+  const outputRelativeToDist = relative(distRoot, output);
+  if (outputRelativeToDist === "" || !outputRelativeToDist.startsWith("..") && outputRelativeToDist !== "..") {
     return {
       ok: false,
       error: {
         code: "release-output-inside-dist",
-        expected: "the release archive to live outside the derived dist directory",
-        hint: "Use --output release/<game>-web.zip or another path outside dist.",
-        detail: { archive, distRoot }
+        expected: "the release artifact to live outside the derived dist directory",
+        hint: "Use --output release/<game>-web.zip or release/<game>-offline.html.",
+        detail: { output, distRoot, format }
       }
     };
   }
+  const built = await buildCommand({
+    root: facts.value.root,
+    base: "./",
+    ...options.json === void 0 ? {} : { json: options.json }
+  });
+  if (!built.ok) return built;
+  const verified = await verifyDist(distRoot);
+  if (!verified.ok) return verified;
+  if (format === "single-html") {
+    const indexHtml = await readFile(resolve(distRoot, "index.html"), "utf8");
+    const bundle = await bundleSingleHtmlEntry(distRoot, indexHtml, facts.value.root);
+    if (!bundle.ok) return bundle;
+    return writeSingleHtml({
+      distRoot,
+      output,
+      manifest: verified.value,
+      bundle: bundle.value
+    });
+  }
+  const archive = output;
   const temporaryArchive = `${archive}.partial-${process.pid}`;
   const checksumPath = `${archive}.sha256`;
   const temporaryChecksum = `${checksumPath}.partial-${process.pid}`;
@@ -4840,6 +5768,7 @@ var init_commands = __esm({
     init_dist();
     init_host();
     init_project();
+    init_single_html();
     init_types();
     init_assets();
     init_bootstrap_commands();
@@ -4854,6 +5783,19 @@ var init_commands = __esm({
     init_operations();
   }
 });
+function createNativePreviewCatalog(host, selectedName) {
+  return new Map(
+    nativePreviewPlugins.filter(([name]) => selectedName === void 0 || name === selectedName).map(([name, plugin]) => [
+      name,
+      {
+        realm: "host",
+        load: async () => ({
+          default: bindPreviewHost(plugin, host)
+        })
+      }
+    ])
+  );
+}
 var nativePreviewPlugins, nativePreviewTools, nativePreviewDescriptors;
 var init_preview_catalog = __esm({
   "src/tools/preview-catalog.ts"() {
@@ -5350,11 +6292,11 @@ async function runProjectTool(binding, args, options) {
     );
     await loader.root.update(entries2);
     await loader.await();
-    const { createToolRuntime: createToolRuntime5 } = await import('@forgeax/engine-tool-runtime');
-    const { createContextCapabilityResolver } = await import('@forgeax/engine-plugin');
-    return await createToolRuntime5([contribution]).run(contribution, args, {
+    const { createToolRuntime: createToolRuntime6 } = await import('@forgeax/engine-tool-runtime');
+    const { createContextCapabilityResolver: createContextCapabilityResolver2 } = await import('@forgeax/engine-plugin');
+    return await createToolRuntime6([contribution]).run(contribution, args, {
       ...options,
-      capabilityResolver: createContextCapabilityResolver(ctx)
+      capabilityResolver: createContextCapabilityResolver2(ctx)
     }).terminal;
   } catch (cause) {
     return activationFailure(cause);
@@ -5366,6 +6308,50 @@ var init_project_tools = __esm({
   "src/tools/project-tools.ts"() {
   }
 });
+
+// src/tools/contributions.ts
+var contributions_exports = {};
+__export(contributions_exports, {
+  createAuthorContribution: () => createAuthorContribution,
+  createBuildContribution: () => createBuildContribution,
+  createDefaultContributions: () => createDefaultContributions
+});
+function commandFailure2(error) {
+  return { ok: false, error: { ...error, detail: error.detail } };
+}
+function createBuildContribution(projectRoot = process.cwd()) {
+  return defineTool(
+    projectBuildDescriptor,
+    async (options) => {
+      const { buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
+      const result = await buildCommand2({ ...options, root: options.root ?? projectRoot });
+      return result.ok ? result.value : commandFailure2(result.error);
+    }
+  );
+}
+function createAuthorContribution(projectRoot = process.cwd()) {
+  return defineTool(
+    authorPluginInstallDescriptor,
+    async (options) => {
+      const { pluginInstallCommand: pluginInstallCommand2 } = await Promise.resolve().then(() => (init_plugin_authoring(), plugin_authoring_exports));
+      const result = await pluginInstallCommand2({ ...options, root: options.root ?? projectRoot });
+      return result.ok ? result.value : commandFailure2(result.error);
+    }
+  );
+}
+function createDefaultContributions(projectRoot = process.cwd()) {
+  return [
+    createBuildContribution(projectRoot),
+    createAuthorContribution(projectRoot),
+    ...nativePreviewTools
+  ];
+}
+var init_contributions = __esm({
+  "src/tools/contributions.ts"() {
+    init_catalog();
+    init_preview_catalog();
+  }
+});
 function analyzePreviewArtifacts(request) {
   const required = request.required ?? [];
   const validated = request.manifest.schemaVersion === "1.0.0" ? required.some((kind) => kind !== "rhi-tape" && kind !== "png" && kind !== "profile-capture") ? {
@@ -5416,14 +6402,6 @@ function createPreviewContributions() {
     createOfflineAnalysisContribution()
   ];
 }
-function createDomainPreviewContributions() {
-  return [
-    createMaterialPreviewContribution(),
-    createMeshPreviewContribution(),
-    createVfxPreviewContribution(),
-    createTexturePreviewContribution()
-  ];
-}
 var init_preview_contributions = __esm({
   "src/tools/preview-contributions.ts"() {
     init_catalog();
@@ -5432,50 +6410,6 @@ var init_preview_contributions = __esm({
   }
 });
 
-// src/tools/contributions.ts
-var contributions_exports = {};
-__export(contributions_exports, {
-  createAuthorContribution: () => createAuthorContribution,
-  createBuildContribution: () => createBuildContribution,
-  createDefaultContributions: () => createDefaultContributions
-});
-function commandFailure2(error) {
-  return { ok: false, error: { ...error, detail: error.detail } };
-}
-function createBuildContribution(projectRoot = process.cwd()) {
-  return defineTool(
-    projectBuildDescriptor,
-    async (options) => {
-      const { buildCommand: buildCommand2 } = await Promise.resolve().then(() => (init_commands(), commands_exports));
-      const result = await buildCommand2({ ...options, root: options.root ?? projectRoot });
-      return result.ok ? result.value : commandFailure2(result.error);
-    }
-  );
-}
-function createAuthorContribution(projectRoot = process.cwd()) {
-  return defineTool(
-    authorPluginInstallDescriptor,
-    async (options) => {
-      const { pluginInstallCommand: pluginInstallCommand2 } = await Promise.resolve().then(() => (init_plugin_authoring(), plugin_authoring_exports));
-      const result = await pluginInstallCommand2({ ...options, root: options.root ?? projectRoot });
-      return result.ok ? result.value : commandFailure2(result.error);
-    }
-  );
-}
-function createDefaultContributions(projectRoot = process.cwd()) {
-  return [
-    createBuildContribution(projectRoot),
-    createAuthorContribution(projectRoot),
-    ...createDomainPreviewContributions()
-  ];
-}
-var init_contributions = __esm({
-  "src/tools/contributions.ts"() {
-    init_catalog();
-    init_preview_contributions();
-  }
-});
-
 // src/tools/runtime.ts
 var runtime_exports = {};
 __export(runtime_exports, {
@@ -5493,1078 +6427,1336 @@ var init_runtime = __esm({
     init_preview_contributions();
   }
 });
-
-// src/index.ts
-init_commands();
-init_dist();
-init_engine_binding();
-init_init();
-init_project();
-init_operations();
-init_software_capture();
-
-// src/tools/benchmark/statistics.ts
-function calculateSampleStatistics(samples) {
-  if (samples.length === 0) throw new RangeError("benchmark samples must not be empty");
-  const sorted = [...samples].sort((left, right) => left - right);
-  const medianIndex = (sorted.length - 1) / 2;
-  const median = interpolate(sorted, medianIndex);
-  const p95 = interpolate(sorted, Math.ceil(sorted.length * 0.95) - 1);
-  const max = sorted[sorted.length - 1];
-  if (max === void 0) throw new RangeError("benchmark samples must not be empty");
-  return { count: sorted.length, median, p95, max };
-}
-function interpolate(values, index) {
-  const lower = Math.floor(index);
-  const upper = Math.ceil(index);
-  const lowerValue = values[lower];
-  const upperValue = values[upper];
-  if (lowerValue === void 0 || upperValue === void 0) {
-    throw new RangeError("benchmark percentile index is out of range");
-  }
-  return lower === upper ? lowerValue : lowerValue + (upperValue - lowerValue) * (index - lower);
-}
-
-// src/tools/benchmark/report.ts
-var DEFAULT_ADMISSION_THRESHOLDS = {
-  sampleCountPerPhase: 30,
-  medianImprovement: 0.2,
-  p95Improvement: 0.1,
-  maxRegression: 0.1,
-  peakRssMultiplier: 1.25
-};
-function summarizeBenchmarkSamples(samples) {
-  if (samples.length === 0) {
+function transportCause(cause) {
+  if (cause instanceof Error) {
     return {
-      samples: 0,
-      durationMs: { count: 0, median: 0, p95: 0, max: 0 },
-      peakRssBytes: { count: 0, median: 0, p95: 0, max: 0 },
-      cleanupPassed: false,
-      evictionPassed: false,
-      exclusivePhasesMs: {}
+      name: cause.name,
+      message: cause.message,
+      ...cause.stack === void 0 ? {} : { stack: cause.stack }
     };
   }
-  const durations = samples.map((sample) => sample.durationMs);
-  const rss = samples.map((sample) => sample.peakRssBytes);
-  const phaseNames = [
-    ...new Set(samples.flatMap((sample) => Object.keys(sample.exclusivePhasesMs)))
-  ];
-  const exclusivePhasesMs = Object.fromEntries(
-    phaseNames.map((phase) => [
-      phase,
-      calculateSampleStatistics(samples.map((sample) => sample.exclusivePhasesMs[phase] ?? 0))
-    ])
-  );
+  if (cause === void 0) return "undefined";
+  try {
+    return JSON.parse(JSON.stringify(cause));
+  } catch {
+    return String(cause);
+  }
+}
+function dataUriBytes(uri) {
+  const separator = uri.indexOf(",");
+  if (separator < 0) throw new TypeError("preview artifact must be a data URI before publication");
+  return Buffer.from(uri.slice(separator + 1), "base64");
+}
+function projectUri(projectRoot, path) {
+  return relative(projectRoot, path).split(sep).join("/");
+}
+async function allocateLoopbackPort() {
+  const probe = createServer$1();
+  try {
+    await new Promise((resolve19, reject) => {
+      const onError = (error) => {
+        probe.off("listening", onListening);
+        reject(error);
+      };
+      const onListening = () => {
+        probe.off("error", onError);
+        resolve19();
+      };
+      probe.once("error", onError);
+      probe.once("listening", onListening);
+      probe.listen(0, "127.0.0.1");
+    });
+    const address = probe.address();
+    if (address === null || typeof address === "string") {
+      throw new Error("loopback port probe did not expose a TCP address");
+    }
+    return address.port;
+  } finally {
+    if (probe.listening) {
+      await new Promise((resolve19) => probe.close(() => resolve19()));
+    }
+  }
+}
+function sha256(bytes) {
+  return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+}
+function artifactRef(artifact) {
+  const kind = artifact.kind === "report" || artifact.kind === "contact-sheet" ? "tool-result" : artifact.kind;
   return {
-    samples: samples.length,
-    durationMs: calculateSampleStatistics(durations),
-    peakRssBytes: calculateSampleStatistics(rss),
-    cleanupPassed: samples.every((sample) => sample.cleanupPassed),
-    evictionPassed: samples.every((sample) => sample.evictionPassed),
-    exclusivePhasesMs
+    kind,
+    digest: artifact.digest,
+    uri: artifact.uri,
+    mediaType: artifact.mediaType,
+    sizeBytes: artifact.byteLength
   };
 }
-function createAdmissionReport(recipe, samples, thresholds = DEFAULT_ADMISSION_THRESHOLDS) {
-  const privateSamples = samples.filter((sample) => sample.mode === "private");
-  const serviceSamples = samples.filter((sample) => sample.mode === "service");
-  const order = samples.map((sample) => sample.mode);
-  const privateReport = summarizeBenchmarkSamples(privateSamples);
-  const serviceReport = summarizeBenchmarkSamples(serviceSamples);
-  const reasons = [];
-  const expectedSamples = thresholds.sampleCountPerPhase * 2;
-  const complete = privateSamples.length === expectedSamples && serviceSamples.length === expectedSamples;
-  if (!complete) {
-    reasons.push("sample count is incomplete");
-  }
-  if (samples.some((sample) => sample.recipeDigest !== recipe.digest)) {
-    reasons.push("recipe identity drifted");
+async function publishPreviewArtifacts(projectRoot, runId, result, reportInput) {
+  if (result.manifest.identity.runId !== runId) {
+    throw new Error(
+      `preview artifact run identity mismatch: manifest=${result.manifest.identity.runId} requested=${runId}`
+    );
   }
-  if (!privateReport.cleanupPassed || !serviceReport.cleanupPassed) reasons.push("cleanup failed");
-  if (!privateReport.evictionPassed || !serviceReport.evictionPassed)
-    reasons.push("eviction failed");
-  if (order.some((mode, index) => index > 0 && mode === order[index - 1])) {
-    reasons.push("private and service samples were not alternated");
-  }
-  const medianLimit = privateReport.durationMs.median * (1 - thresholds.medianImprovement);
-  const p95Limit = privateReport.durationMs.p95 * (1 - thresholds.p95Improvement);
-  const maxLimit = privateReport.durationMs.max * (1 + thresholds.maxRegression);
-  const rssLimit = privateReport.peakRssBytes.median * thresholds.peakRssMultiplier;
-  if (complete && serviceReport.durationMs.median > medianLimit)
-    reasons.push("median improvement threshold missed");
-  if (complete && serviceReport.durationMs.p95 > p95Limit)
-    reasons.push("p95 improvement threshold missed");
-  if (complete && serviceReport.durationMs.max > maxLimit)
-    reasons.push("max regression threshold exceeded");
-  if (complete && serviceReport.peakRssBytes.median > rssLimit)
-    reasons.push("peak RSS threshold exceeded");
-  return {
-    schema: "forgeax.tool-service-admission.v1",
-    recipe,
-    thresholds,
-    order,
-    private: privateReport,
-    service: serviceReport,
-    valid: complete && !reasons.some(
-      (reason) => [
-        "recipe identity drifted",
-        "cleanup failed",
-        "eviction failed",
-        "private and service samples were not alternated"
-      ].includes(reason)
-    ),
-    admitted: reasons.length === 0,
-    reasons
+  const runsRoot = join(projectRoot, ".forgeax", "tool-runs");
+  await mkdir(runsRoot, { recursive: true });
+  const directoryName = runId.replace(/[^a-zA-Z0-9._-]/g, "_");
+  const published = join(runsRoot, directoryName);
+  const finalPaths = {
+    tapeJson: join(published, "rhi-tape.json"),
+    tapeBlob: join(published, "rhi-tape.bin"),
+    capturePng: join(published, "capture.png"),
+    freshReplayPng: join(published, "fresh-replay.png"),
+    profile: join(published, "profile.json"),
+    manifest: join(published, "manifest.json"),
+    report: join(published, "report.json")
   };
-}
-
-// src/tools/benchmark/harness.ts
-async function runBenchmarkAdmission(options) {
-  const sampleCount = options.thresholds?.sampleCountPerPhase ?? 30;
-  const samples = [];
-  const phases = ["cold", "warm"];
-  const modes = ["private", "service"];
-  for (const phase of phases) {
-    for (let index = 0; index < sampleCount; index += 1) {
-      for (const mode of modes) {
-        const measurement = await options.measure(mode, phase, index);
-        samples.push({
-          mode,
-          phase,
-          durationMs: measurement.durationMs,
-          peakRssBytes: measurement.peakRssBytes,
-          exclusivePhasesMs: measurement.exclusivePhasesMs ?? {},
-          rhiDebugOverheadMs: measurement.rhiDebugOverheadMs ?? 0,
-          carrierRendezvousMs: measurement.carrierRendezvousMs ?? 0,
-          cleanupPassed: measurement.cleanupPassed,
-          evictionPassed: measurement.evictionPassed,
-          recipeDigest: options.recipe.digest
-        });
-      }
+  const tapeJson = dataUriBytes(result.tape.jsonUri);
+  const tapeBlob = dataUriBytes(result.tape.blobUri);
+  const capturePng = dataUriBytes(result.capturePng.uri);
+  const freshReplayPng = dataUriBytes(result.png.uri);
+  const profile = dataUriBytes(result.profile.uri);
+  const bytesByRole = {
+    "rhi-tape": tapeJson,
+    capture: capturePng,
+    "fresh-replay": freshReplayPng,
+    "profile-capture": profile
+  };
+  const uriByRole = {
+    "rhi-tape": projectUri(projectRoot, finalPaths.tapeJson),
+    capture: projectUri(projectRoot, finalPaths.capturePng),
+    "fresh-replay": projectUri(projectRoot, finalPaths.freshReplayPng),
+    "profile-capture": projectUri(projectRoot, finalPaths.profile)
+  };
+  const mediaTypeByRole = {
+    "rhi-tape": "application/vnd.forgeax.rhi-tape+json",
+    capture: "image/png",
+    "fresh-replay": "image/png",
+    "profile-capture": "application/vnd.forgeax.profile+json"
+  };
+  const requiredRoles = ["rhi-tape", "capture", "fresh-replay", "profile-capture"];
+  const nonReportArtifacts = result.manifest.artifacts.filter((artifact) => artifact.role !== "report").map((artifact) => {
+    if (!(artifact.role in bytesByRole)) {
+      return artifact;
     }
-  }
-  return createAdmissionReport(options.recipe, samples, options.thresholds);
-}
-async function bootstrapRealm(ctx, input) {
-  const cloneSafe = validateRealmBootstrapPayload(input.payload);
-  if (!cloneSafe.ok) return cloneSafe;
-  if (!input.supportedRealms.includes(input.realm)) {
-    return {
-      ok: false,
-      error: {
-        code: "realm-capability-unavailable",
-        realm: input.realm,
-        supportedRealms: input.supportedRealms
-      }
-    };
-  }
-  const entries2 = projectPluginEntries(input.entries, input.realm, input.realm);
-  if (input.realm === "build") {
-    if (input.lifecycle === void 0) {
-      return {
-        ok: false,
-        error: {
-          code: "realm-lifecycle-adapter-missing",
-          realm: input.realm,
-          hint: "Inject a build lifecycle adapter that owns execution and stop cleanup."
-        }
-      };
+    const role = artifact.role;
+    const bytes = bytesByRole[role];
+    const digest = sha256(bytes);
+    if (artifact.digest !== digest) {
+      throw new Error(`preview artifact digest mismatch for ${artifact.role}`);
     }
-    const lifecycle = await input.lifecycle.start({
-      realm: input.realm,
-      entries: entries2,
-      catalog: input.catalog,
-      catalogDigest: input.catalogDigest
-    });
-    return {
-      ok: true,
-      value: { realm: input.realm, catalogDigest: input.catalogDigest, entries: entries2, lifecycle }
-    };
-  }
-  if (ctx === void 0) {
     return {
-      ok: false,
-      error: { code: "realm-context-missing", realm: input.realm }
+      ...artifact,
+      uri: uriByRole[role],
+      digest,
+      byteLength: bytes.byteLength,
+      mediaType: mediaTypeByRole[role]
     };
+  });
+  if (requiredRoles.some((role) => !nonReportArtifacts.some((artifact) => artifact.role === role))) {
+    throw new Error(
+      "preview publication is missing capture, fresh-replay, tape, or profile artifact"
+    );
   }
-  const loaded = await bootstrapCatalogLoader(ctx, input.catalog, input.realm, {
-    catalogDigest: input.catalogDigest,
-    supportedRealms: input.supportedRealms
+  let report;
+  let reportBytes;
+  if (reportInput !== void 0) {
+    if (reportInput.snapshot.digest !== result.manifest.identity.snapshotDigest) {
+      throw new Error("preview report snapshot identity does not match the artifact manifest");
+    }
+    report = createResourcePreviewReport({
+      runId,
+      snapshot: reportInput.snapshot,
+      subject: reportInput.subject,
+      presentation: reportInput.presentation,
+      oracle: reportInput.oracle,
+      artifacts: nonReportArtifacts
+    });
+    reportBytes = new TextEncoder().encode(JSON.stringify(report));
+  }
+  const reportArtifact = reportBytes === void 0 ? void 0 : {
+    owner: "resource-preview",
+    kind: "report",
+    role: "report",
+    uri: projectUri(projectRoot, finalPaths.report),
+    digest: sha256(reportBytes),
+    byteLength: reportBytes.byteLength,
+    mediaType: "application/vnd.forgeax.resource-preview+json",
+    derivedFrom: nonReportArtifacts.map((artifact) => artifact.digest)
+  };
+  const manifest = createPreviewArtifactManifest({
+    ...result.manifest,
+    artifacts: reportArtifact === void 0 ? nonReportArtifacts : [reportArtifact, ...nonReportArtifacts]
   });
-  if (!loaded.ok) return loaded;
+  const validated = validatePreviewArtifactManifest$1(
+    manifest,
+    reportArtifact === void 0 ? requiredRoles : ["report", ...requiredRoles]
+  );
+  if (!validated.ok) throw new Error(JSON.stringify(validated.error.detail));
+  const staging = await mkdtemp(join(runsRoot, ".staging-"));
+  const paths = {
+    tapeJson: join(staging, "rhi-tape.json"),
+    tapeBlob: join(staging, "rhi-tape.bin"),
+    capturePng: join(staging, "capture.png"),
+    freshReplayPng: join(staging, "fresh-replay.png"),
+    profile: join(staging, "profile.json"),
+    manifest: join(staging, "manifest.json"),
+    report: join(staging, "report.json")
+  };
+  try {
+    await Promise.all([
+      writeFile(paths.tapeJson, tapeJson),
+      writeFile(paths.tapeBlob, tapeBlob),
+      writeFile(paths.capturePng, capturePng),
+      writeFile(paths.freshReplayPng, freshReplayPng),
+      writeFile(paths.profile, profile),
+      ...reportBytes === void 0 ? [] : [writeFile(paths.report, reportBytes)]
+    ]);
+    await writeFile(paths.manifest, `${JSON.stringify(manifest, null, 2)}
+`);
+    await rename(staging, published);
+  } catch (cause) {
+    await rm(staging, { recursive: true, force: true });
+    throw cause;
+  }
   return {
-    ok: true,
-    value: {
-      realm: input.realm,
-      catalogDigest: input.catalogDigest,
-      entries: entries2,
-      loader: loaded.value
-    }
+    ...result,
+    tape: {
+      ...result.tape,
+      jsonUri: projectUri(projectRoot, finalPaths.tapeJson),
+      blobUri: projectUri(projectRoot, finalPaths.tapeBlob)
+    },
+    profile: { ...result.profile, uri: projectUri(projectRoot, finalPaths.profile) },
+    capturePng: { ...result.capturePng, uri: projectUri(projectRoot, finalPaths.capturePng) },
+    png: { ...result.png, uri: projectUri(projectRoot, finalPaths.freshReplayPng) },
+    manifest,
+    artifacts: manifest.artifacts.map(artifactRef)
   };
 }
-
-// src/tools/cache.ts
-function createServiceCache() {
-  const entries2 = /* @__PURE__ */ new Map();
+function browserFailure(phase, cause, pageErrors = []) {
   return {
-    get: (key) => entries2.get(key),
-    set: (key, entry) => entries2.set(key, entry),
-    evict: (key) => entries2.delete(key),
-    clear: () => entries2.clear(),
-    size: () => entries2.size
+    ok: false,
+    error: {
+      code: "tool-preview-browser-host-failed",
+      expected: "a real Chromium page, project bootstrap, WebGPU device, and bounded preview run",
+      hint: "Inspect the Browser Host phase and repair the project or local WebGPU capability.",
+      detail: {
+        phase,
+        cause: transportCause(cause),
+        pageErrors
+      }
+    }
   };
 }
-function errorResult(code, expected, hint, detail = {}) {
-  return { ok: false, error: { code, expected, hint, detail } };
-}
-async function readBody(request) {
-  const chunks = [];
-  for await (const chunk of request) chunks.push(Buffer.from(chunk));
-  const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
-  if (typeof value !== "object" || value === null || Array.isArray(value))
-    throw new Error("carrier request must be an object");
-  return value;
-}
-function reply(response, status, payload) {
-  response.statusCode = status;
-  response.setHeader("content-type", "application/json");
-  response.end(JSON.stringify(payload));
-}
-async function createCarrierProviderService(options) {
-  const host = options.host ?? "127.0.0.1";
-  const bearerToken = options.machine.offer.bearerToken;
-  const server = createServer(async (request, response) => {
-    if (request.method !== "POST" || !request.url?.startsWith("/carrier/")) {
-      reply(
-        response,
-        404,
-        errorResult(
-          "carrier-provider-exit",
-          "a carrier protocol route",
-          "Request a fresh visible offer from the provider."
-        )
-      );
-      return;
-    }
-    if (request.headers.authorization !== `Bearer ${bearerToken}`) {
-      reply(
-        response,
-        401,
-        errorResult(
-          "carrier-token-invalid",
-          "the ephemeral bearer token",
-          "Request a fresh authenticated offer; never guess or persist bearer tokens."
-        )
-      );
-      return;
-    }
-    try {
-      const body = await readBody(request);
-      const route = request.url.slice("/carrier/".length);
-      if (route === "lease") {
-        const result = options.machine.lease({
-          consumerId: String(body.consumerId ?? ""),
-          bearerToken,
-          now: Number(body.now),
-          descriptorDigest: typeof body.descriptorDigest === "string" ? body.descriptorDigest : void 0,
-          recipeDigest: typeof body.recipeDigest === "string" ? body.recipeDigest : void 0
-        });
-        reply(response, result.ok ? 200 : 409, result.ok ? result : result);
-        return;
-      }
-      const leaseId = typeof body.leaseId === "string" ? body.leaseId : "";
-      if (route === "start") {
-        const result = options.machine.started(leaseId);
-        reply(response, result.ok ? 200 : 409, result.ok ? result : result);
-        return;
+async function runBrowserPreviewHost(projectRoot, recipe, snapshot, runId, signal, bootstrapRoot = "project-bootstrap", resource, options = {}) {
+  const facts = await readProjectFacts(projectRoot);
+  if (!facts.ok)
+    return { ok: false, error: { ...facts.error, detail: facts.error.detail } };
+  const config = await createViteConfig(facts.value, "serve", "/", { bootstrapRoot });
+  const cacheDir = await mkdtemp(join(facts.value.root, ".forgeax", ".browser-host-vite-"));
+  let server;
+  try {
+    const port = await allocateLoopbackPort();
+    server = await createServer$2({
+      ...config,
+      cacheDir,
+      logLevel: "silent",
+      optimizeDeps: {
+        ...config.optimizeDeps,
+        // Tool runs must observe the current workspace build, even when a
+        // persistent runner retains Vite's optimized-dependency cache.
+        force: true
+      },
+      server: {
+        ...config.server,
+        host: "127.0.0.1",
+        port,
+        // Vite's port 0 means its default 5173. Bind the probed port exactly so
+        // another project or runner cannot be mistaken for this Browser Host.
+        strictPort: true
       }
-      if (route === "exit") {
-        const result = options.machine.exit(leaseId);
-        reply(response, result.ok ? 200 : 409, result.ok ? result : result);
-        return;
+    });
+  } catch (cause) {
+    await rm(cacheDir, { recursive: true, force: true });
+    throw cause;
+  }
+  const hostStartedAtMs = performance.now();
+  let phase = "server-listen";
+  let browser;
+  let page;
+  let pageErrors = [];
+  let responseDiagnostics = [];
+  const launchBrowser = (headless) => chromium.launch({
+    channel: process.env.FORGEAX_CHROME_CHANNEL ?? "chrome",
+    headless,
+    args: [
+      "--enable-unsafe-webgpu",
+      "--enable-features=Vulkan,UseSkiaRenderer,SharedArrayBuffer",
+      "--use-vulkan=swiftshader",
+      "--use-angle=swiftshader",
+      "--disable-vulkan-surface",
+      "--ignore-gpu-blocklist",
+      "--disable-gpu-driver-bug-workarounds",
+      "--disable-dawn-features=disallow_unsafe_apis",
+      "--autoplay-policy=no-user-gesture-required"
+    ]
+  });
+  const observePage = (target) => {
+    target.on("pageerror", (error) => pageErrors.push(error.message));
+    target.on("console", (message) => {
+      if (message.type() === "error" || message.type() === "warning") {
+        pageErrors.push(`${message.type()}: ${message.text()}`);
       }
-      if (route === "execute") {
-        const snapshot = options.machine.snapshot();
-        if (snapshot.leaseId !== leaseId || snapshot.state !== "started") {
-          reply(
-            response,
-            409,
-            errorResult(
-              snapshot.state === "exited" ? "carrier-exited" : "carrier-lease-required",
-              "a started carrier lease",
-              "Do not fallback after started; report the structured terminal error and offer a new carrier."
-            )
-          );
-          return;
-        }
-        if (body.descriptorDigest !== options.descriptorDigest) {
-          reply(
-            response,
-            409,
-            errorResult(
-              "carrier-descriptor-mismatch",
-              "the offered descriptor digest",
-              "Rebuild the offer from the current descriptor before retrying."
-            )
-          );
-          return;
-        }
-        if (body.recipeDigest !== options.recipeDigest) {
-          reply(
-            response,
-            409,
-            errorResult(
-              "carrier-recipe-mismatch",
-              "the offered recipe digest",
-              "Serialize a fresh snapshot and request a new carrier before retrying."
-            )
-          );
-          return;
-        }
-        const terminal = await options.execute({
-          leaseId,
-          descriptorDigest: options.descriptorDigest,
-          recipeDigest: options.recipeDigest,
-          args: body.args
-        });
-        reply(response, 200, { ok: true, value: terminal, state: "started" });
-        return;
+    });
+    target.on("response", (response) => {
+      if (response.status() >= 400) {
+        responseDiagnostics.push(
+          response.text().then((body) => {
+            pageErrors.push(`HTTP ${response.status()}: ${response.url()} ${body}`);
+          }).catch(() => {
+            pageErrors.push(`HTTP ${response.status()}: ${response.url()}`);
+          })
+        );
       }
-      reply(
-        response,
-        404,
-        errorResult(
-          "carrier-provider-exit",
-          "a carrier protocol route",
-          "Request a fresh visible offer from the provider."
-        )
-      );
-    } catch (cause) {
-      reply(
-        response,
-        400,
-        errorResult(
-          "carrier-provider-exit",
-          "a valid carrier request",
-          "Serialize POD only and retry from the last safe snapshot.",
-          { cause: cause instanceof Error ? cause.message : String(cause) }
-        )
-      );
-    }
-  });
-  await new Promise((resolve18, reject) => {
-    const onError = (error) => {
-      server.off("listening", onListening);
-      reject(error);
-    };
-    const onListening = () => {
-      server.off("error", onError);
-      resolve18();
-    };
-    server.once("error", onError);
-    server.once("listening", onListening);
-    server.listen(0, host);
-  });
-  const address = server.address();
-  if (address === null || typeof address === "string")
-    throw new Error("carrier provider did not expose a loopback port");
-  const endpoint = `http://${host}:${address.port}/carrier`;
-  let closed = false;
-  return {
-    endpoint,
-    offer: options.machine.offer,
-    async close() {
-      if (closed) return;
-      closed = true;
-      await new Promise(
-        (resolve18, reject) => server.close((error) => error === void 0 ? resolve18() : reject(error))
-      );
-    }
+    });
   };
-}
-function createCarrierProvider(machine) {
-  return {
-    offer: machine.offer,
-    accept(request) {
-      const result = machine.lease(request);
-      if (!result.ok) return result;
-      return { ok: true, value: { leaseId: result.value.leaseId }, state: result.state };
-    },
-    started: machine.started,
-    exit: machine.exit
+  const closeBrowserProcess = async () => {
+    await page?.close().catch(() => void 0);
+    page = void 0;
+    await browser?.close().catch(() => void 0);
+    browser = void 0;
   };
-}
-function createCarrierRendezvous(options) {
-  const machine = createCarrierStateMachine({
-    projectId: options.projectId,
-    consumerId: options.consumerId,
-    endpoint: options.endpoint ?? "http://127.0.0.1:5740/carrier",
-    now: options.now,
-    ttlMs: options.ttlMs ?? 3e4
-  });
-  let lookupCount = 0;
-  const lookup = () => {
-    if (options.presentation !== "visible" || machine.snapshot().state !== "offered") return;
-    lookupCount += 1;
-    return machine.offer;
+  const abort = () => {
+    void closeBrowserProcess();
+    void server.close();
   };
-  return {
-    ...machine,
-    lookup,
-    get lookupCount() {
-      return lookupCount;
+  signal.addEventListener("abort", abort, { once: true });
+  try {
+    if (signal.aborted) throw new Error("Browser Host aborted before launch");
+    await server.listen();
+    const address = server.httpServer?.address();
+    if (address === null || address === void 0 || typeof address === "string") {
+      throw new Error("Vite Browser Host did not expose a loopback TCP address");
     }
-  };
-}
-
-// src/index.ts
-init_catalog();
-function decorateResourcePreviewTerminal(terminal) {
-  if (terminal.outcome === "succeeded") return terminal;
-  const recovery = describeResourcePreviewFailure(terminal.failure);
-  if (recovery === void 0) return terminal;
-  if (terminal.failure.code !== "tool-domain-failed") return terminal;
-  return {
-    ...terminal,
-    failure: {
-      ...terminal.failure,
-      detail: {
-        ...terminal.failure.detail,
-        ...recovery.suggestedOperation === void 0 ? {} : { suggestedOperation: recovery.suggestedOperation },
-        recovery: recovery.actions
-      }
+    phase = "server-transform";
+    const entryTransform = await server.transformRequest("/main.ts");
+    if (entryTransform === null) {
+      throw new Error("Vite Browser Host entry transform returned no module");
     }
-  };
-}
-function missingTool(id) {
-  return {
-    outcome: "failed",
-    failure: capabilityUnavailableError(`tool:${id}`, "build"),
-    artifacts: []
-  };
-}
-function runNamedTool(runtime, id, args) {
-  const contribution = runtime.get(id);
-  if (contribution === void 0) return Promise.resolve(missingTool(id));
-  return runtime.run(contribution, args).terminal.then(decorateResourcePreviewTerminal);
-}
-function runGenericTool(runtime, id, encodedArgs) {
-  let args;
-  try {
-    args = JSON.parse(encodedArgs);
-  } catch {
-    return Promise.resolve({
-      outcome: "failed",
-      failure: {
-        code: "tool-invalid-args",
-        expected: "generic CLI arguments to be valid JSON",
-        hint: "Encode one JSON value that conforms to the descriptor argsSchema.",
-        detail: { message: "Invalid JSON", value: null }
-      },
-      artifacts: []
+    phase = "capture-browser-launch";
+    browser = await launchBrowser(recipe.presentation === "hidden");
+    phase = "capture-page-bootstrap";
+    page = await browser.newPage({
+      viewport: recipe.viewport,
+      deviceScaleFactor: 1
     });
-  }
-  return runNamedTool(runtime, id, args);
-}
-
-// src/tools/client.ts
-init_catalog();
-init_preview_migration();
-function missingTool2(id) {
-  return {
-    outcome: "failed",
-    failure: {
-      code: "tool-capability-unavailable",
-      expected: `tool ${id} to exist in the project-derived catalog`,
-      hint: "Run tool list and choose one of the discovered operation ids.",
-      detail: { capability: `tool:${id}`, realm: "build" }
-    },
-    artifacts: []
-  };
-}
-async function createToolClient(options) {
-  const projectDiscovery = options.projectDiscovery;
-  const runProjectTool2 = projectDiscovery === void 0 ? (await Promise.resolve().then(() => (init_project_tools(), project_tools_exports))).runProjectTool : void 0;
-  const builtins = options.baseContributions ?? (await Promise.resolve().then(() => (init_contributions(), contributions_exports))).createDefaultContributions(options.projectRoot);
-  const project = projectDiscovery === void 0 ? await (await Promise.resolve().then(() => (init_project_tools(), project_tools_exports))).discoverProjectTools(
-    options.projectRoot,
-    options
-  ) : await projectDiscovery(options.projectRoot);
-  const contributions = [...builtins, ...project.map(({ contribution }) => contribution)];
-  const runtime = options.baseContributions === void 0 ? (await Promise.resolve().then(() => (init_runtime(), runtime_exports))).createDevkitToolRuntime(contributions) : createToolRuntime(contributions);
-  const realmDispatch = options.realmOwners === void 0 ? void 0 : createRealmDispatch(contributions, options.realmOwners);
-  const bindingById = new Map(
-    project.map((binding) => [binding.contribution.descriptor.id, binding])
-  );
-  const descriptors = runtime.list();
-  const loaded = await loadToolCatalog(
-    createProjectToolCatalogAuthority(options.projectRoot, descriptors),
-    descriptors
-  );
-  if (!loaded.ok) throw loaded.error;
-  return {
-    list: () => listTools(loaded.value),
-    describe: (id) => describeTool(loaded.value, id),
-    async run(id, args, runOptions = {}) {
-      if (id === "preview.run") return retiredPreviewTool();
-      const contribution = runtime.get(id);
-      if (contribution === void 0) return missingTool2(id);
-      const binding = bindingById.get(id);
-      const terminal = binding !== void 0 && runProjectTool2 !== void 0 ? await runProjectTool2(binding, args, runOptions) : realmDispatch === void 0 ? await runtime.run(contribution, args, runOptions).terminal : await realmDispatch.run(id, args, runOptions);
-      return decorateResourcePreviewTerminal(terminal);
-    }
-  };
-}
-
-// src/index.ts
-init_contributions();
-function runLibraryTool(contribution, args, options) {
-  return createToolRuntime([contribution]).run(contribution, args, options).terminal;
-}
-var roster = [
-  {
-    operation: "project.preview",
-    owner: "devkit/preview-host",
-    realm: "host",
-    artifacts: previewArtifacts(),
-    benefit: "reuse the real WebGPU hidden preview recipe",
-    fallback: "private"
-  },
-  {
-    operation: "material.preview",
-    owner: "engine-preview/material",
-    realm: "host",
-    artifacts: previewArtifacts(),
-    benefit: "preview one material subject through the canonical lit rig",
-    fallback: "private"
-  },
-  {
-    operation: "mesh.preview",
-    owner: "engine-preview/mesh",
-    realm: "host",
-    artifacts: previewArtifacts(),
-    benefit: "preview one mesh subject with every submesh and AABB evidence",
-    fallback: "private"
-  },
-  {
-    operation: "vfx.preview",
-    owner: "engine-preview/vfx",
-    realm: "host",
-    artifacts: previewArtifacts(),
-    benefit: "preview one bounded VFX timeline with compute evidence",
-    fallback: "private"
-  },
-  {
-    operation: "texture.preview",
-    owner: "engine-preview/texture",
-    realm: "host",
-    artifacts: previewArtifacts(),
-    benefit: "preview one texture on the aspect-preserving unlit quad",
-    fallback: "private"
-  }
-];
-function previewArtifacts() {
-  return [
-    {
-      owner: "preview-tool-proof",
-      source: "M3",
-      ref: {
-        kind: "rhi-tape",
-        digest: "sha256:e62a302dd29e302e1d0928306fe9c90c47ee336aa2e9e35fdc1d75586ae0018d",
-        uri: "repo:apps/preview/__tests__/tool-proof.recipe.integration.test.ts"
-      }
-    },
-    {
-      owner: "preview-tool-proof",
-      source: "M3",
-      ref: {
-        kind: "profile-capture",
-        digest: "sha256:11ec9024e1ea08b38f0901db272847ac402d2dce0c757efe744315608e889c5c",
-        uri: "repo:packages/profiler/src/__tests__/fixtures/profile-capture/model-input.json"
+    observePage(page);
+    const captureUrl = new URL(`http://127.0.0.1:${address.port}/`);
+    captureUrl.searchParams.set("forgeax-tool-recipe", JSON.stringify(recipe));
+    captureUrl.searchParams.set("forgeax-tool-snapshot", JSON.stringify(snapshot));
+    captureUrl.searchParams.set("forgeax-tool-run-id", runId);
+    if (resource !== void 0)
+      captureUrl.searchParams.set("forgeax-resource-preview", JSON.stringify(resource));
+    await page.goto(captureUrl.href, { waitUntil: "networkidle", timeout: 45e3 });
+    await page.waitForFunction(
+      () => globalThis.__forgeaxToolHost?.ready === true,
+      void 0,
+      { timeout: 45e3 }
+    );
+    phase = "capture-run";
+    const captured = await page.evaluate(async () => {
+      const host = globalThis.__forgeaxToolHost;
+      const value2 = await host.capture();
+      return JSON.parse(
+        JSON.stringify(
+          value2,
+          (_key, nested) => nested instanceof Error ? {
+            ...nested,
+            name: nested.name,
+            message: nested.message,
+            stack: nested.stack
+          } : nested
+        )
+      );
+    });
+    await Promise.all(responseDiagnostics);
+    if (!captured.ok) return browserFailure("capture-run", captured.error, pageErrors);
+    if (pageErrors.length > 0)
+      return browserFailure("capture-page-runtime", pageErrors[0], pageErrors);
+    const capturePng = await page.screenshot({ type: "png" });
+    const capturedResult = {
+      ...captured.result,
+      capturePng: {
+        uri: `data:image/png;base64,${capturePng.toString("base64")}`,
+        width: recipe.viewport.width,
+        height: recipe.viewport.height
       }
-    }
-  ];
-}
-function validEvidence(entry) {
-  return entry.owner.length > 0 && entry.artifacts.length > 0 && entry.artifacts.every(
-    ({ owner, source, ref }) => owner.length > 0 && source === "M3" && /^sha256:[0-9a-f]{64}$/.test(ref.digest) && typeof ref.uri === "string" && ref.uri.startsWith("repo:") && isSupportedEvidenceKind(ref.kind)
-  );
-}
-function isSupportedEvidenceKind(kind) {
-  return kind === "rhi-tape" || kind === "profile-capture" || kind === "png";
-}
-function createMigrationRoster() {
-  return roster.filter(validEvidence).map((entry) => ({
-    ...entry,
-    artifacts: entry.artifacts.map((artifact) => ({ ...artifact, ref: { ...artifact.ref } }))
-  }));
-}
-function resolveMigration(entries2, operation, target) {
-  const entry = entries2.find((candidate) => candidate.operation === operation);
-  if (entry === void 0 || !validEvidence(entry)) {
-    return {
-      ok: false,
-      error: capabilityUnavailableError(`migration:${operation}`, target.realm)
     };
-  }
-  if (entry.realm !== target.realm || target.catalogDigest.length === 0) {
-    return { ok: false, error: capabilityUnavailableError(`migration:${operation}`, target.realm) };
-  }
-  if (entry.realm === "host" && target.rhiBackend !== "webgpu") {
-    return { ok: false, error: capabilityUnavailableError(`rhi:${operation}`, target.realm) };
-  }
-  const evidenceKinds = entry.artifacts.map(({ ref }) => ref.kind).filter(isSupportedEvidenceKind);
-  if (!evidenceKinds.every((kind) => target.evidence.includes(kind))) {
-    return { ok: false, error: capabilityUnavailableError(`evidence:${operation}`, target.realm) };
-  }
-  const service = createServiceCapability(void 0, {
-    toolId: operation,
-    descriptorDigest: entry.artifacts[0]?.ref.digest ?? "",
-    recipeDigest: entry.artifacts[0]?.ref.digest ?? "",
-    workloadClass: `migration:${operation}`,
-    codeDigest: target.catalogDigest,
-    browserVersion: "unavailable",
-    backend: "webgpu"
-  });
-  return {
-    ok: true,
-    value: {
-      path: service.available ? "service" : "private",
-      operation,
-      owner: entry.owner,
-      artifacts: entry.artifacts.map((artifact) => ({ ...artifact, ref: { ...artifact.ref } })),
-      service
-    }
-  };
-}
-
-// src/index.ts
-init_offline_analysis();
-init_preview_contributions();
-
-// src/tools/browser-host.ts
-init_host();
-init_project();
-function transportCause(cause) {
-  if (cause instanceof Error) {
+    await closeBrowserProcess();
+    pageErrors = [];
+    responseDiagnostics = [];
+    phase = "replay-browser-launch";
+    browser = await launchBrowser(true);
+    phase = "replay-page-bootstrap";
+    page = await browser.newPage({
+      viewport: recipe.viewport,
+      deviceScaleFactor: 1
+    });
+    observePage(page);
+    const replayUrl = new URL(`http://127.0.0.1:${address.port}/`);
+    replayUrl.searchParams.set("forgeax-tool-replay", "1");
+    await page.goto(replayUrl.href, { waitUntil: "networkidle", timeout: 45e3 });
+    await page.waitForFunction(
+      () => globalThis.__forgeaxToolReplayHost?.ready === true,
+      void 0,
+      { timeout: 45e3 }
+    );
+    phase = "replay-run";
+    const result = await page.evaluate(async (serializedCapture) => {
+      const host = globalThis.__forgeaxToolReplayHost;
+      const value2 = await host.run(JSON.parse(serializedCapture));
+      return JSON.parse(
+        JSON.stringify(
+          value2,
+          (_key, nested) => nested instanceof Error ? {
+            ...nested,
+            name: nested.name,
+            message: nested.message,
+            stack: nested.stack
+          } : nested
+        )
+      );
+    }, JSON.stringify(capturedResult));
+    await Promise.all(responseDiagnostics);
+    if (!result.ok) return browserFailure("replay-run", result.error, pageErrors);
+    if (pageErrors.length > 0)
+      return browserFailure("replay-page-runtime", pageErrors[0], pageErrors);
+    const endedAtMs = performance.now();
+    const phases = result.result.operationTiming.phases;
+    const observedDurationMs = phases === void 0 ? 0 : Object.values(phases).reduce(
+      (total, observation) => total + (observation.status === "observed" ? observation.durationMs : 0),
+      0
+    );
+    const durationMs = endedAtMs - hostStartedAtMs;
+    const value = {
+      ...result.result,
+      operationTiming: {
+        ...result.result.operationTiming,
+        startedAtMs: hostStartedAtMs,
+        endedAtMs,
+        durationMs,
+        ...phases === void 0 ? { unattributedMs: durationMs } : {
+          phases: {
+            ...phases,
+            transport: {
+              status: "observed",
+              durationMs: Math.max(0, durationMs - observedDurationMs)
+            }
+          },
+          unattributedMs: 0
+        }
+      },
+      actualCarrier: recipe.presentation === "hidden" ? "headless-private" : "headed-private"
+    };
+    phase = "artifact-publish";
     return {
-      name: cause.name,
-      message: cause.message,
-      ...cause.stack === void 0 ? {} : { stack: cause.stack }
+      ok: true,
+      value: options.publish === false ? value : await publishPreviewArtifacts(projectRoot, runId, value)
     };
-  }
-  if (cause === void 0) return "undefined";
-  try {
-    return JSON.parse(JSON.stringify(cause));
-  } catch {
-    return String(cause);
+  } catch (cause) {
+    await Promise.all(responseDiagnostics);
+    return browserFailure(phase, cause, pageErrors);
+  } finally {
+    signal.removeEventListener("abort", abort);
+    await closeBrowserProcess();
+    await server.close().catch(() => void 0);
+    await rm(cacheDir, { recursive: true, force: true });
   }
 }
-function dataUriBytes(uri) {
-  const separator = uri.indexOf(",");
-  if (separator < 0) throw new TypeError("preview artifact must be a data URI before publication");
-  return Buffer.from(uri.slice(separator + 1), "base64");
+function runBrowserResourcePreviewHost(projectRoot, recipe, snapshot, runId, signal, resource, options = {}) {
+  return runBrowserPreviewHost(
+    projectRoot,
+    recipe,
+    snapshot,
+    runId,
+    signal,
+    "resource-bootstrap",
+    resource,
+    options
+  );
 }
-function projectUri(projectRoot, path) {
-  return relative(projectRoot, path).split(sep).join("/");
+var init_browser_host = __esm({
+  "src/tools/browser-host.ts"() {
+    init_host();
+    init_project();
+  }
+});
+
+// src/tools/native-preview.ts
+var native_preview_exports = {};
+__export(native_preview_exports, {
+  isNativePreviewTool: () => isNativePreviewTool,
+  runNativePreviewTool: () => runNativePreviewTool
+});
+function isNativePreviewTool(id) {
+  return previewToolIds.has(id);
 }
-async function allocateLoopbackPort() {
-  const probe = createServer$1();
+async function runNativePreviewTool(contribution, args, options, projectRoot) {
+  const kind = contribution.descriptor.id.split(".")[0];
+  if (kind !== "material" && kind !== "mesh" && kind !== "texture" && kind !== "vfx") {
+    throw new Error(`unsupported native preview operation ${contribution.descriptor.id}`);
+  }
+  const parsed = contribution.descriptor.argsSchema.parse(args);
+  if (!parsed.ok) {
+    return {
+      outcome: "failed",
+      failure: {
+        code: "tool-invalid-args",
+        expected: "preview arguments to match the operation argsSchema",
+        hint: "Pass { guid } and an optional power-of-two size from AssetRegistry catalog identity.",
+        detail: { message: parsed.error, value: null }
+      },
+      artifacts: []
+    };
+  }
+  const request = parsed.value;
+  const { guid, size = RESOURCE_PREVIEW_DEFAULT_SIZE } = request;
+  const selectedPreviewPlugin = nativePreviewPlugins.find(
+    ([, plugin]) => plugin.tools.some(
+      (tool) => tool.descriptor.id === contribution.descriptor.id
+    )
+  );
+  if (selectedPreviewPlugin === void 0) {
+    throw new Error(`native preview plugin does not export ${contribution.descriptor.id}`);
+  }
+  const selectedPluginName = selectedPreviewPlugin[0];
+  const snapshot = options.snapshot ?? { revision: 0, digest: `sha256:project:${projectRoot}` };
+  const previewRunId = `${contribution.descriptor.id}:${crypto.randomUUID()}`;
+  const browser = await runBrowserResourcePreviewHost(
+    projectRoot,
+    createToolPreviewRecipe({
+      presentation: "hidden",
+      viewport: { width: size, height: size },
+      frames: 32
+    }),
+    snapshot,
+    previewRunId,
+    options.signal ?? new AbortController().signal,
+    { kind, guid, size },
+    { publish: false }
+  );
+  if (!browser.ok || browser.value.resource === void 0) {
+    const failure2 = browser.ok ? {
+      code: "tool-preview-bootstrap-failed",
+      expected: "the Browser resource bootstrap to return AssetRegistry owner facts",
+      hint: "Inspect resource-bootstrap and retry after the owner publishes the GUID payload.",
+      detail: { phase: "resource-owner" }
+    } : browser.error;
+    return {
+      outcome: "failed",
+      failure: {
+        code: "tool-domain-failed",
+        expected: failure2.expected ?? "the Browser resource bootstrap to succeed",
+        hint: failure2.hint ?? "Inspect the Browser resource bootstrap failure and retry.",
+        detail: {
+          code: failure2.code,
+          ...failure2.detail === void 0 ? {} : { payload: failure2.detail }
+        }
+      },
+      artifacts: []
+    };
+  }
+  const resource = browser.value.resource;
+  const subjectDrawn = kind === "texture" ? browser.value.drawCalls > 0 : browser.value.drawCalls > 2;
+  if (!subjectDrawn) {
+    return {
+      outcome: "failed",
+      failure: {
+        code: "tool-domain-failed",
+        expected: "the captured resource frame to contain a subject draw in addition to canonical presentation passes",
+        hint: "Inspect material readiness and the RHI tape before retrying the same GUID preview.",
+        detail: {
+          code: "tool-preview-subject-not-rendered",
+          payload: { kind, drawCalls: browser.value.drawCalls }
+        }
+      },
+      artifacts: []
+    };
+  }
+  const ctx = new Context();
   try {
-    await new Promise((resolve18, reject) => {
-      const onError = (error) => {
-        probe.off("listening", onListening);
-        reject(error);
-      };
-      const onListening = () => {
-        probe.off("error", onError);
-        resolve18();
-      };
-      probe.once("error", onError);
-      probe.once("listening", onListening);
-      probe.listen(0, "127.0.0.1");
+    const host = createNativePreviewHost({
+      runId: `${contribution.descriptor.id}:native`,
+      snapshot,
+      projectRoot,
+      backend: "webgpu",
+      signal: options.signal ?? new AbortController().signal,
+      assets: {
+        loadByGuid: async () => ({
+          ok: true,
+          value: resource.asset,
+          ...resource.digest === void 0 ? {} : { digest: resource.digest },
+          ...resource.ownerFacts === void 0 ? {} : { ownerFacts: resource.ownerFacts }
+        })
+      },
+      renderer: {
+        rendererReady: browser.value.trace.events.includes("renderer-created"),
+        worldReady: browser.value.trace.events.includes("world-updated"),
+        drawCalls: browser.value.drawCalls,
+        nonBlackPixels: browser.value.nonBlackPixels,
+        ...resource.observation === void 0 ? {} : { observation: resource.observation },
+        ...kind === "vfx" && resource.observation !== void 0 ? {
+          vfx: {
+            dispatches: typeof resource.observation.dispatches === "number" ? resource.observation.dispatches : 0,
+            indirectDraws: typeof resource.observation.indirectDraws === "number" ? resource.observation.indirectDraws : 0,
+            subjectOutputs: typeof resource.observation.subjectOutputs === "number" ? resource.observation.subjectOutputs : 0
+          }
+        } : {},
+        texture: { drawCalls: browser.value.drawCalls }
+      },
+      artifacts: browser.value.artifacts
     });
-    const address = probe.address();
-    if (address === null || typeof address === "string") {
-      throw new Error("loopback port probe did not expose a TCP address");
+    const { loader } = await installCatalogLoader(
+      ctx,
+      createNativePreviewCatalog(host, selectedPluginName),
+      "host"
+    );
+    await loader.root.update(
+      projectPluginEntries(
+        previewPluginEntries.filter(({ name }) => name === selectedPluginName),
+        "host",
+        "host"
+      )
+    );
+    await loader.await();
+    const nativeContribution = nativePreviewTools.find(
+      (candidate) => candidate.descriptor.id === contribution.descriptor.id
+    );
+    if (nativeContribution === void 0) {
+      throw new Error(`native preview plugin does not export ${contribution.descriptor.id}`);
     }
-    return address.port;
-  } finally {
-    if (probe.listening) {
-      await new Promise((resolve18) => probe.close(() => resolve18()));
+    const terminal = await createToolRuntime([nativeContribution]).run(nativeContribution, args, {
+      ...options,
+      snapshot,
+      capabilityResolver: createContextCapabilityResolver(ctx)
+    }).terminal;
+    if (terminal.outcome !== "succeeded") return terminal;
+    const domainResult = terminal.result;
+    let published;
+    try {
+      published = await publishPreviewArtifacts(projectRoot, previewRunId, browser.value, {
+        snapshot,
+        subject: domainResult.subject,
+        presentation: domainResult.presentation,
+        oracle: domainResult.oracle
+      });
+    } catch (cause) {
+      return {
+        outcome: "failed",
+        failure: {
+          code: "tool-domain-failed",
+          expected: "the preview report and all capture artifacts to publish atomically",
+          hint: "Inspect the artifact manifest identity or digest failure and retry the same ToolRun.",
+          detail: {
+            code: "tool-artifact-manifest-invalid",
+            payload: cause instanceof Error ? cause.message : String(cause)
+          }
+        },
+        artifacts: []
+      };
+    }
+    const report = published.manifest.artifacts.find((artifact) => artifact.role === "report");
+    if (report === void 0) {
+      throw new Error("resource preview publisher returned no report artifact");
     }
+    return {
+      ...terminal,
+      result: {
+        ...terminal.result,
+        actualCarrier: browser.value.actualCarrier,
+        report: {
+          kind: "tool-result",
+          digest: report.digest,
+          uri: report.uri,
+          mediaType: report.mediaType,
+          sizeBytes: report.byteLength
+        },
+        artifacts: published.artifacts
+      },
+      artifacts: published.artifacts
+    };
+  } finally {
+    await ctx.fiber.dispose();
   }
 }
-function sha256(bytes) {
-  return `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+var previewPluginEntries, previewToolIds;
+var init_native_preview = __esm({
+  "src/tools/native-preview.ts"() {
+    init_browser_host();
+    init_preview_catalog();
+    previewPluginEntries = nativePreviewPlugins.map(([name]) => ({
+      id: `forgeax-preview-${name.slice(name.lastIndexOf("/") + 1)}`,
+      name,
+      realm: "host"
+    }));
+    previewToolIds = new Set(nativePreviewTools.map(({ descriptor }) => descriptor.id));
+  }
+});
+
+// src/index.ts
+init_commands();
+init_dist();
+init_engine_binding();
+init_init();
+init_project();
+init_operations();
+init_single_html();
+init_software_capture();
+
+// src/tools/benchmark/statistics.ts
+function calculateSampleStatistics(samples) {
+  if (samples.length === 0) throw new RangeError("benchmark samples must not be empty");
+  const sorted = [...samples].sort((left, right) => left - right);
+  const medianIndex = (sorted.length - 1) / 2;
+  const median = interpolate(sorted, medianIndex);
+  const p95 = interpolate(sorted, Math.ceil(sorted.length * 0.95) - 1);
+  const max = sorted[sorted.length - 1];
+  if (max === void 0) throw new RangeError("benchmark samples must not be empty");
+  return { count: sorted.length, median, p95, max };
 }
-function artifactRef(artifact) {
-  const kind = artifact.kind === "report" || artifact.kind === "contact-sheet" ? "tool-result" : artifact.kind;
+function interpolate(values, index) {
+  const lower = Math.floor(index);
+  const upper = Math.ceil(index);
+  const lowerValue = values[lower];
+  const upperValue = values[upper];
+  if (lowerValue === void 0 || upperValue === void 0) {
+    throw new RangeError("benchmark percentile index is out of range");
+  }
+  return lower === upper ? lowerValue : lowerValue + (upperValue - lowerValue) * (index - lower);
+}
+
+// src/tools/benchmark/report.ts
+var DEFAULT_ADMISSION_THRESHOLDS = {
+  sampleCountPerPhase: 30,
+  medianImprovement: 0.2,
+  p95Improvement: 0.1,
+  maxRegression: 0.1,
+  peakRssMultiplier: 1.25
+};
+function summarizeBenchmarkSamples(samples) {
+  if (samples.length === 0) {
+    return {
+      samples: 0,
+      durationMs: { count: 0, median: 0, p95: 0, max: 0 },
+      peakRssBytes: { count: 0, median: 0, p95: 0, max: 0 },
+      cleanupPassed: false,
+      evictionPassed: false,
+      exclusivePhasesMs: {}
+    };
+  }
+  const durations = samples.map((sample) => sample.durationMs);
+  const rss = samples.map((sample) => sample.peakRssBytes);
+  const phaseNames = [
+    ...new Set(samples.flatMap((sample) => Object.keys(sample.exclusivePhasesMs)))
+  ];
+  const exclusivePhasesMs = Object.fromEntries(
+    phaseNames.map((phase) => [
+      phase,
+      calculateSampleStatistics(samples.map((sample) => sample.exclusivePhasesMs[phase] ?? 0))
+    ])
+  );
   return {
-    kind,
-    digest: artifact.digest,
-    uri: artifact.uri,
-    mediaType: artifact.mediaType,
-    sizeBytes: artifact.byteLength
+    samples: samples.length,
+    durationMs: calculateSampleStatistics(durations),
+    peakRssBytes: calculateSampleStatistics(rss),
+    cleanupPassed: samples.every((sample) => sample.cleanupPassed),
+    evictionPassed: samples.every((sample) => sample.evictionPassed),
+    exclusivePhasesMs
   };
 }
-async function publishPreviewArtifacts(projectRoot, runId, result, reportInput) {
-  if (result.manifest.identity.runId !== runId) {
-    throw new Error(
-      `preview artifact run identity mismatch: manifest=${result.manifest.identity.runId} requested=${runId}`
-    );
+function createAdmissionReport(recipe, samples, thresholds = DEFAULT_ADMISSION_THRESHOLDS) {
+  const privateSamples = samples.filter((sample) => sample.mode === "private");
+  const serviceSamples = samples.filter((sample) => sample.mode === "service");
+  const order = samples.map((sample) => sample.mode);
+  const privateReport = summarizeBenchmarkSamples(privateSamples);
+  const serviceReport = summarizeBenchmarkSamples(serviceSamples);
+  const reasons = [];
+  const expectedSamples = thresholds.sampleCountPerPhase * 2;
+  const complete = privateSamples.length === expectedSamples && serviceSamples.length === expectedSamples;
+  if (!complete) {
+    reasons.push("sample count is incomplete");
   }
-  const runsRoot = join(projectRoot, ".forgeax", "tool-runs");
-  await mkdir(runsRoot, { recursive: true });
-  const directoryName = runId.replace(/[^a-zA-Z0-9._-]/g, "_");
-  const published = join(runsRoot, directoryName);
-  const finalPaths = {
-    tapeJson: join(published, "rhi-tape.json"),
-    tapeBlob: join(published, "rhi-tape.bin"),
-    capturePng: join(published, "capture.png"),
-    freshReplayPng: join(published, "fresh-replay.png"),
-    profile: join(published, "profile.json"),
-    manifest: join(published, "manifest.json"),
-    report: join(published, "report.json")
-  };
-  const tapeJson = dataUriBytes(result.tape.jsonUri);
-  const tapeBlob = dataUriBytes(result.tape.blobUri);
-  const capturePng = dataUriBytes(result.capturePng.uri);
-  const freshReplayPng = dataUriBytes(result.png.uri);
-  const profile = dataUriBytes(result.profile.uri);
-  const bytesByRole = {
-    "rhi-tape": tapeJson,
-    capture: capturePng,
-    "fresh-replay": freshReplayPng,
-    "profile-capture": profile
-  };
-  const uriByRole = {
-    "rhi-tape": projectUri(projectRoot, finalPaths.tapeJson),
-    capture: projectUri(projectRoot, finalPaths.capturePng),
-    "fresh-replay": projectUri(projectRoot, finalPaths.freshReplayPng),
-    "profile-capture": projectUri(projectRoot, finalPaths.profile)
-  };
-  const mediaTypeByRole = {
-    "rhi-tape": "application/vnd.forgeax.rhi-tape+json",
-    capture: "image/png",
-    "fresh-replay": "image/png",
-    "profile-capture": "application/vnd.forgeax.profile+json"
+  if (samples.some((sample) => sample.recipeDigest !== recipe.digest)) {
+    reasons.push("recipe identity drifted");
+  }
+  if (!privateReport.cleanupPassed || !serviceReport.cleanupPassed) reasons.push("cleanup failed");
+  if (!privateReport.evictionPassed || !serviceReport.evictionPassed)
+    reasons.push("eviction failed");
+  if (order.some((mode, index) => index > 0 && mode === order[index - 1])) {
+    reasons.push("private and service samples were not alternated");
+  }
+  const medianLimit = privateReport.durationMs.median * (1 - thresholds.medianImprovement);
+  const p95Limit = privateReport.durationMs.p95 * (1 - thresholds.p95Improvement);
+  const maxLimit = privateReport.durationMs.max * (1 + thresholds.maxRegression);
+  const rssLimit = privateReport.peakRssBytes.median * thresholds.peakRssMultiplier;
+  if (complete && serviceReport.durationMs.median > medianLimit)
+    reasons.push("median improvement threshold missed");
+  if (complete && serviceReport.durationMs.p95 > p95Limit)
+    reasons.push("p95 improvement threshold missed");
+  if (complete && serviceReport.durationMs.max > maxLimit)
+    reasons.push("max regression threshold exceeded");
+  if (complete && serviceReport.peakRssBytes.median > rssLimit)
+    reasons.push("peak RSS threshold exceeded");
+  return {
+    schema: "forgeax.tool-service-admission.v1",
+    recipe,
+    thresholds,
+    order,
+    private: privateReport,
+    service: serviceReport,
+    valid: complete && !reasons.some(
+      (reason) => [
+        "recipe identity drifted",
+        "cleanup failed",
+        "eviction failed",
+        "private and service samples were not alternated"
+      ].includes(reason)
+    ),
+    admitted: reasons.length === 0,
+    reasons
   };
-  const requiredRoles = ["rhi-tape", "capture", "fresh-replay", "profile-capture"];
-  const nonReportArtifacts = result.manifest.artifacts.filter((artifact) => artifact.role !== "report").map((artifact) => {
-    if (!(artifact.role in bytesByRole)) {
-      return artifact;
+}
+
+// src/tools/benchmark/harness.ts
+async function runBenchmarkAdmission(options) {
+  const sampleCount = options.thresholds?.sampleCountPerPhase ?? 30;
+  const samples = [];
+  const phases = ["cold", "warm"];
+  const modes = ["private", "service"];
+  for (const phase of phases) {
+    for (let index = 0; index < sampleCount; index += 1) {
+      for (const mode of modes) {
+        const measurement = await options.measure(mode, phase, index);
+        samples.push({
+          mode,
+          phase,
+          durationMs: measurement.durationMs,
+          peakRssBytes: measurement.peakRssBytes,
+          exclusivePhasesMs: measurement.exclusivePhasesMs ?? {},
+          rhiDebugOverheadMs: measurement.rhiDebugOverheadMs ?? 0,
+          carrierRendezvousMs: measurement.carrierRendezvousMs ?? 0,
+          cleanupPassed: measurement.cleanupPassed,
+          evictionPassed: measurement.evictionPassed,
+          recipeDigest: options.recipe.digest
+        });
+      }
     }
-    const role = artifact.role;
-    const bytes = bytesByRole[role];
-    const digest = sha256(bytes);
-    if (artifact.digest !== digest) {
-      throw new Error(`preview artifact digest mismatch for ${artifact.role}`);
+  }
+  return createAdmissionReport(options.recipe, samples, options.thresholds);
+}
+async function bootstrapRealm(ctx, input) {
+  const cloneSafe = validateRealmBootstrapPayload(input.payload);
+  if (!cloneSafe.ok) return cloneSafe;
+  if (!input.supportedRealms.includes(input.realm)) {
+    return {
+      ok: false,
+      error: {
+        code: "realm-capability-unavailable",
+        realm: input.realm,
+        supportedRealms: input.supportedRealms
+      }
+    };
+  }
+  const entries2 = projectPluginEntries(input.entries, input.realm, input.realm);
+  if (input.realm === "build") {
+    if (input.lifecycle === void 0) {
+      return {
+        ok: false,
+        error: {
+          code: "realm-lifecycle-adapter-missing",
+          realm: input.realm,
+          hint: "Inject a build lifecycle adapter that owns execution and stop cleanup."
+        }
+      };
     }
+    const lifecycle = await input.lifecycle.start({
+      realm: input.realm,
+      entries: entries2,
+      catalog: input.catalog,
+      catalogDigest: input.catalogDigest
+    });
     return {
-      ...artifact,
-      uri: uriByRole[role],
-      digest,
-      byteLength: bytes.byteLength,
-      mediaType: mediaTypeByRole[role]
+      ok: true,
+      value: { realm: input.realm, catalogDigest: input.catalogDigest, entries: entries2, lifecycle }
     };
-  });
-  if (requiredRoles.some((role) => !nonReportArtifacts.some((artifact) => artifact.role === role))) {
-    throw new Error(
-      "preview publication is missing capture, fresh-replay, tape, or profile artifact"
-    );
   }
-  let reportBytes;
-  const manifest = createPreviewArtifactManifest({
-    ...result.manifest,
-    artifacts: nonReportArtifacts 
+  if (ctx === void 0) {
+    return {
+      ok: false,
+      error: { code: "realm-context-missing", realm: input.realm }
+    };
+  }
+  const loaded = await bootstrapCatalogLoader(ctx, input.catalog, input.realm, {
+    catalogDigest: input.catalogDigest,
+    supportedRealms: input.supportedRealms
   });
-  const validated = validatePreviewArtifactManifest$1(
-    manifest,
-    requiredRoles 
-  );
-  if (!validated.ok) throw new Error(JSON.stringify(validated.error.detail));
-  const staging = await mkdtemp(join(runsRoot, ".staging-"));
-  const paths = {
-    tapeJson: join(staging, "rhi-tape.json"),
-    tapeBlob: join(staging, "rhi-tape.bin"),
-    capturePng: join(staging, "capture.png"),
-    freshReplayPng: join(staging, "fresh-replay.png"),
-    profile: join(staging, "profile.json"),
-    manifest: join(staging, "manifest.json"),
-    report: join(staging, "report.json")
+  if (!loaded.ok) return loaded;
+  return {
+    ok: true,
+    value: {
+      realm: input.realm,
+      catalogDigest: input.catalogDigest,
+      entries: entries2,
+      loader: loaded.value
+    }
+  };
+}
+
+// src/tools/cache.ts
+function createServiceCache() {
+  const entries2 = /* @__PURE__ */ new Map();
+  return {
+    get: (key) => entries2.get(key),
+    set: (key, entry) => entries2.set(key, entry),
+    evict: (key) => entries2.delete(key),
+    clear: () => entries2.clear(),
+    size: () => entries2.size
+  };
+}
+function errorResult2(code, expected, hint, detail = {}) {
+  return { ok: false, error: { code, expected, hint, detail } };
+}
+async function readBody(request) {
+  const chunks = [];
+  for await (const chunk of request) chunks.push(Buffer.from(chunk));
+  const value = JSON.parse(Buffer.concat(chunks).toString("utf8"));
+  if (typeof value !== "object" || value === null || Array.isArray(value))
+    throw new Error("carrier request must be an object");
+  return value;
+}
+function reply(response, status, payload) {
+  response.statusCode = status;
+  response.setHeader("content-type", "application/json");
+  response.end(JSON.stringify(payload));
+}
+async function createCarrierProviderService(options) {
+  const host = options.host ?? "127.0.0.1";
+  const bearerToken = options.machine.offer.bearerToken;
+  const server = createServer(async (request, response) => {
+    if (request.method !== "POST" || !request.url?.startsWith("/carrier/")) {
+      reply(
+        response,
+        404,
+        errorResult2(
+          "carrier-provider-exit",
+          "a carrier protocol route",
+          "Request a fresh visible offer from the provider."
+        )
+      );
+      return;
+    }
+    if (request.headers.authorization !== `Bearer ${bearerToken}`) {
+      reply(
+        response,
+        401,
+        errorResult2(
+          "carrier-token-invalid",
+          "the ephemeral bearer token",
+          "Request a fresh authenticated offer; never guess or persist bearer tokens."
+        )
+      );
+      return;
+    }
+    try {
+      const body = await readBody(request);
+      const route = request.url.slice("/carrier/".length);
+      if (route === "lease") {
+        const result = options.machine.lease({
+          consumerId: String(body.consumerId ?? ""),
+          bearerToken,
+          now: Number(body.now),
+          descriptorDigest: typeof body.descriptorDigest === "string" ? body.descriptorDigest : void 0,
+          recipeDigest: typeof body.recipeDigest === "string" ? body.recipeDigest : void 0
+        });
+        reply(response, result.ok ? 200 : 409, result.ok ? result : result);
+        return;
+      }
+      const leaseId = typeof body.leaseId === "string" ? body.leaseId : "";
+      if (route === "start") {
+        const result = options.machine.started(leaseId);
+        reply(response, result.ok ? 200 : 409, result.ok ? result : result);
+        return;
+      }
+      if (route === "exit") {
+        const result = options.machine.exit(leaseId);
+        reply(response, result.ok ? 200 : 409, result.ok ? result : result);
+        return;
+      }
+      if (route === "execute") {
+        const snapshot = options.machine.snapshot();
+        if (snapshot.leaseId !== leaseId || snapshot.state !== "started") {
+          reply(
+            response,
+            409,
+            errorResult2(
+              snapshot.state === "exited" ? "carrier-exited" : "carrier-lease-required",
+              "a started carrier lease",
+              "Do not fallback after started; report the structured terminal error and offer a new carrier."
+            )
+          );
+          return;
+        }
+        if (body.descriptorDigest !== options.descriptorDigest) {
+          reply(
+            response,
+            409,
+            errorResult2(
+              "carrier-descriptor-mismatch",
+              "the offered descriptor digest",
+              "Rebuild the offer from the current descriptor before retrying."
+            )
+          );
+          return;
+        }
+        if (body.recipeDigest !== options.recipeDigest) {
+          reply(
+            response,
+            409,
+            errorResult2(
+              "carrier-recipe-mismatch",
+              "the offered recipe digest",
+              "Serialize a fresh snapshot and request a new carrier before retrying."
+            )
+          );
+          return;
+        }
+        const terminal = await options.execute({
+          leaseId,
+          descriptorDigest: options.descriptorDigest,
+          recipeDigest: options.recipeDigest,
+          args: body.args
+        });
+        reply(response, 200, { ok: true, value: terminal, state: "started" });
+        return;
+      }
+      reply(
+        response,
+        404,
+        errorResult2(
+          "carrier-provider-exit",
+          "a carrier protocol route",
+          "Request a fresh visible offer from the provider."
+        )
+      );
+    } catch (cause) {
+      reply(
+        response,
+        400,
+        errorResult2(
+          "carrier-provider-exit",
+          "a valid carrier request",
+          "Serialize POD only and retry from the last safe snapshot.",
+          { cause: cause instanceof Error ? cause.message : String(cause) }
+        )
+      );
+    }
+  });
+  await new Promise((resolve19, reject) => {
+    const onError = (error) => {
+      server.off("listening", onListening);
+      reject(error);
+    };
+    const onListening = () => {
+      server.off("error", onError);
+      resolve19();
+    };
+    server.once("error", onError);
+    server.once("listening", onListening);
+    server.listen(0, host);
+  });
+  const address = server.address();
+  if (address === null || typeof address === "string")
+    throw new Error("carrier provider did not expose a loopback port");
+  const endpoint = `http://${host}:${address.port}/carrier`;
+  let closed = false;
+  return {
+    endpoint,
+    offer: options.machine.offer,
+    async close() {
+      if (closed) return;
+      closed = true;
+      await new Promise(
+        (resolve19, reject) => server.close((error) => error === void 0 ? resolve19() : reject(error))
+      );
+    }
   };
-  try {
-    await Promise.all([
-      writeFile(paths.tapeJson, tapeJson),
-      writeFile(paths.tapeBlob, tapeBlob),
-      writeFile(paths.capturePng, capturePng),
-      writeFile(paths.freshReplayPng, freshReplayPng),
-      writeFile(paths.profile, profile),
-      ...reportBytes === void 0 ? [] : [writeFile(paths.report, reportBytes)]
-    ]);
-    await writeFile(paths.manifest, `${JSON.stringify(manifest, null, 2)}
-`);
-    await rename(staging, published);
-  } catch (cause) {
-    await rm(staging, { recursive: true, force: true });
-    throw cause;
-  }
+}
+function createCarrierProvider(machine) {
   return {
-    ...result,
-    tape: {
-      ...result.tape,
-      jsonUri: projectUri(projectRoot, finalPaths.tapeJson),
-      blobUri: projectUri(projectRoot, finalPaths.tapeBlob)
+    offer: machine.offer,
+    accept(request) {
+      const result = machine.lease(request);
+      if (!result.ok) return result;
+      return { ok: true, value: { leaseId: result.value.leaseId }, state: result.state };
     },
-    profile: { ...result.profile, uri: projectUri(projectRoot, finalPaths.profile) },
-    capturePng: { ...result.capturePng, uri: projectUri(projectRoot, finalPaths.capturePng) },
-    png: { ...result.png, uri: projectUri(projectRoot, finalPaths.freshReplayPng) },
-    manifest,
-    artifacts: manifest.artifacts.map(artifactRef)
+    started: machine.started,
+    exit: machine.exit
   };
 }
-function browserFailure(phase, cause, pageErrors = []) {
+function createCarrierRendezvous(options) {
+  const machine = createCarrierStateMachine({
+    projectId: options.projectId,
+    consumerId: options.consumerId,
+    endpoint: options.endpoint ?? "http://127.0.0.1:5740/carrier",
+    now: options.now,
+    ttlMs: options.ttlMs ?? 3e4
+  });
+  let lookupCount = 0;
+  const lookup = () => {
+    if (options.presentation !== "visible" || machine.snapshot().state !== "offered") return;
+    lookupCount += 1;
+    return machine.offer;
+  };
   return {
-    ok: false,
-    error: {
-      code: "tool-preview-browser-host-failed",
-      expected: "a real Chromium page, project bootstrap, WebGPU device, and bounded preview run",
-      hint: "Inspect the Browser Host phase and repair the project or local WebGPU capability.",
+    ...machine,
+    lookup,
+    get lookupCount() {
+      return lookupCount;
+    }
+  };
+}
+
+// src/index.ts
+init_catalog();
+function decorateResourcePreviewTerminal(terminal) {
+  if (terminal.outcome === "succeeded") return terminal;
+  const recovery = describeResourcePreviewFailure(terminal.failure);
+  if (recovery === void 0) return terminal;
+  if (terminal.failure.code !== "tool-domain-failed") return terminal;
+  return {
+    ...terminal,
+    failure: {
+      ...terminal.failure,
       detail: {
-        phase,
-        cause: transportCause(cause),
-        pageErrors
+        ...terminal.failure.detail,
+        ...recovery.suggestedOperation === void 0 ? {} : { suggestedOperation: recovery.suggestedOperation },
+        recovery: recovery.actions
       }
     }
   };
 }
-async function runBrowserPreviewHost(projectRoot, recipe, snapshot, runId, signal, bootstrapRoot = "project-bootstrap", resource, options = {}) {
-  const facts = await readProjectFacts(projectRoot);
-  if (!facts.ok)
-    return { ok: false, error: { ...facts.error, detail: facts.error.detail } };
-  const config = await createViteConfig(facts.value, "serve", "/", { bootstrapRoot });
-  const cacheDir = await mkdtemp(join(facts.value.root, ".forgeax", ".browser-host-vite-"));
-  let server;
+function missingTool(id) {
+  return {
+    outcome: "failed",
+    failure: capabilityUnavailableError(`tool:${id}`, "build"),
+    artifacts: []
+  };
+}
+function runNamedTool(runtime, id, args) {
+  const contribution = runtime.get(id);
+  if (contribution === void 0) return Promise.resolve(missingTool(id));
+  return runtime.run(contribution, args).terminal.then(decorateResourcePreviewTerminal);
+}
+function runGenericTool(runtime, id, encodedArgs) {
+  let args;
   try {
-    const port = await allocateLoopbackPort();
-    server = await createServer$2({
-      ...config,
-      cacheDir,
-      logLevel: "silent",
-      optimizeDeps: {
-        ...config.optimizeDeps,
-        // Tool runs must observe the current workspace build, even when a
-        // persistent runner retains Vite's optimized-dependency cache.
-        force: true
+    args = JSON.parse(encodedArgs);
+  } catch {
+    return Promise.resolve({
+      outcome: "failed",
+      failure: {
+        code: "tool-invalid-args",
+        expected: "generic CLI arguments to be valid JSON",
+        hint: "Encode one JSON value that conforms to the descriptor argsSchema.",
+        detail: { message: "Invalid JSON", value: null }
       },
-      server: {
-        ...config.server,
-        host: "127.0.0.1",
-        port,
-        // Vite's port 0 means its default 5173. Bind the probed port exactly so
-        // another project or runner cannot be mistaken for this Browser Host.
-        strictPort: true
-      }
+      artifacts: []
     });
-  } catch (cause) {
-    await rm(cacheDir, { recursive: true, force: true });
-    throw cause;
   }
-  const hostStartedAtMs = performance.now();
-  let phase = "server-listen";
-  let browser;
-  let page;
-  let pageErrors = [];
-  let responseDiagnostics = [];
-  const launchBrowser = (headless) => chromium.launch({
-    channel: process.env.FORGEAX_CHROME_CHANNEL ?? "chrome",
-    headless,
-    args: [
-      "--enable-unsafe-webgpu",
-      "--enable-features=Vulkan,UseSkiaRenderer,SharedArrayBuffer",
-      "--use-vulkan=swiftshader",
-      "--use-angle=swiftshader",
-      "--disable-vulkan-surface",
-      "--ignore-gpu-blocklist",
-      "--disable-gpu-driver-bug-workarounds",
-      "--disable-dawn-features=disallow_unsafe_apis",
-      "--autoplay-policy=no-user-gesture-required"
-    ]
-  });
-  const observePage = (target) => {
-    target.on("pageerror", (error) => pageErrors.push(error.message));
-    target.on("console", (message) => {
-      if (message.type() === "error" || message.type() === "warning") {
-        pageErrors.push(`${message.type()}: ${message.text()}`);
+  return runNamedTool(runtime, id, args);
+}
+
+// src/tools/client.ts
+init_catalog();
+init_preview_migration();
+function missingTool2(id) {
+  return {
+    outcome: "failed",
+    failure: {
+      code: "tool-capability-unavailable",
+      expected: `tool ${id} to exist in the project-derived catalog`,
+      hint: "Run tool list and choose one of the discovered operation ids.",
+      detail: { capability: `tool:${id}`, realm: "build" }
+    },
+    artifacts: []
+  };
+}
+async function createToolClient(options) {
+  const projectDiscovery = options.projectDiscovery;
+  const runProjectTool2 = projectDiscovery === void 0 ? (await Promise.resolve().then(() => (init_project_tools(), project_tools_exports))).runProjectTool : void 0;
+  const builtins = options.baseContributions ?? (await Promise.resolve().then(() => (init_contributions(), contributions_exports))).createDefaultContributions(options.projectRoot);
+  const project = projectDiscovery === void 0 ? await (await Promise.resolve().then(() => (init_project_tools(), project_tools_exports))).discoverProjectTools(
+    options.projectRoot,
+    options
+  ) : await projectDiscovery(options.projectRoot);
+  const contributions = [...builtins, ...project.map(({ contribution }) => contribution)];
+  const runtime = options.baseContributions === void 0 ? (await Promise.resolve().then(() => (init_runtime(), runtime_exports))).createDevkitToolRuntime(contributions) : createToolRuntime(contributions);
+  const realmDispatch = options.realmOwners === void 0 ? void 0 : createRealmDispatch(contributions, options.realmOwners);
+  const bindingById = new Map(
+    project.map((binding) => [binding.contribution.descriptor.id, binding])
+  );
+  const descriptors = runtime.list();
+  const loaded = await loadToolCatalog(
+    createProjectToolCatalogAuthority(options.projectRoot, descriptors),
+    descriptors
+  );
+  if (!loaded.ok) throw loaded.error;
+  return {
+    list: () => listTools(loaded.value),
+    describe: (id) => describeTool(loaded.value, id),
+    async run(id, args, runOptions = {}) {
+      if (id === "preview.run") return retiredPreviewTool();
+      const contribution = runtime.get(id);
+      if (contribution === void 0) return missingTool2(id);
+      const binding = bindingById.get(id);
+      const nativePreview = binding === void 0 && id.endsWith(".preview") ? await Promise.resolve().then(() => (init_native_preview(), native_preview_exports)) : void 0;
+      const terminal = nativePreview?.isNativePreviewTool(id) === true ? await nativePreview.runNativePreviewTool(
+        contribution,
+        args,
+        runOptions,
+        options.projectRoot
+      ) : binding !== void 0 && runProjectTool2 !== void 0 ? await runProjectTool2(binding, args, runOptions) : realmDispatch === void 0 ? await runtime.run(contribution, args, runOptions).terminal : await realmDispatch.run(id, args, runOptions);
+      return decorateResourcePreviewTerminal(terminal);
+    }
+  };
+}
+
+// src/index.ts
+init_contributions();
+function runLibraryTool(contribution, args, options) {
+  return createToolRuntime([contribution]).run(contribution, args, options).terminal;
+}
+var roster = [
+  {
+    operation: "project.preview",
+    owner: "devkit/preview-host",
+    realm: "host",
+    artifacts: previewArtifacts(),
+    benefit: "reuse the real WebGPU hidden preview recipe",
+    fallback: "private"
+  },
+  {
+    operation: "material.preview",
+    owner: "engine-preview/material",
+    realm: "host",
+    artifacts: previewArtifacts(),
+    benefit: "preview one material subject through the canonical lit rig",
+    fallback: "private"
+  },
+  {
+    operation: "mesh.preview",
+    owner: "engine-preview/mesh",
+    realm: "host",
+    artifacts: previewArtifacts(),
+    benefit: "preview one mesh subject with every submesh and AABB evidence",
+    fallback: "private"
+  },
+  {
+    operation: "vfx.preview",
+    owner: "engine-preview/vfx",
+    realm: "host",
+    artifacts: previewArtifacts(),
+    benefit: "preview one bounded VFX timeline with compute evidence",
+    fallback: "private"
+  },
+  {
+    operation: "texture.preview",
+    owner: "engine-preview/texture",
+    realm: "host",
+    artifacts: previewArtifacts(),
+    benefit: "preview one texture on the aspect-preserving unlit quad",
+    fallback: "private"
+  }
+];
+function previewArtifacts() {
+  return [
+    {
+      owner: "preview-tool-proof",
+      source: "M3",
+      ref: {
+        kind: "rhi-tape",
+        digest: "sha256:e62a302dd29e302e1d0928306fe9c90c47ee336aa2e9e35fdc1d75586ae0018d",
+        uri: "repo:apps/preview/__tests__/tool-proof.recipe.integration.test.ts"
       }
-    });
-    target.on("response", (response) => {
-      if (response.status() >= 400) {
-        responseDiagnostics.push(
-          response.text().then((body) => {
-            pageErrors.push(`HTTP ${response.status()}: ${response.url()} ${body}`);
-          }).catch(() => {
-            pageErrors.push(`HTTP ${response.status()}: ${response.url()}`);
-          })
-        );
+    },
+    {
+      owner: "preview-tool-proof",
+      source: "M3",
+      ref: {
+        kind: "profile-capture",
+        digest: "sha256:11ec9024e1ea08b38f0901db272847ac402d2dce0c757efe744315608e889c5c",
+        uri: "repo:packages/profiler/src/__tests__/fixtures/profile-capture/model-input.json"
       }
-    });
-  };
-  const closeBrowserProcess = async () => {
-    await page?.close().catch(() => void 0);
-    page = void 0;
-    await browser?.close().catch(() => void 0);
-    browser = void 0;
-  };
-  const abort = () => {
-    void closeBrowserProcess();
-    void server.close();
-  };
-  signal.addEventListener("abort", abort, { once: true });
-  try {
-    if (signal.aborted) throw new Error("Browser Host aborted before launch");
-    await server.listen();
-    const address = server.httpServer?.address();
-    if (address === null || address === void 0 || typeof address === "string") {
-      throw new Error("Vite Browser Host did not expose a loopback TCP address");
     }
-    phase = "server-transform";
-    const entryTransform = await server.transformRequest("/main.ts");
-    if (entryTransform === null) {
-      throw new Error("Vite Browser Host entry transform returned no module");
-    }
-    phase = "capture-browser-launch";
-    browser = await launchBrowser(recipe.presentation === "hidden");
-    phase = "capture-page-bootstrap";
-    page = await browser.newPage({
-      viewport: recipe.viewport,
-      deviceScaleFactor: 1
-    });
-    observePage(page);
-    const captureUrl = new URL(`http://127.0.0.1:${address.port}/`);
-    captureUrl.searchParams.set("forgeax-tool-recipe", JSON.stringify(recipe));
-    captureUrl.searchParams.set("forgeax-tool-snapshot", JSON.stringify(snapshot));
-    captureUrl.searchParams.set("forgeax-tool-run-id", runId);
-    if (resource !== void 0)
-      ;
-    await page.goto(captureUrl.href, { waitUntil: "networkidle", timeout: 45e3 });
-    await page.waitForFunction(
-      () => globalThis.__forgeaxToolHost?.ready === true,
-      void 0,
-      { timeout: 45e3 }
-    );
-    phase = "capture-run";
-    const captured = await page.evaluate(async () => {
-      const host = globalThis.__forgeaxToolHost;
-      const value2 = await host.capture();
-      return JSON.parse(
-        JSON.stringify(
-          value2,
-          (_key, nested) => nested instanceof Error ? {
-            ...nested,
-            name: nested.name,
-            message: nested.message,
-            stack: nested.stack
-          } : nested
-        )
-      );
-    });
-    await Promise.all(responseDiagnostics);
-    if (!captured.ok) return browserFailure("capture-run", captured.error, pageErrors);
-    if (pageErrors.length > 0)
-      return browserFailure("capture-page-runtime", pageErrors[0], pageErrors);
-    const capturePng = await page.screenshot({ type: "png" });
-    const capturedResult = {
-      ...captured.result,
-      capturePng: {
-        uri: `data:image/png;base64,${capturePng.toString("base64")}`,
-        width: recipe.viewport.width,
-        height: recipe.viewport.height
-      }
-    };
-    await closeBrowserProcess();
-    pageErrors = [];
-    responseDiagnostics = [];
-    phase = "replay-browser-launch";
-    browser = await launchBrowser(true);
-    phase = "replay-page-bootstrap";
-    page = await browser.newPage({
-      viewport: recipe.viewport,
-      deviceScaleFactor: 1
-    });
-    observePage(page);
-    const replayUrl = new URL(`http://127.0.0.1:${address.port}/`);
-    replayUrl.searchParams.set("forgeax-tool-replay", "1");
-    await page.goto(replayUrl.href, { waitUntil: "networkidle", timeout: 45e3 });
-    await page.waitForFunction(
-      () => globalThis.__forgeaxToolReplayHost?.ready === true,
-      void 0,
-      { timeout: 45e3 }
-    );
-    phase = "replay-run";
-    const result = await page.evaluate(async (serializedCapture) => {
-      const host = globalThis.__forgeaxToolReplayHost;
-      const value2 = await host.run(JSON.parse(serializedCapture));
-      return JSON.parse(
-        JSON.stringify(
-          value2,
-          (_key, nested) => nested instanceof Error ? {
-            ...nested,
-            name: nested.name,
-            message: nested.message,
-            stack: nested.stack
-          } : nested
-        )
-      );
-    }, JSON.stringify(capturedResult));
-    await Promise.all(responseDiagnostics);
-    if (!result.ok) return browserFailure("replay-run", result.error, pageErrors);
-    if (pageErrors.length > 0)
-      return browserFailure("replay-page-runtime", pageErrors[0], pageErrors);
-    const endedAtMs = performance.now();
-    const phases = result.result.operationTiming.phases;
-    const observedDurationMs = phases === void 0 ? 0 : Object.values(phases).reduce(
-      (total, observation) => total + (observation.status === "observed" ? observation.durationMs : 0),
-      0
-    );
-    const durationMs = endedAtMs - hostStartedAtMs;
-    const value = {
-      ...result.result,
-      operationTiming: {
-        ...result.result.operationTiming,
-        startedAtMs: hostStartedAtMs,
-        endedAtMs,
-        durationMs,
-        ...phases === void 0 ? { unattributedMs: durationMs } : {
-          phases: {
-            ...phases,
-            transport: {
-              status: "observed",
-              durationMs: Math.max(0, durationMs - observedDurationMs)
-            }
-          },
-          unattributedMs: 0
-        }
-      },
-      actualCarrier: recipe.presentation === "hidden" ? "headless-private" : "headed-private"
-    };
-    phase = "artifact-publish";
+  ];
+}
+function validEvidence(entry) {
+  return entry.owner.length > 0 && entry.artifacts.length > 0 && entry.artifacts.every(
+    ({ owner, source, ref }) => owner.length > 0 && source === "M3" && /^sha256:[0-9a-f]{64}$/.test(ref.digest) && typeof ref.uri === "string" && ref.uri.startsWith("repo:") && isSupportedEvidenceKind(ref.kind)
+  );
+}
+function isSupportedEvidenceKind(kind) {
+  return kind === "rhi-tape" || kind === "profile-capture" || kind === "png";
+}
+function createMigrationRoster() {
+  return roster.filter(validEvidence).map((entry) => ({
+    ...entry,
+    artifacts: entry.artifacts.map((artifact) => ({ ...artifact, ref: { ...artifact.ref } }))
+  }));
+}
+function resolveMigration(entries2, operation, target) {
+  const entry = entries2.find((candidate) => candidate.operation === operation);
+  if (entry === void 0 || !validEvidence(entry)) {
     return {
-      ok: true,
-      value: options.publish === false ? value : await publishPreviewArtifacts(projectRoot, runId, value)
+      ok: false,
+      error: capabilityUnavailableError(`migration:${operation}`, target.realm)
     };
-  } catch (cause) {
-    await Promise.all(responseDiagnostics);
-    return browserFailure(phase, cause, pageErrors);
-  } finally {
-    signal.removeEventListener("abort", abort);
-    await closeBrowserProcess();
-    await server.close().catch(() => void 0);
-    await rm(cacheDir, { recursive: true, force: true });
   }
+  if (entry.realm !== target.realm || target.catalogDigest.length === 0) {
+    return { ok: false, error: capabilityUnavailableError(`migration:${operation}`, target.realm) };
+  }
+  if (entry.realm === "host" && target.rhiBackend !== "webgpu") {
+    return { ok: false, error: capabilityUnavailableError(`rhi:${operation}`, target.realm) };
+  }
+  const evidenceKinds = entry.artifacts.map(({ ref }) => ref.kind).filter(isSupportedEvidenceKind);
+  if (!evidenceKinds.every((kind) => target.evidence.includes(kind))) {
+    return { ok: false, error: capabilityUnavailableError(`evidence:${operation}`, target.realm) };
+  }
+  const service = createServiceCapability(void 0, {
+    toolId: operation,
+    descriptorDigest: entry.artifacts[0]?.ref.digest ?? "",
+    recipeDigest: entry.artifacts[0]?.ref.digest ?? "",
+    workloadClass: `migration:${operation}`,
+    codeDigest: target.catalogDigest,
+    browserVersion: "unavailable",
+    backend: "webgpu"
+  });
+  return {
+    ok: true,
+    value: {
+      path: service.available ? "service" : "private",
+      operation,
+      owner: entry.owner,
+      artifacts: entry.artifacts.map((artifact) => ({ ...artifact, ref: { ...artifact.ref } })),
+      service
+    }
+  };
 }
 
+// src/index.ts
+init_offline_analysis();
+init_preview_contributions();
+
 // src/tools/preview-host.ts
+init_browser_host();
 function carrierRouteFailure(code, expected, hint, detail) {
   return { ok: false, error: { code, expected, hint, detail } };
 }
@@ -6836,14 +8028,14 @@ async function createAuthenticatedLoopbackService(options) {
       reply2(response, 400, { error: message });
     }
   });
-  await new Promise((resolve18, reject) => {
+  await new Promise((resolve19, reject) => {
     const onError = (error) => {
       server.off("listening", onListening);
       reject(error);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve18();
+      resolve19();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -6851,7 +8043,7 @@ async function createAuthenticatedLoopbackService(options) {
   });
   const address = server.address();
   if (address === null || typeof address === "string") {
-    await new Promise((resolve18) => server.close(() => resolve18()));
+    await new Promise((resolve19) => server.close(() => resolve19()));
     throw new Error("loopback service did not expose a TCP address");
   }
   const endpoint = `http://${host}:${address.port}/run`;
@@ -6866,8 +8058,8 @@ async function createAuthenticatedLoopbackService(options) {
     async close() {
       if (closed) return;
       closed = true;
-      await new Promise((resolve18, reject) => {
-        server.close((error) => error === void 0 ? resolve18() : reject(error));
+      await new Promise((resolve19, reject) => {
+        server.close((error) => error === void 0 ? resolve19() : reject(error));
       });
       transport.close();
     }
@@ -6877,6 +8069,6 @@ async function createAuthenticatedLoopbackService(options) {
 // src/index.ts
 init_types();
 
-export { DEFAULT_ADMISSION_THRESHOLDS, ENGINE_BINDING_SCHEMA_VERSION, RHI_DEBUG_OPERATION_MANIFEST, analyzePreviewArtifacts, assetAddCommand, assetInspectCommand, assetListCommand, assetVerifyCommand, bootstrapRealm, browserCaptureCommand, buildCommand, createAdmissionReport, createAuthenticatedLoopbackService, createAuthorContribution, createBrowserCapture, createBuildContribution, createCarrierProvider, createCarrierProviderService, createCarrierRendezvous, createCliRhiDebugOperationContext, createDefaultContributions, createDevkitToolRuntime, createDomainPreviewContributions, createInitPlan, createMigrationRoster, createOfflineAnalysisContribution, createPreviewContribution, createPreviewContributions, createPreviewToolRuntime, createResourceProbe, createRhiDebugOperationContext, createServiceCache, createServiceExecutor, createSoftwareBrowser, createToolClient, describeTool, devCommand, discoverRhiDebugOperations, doctorCommand, engineBindingFilePath, engineDoctorCommand, engineStatusCommand, engineUnlinkCommand, engineUseLocalCommand, initCommand, inspectEngineWorkspace, listTools, materializeToolCatalog, newCommand, packageCommand, pluginInstallCommand, pluginUninstallCommand, previewCommand, readEngineBinding, readProjectFacts, rebuildToolCatalog, recoverRhiDebugError, renderRhiDebugHelp, resolveMigration, resolveProjectPort, resolveRealmCapability, runBenchmarkAdmission, runCarrierPreviewRoute, runGenericTool, runLibraryTool, runNamedTool, runPreviewHost, runPrivateTool, runRhiDebugCommand, runRhiDebugOperation, sdkInstallCommand, shaderCheckCommand, skillInstallCommand, skillVerifyCommand, softwareCaptureCommand, summarizeBenchmarkSamples, testCommand, verifyDist, writeDistManifest };
+export { DEFAULT_ADMISSION_THRESHOLDS, ENGINE_BINDING_SCHEMA_VERSION, RHI_DEBUG_OPERATION_MANIFEST, analyzePreviewArtifacts, assetAddCommand, assetInspectCommand, assetListCommand, assetVerifyCommand, bootstrapRealm, browserCaptureCommand, buildCommand, bundleSingleHtmlEntry, createAdmissionReport, createAuthenticatedLoopbackService, createAuthorContribution, createBrowserCapture, createBuildContribution, createCarrierProvider, createCarrierProviderService, createCarrierRendezvous, createCliRhiDebugOperationContext, createDefaultContributions, createDevkitToolRuntime, createInitPlan, createMigrationRoster, createOfflineAnalysisContribution, createPreviewContribution, createPreviewContributions, createPreviewToolRuntime, createResourceProbe, createRhiDebugOperationContext, createServiceCache, createServiceExecutor, createSoftwareBrowser, createToolClient, describeTool, devCommand, discoverRhiDebugOperations, doctorCommand, engineBindingFilePath, engineDoctorCommand, engineStatusCommand, engineUnlinkCommand, engineUseLocalCommand, initCommand, inspectEngineWorkspace, listTools, materializeToolCatalog, newCommand, packageCommand, packageFormatError, packageOutputError, pluginInstallCommand, pluginUninstallCommand, previewCommand, readEngineBinding, readProjectFacts, rebuildToolCatalog, recoverRhiDebugError, renderRhiDebugHelp, resolveMigration, resolveProjectPort, resolveRealmCapability, runBenchmarkAdmission, runCarrierPreviewRoute, runGenericTool, runLibraryTool, runNamedTool, runPreviewHost, runPrivateTool, runRhiDebugCommand, runRhiDebugOperation, sdkInstallCommand, shaderCheckCommand, skillInstallCommand, skillVerifyCommand, softwareCaptureCommand, summarizeBenchmarkSamples, testCommand, verifyDist, writeDistManifest, writeSingleHtml };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map