nudge-ui 0.2.1 → 0.2.3

package/dist/nudge-ui.mjs

@@ -2020,7 +2020,7 @@ var require_util = __commonJS({
         }
         path = url.path;
       }
-      var isAbsolute4 = exports.isAbsolute(path);
+      var isAbsolute5 = exports.isAbsolute(path);
       var parts = [];
       var start = 0;
       var i = 0;
@@ -2055,7 +2055,7 @@ var require_util = __commonJS({
       }
       path = parts.join("/");
       if (path === "") {
-        path = isAbsolute4 ? "/" : ".";
+        path = isAbsolute5 ? "/" : ".";
       }
       if (url) {
         url.path = path;
@@ -2064,7 +2064,7 @@ var require_util = __commonJS({
       return path;
     });
     exports.normalize = normalize;
-    function join6(aRoot, aPath) {
+    function join7(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -2096,11 +2096,11 @@ var require_util = __commonJS({
       }
       return joined;
     }
-    exports.join = join6;
+    exports.join = join7;
     exports.isAbsolute = function(aPath) {
       return aPath.charAt(0) === "/" || urlRegexp.test(aPath);
     };
-    function relative4(aRoot, aPath) {
+    function relative5(aRoot, aPath) {
       if (aRoot === "") {
         aRoot = ".";
       }
@@ -2119,7 +2119,7 @@ var require_util = __commonJS({
       }
       return Array(level + 1).join("../") + aPath.substr(aRoot.length + 1);
     }
-    exports.relative = relative4;
+    exports.relative = relative5;
     var supportsNullProto = (function() {
       var obj = /* @__PURE__ */ Object.create(null);
       return !("__proto__" in obj);
@@ -2310,7 +2310,7 @@ var require_util = __commonJS({
             parsed.path = parsed.path.substring(0, index + 1);
           }
         }
-        sourceURL = join6(urlGenerate(parsed), sourceURL);
+        sourceURL = join7(urlGenerate(parsed), sourceURL);
       }
       return normalize(sourceURL);
     }
@@ -3750,8 +3750,8 @@ var require_source_map = __commonJS({
 var require_previous_map = __commonJS({
   "../../node_modules/.pnpm/postcss@8.5.26/node_modules/postcss/lib/previous-map.js"(exports, module) {
     "use strict";
-    var { existsSync: existsSync4, readFileSync, realpathSync: realpathSync3 } = __require("fs");
-    var { dirname: dirname5, isAbsolute: isAbsolute4, join: join6, relative: relative4, sep: sep3 } = __require("path");
+    var { existsSync: existsSync4, readFileSync: readFileSync2, realpathSync: realpathSync3 } = __require("fs");
+    var { dirname: dirname5, isAbsolute: isAbsolute5, join: join7, relative: relative5, sep: sep4 } = __require("path");
     var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     function realPath(path) {
       try {
@@ -3824,15 +3824,15 @@ var require_previous_map = __commonJS({
         if (!trusted && !this.unsafeMap) {
           if (!/\.map$/i.test(path)) return void 0;
           if (!cssFile) return void 0;
-          let rel = relative4(realPath(dirname5(cssFile)), realPath(path));
-          if (rel === ".." || rel.startsWith(".." + sep3) || isAbsolute4(rel)) {
+          let rel = relative5(realPath(dirname5(cssFile)), realPath(path));
+          if (rel === ".." || rel.startsWith(".." + sep4) || isAbsolute5(rel)) {
             return void 0;
           }
         }
         this.root = dirname5(path);
         if (existsSync4(path)) {
           this.mapFile = path;
-          return readFileSync(path, "utf-8").toString().trim();
+          return readFileSync2(path, "utf-8").toString().trim();
         }
       }
       loadMap(file, prev) {
@@ -3866,7 +3866,7 @@ var require_previous_map = __commonJS({
           return this.decodeInline(this.annotation);
         } else if (this.annotation) {
           let map = this.annotation;
-          if (file) map = join6(dirname5(file), map);
+          if (file) map = join7(dirname5(file), map);
           let unknown = this.loadFile(map, file, false);
           if (unknown) {
             try {
@@ -3896,7 +3896,7 @@ var require_input = __commonJS({
   "../../node_modules/.pnpm/postcss@8.5.26/node_modules/postcss/lib/input.js"(exports, module) {
     "use strict";
     var { nanoid } = require_non_secure();
-    var { isAbsolute: isAbsolute4, resolve: resolve5 } = __require("path");
+    var { isAbsolute: isAbsolute5, resolve: resolve5 } = __require("path");
     var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     var { fileURLToPath, pathToFileURL: pathToFileURL2 } = __require("url");
     var CssSyntaxError2 = require_css_syntax_error();
@@ -3904,7 +3904,7 @@ var require_input = __commonJS({
     var terminalHighlight = require_terminal_highlight();
     var lineToIndexCache = /* @__PURE__ */ Symbol("lineToIndexCache");
     var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
-    var pathAvailable = Boolean(resolve5 && isAbsolute4);
+    var pathAvailable = Boolean(resolve5 && isAbsolute5);
     function getLineToIndex(input) {
       if (input[lineToIndexCache]) return input[lineToIndexCache];
       let lines = input.css.split("\n");
@@ -3935,7 +3935,7 @@ var require_input = __commonJS({
         this.document = this.css;
         if (opts.document) this.document = opts.document.toString();
         if (opts.from) {
-          if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute4(opts.from)) {
+          if (!pathAvailable || /^\w+:\/\//.test(opts.from) || isAbsolute5(opts.from)) {
             this.file = opts.from;
           } else {
             this.file = resolve5(opts.from);
@@ -4075,7 +4075,7 @@ var require_input = __commonJS({
           if (toPosition.source) to = toPosition;
         }
         let fromUrl;
-        if (isAbsolute4(from.source)) {
+        if (isAbsolute5(from.source)) {
           fromUrl = pathToFileURL2(from.source);
         } else {
           fromUrl = new URL(
@@ -4256,8 +4256,8 @@ var require_rule = __commonJS({
       }
       set selectors(values) {
         let match = this.selector ? this.selector.match(/,\s*/) : null;
-        let sep3 = match ? match[0] : "," + this.raw("between", "beforeOpen");
-        this.selector = values.join(sep3);
+        let sep4 = match ? match[0] : "," + this.raw("between", "beforeOpen");
+        this.selector = values.join(sep4);
       }
       constructor(defaults) {
         super(defaults);
@@ -4369,12 +4369,12 @@ var require_fromJSON = __commonJS({
 var require_map_generator = __commonJS({
   "../../node_modules/.pnpm/postcss@8.5.26/node_modules/postcss/lib/map-generator.js"(exports, module) {
     "use strict";
-    var { dirname: dirname5, relative: relative4, resolve: resolve5, sep: sep3 } = __require("path");
+    var { dirname: dirname5, relative: relative5, resolve: resolve5, sep: sep4 } = __require("path");
     var { SourceMapConsumer, SourceMapGenerator } = require_source_map();
     var { pathToFileURL: pathToFileURL2 } = __require("url");
     var Input2 = require_input();
     var sourceMapAvailable = Boolean(SourceMapConsumer && SourceMapGenerator);
-    var pathAvailable = Boolean(dirname5 && resolve5 && relative4 && sep3);
+    var pathAvailable = Boolean(dirname5 && resolve5 && relative5 && sep4);
     var MapGenerator = class {
       constructor(stringify2, root2, opts, cssString) {
         this.stringify = stringify2;
@@ -4605,7 +4605,7 @@ var require_map_generator = __commonJS({
         if (typeof this.mapOpts.annotation === "string") {
           from = dirname5(resolve5(from, this.mapOpts.annotation));
         }
-        let path = relative4(from, file);
+        let path = relative5(from, file);
         this.memoizedPaths.set(file, path);
         return path;
       }
@@ -4678,7 +4678,7 @@ var require_map_generator = __commonJS({
       toUrl(path) {
         let cached = this.memoizedURLs.get(path);
         if (cached) return cached;
-        if (sep3 === "\\") {
+        if (sep4 === "\\") {
           path = path.replace(/\\/g, "/");
         }
         let url = encodeURI(path).replace(/[#?]/g, encodeURIComponent);
@@ -6182,13 +6182,13 @@ function planAgentCommand(args, projectRoot, packageVersion) {
   throw new Error("Usage: nudge-ui agent <setup|doctor> [options]");
 }
 function findLocalMcp(projectRoot, projectRequire) {
-  let directory = projectRoot;
+  let directory2 = projectRoot;
   while (true) {
-    const candidate = join(directory, "node_modules", "@nudge-ui", "mcp");
+    const candidate = join(directory2, "node_modules", "@nudge-ui", "mcp");
     if (existsSync(join(candidate, "package.json"))) return candidate;
-    const parent = dirname(directory);
-    if (parent === directory) break;
-    directory = parent;
+    const parent = dirname(directory2);
+    if (parent === directory2) break;
+    directory2 = parent;
   }
   if (process.versions.pnp) {
     return projectRequire.resolve("@nudge-ui/mcp");
@@ -6204,20 +6204,122 @@ function runAgentCommand(args, packageVersion) {
   }
 }
 
-// src/hosts/static/server.ts
-import { createHash as createHash2 } from "node:crypto";
-import {
-  createServer
-} from "node:http";
-import {
-  constants,
-  existsSync as existsSync3,
-  realpathSync as realpathSync2,
-  statSync as statSync2
-} from "node:fs";
-import { open, stat as stat2 } from "node:fs/promises";
-import { dirname as dirname4, extname as extname2, isAbsolute as isAbsolute3, join as join5, relative as relative3, resolve as resolve3 } from "node:path";
-import { createRequire as createRequire3 } from "node:module";
+// src/transport/artifacts.ts
+var HTML_ARTIFACT_REVISION_ATTRIBUTE = "data-nudge-artifact-revision";
+var HTML_ITERATION_CONFLICT = "This iteration changed outside Nudge. Your visual edits are still pending. Create another iteration to keep your design, then clear this iteration\u2019s changes to load the external update.";
+function isHtmlArtifactRevision(value) {
+  if (!value || typeof value !== "object") return false;
+  const item = value;
+  return typeof item.document === "string" && /^[a-f0-9]{64}$/.test(item.document) && typeof item.preview === "string" && /^[a-f0-9]{64}$/.test(item.preview);
+}
+
+// src/project/artifacts.ts
+import { createHash } from "node:crypto";
+import { readFileSync, renameSync, writeFileSync } from "node:fs";
+import { mkdir, readFile, realpath, rename, rm, writeFile } from "node:fs/promises";
+import { isAbsolute, join as join2, relative, sep } from "node:path";
+
+// src/transport/routes.ts
+var NUDGE_UI_ROUTE_PREFIX = "/__nudge_ui__/";
+var NUDGE_UI_MANIFEST_PATH = `${NUDGE_UI_ROUTE_PREFIX}manifest`;
+var NUDGE_UI_CLIENT_PATH = `${NUDGE_UI_ROUTE_PREFIX}client.mjs`;
+var NUDGE_UI_EDITOR_PATH = `${NUDGE_UI_ROUTE_PREFIX}editor`;
+var NUDGE_UI_RELOAD_PATH = `${NUDGE_UI_ROUTE_PREFIX}reload`;
+var NUDGE_UI_ARTIFACTS_PATH = `${NUDGE_UI_ROUTE_PREFIX}artifacts`;
+var NUDGE_UI_MOUNT_ID = "nudge-ui-root";
+var NUDGE_UI_EDITOR_QUERY_PARAM = "nudge-ui";
+var NUDGE_UI_EDITOR_QUERY_VALUE = "editor";
+function isReservedNudgeUiRoute(pathname) {
+  return pathname === NUDGE_UI_ROUTE_PREFIX.slice(0, -1) || pathname.startsWith(NUDGE_UI_ROUTE_PREFIX);
+}
+
+// src/transport/editor.ts
+function isNudgeUiEditorDocumentRequest(requestHref, method, headers) {
+  const normalizedMethod = (method ?? "GET").toUpperCase();
+  if (normalizedMethod !== "GET" && normalizedMethod !== "HEAD") return false;
+  const url = new URL(requestHref, "http://nudge-ui.local");
+  if (url.pathname === NUDGE_UI_EDITOR_PATH) return true;
+  if (!isApplicationUrl(url)) return false;
+  if (!url.searchParams.getAll(NUDGE_UI_EDITOR_QUERY_PARAM).includes(NUDGE_UI_EDITOR_QUERY_VALUE)) return false;
+  const header = (name) => {
+    const value = headers?.[name] ?? headers?.[name.toLowerCase()];
+    return typeof value === "string" ? value : value?.join(",") ?? "";
+  };
+  return header("sec-fetch-dest").toLowerCase() === "document" || header("accept").toLowerCase().includes("text/html");
+}
+function isApplicationUrl(url) {
+  return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "" && !isReservedNudgeUiRoute(url.pathname);
+}
+function createNudgeUiEditorDocument() {
+  return `<!doctype html>
+<html lang="en" data-nudge-ui-editor>
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title>Nudge UI</title>
+  <style>html,body,#${NUDGE_UI_MOUNT_ID}{width:100%;height:100%;margin:0}body{overflow:hidden}</style>
+</head>
+<body>
+  <div id="${NUDGE_UI_MOUNT_ID}"></div>
+  <script type="module" src="${NUDGE_UI_CLIENT_PATH}" data-nudge-ui-client data-nudge-ui-manifest="${NUDGE_UI_MANIFEST_PATH}"></script>
+</body>
+</html>`;
+}
+
+// src/transport/index.ts
+var NUDGE_UI_MANIFEST_VERSION = 1;
+
+// src/hosts/environment.ts
+function readNudgeUiEnvironmentSwitch(env = process.env) {
+  const value = env.NUDGE_UI?.trim().toLowerCase();
+  if (value === "0" || value === "false" || value === "off") return "off";
+  if (value === "1" || value === "true" || value === "on") return "on";
+  return null;
+}
+function automationManifestFields(env = process.env) {
+  return readNudgeUiEnvironmentSwitch(env) === "on" ? { inspectAutomatedBrowsers: true } : {};
+}
+
+// src/hosts/static/manifest.ts
+function createStandaloneRuntimeManifest(projectId, tokenSnapshot = emptyTokenSnapshot(), revision2 = 0) {
+  return {
+    version: NUDGE_UI_MANIFEST_VERSION,
+    revision: revision2,
+    runtime: {
+      projectId,
+      host: "static-html",
+      framework: "HTML",
+      stylingSystem: "CSS custom properties",
+      // Canvas shares the Vite host's controller/renderer runtime (ADR-0012):
+      // every served document carries the bootstrap, so card iframes boot as
+      // renderers without host-specific code.
+      capabilities: { canvas: true, componentSemantics: false, domNavigation: true },
+      tokenCatalog: tokenSnapshot.tokenCatalog,
+      tokens: tokenSnapshot.tokens,
+      tokenDiagnostics: tokenSnapshot.tokenDiagnostics,
+      tokenGeneration: tokenSnapshot.tokenGeneration,
+      componentContracts: []
+    },
+    document: {
+      runtimeIdentity: "static-html",
+      stylesheetOrder: "browser"
+    },
+    reload: {
+      endpoint: NUDGE_UI_RELOAD_PATH,
+      strategy: "reload-document",
+      events: ["ready", "reload"]
+    },
+    ...automationManifestFields()
+  };
+}
+function emptyTokenSnapshot() {
+  return {
+    tokenCatalog: [],
+    tokens: [],
+    tokenDiagnostics: [],
+    tokenGeneration: "empty"
+  };
+}
 
 // ../../node_modules/.pnpm/parse5@7.3.0/node_modules/parse5/dist/common/unicode.js
 var UNDEFINED_CODE_POINTS = /* @__PURE__ */ new Set([
@@ -14073,6 +14175,323 @@ function parse(html, options) {
   return Parser.parse(html, options);
 }
 
+// src/hosts/static/html/bootstrap.ts
+var CLIENT_MARKER = "data-nudge-ui-client";
+var MOUNT_MARKER = "data-nudge-ui-mount";
+function injectStandaloneBootstrap(html, options = {}) {
+  const clientPath = options.clientPath ?? NUDGE_UI_CLIENT_PATH;
+  const manifestPath = options.manifestPath ?? NUDGE_UI_MANIFEST_PATH;
+  const document2 = parse(html, { sourceCodeLocationInfo: true });
+  const sourceFacts = inspectSource(document2, clientPath);
+  const nodes = [];
+  if (!sourceFacts.hasMount) {
+    nodes.push(
+      `<div id="${NUDGE_UI_MOUNT_ID}" ${MOUNT_MARKER}></div>`
+    );
+  }
+  if (!sourceFacts.hasClient) {
+    nodes.push(
+      `<script type="module" src="${escapeAttributeValue(clientPath)}" ${CLIENT_MARKER} data-nudge-ui-manifest="${escapeAttributeValue(manifestPath)}"></script>`
+    );
+  }
+  if (nodes.length === 0) return { html, injected: false };
+  const injection = `
+${nodes.join("\n")}
+`;
+  const offset = sourceFacts.bodyEndOffset ?? sourceFacts.htmlEndOffset ?? html.length;
+  return {
+    html: `${html.slice(0, offset)}${injection}${html.slice(offset)}`,
+    injected: true
+  };
+}
+function inspectSource(document2, clientPath) {
+  const facts = {
+    hasMount: false,
+    hasClient: false,
+    bodyEndOffset: null,
+    htmlEndOffset: null
+  };
+  let body2 = null;
+  visitElements(document2, (element) => {
+    if (element.namespaceURI !== "http://www.w3.org/1999/xhtml") return;
+    const tagName = element.tagName.toLowerCase();
+    if (tagName === "body") body2 = element;
+    if (tagName === "script" && (attributeValue(element, CLIENT_MARKER) !== null || attributeValue(element, "src") === clientPath)) {
+      facts.hasClient = true;
+    }
+    const endOffset = element.sourceCodeLocation?.endTag?.startOffset;
+    if (tagName === "body" && endOffset !== void 0) facts.bodyEndOffset = endOffset;
+    if (tagName === "html" && endOffset !== void 0) facts.htmlEndOffset = endOffset;
+  });
+  if (body2) {
+    visitElements(body2, (element) => {
+      if (element !== body2 && attributeValue(element, "id") === NUDGE_UI_MOUNT_ID) {
+        facts.hasMount = true;
+      }
+    });
+  }
+  return facts;
+}
+function visitElements(parent, visit) {
+  for (const child of parent.childNodes) {
+    if (!("tagName" in child) || typeof child.tagName !== "string") continue;
+    if (child.tagName.toLowerCase() === "template") continue;
+    visit(child);
+    visitElements(child, visit);
+  }
+}
+function attributeValue(element, name) {
+  return element.attrs.find((attribute) => attribute.name === name)?.value ?? null;
+}
+function escapeAttributeValue(value) {
+  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
+}
+
+// src/project/artifacts.ts
+var artifactOperations = /* @__PURE__ */ new Map();
+async function withArtifactLock(path, operation) {
+  const previous = artifactOperations.get(path) ?? Promise.resolve();
+  const pending = previous.catch(() => void 0).then(operation);
+  artifactOperations.set(path, pending);
+  try {
+    return await pending;
+  } finally {
+    if (artifactOperations.get(path) === pending) artifactOperations.delete(path);
+  }
+}
+function revision(html) {
+  return createHash("sha256").update(html).digest("hex");
+}
+async function readRevision(target) {
+  const [document2, preview] = await Promise.all([
+    readFile(join2(target, "document.html")),
+    readFile(join2(target, "preview.html"))
+  ]);
+  return { document: revision(document2), preview: revision(preview) };
+}
+function sameRevision(left, right) {
+  return left.document === right.document && left.preview === right.preview;
+}
+var ID = /^[a-f0-9-]{36}$/i;
+var MAX_BYTES = 12 * 1024 * 1024;
+var INERT_INTERACTIONS = `<script data-nudge-artifact-guard>
+document.addEventListener("submit", event => event.preventDefault(), true);
+document.addEventListener("click", event => {
+  if (event.target instanceof Element && event.target.closest("a")) event.preventDefault();
+}, true);
+</script>`;
+async function directory(root2, id) {
+  const project = await realpath(root2);
+  const artifacts = join2(project, ".nudge", "artifacts");
+  await mkdir(artifacts, { recursive: true });
+  const actual = await realpath(artifacts);
+  const pathFromRoot = relative(project, actual);
+  if (pathFromRoot === ".." || pathFromRoot.startsWith(`..${sep}`) || isAbsolute(pathFromRoot)) {
+    throw new Error("Artifact storage must remain inside the project root");
+  }
+  return join2(actual, id);
+}
+async function body(request) {
+  const chunks = [];
+  let size = 0;
+  for await (const chunk of request) {
+    const data = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+    size += data.byteLength;
+    if (size > MAX_BYTES) throw new Error("HTML artifact exceeds 12 MB");
+    chunks.push(data);
+  }
+  const text = Buffer.concat(chunks).toString("utf8");
+  return text.length === 0 ? {} : JSON.parse(text);
+}
+function respond(response, status, content, type = "text/plain; charset=utf-8") {
+  response.writeHead(status, {
+    "content-type": type,
+    "cache-control": "no-store",
+    "x-content-type-options": "nosniff"
+  });
+  response.end(content);
+}
+async function handleHtmlArtifactRequest(request, response, root2, transformHtml) {
+  const pathname = new URL(request.url ?? "/", "http://nudge-ui.local").pathname;
+  if (pathname !== NUDGE_UI_ARTIFACTS_PATH && !pathname.startsWith(`${NUDGE_UI_ARTIFACTS_PATH}/`)) return false;
+  const parts = pathname.slice(NUDGE_UI_ARTIFACTS_PATH.length).split("/").filter(Boolean);
+  if (request.method !== "GET" && request.method !== "HEAD") {
+    const origin = request.headers.origin;
+    const host = request.headers.host;
+    if (origin && host) {
+      try {
+        if (new URL(origin).host !== host) {
+          respond(response, 403, "Cross-origin artifact writes are not allowed");
+          return true;
+        }
+      } catch {
+        respond(response, 403, "Invalid request origin");
+        return true;
+      }
+    }
+  }
+  const id = parts[0];
+  if (parts.length > 2 || id && !ID.test(id) || parts.length === 2 && !["document", "baseline", "preview", "commit", "revision"].includes(parts[1])) {
+    respond(response, 404, "Not Found");
+    return true;
+  }
+  try {
+    if (request.method === "POST" && parts.length === 0) {
+      const input = await body(request);
+      if (!validArtifact(input)) {
+        respond(response, 400, "Invalid artifact");
+        return true;
+      }
+      const target2 = await directory(root2, input.id);
+      const temporary = `${target2}.create-${crypto.randomUUID()}`;
+      const metadata = {
+        id: input.id,
+        sourceUrl: input.sourceUrl,
+        title: input.title,
+        capturedAt: Date.now(),
+        viewport: input.viewport
+      };
+      await mkdir(temporary);
+      try {
+        await writeFile(join2(temporary, "baseline.html"), input.html);
+        await writeFile(join2(temporary, "preview.html"), input.html);
+        await writeFile(join2(temporary, "document.html"), input.html);
+        await writeFile(join2(temporary, "metadata.json"), JSON.stringify(metadata));
+        await rename(temporary, target2);
+      } catch (error) {
+        await rm(temporary, { recursive: true, force: true });
+        throw error;
+      }
+      respond(response, 201, JSON.stringify(metadata), "application/json; charset=utf-8");
+      return true;
+    }
+    if (!id) {
+      respond(response, 405, "Method Not Allowed");
+      return true;
+    }
+    const target = await directory(root2, id);
+    return await withArtifactLock(target, async () => {
+      if (request.method !== "DELETE") {
+        const actual = await realpath(target);
+        if (actual !== target) throw new Error("Artifact directory must not be a symbolic link");
+      }
+      if (request.method === "GET" && parts[1] === "revision") {
+        respond(response, 200, JSON.stringify(await readRevision(target)), "application/json; charset=utf-8");
+        return true;
+      }
+      if (request.method === "GET" && parts.length === 2 && parts[1] !== "commit") {
+        const file = parts[1] === "baseline" ? "baseline.html" : parts[1] === "preview" ? "preview.html" : "document.html";
+        const html = await readFile(join2(target, file), "utf8");
+        const stamped = html.replace(/<html\b/i, `<html ${HTML_ARTIFACT_REVISION_ATTRIBUTE}="${revision(html)}"`);
+        const bootstrapped = injectStandaloneBootstrap(stamped).html;
+        const guarded = bootstrapped.replace(/<\/body>/i, `${INERT_INTERACTIONS}</body>`);
+        respond(response, 200, transformHtml ? await transformHtml(guarded) : guarded, "text/html; charset=utf-8");
+        return true;
+      }
+      if (request.method === "GET" && parts.length === 1) {
+        respond(response, 200, await readFile(join2(target, "metadata.json"), "utf8"), "application/json; charset=utf-8");
+        return true;
+      }
+      if (request.method === "PUT" && parts[1] === "document" || request.method === "POST" && parts[1] === "commit") {
+        const input = await body(request);
+        if (!input || typeof input !== "object") {
+          respond(response, 400, "Invalid document");
+          return true;
+        }
+        const item = input;
+        if (!isHtmlArtifactRevision(item.expected)) {
+          respond(response, 428, "An expected iteration revision is required");
+          return true;
+        }
+        if (item.html !== void 0 && typeof item.html !== "string" || request.method === "PUT" && typeof item.html !== "string") {
+          respond(response, 400, "Invalid document");
+          return true;
+        }
+        const expected = item.expected;
+        if (!sameRevision(await readRevision(target), expected)) {
+          respond(response, 409, HTML_ITERATION_CONFLICT);
+          return true;
+        }
+        const html = typeof item.html === "string" ? item.html : await readFile(join2(target, "document.html"), "utf8");
+        const writes = request.method === "POST" ? ["preview.html"] : [];
+        if (typeof item.html === "string") writes.push("document.html");
+        const previewBefore = await readFile(join2(target, "preview.html"));
+        const temporaryFiles = [];
+        try {
+          for (const file of writes) {
+            const temporary = join2(target, `${file}-${crypto.randomUUID()}.tmp`);
+            temporaryFiles.push({ temporary, destination: join2(target, file) });
+            await writeFile(temporary, html);
+          }
+          const latest = {
+            document: revision(readFileSync(join2(target, "document.html"))),
+            preview: revision(readFileSync(join2(target, "preview.html")))
+          };
+          if (!sameRevision(latest, expected)) {
+            respond(response, 409, HTML_ITERATION_CONFLICT);
+            return true;
+          }
+          let replacedPreview = false;
+          try {
+            for (const file of temporaryFiles) {
+              renameSync(file.temporary, file.destination);
+              replacedPreview ||= file.destination === join2(target, "preview.html");
+            }
+          } catch (error) {
+            if (replacedPreview) {
+              const rollback = join2(target, `preview-rollback-${crypto.randomUUID()}.tmp`);
+              writeFileSync(rollback, previewBefore);
+              renameSync(rollback, join2(target, "preview.html"));
+            }
+            throw error;
+          }
+        } finally {
+          await Promise.all(temporaryFiles.map((file) => rm(file.temporary, { force: true }).catch(() => void 0)));
+        }
+        const saved = revision(html);
+        respond(response, 200, JSON.stringify({ document: saved, preview: request.method === "POST" ? saved : expected.preview }), "application/json; charset=utf-8");
+        return true;
+      }
+      if (request.method === "DELETE" && parts.length === 1) {
+        await rm(target, { recursive: true, force: true });
+        respond(response, 204, "");
+        return true;
+      }
+      respond(response, 405, "Method Not Allowed");
+      return true;
+    });
+  } catch (error) {
+    const code = error.code;
+    respond(
+      response,
+      code === "ENOENT" ? 404 : code === "EEXIST" || code === "ENOTEMPTY" ? 409 : 500,
+      code === "ENOENT" ? "Artifact not found" : error instanceof Error ? error.message : "Artifact storage failed"
+    );
+  }
+  return true;
+}
+function validArtifact(value) {
+  if (!value || typeof value !== "object") return false;
+  const item = value;
+  const viewport = item.viewport;
+  return typeof item.id === "string" && ID.test(item.id) && typeof item.sourceUrl === "string" && item.sourceUrl.length < 4096 && typeof item.title === "string" && item.title.length < 512 && typeof item.html === "string" && item.html.length > 0 && !!viewport && typeof viewport.width === "number" && typeof viewport.height === "number";
+}
+
+// src/hosts/static/server.ts
+import { createHash as createHash3 } from "node:crypto";
+import {
+  createServer
+} from "node:http";
+import {
+  constants,
+  existsSync as existsSync3,
+  realpathSync as realpathSync2,
+  statSync as statSync2
+} from "node:fs";
+import { open, stat as stat2 } from "node:fs/promises";
+import { dirname as dirname4, extname as extname2, isAbsolute as isAbsolute4, join as join6, relative as relative4, resolve as resolve3 } from "node:path";
+import { createRequire as createRequire3 } from "node:module";
+
 // src/html/dom.ts
 var HTML_NAMESPACE = "http://www.w3.org/1999/xhtml";
 var EXCLUDED_TAG_NAMES = /* @__PURE__ */ new Set([
@@ -14106,7 +14525,7 @@ function findBodyElements(document2) {
   visit(document2);
   return bodies;
 }
-function escapeAttributeValue(value) {
+function escapeAttributeValue2(value) {
   return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
 }
 
@@ -14160,19 +14579,6 @@ function positionAt(positions, offset) {
   return { line: low + 1, column: offset - lineStarts[low] + 1 };
 }
 
-// src/transport/routes.ts
-var NUDGE_UI_ROUTE_PREFIX = "/__nudge_ui__/";
-var NUDGE_UI_MANIFEST_PATH = `${NUDGE_UI_ROUTE_PREFIX}manifest`;
-var NUDGE_UI_CLIENT_PATH = `${NUDGE_UI_ROUTE_PREFIX}client.mjs`;
-var NUDGE_UI_EDITOR_PATH = `${NUDGE_UI_ROUTE_PREFIX}editor`;
-var NUDGE_UI_RELOAD_PATH = `${NUDGE_UI_ROUTE_PREFIX}reload`;
-var NUDGE_UI_MOUNT_ID = "nudge-ui-root";
-var NUDGE_UI_EDITOR_QUERY_PARAM = "nudge-ui";
-var NUDGE_UI_EDITOR_QUERY_VALUE = "editor";
-function isReservedNudgeUiRoute(pathname) {
-  return pathname === NUDGE_UI_ROUTE_PREFIX.slice(0, -1) || pathname.startsWith(NUDGE_UI_ROUTE_PREFIX);
-}
-
 // src/html/identity.ts
 function runIdentityPass(source, pass) {
   const diagnostics = [];
@@ -14245,8 +14651,8 @@ function runIdentityPass(source, pass) {
       if (isElement(child)) visit(child);
     }
   };
-  for (const body of findBodyElements(document2)) {
-    for (const child of body.childNodes) {
+  for (const body2 of findBodyElements(document2)) {
+    for (const child of body2.childNodes) {
       if (isElement(child)) visit(child);
     }
   }
@@ -14262,168 +14668,20 @@ function instrumentSourceHtml(source, file) {
     attributesFor({ element, line, column }) {
       const attributes = [];
       if (!hasAttribute(element, "data-cid")) {
-        attributes.push(`data-cid="${escapeAttributeValue(`html:${element.tagName}`)}"`);
+        attributes.push(`data-cid="${escapeAttributeValue2(`html:${element.tagName}`)}"`);
       }
       if (!hasAttribute(element, "data-src")) {
-        attributes.push(`data-src="${escapeAttributeValue(`${file}:${line}:${column}`)}"`);
+        attributes.push(`data-src="${escapeAttributeValue2(`${file}:${line}:${column}`)}"`);
       }
       return attributes;
     }
   });
 }
 
-// src/transport/editor.ts
-function isNudgeUiEditorDocumentRequest(requestHref, method, headers) {
-  const normalizedMethod = (method ?? "GET").toUpperCase();
-  if (normalizedMethod !== "GET" && normalizedMethod !== "HEAD") return false;
-  const url = new URL(requestHref, "http://nudge-ui.local");
-  if (url.pathname === NUDGE_UI_EDITOR_PATH) return true;
-  if (!isApplicationUrl(url)) return false;
-  if (!url.searchParams.getAll(NUDGE_UI_EDITOR_QUERY_PARAM).includes(NUDGE_UI_EDITOR_QUERY_VALUE)) return false;
-  const header = (name) => {
-    const value = headers?.[name] ?? headers?.[name.toLowerCase()];
-    return typeof value === "string" ? value : value?.join(",") ?? "";
-  };
-  return header("sec-fetch-dest").toLowerCase() === "document" || header("accept").toLowerCase().includes("text/html");
-}
-function isApplicationUrl(url) {
-  return (url.protocol === "http:" || url.protocol === "https:") && url.username === "" && url.password === "" && !isReservedNudgeUiRoute(url.pathname);
-}
-function createNudgeUiEditorDocument() {
-  return `<!doctype html>
-<html lang="en" data-nudge-ui-editor>
-<head>
-  <meta charset="utf-8">
-  <meta name="viewport" content="width=device-width, initial-scale=1">
-  <title>Nudge UI</title>
-  <style>html,body,#${NUDGE_UI_MOUNT_ID}{width:100%;height:100%;margin:0}body{overflow:hidden}</style>
-</head>
-<body>
-  <div id="${NUDGE_UI_MOUNT_ID}"></div>
-  <script type="module" src="${NUDGE_UI_CLIENT_PATH}" data-nudge-ui-client data-nudge-ui-manifest="${NUDGE_UI_MANIFEST_PATH}"></script>
-</body>
-</html>`;
-}
-
-// src/transport/index.ts
-var NUDGE_UI_MANIFEST_VERSION = 1;
-
-// src/hosts/static/manifest.ts
-function createStandaloneRuntimeManifest(projectId, tokenSnapshot = emptyTokenSnapshot(), revision = 0) {
-  return {
-    version: NUDGE_UI_MANIFEST_VERSION,
-    revision,
-    runtime: {
-      projectId,
-      host: "static-html",
-      framework: "HTML",
-      stylingSystem: "CSS custom properties",
-      // Canvas shares the Vite host's controller/renderer runtime (ADR-0012):
-      // every served document carries the bootstrap, so card iframes boot as
-      // renderers without host-specific code.
-      capabilities: { canvas: true, componentSemantics: false },
-      tokenCatalog: tokenSnapshot.tokenCatalog,
-      tokens: tokenSnapshot.tokens,
-      tokenDiagnostics: tokenSnapshot.tokenDiagnostics,
-      tokenGeneration: tokenSnapshot.tokenGeneration,
-      componentContracts: []
-    },
-    document: {
-      runtimeIdentity: "static-html",
-      stylesheetOrder: "browser"
-    },
-    reload: {
-      endpoint: NUDGE_UI_RELOAD_PATH,
-      strategy: "reload-document",
-      events: ["ready", "reload"]
-    }
-  };
-}
-function emptyTokenSnapshot() {
-  return {
-    tokenCatalog: [],
-    tokens: [],
-    tokenDiagnostics: [],
-    tokenGeneration: "empty"
-  };
-}
-
-// src/hosts/static/html/bootstrap.ts
-var CLIENT_MARKER = "data-nudge-ui-client";
-var MOUNT_MARKER = "data-nudge-ui-mount";
-function injectStandaloneBootstrap(html, options = {}) {
-  const clientPath = options.clientPath ?? NUDGE_UI_CLIENT_PATH;
-  const manifestPath = options.manifestPath ?? NUDGE_UI_MANIFEST_PATH;
-  const document2 = parse(html, { sourceCodeLocationInfo: true });
-  const sourceFacts = inspectSource(document2, clientPath);
-  const nodes = [];
-  if (!sourceFacts.hasMount) {
-    nodes.push(
-      `<div id="${NUDGE_UI_MOUNT_ID}" ${MOUNT_MARKER}></div>`
-    );
-  }
-  if (!sourceFacts.hasClient) {
-    nodes.push(
-      `<script type="module" src="${escapeAttributeValue2(clientPath)}" ${CLIENT_MARKER} data-nudge-ui-manifest="${escapeAttributeValue2(manifestPath)}"></script>`
-    );
-  }
-  if (nodes.length === 0) return { html, injected: false };
-  const injection = `
-${nodes.join("\n")}
-`;
-  const offset = sourceFacts.bodyEndOffset ?? sourceFacts.htmlEndOffset ?? html.length;
-  return {
-    html: `${html.slice(0, offset)}${injection}${html.slice(offset)}`,
-    injected: true
-  };
-}
-function inspectSource(document2, clientPath) {
-  const facts = {
-    hasMount: false,
-    hasClient: false,
-    bodyEndOffset: null,
-    htmlEndOffset: null
-  };
-  let body = null;
-  visitElements(document2, (element) => {
-    if (element.namespaceURI !== "http://www.w3.org/1999/xhtml") return;
-    const tagName = element.tagName.toLowerCase();
-    if (tagName === "body") body = element;
-    if (tagName === "script" && (attributeValue(element, CLIENT_MARKER) !== null || attributeValue(element, "src") === clientPath)) {
-      facts.hasClient = true;
-    }
-    const endOffset = element.sourceCodeLocation?.endTag?.startOffset;
-    if (tagName === "body" && endOffset !== void 0) facts.bodyEndOffset = endOffset;
-    if (tagName === "html" && endOffset !== void 0) facts.htmlEndOffset = endOffset;
-  });
-  if (body) {
-    visitElements(body, (element) => {
-      if (element !== body && attributeValue(element, "id") === NUDGE_UI_MOUNT_ID) {
-        facts.hasMount = true;
-      }
-    });
-  }
-  return facts;
-}
-function visitElements(parent, visit) {
-  for (const child of parent.childNodes) {
-    if (!("tagName" in child) || typeof child.tagName !== "string") continue;
-    if (child.tagName.toLowerCase() === "template") continue;
-    visit(child);
-    visitElements(child, visit);
-  }
-}
-function attributeValue(element, name) {
-  return element.attrs.find((attribute) => attribute.name === name)?.value ?? null;
-}
-function escapeAttributeValue2(value) {
-  return value.replaceAll("&", "&amp;").replaceAll('"', "&quot;").replaceAll("<", "&lt;").replaceAll(">", "&gt;");
-}
-
 // src/hosts/projectBridge.ts
 import { existsSync as existsSync2 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname2, join as join2, parse as parse2 } from "node:path";
+import { dirname as dirname2, join as join3, parse as parse2 } from "node:path";
 import { pathToFileURL } from "node:url";
 var runningBridges = /* @__PURE__ */ new Map();
 async function startOptionalProjectBridge(input) {
@@ -14444,7 +14702,7 @@ async function launchOptionalProjectBridge(input, key) {
       runningBridges.delete(key);
       return null;
     }
-    modulePath = createRequire2(join2(input.appRoot, "package.json")).resolve("@nudge-ui/mcp/project");
+    modulePath = createRequire2(join3(input.appRoot, "package.json")).resolve("@nudge-ui/mcp/project");
   } catch {
     runningBridges.delete(key);
     return null;
@@ -14464,6 +14722,7 @@ async function launchOptionalProjectBridge(input, key) {
       await runtime.close().catch(() => void 0);
       throw new Error("the project bridge returned a different project or origin");
     }
+    input.info?.(`[nudge-ui] project bridge ready for ${input.projectId}`);
     let closed = false;
     return {
       browser: { baseUrl: runtime.browser.bridgeUrl, autoConnect: true },
@@ -14485,24 +14744,24 @@ function isPnpRuntime() {
   return typeof process.versions.pnp === "string";
 }
 function hasProjectInstalledMcp(appRoot) {
-  let directory = appRoot;
-  const root2 = parse2(directory).root;
+  let directory2 = appRoot;
+  const root2 = parse2(directory2).root;
   for (; ; ) {
-    if (existsSync2(join2(directory, "node_modules", "@nudge-ui", "mcp", "package.json"))) return true;
-    if (directory === root2) return false;
-    directory = dirname2(directory);
+    if (existsSync2(join3(directory2, "node_modules", "@nudge-ui", "mcp", "package.json"))) return true;
+    if (directory2 === root2) return false;
+    directory2 = dirname2(directory2);
   }
 }
 
 // src/project/tokens.ts
-import { createHash } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 import {
   readFile as readUtf8File,
   readdir,
-  realpath,
+  realpath as realpath2,
   stat
 } from "node:fs/promises";
-import { extname, isAbsolute, join as join3, relative, resolve, sep } from "node:path";
+import { extname, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve, sep as sep2 } from "node:path";
 
 // ../../node_modules/.pnpm/postcss@8.5.26/node_modules/postcss/lib/postcss.mjs
 var import_postcss = __toESM(require_postcss(), 1);
@@ -15016,7 +15275,7 @@ var EMPTY_PROJECT_TOKEN_SNAPSHOT = {
 async function createProjectTokenSnapshot(options) {
   const rootDirectory = await canonicalRoot(options.rootDirectory);
   const additionalRoots = (await Promise.all(
-    (options.additionalRootDirectories ?? []).map((directory) => canonicalOptionalRoot(directory))
+    (options.additionalRootDirectories ?? []).map((directory2) => canonicalOptionalRoot(directory2))
   )).filter((root2) => root2 !== null);
   const scanRoots = [rootDirectory, ...additionalRoots.filter((root2) => root2 !== rootDirectory)];
   const discovered = await Promise.all(
@@ -15026,12 +15285,12 @@ async function createProjectTokenSnapshot(options) {
   const seenFiles = /* @__PURE__ */ new Set();
   for (let index = 0; index < discovered.length; index += 1) {
     for (const artifact of discovered[index] ?? []) {
-      const canonicalPath = await realpath(artifact.absolutePath).catch(() => artifact.absolutePath);
+      const canonicalPath = await realpath2(artifact.absolutePath).catch(() => artifact.absolutePath);
       if (seenFiles.has(canonicalPath)) continue;
       seenFiles.add(canonicalPath);
       artifacts.push({
         ...artifact,
-        projectPath: index === 0 ? artifact.projectPath : relative(rootDirectory, artifact.absolutePath).split(sep).join("/")
+        projectPath: index === 0 ? artifact.projectPath : relative2(rootDirectory, artifact.absolutePath).split(sep2).join("/")
       });
     }
   }
@@ -15074,32 +15333,32 @@ async function createProjectTokenSnapshot(options) {
     tokenGeneration
   };
 }
-async function discoverProjectCssArtifacts(rootDirectory, readFile = (absolutePath) => readUtf8File(absolutePath, "utf8")) {
+async function discoverProjectCssArtifacts(rootDirectory, readFile2 = (absolutePath) => readUtf8File(absolutePath, "utf8")) {
   const root2 = await canonicalRoot(rootDirectory);
   const artifacts = [];
   const visitedDirectories = /* @__PURE__ */ new Set();
   const visitedFiles = /* @__PURE__ */ new Set();
-  await walkDirectory(root2, root2, visitedDirectories, visitedFiles, artifacts, readFile);
+  await walkDirectory(root2, root2, visitedDirectories, visitedFiles, artifacts, readFile2);
   artifacts.sort((a, b) => comparePosixStrings(a.projectPath, b.projectPath));
   return artifacts;
 }
-async function walkDirectory(rootDirectory, directory, visitedDirectories, visitedFiles, artifacts, readFile) {
-  const canonicalDirectoryPath = await canonicalWithinRoot(rootDirectory, directory);
+async function walkDirectory(rootDirectory, directory2, visitedDirectories, visitedFiles, artifacts, readFile2) {
+  const canonicalDirectoryPath = await canonicalWithinRoot(rootDirectory, directory2);
   if (!canonicalDirectoryPath || visitedDirectories.has(canonicalDirectoryPath)) return;
-  const projectDirectoryPath = relative(rootDirectory, directory).split(sep).join("/");
-  const canonicalProjectDirectoryPath = relative(rootDirectory, canonicalDirectoryPath).split(sep).join("/");
+  const projectDirectoryPath = relative2(rootDirectory, directory2).split(sep2).join("/");
+  const canonicalProjectDirectoryPath = relative2(rootDirectory, canonicalDirectoryPath).split(sep2).join("/");
   if (isSensitiveProjectPath(projectDirectoryPath) || isSensitiveProjectPath(canonicalProjectDirectoryPath)) return;
   visitedDirectories.add(canonicalDirectoryPath);
   let entries;
   try {
-    entries = await readdir(directory, { withFileTypes: true });
+    entries = await readdir(directory2, { withFileTypes: true });
   } catch {
     return;
   }
   entries.sort((a, b) => comparePosixStrings(a.name, b.name));
   for (const entry of entries) {
     if (entry.isDirectory() && isExcludedDirectoryName(entry.name)) continue;
-    const absolutePath = join3(directory, entry.name);
+    const absolutePath = join4(directory2, entry.name);
     const canonicalPath = await canonicalWithinRoot(rootDirectory, absolutePath);
     if (!canonicalPath) continue;
     let stats;
@@ -15116,20 +15375,20 @@ async function walkDirectory(rootDirectory, directory, visitedDirectories, visit
         visitedDirectories,
         visitedFiles,
         artifacts,
-        readFile
+        readFile2
       );
       continue;
     }
     if (!stats.isFile() || extname(entry.name).toLowerCase() !== ".css") continue;
     if (visitedFiles.has(canonicalPath)) continue;
     visitedFiles.add(canonicalPath);
-    const projectPath = relative(rootDirectory, absolutePath).split(sep).join("/");
-    const canonicalProjectPath2 = relative(rootDirectory, canonicalPath).split(sep).join("/");
+    const projectPath = relative2(rootDirectory, absolutePath).split(sep2).join("/");
+    const canonicalProjectPath2 = relative2(rootDirectory, canonicalPath).split(sep2).join("/");
     if (isSensitiveProjectPath(projectPath) || isSensitiveProjectPath(canonicalProjectPath2)) {
       continue;
     }
     try {
-      const content = await readFile(absolutePath);
+      const content = await readFile2(absolutePath);
       artifacts.push({ absolutePath, projectPath, content });
     } catch (error) {
       artifacts.push({
@@ -15141,7 +15400,7 @@ async function walkDirectory(rootDirectory, directory, visitedDirectories, visit
   }
 }
 async function canonicalRoot(rootDirectory) {
-  const root2 = await realpath(resolve(rootDirectory));
+  const root2 = await realpath2(resolve(rootDirectory));
   if (!(await stat(root2)).isDirectory()) {
     throw new Error(`Standalone root is not a directory: ${rootDirectory}`);
   }
@@ -15156,9 +15415,9 @@ async function canonicalOptionalRoot(rootDirectory) {
 }
 async function canonicalWithinRoot(rootDirectory, candidate) {
   try {
-    const canonical = await realpath(candidate);
-    const pathFromRoot = relative(rootDirectory, canonical);
-    if (pathFromRoot === "" || !pathFromRoot.startsWith(`..${sep}`) && pathFromRoot !== ".." && !isAbsolute(pathFromRoot)) {
+    const canonical = await realpath2(candidate);
+    const pathFromRoot = relative2(rootDirectory, canonical);
+    if (pathFromRoot === "" || !pathFromRoot.startsWith(`..${sep2}`) && pathFromRoot !== ".." && !isAbsolute2(pathFromRoot)) {
       return canonical;
     }
   } catch {
@@ -15186,7 +15445,7 @@ function deterministicGeneration(artifacts, inventoryGeneration, label) {
     content: artifact.content,
     readError: artifact.readError
   }));
-  const digest = createHash("sha256").update(`${facts.join("\n")}
+  const digest = createHash2("sha256").update(`${facts.join("\n")}
 ${inventoryGeneration}`).digest("hex").slice(0, 24);
   return `${label}:${digest}`;
 }
@@ -15198,7 +15457,7 @@ function comparePosixStrings(a, b) {
 import { watch } from "node:fs";
 import { readdir as readdir2 } from "node:fs/promises";
 import { realpathSync, statSync } from "node:fs";
-import { dirname as dirname3, isAbsolute as isAbsolute2, join as join4, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+import { dirname as dirname3, isAbsolute as isAbsolute3, join as join5, relative as relative3, resolve as resolve2, sep as sep3 } from "node:path";
 function createProjectFileWatcher(options) {
   const rootDirectory = realpathSync(resolve2(options.rootDirectory));
   const debounceMs = Math.max(0, options.debounceMs ?? 60);
@@ -15228,30 +15487,30 @@ function createProjectFileWatcher(options) {
     pending.clear();
     void Promise.resolve(options.onSettled(changes)).catch(reportError);
   };
-  const closeDirectory = (directory) => {
-    const entry = watches.get(directory);
+  const closeDirectory = (directory2) => {
+    const entry = watches.get(directory2);
     if (!entry) return;
-    watches.delete(directory);
+    watches.delete(directory2);
     entry.watcher.close();
   };
-  const closeDescendants = (directory) => {
+  const closeDescendants = (directory2) => {
     for (const watchedDirectory of [...watches.keys()]) {
-      if (watchedDirectory === directory || watchedDirectory.startsWith(`${directory}${sep2}`)) {
+      if (watchedDirectory === directory2 || watchedDirectory.startsWith(`${directory2}${sep3}`)) {
         closeDirectory(watchedDirectory);
       }
     }
   };
-  const watchDirectory = (directory) => {
-    if (closed || !isProjectDirectory(rootDirectory, directory)) return;
-    const canonicalDirectory2 = canonicalProjectPath(rootDirectory, directory);
+  const watchDirectory = (directory2) => {
+    if (closed || !isProjectDirectory(rootDirectory, directory2)) return;
+    const canonicalDirectory2 = canonicalProjectPath(rootDirectory, directory2);
     if (!canonicalDirectory2 || [...watches.values()].some(
       (entry) => entry.canonicalDirectory === canonicalDirectory2
     )) return;
     let directoryWatcher;
     try {
-      directoryWatcher = watch(directory, { persistent: true }, (eventType, filename) => {
+      directoryWatcher = watch(directory2, { persistent: true }, (eventType, filename) => {
         const changedName = filename?.toString();
-        const changedPath = changedName ? join4(directory, changedName) : directory;
+        const changedPath = changedName ? join5(directory2, changedName) : directory2;
         if (!isProjectPath(rootDirectory, changedPath)) return;
         if (isProjectDirectory(rootDirectory, changedPath)) watchDirectory(changedPath);
         else if (!exists(changedPath)) closeDescendants(changedPath);
@@ -15262,17 +15521,17 @@ function createProjectFileWatcher(options) {
       reportError(error);
       return;
     }
-    watches.set(directory, { directory, canonicalDirectory: canonicalDirectory2, watcher: directoryWatcher });
+    watches.set(directory2, { directory: directory2, canonicalDirectory: canonicalDirectory2, watcher: directoryWatcher });
     pendingScans += 1;
-    scanQueue = scanQueue.then(() => scanSubdirectories(directory)).catch(reportError).finally(() => {
+    scanQueue = scanQueue.then(() => scanSubdirectories(directory2)).catch(reportError).finally(() => {
       pendingScans -= 1;
       if (pendingScans === 0) resolveReady?.();
     });
   };
-  const scanSubdirectories = async (directory) => {
+  const scanSubdirectories = async (directory2) => {
     let entries;
     try {
-      entries = await readdir2(directory, { withFileTypes: true });
+      entries = await readdir2(directory2, { withFileTypes: true });
     } catch {
       return;
     }
@@ -15280,7 +15539,7 @@ function createProjectFileWatcher(options) {
     for (const entry of entries) {
       if (closed) return;
       if (!entry.isDirectory() || isExcludedDirectoryName(entry.name)) continue;
-      const child = join4(directory, entry.name);
+      const child = join5(directory2, entry.name);
       if (!isProjectPath(rootDirectory, child)) continue;
       watchDirectory(child);
     }
@@ -15304,7 +15563,7 @@ function createProjectFileWatcher(options) {
         timer = null;
       }
       pending.clear();
-      for (const directory of [...watches.keys()]) closeDirectory(directory);
+      for (const directory2 of [...watches.keys()]) closeDirectory(directory2);
       await scanQueue;
     }
   };
@@ -15342,24 +15601,24 @@ function isProjectPath(rootDirectory, path) {
 function canonicalProjectPath(rootDirectory, path) {
   try {
     const canonical = realpathSync(path);
-    return isWithin(rootDirectory, canonical) && !isSensitiveProjectPath(relative2(rootDirectory, canonical).split(sep2).join("/")) ? canonical : null;
+    return isWithin(rootDirectory, canonical) && !isSensitiveProjectPath(relative3(rootDirectory, canonical).split(sep3).join("/")) ? canonical : null;
   } catch {
     const parent = dirname3(path);
     if (parent === path) return null;
     try {
       const canonicalParent = realpathSync(parent);
-      return isWithin(rootDirectory, canonicalParent) && !isSensitiveProjectPath(relative2(rootDirectory, canonicalParent).split(sep2).join("/")) ? canonicalParent : null;
+      return isWithin(rootDirectory, canonicalParent) && !isSensitiveProjectPath(relative3(rootDirectory, canonicalParent).split(sep3).join("/")) ? canonicalParent : null;
     } catch {
       return null;
     }
   }
 }
 function isExcludedDirectory(rootDirectory, path) {
-  return relative2(rootDirectory, resolve2(path)).split(sep2).some((segment) => isExcludedDirectoryName(segment));
+  return relative3(rootDirectory, resolve2(path)).split(sep3).some((segment) => isExcludedDirectoryName(segment));
 }
 function isWithin(rootDirectory, candidate) {
-  const pathFromRoot = relative2(rootDirectory, candidate);
-  return pathFromRoot === "" || !pathFromRoot.startsWith(`..${sep2}`) && pathFromRoot !== ".." && !isAbsolute2(pathFromRoot);
+  const pathFromRoot = relative3(rootDirectory, candidate);
+  return pathFromRoot === "" || !pathFromRoot.startsWith(`..${sep3}`) && pathFromRoot !== ".." && !isAbsolute3(pathFromRoot);
 }
 function comparePosixStrings2(a, b) {
   return Buffer.from(a, "utf8").compare(Buffer.from(b, "utf8"));
@@ -15380,15 +15639,15 @@ function createStandaloneServer(options) {
   validatePort(port);
   const clientPath = options.clientPath;
   const projectId = options.projectId ?? createStandaloneProjectId(rootDirectory);
-  let revision = 0;
+  let revision2 = 0;
   let manifest = createStandaloneRuntimeManifest(
     projectId,
     EMPTY_PROJECT_TOKEN_SNAPSHOT,
-    revision
+    revision2
   );
   let projectBridge = null;
   const initialTokens = createProjectTokenSnapshot({ rootDirectory, generationLabel: "static-html" }).then((tokens) => {
-    manifest = createStandaloneRuntimeManifest(projectId, tokens, revision);
+    manifest = createStandaloneRuntimeManifest(projectId, tokens, revision2);
     return tokens;
   });
   void initialTokens.catch(() => void 0);
@@ -15404,7 +15663,7 @@ function createStandaloneServer(options) {
   };
   const notifyReload = () => {
     const payload = `event: reload
-data: ${JSON.stringify({ revision })}
+data: ${JSON.stringify({ revision: revision2 })}
 
 `;
     for (const client of [...reloadClients]) {
@@ -15424,10 +15683,10 @@ data: ${JSON.stringify({ revision })}
     changeQueue = changeQueue.then(async () => {
       const tokens = await createProjectTokenSnapshot({ rootDirectory, generationLabel: "static-html" });
       manifest = {
-        ...createStandaloneRuntimeManifest(projectId, tokens, revision + 1),
+        ...createStandaloneRuntimeManifest(projectId, tokens, revision2 + 1),
         ...projectBridge ? { agentBridge: projectBridge.browser } : {}
       };
-      revision += 1;
+      revision2 += 1;
       notifyReload();
     }).catch((error) => {
       console.warn(
@@ -15498,6 +15757,7 @@ data: ${JSON.stringify({ revision })}
                 appRoot: rootDirectory,
                 projectId,
                 origin: address.url.replace(/\/$/, ""),
+                info: (message) => console.info(message),
                 warn: (message) => console.warn(message)
               }).then((bridge) => {
                 projectBridge = bridge;
@@ -15561,7 +15821,7 @@ function resolveDecodedStaticFile(root2, decodedPath) {
   let filePath = canonicalCandidate;
   const stats = statSync2(filePath);
   if (stats.isDirectory()) {
-    const indexCandidate = join5(filePath, "index.html");
+    const indexCandidate = join6(filePath, "index.html");
     const canonicalIndex = canonicalExistingAncestor(indexCandidate);
     if (!canonicalIndex || !isWithin2(root2, canonicalIndex) || !existsSync3(indexCandidate)) {
       return null;
@@ -15571,13 +15831,13 @@ function resolveDecodedStaticFile(root2, decodedPath) {
   } else if (!stats.isFile()) {
     return null;
   }
-  const relativePath = relative3(root2, filePath).split("\\").join("/");
+  const relativePath = relative4(root2, filePath).split("\\").join("/");
   if (isSensitiveProjectPath(relativePath)) return null;
   return { absolutePath: filePath, projectPath: relativePath };
 }
 function createStandaloneProjectId(rootDirectory) {
   const canonicalRoot2 = canonicalDirectory(rootDirectory);
-  const digest = createHash2("sha256").update(canonicalRoot2).digest("hex").slice(0, 24);
+  const digest = createHash3("sha256").update(canonicalRoot2).digest("hex").slice(0, 24);
   return `static-html:${digest}`;
 }
 function contentTypeForPath(filePath) {
@@ -15587,15 +15847,15 @@ function contentTypeForPath(filePath) {
 function isReservedNudgeUiRoute2(pathname) {
   return pathname === NUDGE_UI_ROUTE_PREFIX.slice(0, -1) || pathname.startsWith(NUDGE_UI_ROUTE_PREFIX);
 }
-function canonicalDirectory(directory) {
-  const canonical = canonicalDirectoryOrNull(directory);
-  if (!canonical) throw new Error(`Standalone root is not a readable directory: ${directory}`);
+function canonicalDirectory(directory2) {
+  const canonical = canonicalDirectoryOrNull(directory2);
+  if (!canonical) throw new Error(`Standalone root is not a readable directory: ${directory2}`);
   return canonical;
 }
-function canonicalDirectoryOrNull(directory) {
-  if (!isAbsolute3(directory)) return null;
+function canonicalDirectoryOrNull(directory2) {
+  if (!isAbsolute4(directory2)) return null;
   try {
-    const canonical = realpathSync2(directory);
+    const canonical = realpathSync2(directory2);
     return statSync2(canonical).isDirectory() ? canonical : null;
   } catch {
     return null;
@@ -15653,11 +15913,12 @@ function isMissingPathError(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
 }
 function isWithin2(root2, candidate) {
-  const pathFromRoot = relative3(root2, candidate);
-  return pathFromRoot === "" || !pathFromRoot.startsWith("..") && !isAbsolute3(pathFromRoot);
+  const pathFromRoot = relative4(root2, candidate);
+  return pathFromRoot === "" || !pathFromRoot.startsWith("..") && !isAbsolute4(pathFromRoot);
 }
 async function handleRequest(input) {
   const { request, response } = input;
+  if (await handleHtmlArtifactRequest(request, response, input.rootDirectory)) return;
   if (request.method !== "GET" && request.method !== "HEAD") {
     sendText(response, 405, "Method Not Allowed", { Allow: "GET, HEAD" });
     return;
@@ -15672,8 +15933,8 @@ async function handleRequest(input) {
     return;
   }
   if (isNudgeUiEditorDocumentRequest(request.url ?? "/", request.method, request.headers)) {
-    const body2 = request.method === "HEAD" ? Buffer.alloc(0) : Buffer.from(createNudgeUiEditorDocument(), "utf8");
-    sendBody(response, 200, body2, "text/html; charset=utf-8", { "Cache-Control": "no-store" });
+    const body3 = request.method === "HEAD" ? Buffer.alloc(0) : Buffer.from(createNudgeUiEditorDocument(), "utf8");
+    sendBody(response, 200, body3, "text/html; charset=utf-8", { "Cache-Control": "no-store" });
     return;
   }
   const resolution = resolveDecodedStaticFile(input.rootDirectory, decodedPath);
@@ -15684,7 +15945,7 @@ async function handleRequest(input) {
   const isHtml = HTML_EXTENSIONS.has(extname2(resolution.projectPath).toLowerCase());
   const contentType = contentTypeForPath(resolution.projectPath);
   if (request.method === "HEAD") {
-    const body2 = await readProjectFile(resolution.absolutePath);
+    const body3 = await readProjectFile(resolution.absolutePath);
     if (isHtml) {
       response.writeHead(200, {
         "Content-Type": contentType,
@@ -15693,25 +15954,25 @@ async function handleRequest(input) {
       });
       response.end();
     } else {
-      sendBody(response, 200, body2, contentType);
+      sendBody(response, 200, body3, contentType);
     }
     return;
   }
-  let body = await readProjectFile(resolution.absolutePath);
+  let body2 = await readProjectFile(resolution.absolutePath);
   if (isHtml) {
-    body = instrumentHtmlResponse(body, resolution.projectPath);
+    body2 = instrumentHtmlResponse(body2, resolution.projectPath);
   }
-  sendBody(response, 200, body, contentType, isHtml ? { "Cache-Control": "no-cache" } : {});
+  sendBody(response, 200, body2, contentType, isHtml ? { "Cache-Control": "no-cache" } : {});
 }
-function instrumentHtmlResponse(body, projectPath) {
+function instrumentHtmlResponse(body2, projectPath) {
   let source;
   try {
-    source = strictUtf8Decoder.decode(body);
+    source = strictUtf8Decoder.decode(body2);
   } catch {
     console.warn(
       `Nudge UI served ${projectPath} without instrumentation because it is not valid UTF-8.`
     );
-    return body;
+    return body2;
   }
   const identified = instrumentSourceHtml(source, projectPath);
   const bootstrapped = injectStandaloneBootstrap(identified.html);
@@ -15720,23 +15981,23 @@ function instrumentHtmlResponse(body, projectPath) {
 var strictUtf8Decoder = new TextDecoder("utf-8", { fatal: true });
 async function handleNudgeUiRoute(input, pathname) {
   if (pathname === NUDGE_UI_MANIFEST_PATH) {
-    const body = Buffer.from(JSON.stringify(input.getManifest()), "utf8");
-    sendBody(input.response, 200, body, "application/json; charset=utf-8", {
+    const body2 = Buffer.from(JSON.stringify(input.getManifest()), "utf8");
+    sendBody(input.response, 200, body2, "application/json; charset=utf-8", {
       "Cache-Control": "no-store"
     });
     return;
   }
   if (pathname === NUDGE_UI_EDITOR_PATH) {
-    const body = input.request.method === "HEAD" ? Buffer.alloc(0) : Buffer.from(createNudgeUiEditorDocument(), "utf8");
-    sendBody(input.response, 200, body, "text/html; charset=utf-8", {
+    const body2 = input.request.method === "HEAD" ? Buffer.alloc(0) : Buffer.from(createNudgeUiEditorDocument(), "utf8");
+    sendBody(input.response, 200, body2, "text/html; charset=utf-8", {
       "Cache-Control": "no-store"
     });
     return;
   }
   if (pathname === NUDGE_UI_CLIENT_PATH) {
     try {
-      const body = await readFileFromDescriptor(input.clientPath ?? resolveDefaultClientPath());
-      sendBody(input.response, 200, body, "text/javascript; charset=utf-8", {
+      const body2 = await readFileFromDescriptor(input.clientPath ?? resolveDefaultClientPath());
+      sendBody(input.response, 200, body2, "text/javascript; charset=utf-8", {
         "Cache-Control": "no-cache"
       });
     } catch {
@@ -15813,14 +16074,14 @@ function validatePort(port) {
 function sendText(response, status, text, headers = {}) {
   sendBody(response, status, Buffer.from(text, "utf8"), "text/plain; charset=utf-8", headers);
 }
-function sendBody(response, status, body, contentType, headers = {}) {
+function sendBody(response, status, body2, contentType, headers = {}) {
   response.writeHead(status, {
     "Content-Type": contentType,
-    "Content-Length": body.byteLength,
+    "Content-Length": body2.byteLength,
     "X-Content-Type-Options": "nosniff",
     ...headers
   });
-  if (response.req?.method !== "HEAD") response.end(body);
+  if (response.req?.method !== "HEAD") response.end(body2);
   else response.end();
 }
 var MIME_TYPES2 = {
@@ -15856,7 +16117,7 @@ function parseServeArguments(args, currentDirectory = process.cwd()) {
   if (args[0] !== "serve") {
     throw new Error("Usage: nudge-ui serve [directory] [--port <port>] [--host <loopback>]");
   }
-  let directory = ".";
+  let directory2 = ".";
   let host = "127.0.0.1";
   let port = 4173;
   let directoryProvided = false;
@@ -15873,13 +16134,13 @@ function parseServeArguments(args, currentDirectory = process.cwd()) {
     } else if (argument.startsWith("-")) {
       throw new Error(`Unknown option: ${argument}`);
     } else if (!directoryProvided) {
-      directory = argument;
+      directory2 = argument;
       directoryProvided = true;
     } else {
       throw new Error(`Unexpected argument: ${argument}`);
     }
   }
-  return { rootDirectory: resolve4(currentDirectory, directory), host, port };
+  return { rootDirectory: resolve4(currentDirectory, directory2), host, port };
 }
 async function runServeCommand(options) {
   const server = createStandaloneServer(options);