@frontman-ai/astro 0.1.7 → 0.2.2

package/dist/index.js

@@ -1,5 +1,5 @@
 import * as Web from 'stream/web';
-import * as Fs2 from 'fs';
+import * as Fs3 from 'fs';
 import { existsSync, readFileSync } from 'fs';
 import * as Nodepath from 'path';
 import { dirname, join } from 'path';
@@ -140,6 +140,267 @@ function makeFromObject(rawConfig) {
   };
 }
 
+// src/annotation-capture.mjs
+var annotationCaptureScript = `(function() {
+  var PROPS_PREFIX = '__frontman_props__:';
+
+  function parsePropsPayload(text) {
+    text = text.trim();
+    if (text.indexOf(PROPS_PREFIX) !== 0) return null;
+    try {
+      var encoded = text.slice(PROPS_PREFIX.length).trim();
+      return JSON.parse(atob(encoded));
+    } catch(e) {
+      return null;
+    }
+  }
+
+  function captureAnnotations() {
+    var annotations = new Map();
+    var propsMap = new Map();
+    var pendingProps = [];
+
+    var walker = document.createTreeWalker(
+      document.documentElement,
+      NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_ELEMENT,
+      null
+    );
+
+    var node;
+    while (node = walker.nextNode()) {
+      if (node.nodeType === 8) {
+        var parsed = parsePropsPayload(node.textContent);
+        if (parsed) {
+          pendingProps.push(parsed);
+        }
+      } else if (node.nodeType === 1) {
+        if (pendingProps.length > 0 && node.hasAttribute('data-astro-source-file')) {
+          propsMap.set(node, pendingProps.slice());
+          pendingProps = [];
+        }
+      }
+    }
+
+    document.querySelectorAll('[data-astro-source-file]').forEach(function(el) {
+      var sourceFile = el.getAttribute('data-astro-source-file');
+      var annotation = {
+        file: sourceFile,
+        loc: el.getAttribute('data-astro-source-loc')
+      };
+
+      var propsChain = propsMap.get(el);
+
+      if (!propsChain) {
+        var parent = el.parentElement;
+        var maxSteps = 30;
+        while (parent && maxSteps-- > 0) {
+          propsChain = propsMap.get(parent);
+          if (propsChain) break;
+          parent = parent.parentElement;
+        }
+      }
+
+      if (propsChain && propsChain.length > 0) {
+        var match = null;
+        for (var i = 0; i < propsChain.length; i++) {
+          var entry = propsChain[i];
+          if (entry.moduleId) {
+            var entryFile = entry.moduleId.split('/').pop() || '';
+            var srcFile = sourceFile.split('/').pop() || '';
+            if (entryFile === srcFile && entryFile !== '') {
+              match = entry;
+              break;
+            }
+          }
+        }
+        if (!match) match = propsChain[0];
+
+        if (match) {
+          annotation.componentProps = match.props || null;
+          if (match.displayName) {
+            annotation.displayName = match.displayName;
+          }
+        }
+      }
+
+      annotations.set(el, annotation);
+    });
+
+    window.__frontman_annotations__ = {
+      _map: annotations,
+      get: function(el) { return annotations.get(el); },
+      has: function(el) { return annotations.has(el); },
+      size: function() { return annotations.size; }
+    };
+  }
+
+  document.addEventListener('DOMContentLoaded', captureAnnotations);
+
+  var initialLoad = true;
+  document.addEventListener('astro:page-load', function() {
+    if (initialLoad) { initialLoad = false; return; }
+    captureAnnotations();
+  });
+})();`;
+
+// src/vite-plugin-props-injection.mjs
+function frontmanPropsInjectionPlugin() {
+  return {
+    name: "frontman:props-injection",
+    enforce: "pre",
+    apply: "serve",
+    // Only apply in SSR (server-side rendering) mode
+    transform(code, id, options) {
+      if (!options?.ssr) return null;
+      if (!id.includes("astro/dist/runtime/server/render/component") && !id.includes("astro/runtime/server/render/component")) {
+        return null;
+      }
+      if (!code.includes("function renderComponent(")) {
+        console.warn(
+          "[Frontman] Could not find renderComponent in Astro internals \u2014 component props injection will be disabled. This may happen after an Astro upgrade. File: " + id
+        );
+        return null;
+      }
+      let transformed = code.replace(
+        "function renderComponent(",
+        "function __original_renderComponent("
+      );
+      const wrapperCode = `
+
+// --- Frontman props injection wrapper ---
+
+function __frontman_safeSerialize(displayName, Component, props) {
+  try {
+    const clean = {};
+    for (const [key, value] of Object.entries(props || {})) {
+      // Skip internal Astro props (scoped CSS hashes)
+      if (key.startsWith('data-astro-cid-')) continue;
+      // Skip class (styling detail, not semantic)
+      if (key === 'class' || key === 'class:list') continue;
+
+      const t = typeof value;
+      if (t === 'string' || t === 'number' || t === 'boolean') {
+        clean[key] = value;
+      } else if (value === null || value === undefined) {
+        clean[key] = value;
+      } else if (Array.isArray(value)) {
+        try {
+          const serialized = JSON.stringify(value);
+          clean[key] = serialized.length < 1000 ? value : '[Array(' + value.length + ')]';
+        } catch {
+          clean[key] = '[Array]';
+        }
+      } else if (t === 'object') {
+        try {
+          const serialized = JSON.stringify(value);
+          clean[key] = serialized.length < 500 ? value : '{...}';
+        } catch {
+          clean[key] = '{...}';
+        }
+      }
+      // Skip functions, symbols, etc.
+    }
+
+    const entry = { displayName, props: clean };
+    // Include the component's moduleId (file path) if available
+    if (Component && Component.moduleId) {
+      entry.moduleId = Component.moduleId;
+    }
+    return JSON.stringify(entry);
+  } catch {
+    return null;
+  }
+}
+
+function __frontman_toBase64(str) {
+  if (typeof Buffer !== 'undefined') return Buffer.from(str, 'utf-8').toString('base64');
+  if (typeof btoa === 'function') return btoa(unescape(encodeURIComponent(str)));
+  return null;
+}
+
+function __frontman_wrapInstance(renderInstance, displayName, Component, props) {
+  // If no render method (e.g. fragment), pass through
+  if (!renderInstance || typeof renderInstance.render !== 'function') {
+    return renderInstance;
+  }
+
+  const serialized = __frontman_safeSerialize(displayName, Component, props);
+  if (!serialized) return renderInstance;
+
+  const encoded = __frontman_toBase64(serialized);
+  if (!encoded) return renderInstance;
+
+  const originalRender = renderInstance.render;
+
+  renderInstance.render = function(destination) {
+    // Write the props comment BEFORE the component renders.
+    // This creates a Comment node in the DOM immediately preceding
+    // the component's first rendered element.
+    // Guard: markHTMLString is assumed to be in scope from Astro's module.
+    // If it's missing (e.g., after an Astro upgrade), skip injection gracefully.
+    if (typeof markHTMLString === 'function') {
+      destination.write(markHTMLString('<!-- __frontman_props__:' + encoded + ' -->'));
+    }
+    return originalRender.call(renderInstance, destination);
+  };
+
+  return renderInstance;
+}
+
+function renderComponent(result, displayName, Component, props, slots) {
+  const renderInstance = __original_renderComponent(result, displayName, Component, props, slots);
+
+  // Handle promise (async component resolution)
+  if (renderInstance && typeof renderInstance.then === 'function') {
+    return renderInstance.then(function(resolved) {
+      return __frontman_wrapInstance(resolved, displayName, Component, props);
+    });
+  }
+
+  return __frontman_wrapInstance(renderInstance, displayName, Component, props);
+}
+
+// --- End Frontman props injection wrapper ---
+`;
+      transformed += wrapperCode;
+      return {
+        code: transformed,
+        map: null
+      };
+    }
+  };
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Primitive_int.js
+function div(x, y) {
+  if (y === 0) {
+    throw {
+      RE_EXN_ID: "Division_by_zero",
+      Error: new Error()
+    };
+  }
+  return x / y | 0;
+}
+
+// ../../node_modules/@rescript/runtime/lib/es6/Belt_Array.js
+function concatMany(arrs) {
+  let lenArrs = arrs.length;
+  let totalLen = 0;
+  for (let i = 0; i < lenArrs; ++i) {
+    totalLen = totalLen + arrs[i].length | 0;
+  }
+  let result = new Array(totalLen);
+  totalLen = 0;
+  for (let j2 = 0; j2 < lenArrs; ++j2) {
+    let cur = arrs[j2];
+    for (let k2 = 0, k_finish = cur.length; k2 < k_finish; ++k2) {
+      result[totalLen] = cur[k2];
+      totalLen = totalLen + 1 | 0;
+    }
+  }
+  return result;
+}
+
 // ../../node_modules/@rescript/runtime/lib/es6/Primitive_exceptions.js
 function isExtension(e) {
   if (e == null) {
@@ -280,9 +541,9 @@ function stringify(unknown2) {
 function toExpression(schema3) {
   let tag = schema3.type;
   let $$const = schema3.const;
-  let name10 = schema3.name;
-  if (name10 !== void 0) {
-    return name10;
+  let name11 = schema3.name;
+  if (name11 !== void 0) {
+    return name11;
   }
   if ($$const !== void 0) {
     return stringify($$const);
@@ -1402,10 +1663,10 @@ function isPriority(tagFlag, byKey) {
   }
 }
 function isWiderUnionSchema(schemaAnyOf, inputAnyOf) {
-  return inputAnyOf.every((inputSchema9, idx) => {
+  return inputAnyOf.every((inputSchema10, idx) => {
     let schema3 = schemaAnyOf[idx];
-    if (schema3 !== void 0 && !(flags[inputSchema9.type] & 9152) && inputSchema9.type === schema3.type) {
-      return inputSchema9.const === schema3.const;
+    if (schema3 !== void 0 && !(flags[inputSchema10.type] & 9152) && inputSchema10.type === schema3.type) {
+      return inputSchema10.const === schema3.const;
     } else {
       return false;
     }
@@ -2259,6 +2520,7 @@ var $$Error2 = $$Error;
 var string2 = string;
 var bool2 = bool;
 var int2 = int;
+var float2 = float;
 var json2 = json;
 var enableJson2 = enableJson;
 var literal2 = literal;
@@ -2287,7 +2549,7 @@ function string3(json3) {
     return json3;
   }
 }
-function float2(json3) {
+function float3(json3) {
   if (typeof json3 === "number") {
     return json3;
   }
@@ -2306,7 +2568,7 @@ var Decode = {
   bool: bool3,
   $$null: $$null2,
   string: string3,
-  float: float2,
+  float: float3,
   object: object2,
   array: array3
 };
@@ -4010,6 +4272,21 @@ function reduce(arr, init, f) {
 function reduceWithIndex(arr, init, f) {
   return arr.reduce(f, init);
 }
+function filterMap(a, f) {
+  let l = a.length;
+  let r = new Array(l);
+  let j2 = 0;
+  for (let i = 0; i < l; ++i) {
+    let v = a[i];
+    let v$1 = f(v);
+    if (v$1 !== void 0) {
+      r[j2] = valFromOption(v$1);
+      j2 = j2 + 1 | 0;
+    }
+  }
+  r.length = j2;
+  return r;
+}
 
 // ../../node_modules/@rescript/runtime/lib/es6/Stdlib_Int.js
 function fromString2(x, radix) {
@@ -4290,7 +4567,18 @@ Hint: ` + hint;
   }
 }
 
+// ../frontman-protocol/src/FrontmanProtocol__Tool.res.mjs
+var ToolNames = {
+  writeFile: "write_file",
+  readFile: "read_file",
+  listFiles: "list_files",
+  searchFiles: "search_files",
+  grep: "grep",
+  fileExists: "file_exists",
+  loadAgentInstructions: "load_agent_instructions"};
+
 // ../frontman-core/src/tools/FrontmanCore__Tool__Grep.res.mjs
+var name2 = ToolNames.grep;
 var inputSchema = schema2((s2) => ({
   pattern: s2.m(string2),
   path: s2.m(option2(string2)),
@@ -4552,7 +4840,6 @@ async function execute(ctx2, input) {
     return await gitGrepWithFallback();
   }
 }
-var name2 = "grep";
 var description = `Fast content search tool that finds files containing specific text or patterns, returning matching lines sorted by file modification time.
 
 WHEN TO USE THIS TOOL:
@@ -4583,6 +4870,7 @@ LIMITATIONS:
 - Results limited to max_results (default 20)
 - Binary files are automatically skipped
 - Hidden files (starting with '.') are skipped by default`;
+var name3 = ToolNames.readFile;
 var inputSchema2 = schema2((s2) => ({
   path: s2.m(string2),
   offset: s2.m(option2(int2)),
@@ -4611,7 +4899,7 @@ async function execute2(ctx2, input) {
   }
   let result = err._0;
   try {
-    let content = await Fs2.promises.readFile(result.resolvedPath, "utf8");
+    let content = await Fs3.promises.readFile(result.resolvedPath, "utf8");
     let lines = content.split("\n");
     let totalLines = lines.length;
     let selectedLines = lines.slice(offset, offset + limit | 0);
@@ -4639,7 +4927,6 @@ async function execute2(ctx2, input) {
     };
   }
 }
-var name3 = "read_file";
 var description2 = `Reads a file from the filesystem.
 
 Parameters:
@@ -4663,6 +4950,7 @@ function map3(opt, f) {
 }
 
 // ../frontman-core/src/tools/FrontmanCore__Tool__ListFiles.res.mjs
+var name4 = ToolNames.listFiles;
 var inputSchema3 = schema2((s2) => ({
   path: s2.m(option2(string2))
 }));
@@ -4738,20 +5026,20 @@ async function execute3(ctx2, input) {
   }
   try {
     let fullPath = err._0.resolvedPath;
-    let entries = await Fs2.promises.readdir(fullPath);
-    let filteredEntriesResult = map3(await getIgnoredEntries(fullPath, entries), (ignored) => entries.filter((name10) => !ignored.includes(name10)));
+    let entries = await Fs3.promises.readdir(fullPath);
+    let filteredEntriesResult = map3(await getIgnoredEntries(fullPath, entries), (ignored) => entries.filter((name11) => !ignored.includes(name11)));
     if (filteredEntriesResult.TAG !== "Ok") {
       return {
         TAG: "Error",
         _0: filteredEntriesResult._0
       };
     }
-    let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name10) => {
-      let entryPath = Nodepath.join(fullPath, name10);
-      let stats = await Fs2.promises.stat(entryPath);
+    let entriesWithStats = await Promise.all(filteredEntriesResult._0.map(async (name11) => {
+      let entryPath = Nodepath.join(fullPath, name11);
+      let stats = await Fs3.promises.stat(entryPath);
       return {
-        name: name10,
-        path: Nodepath.join(path, name10),
+        name: name11,
+        path: Nodepath.join(path, name11),
         isFile: stats.isFile(),
         isDirectory: stats.isDirectory()
       };
@@ -4769,16 +5057,18 @@ async function execute3(ctx2, input) {
     };
   }
 }
-var name4 = "list_files";
 var description3 = `Lists files and directories in a given path.
 
 Parameters:
 - path (optional): Path to directory - either relative to source root or absolute (must be under source root). Defaults to "." (root directory).
 
 Returns array of entries with name, path, and type information.`;
+var name5 = ToolNames.writeFile;
 var inputSchema4 = schema2((s2) => ({
   path: s2.m(string2),
-  content: s2.m(string2)
+  content: s2.m(option2(string2)),
+  image_ref: s2.m(option2(string2)),
+  encoding: s2.m(option2(literal2("base64")))
 }));
 var pathContextSchema2 = schema2((s2) => ({
   sourceRoot: s2.m(string2),
@@ -4788,7 +5078,35 @@ var pathContextSchema2 = schema2((s2) => ({
 var outputSchema4 = schema2((s2) => ({
   _context: s2.m(option2(pathContextSchema2))
 }));
+function writeContent(resolvedPath, content, encoding) {
+  if (encoding === void 0) {
+    return Fs3.promises.writeFile(resolvedPath, content, "utf8");
+  }
+  let buffer = Nodebuffer.Buffer.from(content, "base64");
+  return Fs3.promises.writeFile(resolvedPath, buffer);
+}
 async function execute4(ctx2, input) {
+  let match = input.content;
+  let match$1 = input.image_ref;
+  if (match === void 0) {
+    if (match$1 !== void 0) {
+      return {
+        TAG: "Error",
+        _0: "image_ref must be resolved to content before execution"
+      };
+    } else {
+      return {
+        TAG: "Error",
+        _0: "Either content or image_ref must be provided"
+      };
+    }
+  }
+  if (match$1 !== void 0) {
+    return {
+      TAG: "Error",
+      _0: "Provide either content or image_ref, not both"
+    };
+  }
   let err = resolve2(ctx2.sourceRoot, input.path);
   if (err.TAG !== "Ok") {
     return {
@@ -4797,12 +5115,11 @@ async function execute4(ctx2, input) {
     };
   }
   let result = err._0;
-  let dirPath = dirname3(result);
   try {
-    await Fs2.promises.mkdir(dirPath, {
+    await Fs3.promises.mkdir(dirname3(result), {
       recursive: true
     });
-    await Fs2.promises.writeFile(result.resolvedPath, input.content, "utf8");
+    await writeContent(result.resolvedPath, match, input.encoding);
     return {
       TAG: "Ok",
       _0: {
@@ -4822,15 +5139,18 @@ async function execute4(ctx2, input) {
     };
   }
 }
-var name5 = "write_file";
 var description4 = `Writes content to a file.
 
 Parameters:
 - path (required): Path to file - either relative to source root or absolute (must be under source root)
-- content (required): Content to write
+- content: Text content to write (mutually exclusive with image_ref)
+- image_ref: URI of a user-attached image to save (e.g., "attachment://att_abc123/photo.png"). Use this to save images the user has pasted into the chat. Mutually exclusive with content.
+- encoding: Set to "base64" when writing binary data (used internally when image_ref is resolved)
 
+Provide either content OR image_ref, not both.
 Creates parent directories if they don't exist. Overwrites existing files.
 The _context field provides path resolution details for debugging.`;
+var name6 = ToolNames.fileExists;
 var inputSchema5 = schema2((s2) => ({
   path: s2.m(string2)
 }));
@@ -4843,7 +5163,7 @@ async function execute5(ctx2, input) {
     };
   }
   try {
-    await Fs2.promises.access(toString(msg._0));
+    await Fs3.promises.access(toString(msg._0));
     return {
       TAG: "Ok",
       _0: true
@@ -4855,7 +5175,6 @@ async function execute5(ctx2, input) {
     };
   }
 }
-var name6 = "file_exists";
 var description5 = `Checks if a file or directory exists.
 
 Parameters:
@@ -4863,12 +5182,294 @@ Parameters:
 
 Returns true if the path exists, false otherwise.`;
 var outputSchema5 = bool2;
+
+// ../bindings/src/Lighthouse.res.mjs
+var run = ((url2, flags2) => import('module').then(({ createRequire }) => {
+  const req = createRequire(import.meta.url);
+  try {
+    const mod = req("lighthouse");
+    const lighthouse = mod.default ?? mod;
+    return lighthouse(url2, flags2);
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      throw new Error("lighthouse is not installed. Run: npm install lighthouse");
+    }
+    throw e;
+  }
+}));
+
+// ../bindings/src/ChromeLauncher.res.mjs
+var launch = ((options) => import('module').then(({ createRequire }) => {
+  const req = createRequire(import.meta.url);
+  try {
+    const mod = req("chrome-launcher");
+    return mod.launch(options);
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      throw new Error("chrome-launcher is not installed. Run: npm install chrome-launcher");
+    }
+    throw e;
+  }
+}));
+
+// ../frontman-core/src/tools/FrontmanCore__Tool__Lighthouse.res.mjs
+var rewriteUrlForRuntime = ((url2) => {
+  const override = process.env.FRONTMAN_LIGHTHOUSE_DEVPOD_LOCALHOST;
+  const worktreeId = process.env.WORKTREE_ID;
+  const overrideLower = typeof override === "string" ? override.toLowerCase() : "";
+  const devpodMode = overrideLower === "1" || overrideLower === "true" || overrideLower === "yes" || overrideLower === "on" || typeof worktreeId === "string";
+  if (!devpodMode) {
+    return url2;
+  }
+  let parsed;
+  try {
+    parsed = new URL(url2);
+  } catch {
+    return url2;
+  }
+  const host2 = parsed.hostname;
+  const mapToLocalhost = (port2, protocol) => {
+    parsed.protocol = protocol;
+    parsed.hostname = "127.0.0.1";
+    parsed.port = String(port2);
+    return parsed.toString();
+  };
+  if (host2.endsWith(".nextjs.frontman.local")) {
+    return mapToLocalhost(3e3, "http:");
+  }
+  if (host2.endsWith(".vite.frontman.local")) {
+    return mapToLocalhost(5173, "http:");
+  }
+  if (host2.endsWith(".api.frontman.local")) {
+    return mapToLocalhost(4e3, "https:");
+  }
+  return url2;
+});
 var inputSchema6 = schema2((s2) => ({
+  url: s2.m(string2),
+  preset: s2.m(option2(string2))
+}));
+var auditIssueSchema = schema2((s2) => ({
+  id: s2.m(string2),
+  title: s2.m(string2),
+  description: s2.m(string2),
+  score: s2.m(float2),
+  displayValue: s2.m(option2(string2))
+}));
+var categoryResultSchema = schema2((s2) => ({
+  id: s2.m(string2),
+  title: s2.m(string2),
+  score: s2.m(int2),
+  topIssues: s2.m(array2(auditIssueSchema))
+}));
+var outputSchema6 = schema2((s2) => ({
+  url: s2.m(string2),
+  fetchTime: s2.m(string2),
+  categories: s2.m(array2(categoryResultSchema)),
+  overallScore: s2.m(int2),
+  warnings: s2.m(array2(string2))
+}));
+var categoryIds = [
+  "performance",
+  "accessibility",
+  "best-practices",
+  "seo"
+];
+function getErrorMessage(exn) {
+  let jsError = fromException(exn);
+  if (jsError === void 0) {
+    return String(exn);
+  }
+  let jsError$1 = valFromOption(jsError);
+  let message3 = getOr(message2(jsError$1), "Unknown error");
+  let stack2 = jsError$1.stack;
+  if (stack2 !== void 0) {
+    return message3 + `
+` + stack2;
+  } else {
+    return message3;
+  }
+}
+function getTopIssues(category, audits, maxIssues) {
+  return filterMap(category.auditRefs, (ref) => audits[ref.id]).filter((audit) => {
+    let score = audit.score;
+    if (!(score == null) && (audit.scoreDisplayMode === "binary" || audit.scoreDisplayMode === "numeric" || audit.scoreDisplayMode === "metricSavings")) {
+      return score < 1;
+    } else {
+      return false;
+    }
+  }).toSorted((a, b) => {
+    let scoreA = getOr(fromNullable(a.score), 0);
+    let scoreB = getOr(fromNullable(b.score), 0);
+    return scoreA - scoreB;
+  }).slice(0, maxIssues).map((audit) => ({
+    id: audit.id,
+    title: audit.title,
+    description: audit.description,
+    score: getOr(fromNullable(audit.score), 0),
+    displayValue: audit.displayValue
+  }));
+}
+function processLhr(lhr) {
+  let categories = filterMap(categoryIds, (id) => lhr.categories[id]).map((category) => {
+    let s2 = category.score;
+    let score = !(s2 == null) ? Math.round(s2 * 100) | 0 : 0;
+    let topIssues = getTopIssues(category, lhr.audits, 3);
+    return {
+      id: category.id,
+      title: category.title,
+      score,
+      topIssues
+    };
+  });
+  let totalScore = reduce(categories, 0, (acc, cat) => acc + cat.score | 0);
+  let len = categories.length;
+  let overallScore = len !== 0 ? div(totalScore, len) : 0;
+  return {
+    url: lhr.finalDisplayedUrl,
+    fetchTime: lhr.fetchTime,
+    categories,
+    overallScore,
+    warnings: lhr.runWarnings
+  };
+}
+async function killChrome(chrome) {
+  try {
+    return await chrome.kill();
+  } catch (exn) {
+    return;
+  }
+}
+async function runLighthouse(chrome, url2, preset) {
+  let port2 = chrome.port;
+  let flags_port = port2;
+  let flags_output = "json";
+  let flags_logLevel = "error";
+  let flags_onlyCategories = categoryIds;
+  let flags_formFactor = preset;
+  let flags_screenEmulation = {
+    disabled: preset === "desktop"
+  };
+  let flags_throttlingMethod = "simulate";
+  let flags2 = {
+    port: flags_port,
+    output: flags_output,
+    logLevel: flags_logLevel,
+    onlyCategories: flags_onlyCategories,
+    formFactor: flags_formFactor,
+    screenEmulation: flags_screenEmulation,
+    throttlingMethod: flags_throttlingMethod
+  };
+  try {
+    let runnerResult = await run(url2, flags2);
+    await killChrome(chrome);
+    if (runnerResult == null) {
+      return {
+        TAG: "Error",
+        _0: "Lighthouse returned no results. The URL may be unreachable."
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: processLhr(runnerResult.lhr)
+      };
+    }
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    await killChrome(chrome);
+    let msg = getErrorMessage(exn);
+    return {
+      TAG: "Error",
+      _0: `Lighthouse audit failed: ` + msg
+    };
+  }
+}
+async function execute6(_ctx, input) {
+  let preset = getOr(input.preset, "desktop");
+  let auditUrl = rewriteUrlForRuntime(input.url);
+  switch (preset) {
+    case "desktop":
+    case "mobile":
+      break;
+    default:
+      return {
+        TAG: "Error",
+        _0: `Invalid preset "` + preset + `". Must be "desktop" or "mobile".`
+      };
+  }
+  try {
+    let chrome = await launch({
+      chromeFlags: [
+        "--headless",
+        "--disable-gpu",
+        "--no-sandbox",
+        "--disable-dev-shm-usage"
+      ]
+    });
+    let result = await runLighthouse(chrome, auditUrl, preset);
+    if (result.TAG !== "Ok") {
+      return result;
+    }
+    let out = result._0;
+    if (auditUrl === input.url) {
+      return {
+        TAG: "Ok",
+        _0: out
+      };
+    }
+    let warning = `DevPod mode: audited local URL ` + auditUrl + ` instead of ` + input.url + `.`;
+    return {
+      TAG: "Ok",
+      _0: {
+        url: input.url,
+        fetchTime: out.fetchTime,
+        categories: out.categories,
+        overallScore: out.overallScore,
+        warnings: concatMany([
+          [warning],
+          out.warnings
+        ])
+      }
+    };
+  } catch (raw_exn) {
+    let exn = internalToException(raw_exn);
+    let msg = getErrorMessage(exn);
+    return {
+      TAG: "Error",
+      _0: `Failed to launch Chrome: ` + msg + `. Make sure Chrome is installed on the system.`
+    };
+  }
+}
+var name7 = "lighthouse";
+var description6 = `Runs a Lighthouse audit on a URL to analyze performance, accessibility, best practices, and SEO.
+
+WHEN TO USE THIS TOOL:
+- After making changes that might affect page load performance
+- When implementing new UI components to check accessibility
+- Before deploying to verify web best practices
+- To diagnose why a page feels slow
+
+PARAMETERS:
+- url (required): The full URL to audit (e.g., "http://localhost:3000/")
+- preset (optional): "desktop" (default) or "mobile" for mobile emulation
+  IMPORTANT: Check the current_page context for device_emulation - if a mobile device is being emulated (e.g., iPhone, Pixel), use preset: "mobile" to match the user's testing context.
+
+OUTPUT:
+Returns scores (0-100) for each category plus the top 3 issues to fix in each category.
+Higher scores are better. Issues include actionable descriptions.
+
+LIMITATIONS:
+- Requires Chrome to be installed on the system
+- Takes 15-30 seconds to complete
+- Results can vary between runs (\xB15 points is normal)
+- URL must be accessible from the machine running the audit`;
+var name8 = ToolNames.searchFiles;
+var inputSchema7 = schema2((s2) => ({
   pattern: s2.m(string2),
   path: s2.m(option2(string2)),
   max_results: s2.m(option2(int2))
 }));
-var outputSchema6 = schema2((s2) => ({
+var outputSchema7 = schema2((s2) => ({
   files: s2.m(array2(string2)),
   totalResults: s2.m(int2),
   truncated: s2.m(bool2)
@@ -4982,7 +5583,7 @@ async function executeGitLsFiles(pattern2, searchPath, maxResults) {
     _0: `Git ls-files failed: ` + match.stderr
   };
 }
-async function execute6(ctx2, input) {
+async function execute7(ctx2, input) {
   let searchPath = resolveSearchPath(ctx2.sourceRoot, input.path);
   let maxResults = getOr(input.max_results, 20);
   let rgPath = getRipgrepPath2();
@@ -4996,8 +5597,7 @@ async function execute6(ctx2, input) {
     return await executeGitLsFiles(input.pattern, searchPath, maxResults);
   }
 }
-var name7 = "search_files";
-var description6 = `Fast file name search tool that finds files matching a pattern.
+var description7 = `Fast file name search tool that finds files matching a pattern.
 
 WHEN TO USE THIS TOOL:
 - Use when you need to find files by name pattern
@@ -5025,14 +5625,15 @@ LIMITATIONS:
 - Hidden files (starting with '.') are included
 - Respects .gitignore when using git ls-files fallback
 - Only finds files, not directories`;
-var inputSchema7 = schema2((s2) => ({
+var name9 = ToolNames.loadAgentInstructions;
+var inputSchema8 = schema2((s2) => ({
   startPath: s2.m(option2(string2))
 }));
 var instructionFileSchema = schema2((s2) => ({
   content: s2.m(string2),
   fullPath: s2.m(string2)
 }));
-var outputSchema7 = array2(instructionFileSchema);
+var outputSchema8 = array2(instructionFileSchema);
 var agentsVariants = [
   "Agents.md",
   ".claude/Agents.md",
@@ -5045,7 +5646,7 @@ var claudeVariants = [
 ];
 async function findFileCaseInsensitive(dir, targetFileName) {
   try {
-    let files = await Fs2.promises.readdir(dir);
+    let files = await Fs3.promises.readdir(dir);
     let targetLower = targetFileName.toLowerCase();
     let found = files.find((file) => file.toLowerCase() === targetLower);
     if (found !== void 0) {
@@ -5065,7 +5666,7 @@ async function loadIfExists(path) {
     return;
   }
   try {
-    let content = await Fs2.promises.readFile(actualPath, "utf8");
+    let content = await Fs3.promises.readFile(actualPath, "utf8");
     return {
       content,
       fullPath: actualPath
@@ -5102,7 +5703,7 @@ async function walkUpDirectories(current, acc) {
   let newAcc = acc.concat(filesAtLevel);
   return await walkUpDirectories(Nodepath.dirname(current), newAcc);
 }
-async function execute7(ctx2, input) {
+async function execute8(ctx2, input) {
   let inputPath = getOr(input.startPath, ".");
   let msg = resolve(ctx2.sourceRoot, inputPath);
   if (msg.TAG !== "Ok") {
@@ -5127,8 +5728,7 @@ async function execute7(ctx2, input) {
     };
   }
 }
-var name8 = "load_agent_instructions";
-var description7 = `Discovers and loads agent instruction files (Agents.md or CLAUDE.md) following Claude Code's discovery algorithm.
+var description8 = `Discovers and loads agent instruction files (Agents.md or CLAUDE.md) following Claude Code's discovery algorithm.
 
 Parameters:
 - startPath (optional): Starting directory for discovery - must be under source root. Defaults to "." (source root).
@@ -5178,11 +5778,11 @@ function coreTools() {
         visibleToAgent: true
       },
       {
-        name: name8,
-        description: description7,
-        inputSchema: inputSchema7,
-        outputSchema: outputSchema7,
-        execute: execute7,
+        name: name9,
+        description: description8,
+        inputSchema: inputSchema8,
+        outputSchema: outputSchema8,
+        execute: execute8,
         visibleToAgent: false
       },
       {
@@ -5193,6 +5793,14 @@ function coreTools() {
         execute,
         visibleToAgent: true
       },
+      {
+        name: name8,
+        description: description7,
+        inputSchema: inputSchema7,
+        outputSchema: outputSchema7,
+        execute: execute7,
+        visibleToAgent: true
+      },
       {
         name: name7,
         description: description6,
@@ -5209,8 +5817,8 @@ function addTools(registry, newTools) {
     tools: registry.tools.concat(newTools)
   };
 }
-function getToolByName(registry, name10) {
-  return registry.tools.find((m) => m.name === name10);
+function getToolByName(registry, name11) {
+  return registry.tools.find((m) => m.name === name11);
 }
 function serializeTool(m) {
   return {
@@ -5243,12 +5851,12 @@ var toolCallRequestSchema = schema2((s2) => ({
 var protocolVersion = "1.0";
 
 // ../frontman-core/src/FrontmanCore__Server.res.mjs
-async function executeTool(registry, ctx2, name10, $$arguments) {
-  let toolModule = getToolByName(registry, name10);
+async function executeTool(registry, ctx2, name11, $$arguments) {
+  let toolModule = getToolByName(registry, name11);
   if (toolModule === void 0) {
     return {
       TAG: "ToolNotFound",
-      _0: name10
+      _0: name11
     };
   }
   let toolCtx_projectRoot = ctx2.projectRoot;
@@ -5516,7 +6124,7 @@ var dynamicTypeSchema = union2([
   literal2("rest"),
   literal2("optional")
 ]);
-var inputSchema8 = schema2((s2) => ({
+var inputSchema9 = schema2((s2) => ({
   placeholder: s2.m(option2(bool2))
 }));
 var pageSchema = schema2((s2) => ({
@@ -5525,7 +6133,7 @@ var pageSchema = schema2((s2) => ({
   isDynamic: s2.m(bool2),
   dynamicType: s2.m(dynamicTypeSchema)
 }));
-var outputSchema8 = array2(pageSchema);
+var outputSchema9 = array2(pageSchema);
 function analyzeDynamicSegment(segment) {
   if (segment.startsWith("[[") && segment.endsWith("]]")) {
     return "optional";
@@ -5580,10 +6188,10 @@ function getMostSignificantDynamicType(segments) {
 async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
   let fullPath = Nodepath.join(projectRoot, baseDir, currentPath);
   try {
-    let entries = await Fs2.promises.readdir(fullPath);
+    let entries = await Fs3.promises.readdir(fullPath);
     return (await Promise.all(entries.map(async (entry) => {
       let entryPath = Nodepath.join(fullPath, entry);
-      let stats = await Fs2.promises.lstat(entryPath);
+      let stats = await Fs3.promises.lstat(entryPath);
       if (stats.isSymbolicLink()) {
         return [];
       }
@@ -5620,7 +6228,7 @@ async function findPages(baseDir, currentPath, projectRoot, sourceRoot) {
     throw exn;
   }
 }
-async function execute8(ctx2, _input) {
+async function execute9(ctx2, _input) {
   try {
     let srcPages = await findPages("src/pages", "", ctx2.projectRoot, ctx2.sourceRoot);
     let rootPages = await findPages("pages", "", ctx2.projectRoot, ctx2.sourceRoot);
@@ -5638,8 +6246,8 @@ async function execute8(ctx2, _input) {
     };
   }
 }
-var name9 = "get_client_pages";
-var description8 = `Lists Astro client pages from the pages directory.
+var name10 = "get_client_pages";
+var description9 = `Lists Astro client pages from the pages directory.
 
 Parameters: None
 
@@ -5648,11 +6256,11 @@ Excludes API routes (src/pages/api/) - focuses on renderable pages only.`;
 
 // src/FrontmanAstro__ToolRegistry.res.mjs
 var astroTools = [{
-  name: name9,
-  description: description8,
-  inputSchema: inputSchema8,
-  outputSchema: outputSchema8,
-  execute: execute8,
+  name: name10,
+  description: description9,
+  inputSchema: inputSchema9,
+  outputSchema: outputSchema9,
+  execute: execute9,
   visibleToAgent: true
 }];
 function make2() {
@@ -5750,8 +6358,8 @@ var collectRequestBody = (async function(req) {
   for await (const chunk of req) {
     chunks.push(chunk);
   }
-  const { Buffer: Buffer3 } = await import('buffer');
-  return Buffer3.concat(chunks);
+  const { Buffer: Buffer4 } = await import('buffer');
+  return Buffer4.concat(chunks);
 });
 
 // src/FrontmanAstro__ViteAdapter.res.mjs
@@ -5843,36 +6451,11 @@ function adaptToConnect(middleware, basePath) {
 }
 
 // src/FrontmanAstro__Integration.res.mjs
+var annotationCaptureScript2 = annotationCaptureScript;
 var icon = `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><circle cx="12" cy="12" r="3"/></svg>`;
 function getToolbarAppPath() {
   return new URL("./toolbar.js", import.meta.url).pathname;
 }
-var annotationCaptureScript = `(function() {
-  function captureAnnotations() {
-    var annotations = new Map();
-    document.querySelectorAll('[data-astro-source-file]').forEach(function(el) {
-      annotations.set(el, {
-        file: el.getAttribute('data-astro-source-file'),
-        loc: el.getAttribute('data-astro-source-loc')
-      });
-    });
-    window.__frontman_annotations__ = {
-      _map: annotations,
-      get: function(el) { return annotations.get(el); },
-      has: function(el) { return annotations.has(el); },
-      size: function() { return annotations.size; }
-    };
-  }
-  // Capture once on initial DOM parse
-  document.addEventListener('DOMContentLoaded', captureAnnotations);
-  // Re-capture on View Transitions (SPA navigations) \u2014 skips the initial
-  // page-load event since DOMContentLoaded already captured
-  var initialLoad = true;
-  document.addEventListener('astro:page-load', function() {
-    if (initialLoad) { initialLoad = false; return; }
-    captureAnnotations();
-  });
-})();`;
 function make3(configInput) {
   let config = makeFromObject(configInput);
   return {
@@ -5883,13 +6466,18 @@ function make3(configInput) {
           if (!ctx2.config.devToolbar.enabled) {
             console.warn("[Frontman] Astro devToolbar is disabled \u2014 element source detection will be limited. Set `devToolbar: { enabled: true }` in your astro.config to enable full component source resolution.");
           }
+          ctx2.updateConfig({
+            vite: {
+              plugins: [frontmanPropsInjectionPlugin()]
+            }
+          });
           ctx2.addDevToolbarApp({
             id: "frontman:toolbar",
             name: "Frontman",
             icon,
             entrypoint: getToolbarAppPath()
           });
-          return ctx2.injectScript("head-inline", annotationCaptureScript);
+          return ctx2.injectScript("head-inline", annotationCaptureScript2);
         }
       },
       "astro:server:setup": (param) => {