@weasel-js/forge 1.9.3 → 1.10.0

package/dist/vite/index.js

@@ -1,19 +1,23 @@
+import { DEFAULT_TITLE } from '../chunk-5DXUNLV2.js';
 import { isGallery } from '../chunk-WEQSLPKT.js';
-import { storyNameFromExport, storyId } from '../chunk-HRGPFQBW.js';
-import { readFileSync, existsSync, mkdirSync, writeFileSync, globSync, statSync } from 'fs';
-import { resolve, sep, relative, matchesGlob, dirname, join, basename } from 'path';
+import { PROP_ARG_TYPES_EXPORT, storyNameFromExport, storyId } from '../chunk-ZAWXMUGZ.js';
+import { readFileSync, mkdtempSync, existsSync, mkdirSync, writeFileSync, globSync, statSync, watch, rmSync } from 'fs';
+import { resolve, sep, relative, join, dirname, basename, matchesGlob, posix } from 'path';
 import { parse } from '@babel/parser';
+import { execFile } from 'child_process';
 import { fileURLToPath } from 'url';
+import { tmpdir } from 'os';
 
 // src/vite/html.ts
-function html(entry, mode = "serve") {
+var escaped = (text) => text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+function html(entry, mode = "serve", title = DEFAULT_TITLE) {
   const src = `${mode === "serve" ? "/@id/" : ""}virtual:forge/${entry}`;
   return `<!doctype html>
 <html lang="en">
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>weaselforge</title>
+    <title>${escaped(title)}</title>
   </head>
   <body>
     <div id="root"></div>
@@ -26,13 +30,13 @@ function html(entry, mode = "serve") {
 // src/vite/build.ts
 var DIR = "node_modules/.forge";
 var PAGES = { index: "shell-entry.js", frame: "frame-entry.js" };
-function writePages(root) {
+function writePages(root, title) {
   const dir = join(root, DIR);
   mkdirSync(dir, { recursive: true });
   return Object.fromEntries(
     Object.entries(PAGES).map(([name, entry]) => {
       const file = join(dir, `${name}.html`);
-      writeFileSync(file, html(entry, "build"));
+      writeFileSync(file, html(entry, "build", title));
       return [name, file];
     })
   );
@@ -47,34 +51,6 @@ function hoistPages(bundle, emit) {
     emit({ type: "asset", fileName: `${name}.html`, source: up(asset.source) });
   }
 }
-var posix = (path) => path.split(sep).join("/");
-var dotted = (path) => /^\.{1,2}([/\\]|$)/.test(path) ? path : `./${path}`;
-function globDirectory(pattern) {
-  const segments = pattern.split("/");
-  const magic = segments.findIndex((segment) => /^!|(^|[^\\])[*?[{(]/.test(segment));
-  return magic === -1 ? dirname(pattern) : segments.slice(0, magic).join("/");
-}
-function titleParts(parts) {
-  const last = parts[parts.length - 1];
-  if (last === void 0) return parts;
-  const stripped = last.replace(/(?:[.](?:story|stories))?([.][^.]+)$/i, "");
-  if (parts.length === 1) return [stripped];
-  const nextToLast = parts[parts.length - 2];
-  if (stripped && nextToLast && stripped.toLowerCase() === nextToLast.toLowerCase()) return [...parts.slice(0, -2), stripped];
-  if (stripped && (/^(story|stories)([.][^.]+)$/i.test(last) || /^index$/i.test(stripped))) return parts.slice(0, -1);
-  return [...parts.slice(0, -1), stripped];
-}
-var titleFrom = (importPath, directory) => titleParts(importPath.replace(directory, "").split("/").filter(Boolean)).join("/");
-function autoTitle(file, root, stories) {
-  const path = posix(relative(root, file));
-  const importPath = dotted(path);
-  for (const pattern of stories) {
-    if (!matchesGlob(path, pattern.replace(/^\.\//, ""))) continue;
-    const directory = dotted(posix(relative(root, resolve(root, globDirectory(pattern))))).replace(/\/$/, "");
-    return titleFrom(importPath, directory);
-  }
-  return titleFrom(importPath, ".");
-}
 var keyOf = (file, local) => `${file}#${local}`;
 var fileOfKey = (key) => key.slice(0, key.lastIndexOf("#"));
 var SCRIPT = /\.[cm]?[jt]sx?$/;
@@ -105,7 +81,7 @@ function createDepGraph({ root, read }) {
     reset() {
       resolutions.clear();
     },
-    async build(entries, resolve4) {
+    async build(entries, resolve5) {
       const resolveFrom = (spec, importer) => {
         let byImporter = resolutions.get(importer);
         if (!byImporter) {
@@ -114,7 +90,7 @@ function createDepGraph({ root, read }) {
         }
         let pending = byImporter.get(spec);
         if (!pending) {
-          pending = resolve4(spec, importer).then(
+          pending = resolve5(spec, importer).then(
             (id) => {
               const file = id?.split("?")[0];
               return file && !file.startsWith("\0") && SCRIPT.test(file) && !file.split(/[\\/]/).includes("node_modules") ? file : null;
@@ -344,6 +320,92 @@ function namesIn(node) {
   walk(node);
   return out;
 }
+var runGit = (args, cwd) => new Promise((done, fail) => {
+  execFile(
+    "git",
+    ["-c", "core.quotepath=off", ...args],
+    { cwd, maxBuffer: 1 << 30 },
+    (error, stdout) => error ? fail(error) : done(stdout)
+  );
+});
+var LOG_FORMAT = "--format=%x00%H%x09%aI";
+function fileDates(log, paths) {
+  const out = /* @__PURE__ */ new Map();
+  const names = new Map(paths.map((path) => [path, path]));
+  let commit = "";
+  let date = "";
+  for (const line of log.split("\n")) {
+    if (names.size === 0) break;
+    if (line.startsWith("\0")) {
+      [commit = "", date = ""] = line.slice(1).split("	");
+      continue;
+    }
+    const [status, ...files] = line.split("	");
+    const name = files.at(-1);
+    const path = name === void 0 ? void 0 : names.get(name);
+    if (!status || name === void 0 || path === void 0) continue;
+    out.set(path, { created: date, modified: out.get(path)?.modified ?? date, commit });
+    const renamed = status.startsWith("R") ? files[0] : void 0;
+    if (status === "A" || renamed !== void 0) names.delete(name);
+    if (renamed !== void 0) names.set(renamed, path);
+  }
+  return out;
+}
+function versionOf(named) {
+  const tag = named.trim().split(/[~^]/)[0] ?? "";
+  return /(?:^v?|@)(\d+\.\d+\.\d+[-+.\w]*)$/.exec(tag)?.[1] ?? null;
+}
+function packageOf(file, top) {
+  for (let dir = dirname(file); dir.startsWith(top); dir = dirname(dir)) {
+    const manifest = join(dir, "package.json");
+    if (existsSync(manifest)) {
+      try {
+        const name = JSON.parse(readFileSync(manifest, "utf8")).name;
+        if (typeof name === "string") return name;
+      } catch {
+      }
+    }
+    if (dir === top) break;
+  }
+  return null;
+}
+function createHistoryReader(root, git = runGit) {
+  let cached = null;
+  async function load(sources) {
+    const [top = "", prefix = ""] = (await git(["rev-parse", "--show-toplevel", "--show-prefix"], root)).split("\n");
+    const inRepo = new Map(sources.map((source) => [posix.normalize(posix.join(prefix, source)), source]));
+    const log = await git(["log", "--name-status", "-M", LOG_FORMAT], top);
+    const dates = fileDates(log, [...inRepo.keys()]);
+    const byPackage = /* @__PURE__ */ new Map();
+    for (const path of dates.keys()) {
+      const name = packageOf(resolve(top, path), top);
+      byPackage.set(name, [...byPackage.get(name) ?? [], path]);
+    }
+    const history = {};
+    for (const [name, paths] of byPackage) {
+      const refs = ["v[0-9]*", "[0-9]*", ...name === null ? [] : [`${name}@[0-9]*`]].map((ref) => `--refs=${ref}`);
+      const commits = paths.map((path) => dates.get(path).commit);
+      const named = (await git(["name-rev", "--tags", "--name-only", ...refs, ...commits], top)).split("\n");
+      paths.forEach((path, i) => {
+        const { created, modified } = dates.get(path);
+        history[inRepo.get(path)] = { created, modified, introduced: versionOf(named[i] ?? "") };
+      });
+    }
+    return history;
+  }
+  return {
+    async read(sources) {
+      try {
+        const head = (await git(["rev-parse", "HEAD"], root)).trim();
+        const key = [...sources].sort().join("\n");
+        if (cached?.head !== head || cached.sources !== key) cached = { head, sources: key, history: await load(sources) };
+        return cached.history;
+      } catch {
+        return {};
+      }
+    }
+  };
+}
 function parseFile(code, file) {
   const plugins = ["typescript", "decorators-legacy", .../\.[jt]sx$/.test(file) ? ["jsx"] : []];
   return parse(code, { sourceType: "module", plugins }).program;
@@ -365,11 +427,59 @@ function calleeOf(node, bindings, depth = 0) {
       return void 0;
   }
 }
+var LITERALS = /* @__PURE__ */ new Set([
+  "StringLiteral",
+  "NumericLiteral",
+  "BooleanLiteral",
+  "NullLiteral",
+  "BigIntLiteral",
+  "RegExpLiteral",
+  "TemplateLiteral",
+  "ArrayExpression",
+  "ArrowFunctionExpression",
+  "FunctionExpression",
+  "FunctionDeclaration",
+  "ClassExpression",
+  "JSXElement",
+  "JSXFragment"
+]);
+function isLiteralValue(node, bindings, depth = 0) {
+  if (!node || depth > 16) return false;
+  switch (node.type) {
+    case "TSSatisfiesExpression":
+    case "TSAsExpression":
+    case "TSTypeAssertion":
+    case "TSNonNullExpression":
+    case "ParenthesizedExpression":
+      return isLiteralValue(node.expression, bindings, depth + 1);
+    case "Identifier":
+      return isLiteralValue(bindings.get(node.name), bindings, depth + 1);
+    case "ObjectExpression":
+      return node.properties.every((p) => p.type !== "SpreadElement");
+    default:
+      return LITERALS.has(node.type);
+  }
+}
 function stringLiteral(node) {
   if (node.type === "StringLiteral") return node.value;
   if (node.type === "TemplateLiteral" && node.expressions.length === 0) return node.quasis.map((q) => q.value.cooked ?? q.value.raw).join("");
   return void 0;
 }
+function stringOf(node, bindings, depth = 0) {
+  if (!node || depth > 16) return void 0;
+  switch (node.type) {
+    case "TSSatisfiesExpression":
+    case "TSAsExpression":
+    case "TSTypeAssertion":
+    case "TSNonNullExpression":
+    case "ParenthesizedExpression":
+      return stringOf(node.expression, bindings, depth + 1);
+    case "Identifier":
+      return stringOf(bindings.get(node.name), bindings, depth + 1);
+    default:
+      return stringLiteral(node);
+  }
+}
 function isDefaultExport(stmt) {
   if (stmt.type === "ExportDefaultDeclaration") return true;
   return stmt.type === "ExportNamedDeclaration" && stmt.specifiers.some((s) => s.type === "ExportSpecifier" && exportedName(s.exported) === "default");
@@ -416,10 +526,58 @@ function stringProp(obj, key) {
   return value?.type === "StringLiteral" ? value.value : void 0;
 }
 
+// src/vite/nativeExports.ts
+var isFn = (node) => node?.type === "ArrowFunctionExpression" || node?.type === "FunctionExpression" || node?.type === "FunctionDeclaration";
+var foreignFrom = (known) => ({
+  value: (name) => known.values[name],
+  call: (name) => known.calls[name],
+  reexport: (name) => known.reexports[name]
+});
+function returnsStory(statements, scope, depth) {
+  return statements.some((stmt) => {
+    if (stmt.type === "ReturnStatement") return mayBeStory(stmt.argument ?? void 0, scope, depth);
+    if (stmt.type === "BlockStatement") return returnsStory(stmt.body, scope, depth);
+    if (stmt.type !== "IfStatement") return false;
+    return returnsStory([stmt.consequent, ...stmt.alternate ? [stmt.alternate] : []], scope, depth);
+  });
+}
+function mayReturnStory(fn, scope, depth = 0) {
+  return fn.body.type === "BlockStatement" ? returnsStory(fn.body.body, scope, depth + 1) : mayBeStory(fn.body, scope, depth + 1);
+}
+function mayBeStory(node, scope, depth = 0) {
+  if (!node) return true;
+  if (depth > 16) return false;
+  switch (node.type) {
+    case "TSSatisfiesExpression":
+    case "TSAsExpression":
+    case "TSTypeAssertion":
+    case "TSNonNullExpression":
+    case "ParenthesizedExpression":
+      return mayBeStory(node.expression, scope, depth + 1);
+    case "Identifier":
+      return scope.bindings.has(node.name) ? mayBeStory(scope.bindings.get(node.name), scope, depth + 1) : scope.foreign?.value(node.name) ?? true;
+    case "CallExpression": {
+      if (node.callee.type !== "Identifier") return false;
+      if (scope.wrappers.has(node.callee.name)) return true;
+      const fn = scope.bindings.get(node.callee.name);
+      if (isFn(fn)) return mayReturnStory(fn, scope, depth);
+      return !scope.bindings.has(node.callee.name) && (scope.foreign?.call(node.callee.name) ?? false);
+    }
+    case "ConditionalExpression":
+      return mayBeStory(node.consequent, scope, depth + 1) || mayBeStory(node.alternate, scope, depth + 1);
+    case "LogicalExpression":
+      return mayBeStory(node.left, scope, depth + 1) || mayBeStory(node.right, scope, depth + 1);
+    case "ObjectExpression":
+      return node.properties.some((p) => p.type === "SpreadElement" && mayBeStory(p.argument, scope, depth + 1));
+    default:
+      return !isLiteralValue(node, scope.bindings);
+  }
+}
+
 // src/vite/indexFile.ts
-function indexFile(code, file, autoTitle2, wrappers = /* @__PURE__ */ new Set()) {
+function indexFile(code, file, autoTitle2, wrappers = /* @__PURE__ */ new Set(), foreign) {
   try {
-    return indexProgram(parseFile(code, file), file, autoTitle2, wrappers);
+    return indexProgram(parseFile(code, file), file, autoTitle2, wrappers, foreign);
   } catch (err) {
     throw new Error(`${file}: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
   }
@@ -464,11 +622,13 @@ function scan(program, extra) {
     const decl = stmt.type === "ExportNamedDeclaration" ? stmt.declaration : stmt;
     if (decl?.type === "VariableDeclaration") {
       for (const d of decl.declarations) if (d.id.type === "Identifier" && d.init) bindings.set(d.id.name, d.init);
+    } else if (decl?.type === "FunctionDeclaration" && decl.id) {
+      bindings.set(decl.id.name, decl);
     }
   }
   return { bindings, wrappers };
 }
-function indexProgram(program, file, autoTitle2, extra) {
+function indexProgram(program, file, autoTitle2, extra, foreign) {
   const { bindings, wrappers } = scan(program, extra);
   let metaNode;
   let metaDoc;
@@ -486,7 +646,7 @@ function indexProgram(program, file, autoTitle2, extra) {
         if (d.id.type === "Identifier") exported.push({ name: d.id.name, node: d.init ?? void 0, doc: docOf(d) ?? doc });
       }
     } else if (decl?.type === "FunctionDeclaration" && decl.id) {
-      exported.push({ name: decl.id.name, node: void 0, doc });
+      exported.push({ name: decl.id.name, node: decl, doc });
     }
     for (const spec of stmt.specifiers) {
       if (spec.type !== "ExportSpecifier" || spec.exportKind === "type") continue;
@@ -495,12 +655,13 @@ function indexProgram(program, file, autoTitle2, extra) {
       if (name === "default") {
         metaNode = node;
         metaDoc ??= doc;
-      } else exported.push({ name, node, doc });
+      } else if (stmt.source) exported.push({ name, node, doc, from: true });
+      else exported.push({ name, node: node ?? (spec.local.type === "Identifier" ? spec.local : void 0), doc });
     }
   }
   if (!metaNode && !program.body.some(isDefaultExport)) return [];
   const meta = objectOf(metaNode, bindings, wrappers);
-  const title = stringProp(meta, "title") ?? autoTitle2;
+  const title = stringOf(prop(meta, "title"), bindings) ?? autoTitle2;
   const include = storyFilter(meta, "includeStories");
   const exclude = storyFilter(meta, "excludeStories");
   const componentNode = prop(meta, "component");
@@ -508,7 +669,7 @@ function indexProgram(program, file, autoTitle2, extra) {
   const metaIsolate = isolateOf(meta, bindings, wrappers, "default");
   const metaTags = tagsOf(meta);
   const native = wrappers.has(calleeOf(metaNode, bindings) ?? "");
-  return exported.filter(({ name }) => name !== "__namedExportsOrder").filter(({ name }) => (!include || include(name)) && (!exclude || !exclude(name))).map(({ name, node, doc }) => {
+  return exported.filter(({ name }) => name !== "__namedExportsOrder").filter(({ name }) => (!include || include(name)) && (!exclude || !exclude(name))).filter((e) => !native || (e.from ? foreign?.reexport(e.name) ?? true : mayBeStory(e.node, { bindings, wrappers, foreign }))).map(({ name, node, doc }) => {
     const spec = objectOf(node, bindings, wrappers);
     const isolate = isolateOf(spec, bindings, wrappers, name) ?? metaIsolate;
     const tags = combineTags(metaTags, tagsOf(spec));
@@ -569,36 +730,105 @@ function storyFilter(obj, key) {
   }
   return null;
 }
-function ownEntries(realms) {
-  const here = fileURLToPath(import.meta.url);
-  for (let dir = dirname(here); dir !== dirname(dir); dir = dirname(dir)) {
-    const manifest = join(dir, "package.json");
-    if (!existsSync(manifest) || JSON.parse(readFileSync(manifest, "utf8")).name !== "@weasel-js/forge") {
-      continue;
+function storyGlobOf(path, stories) {
+  return stories.find((pattern) => matchesGlob(path, pattern.replace(/^\.\//, "")));
+}
+
+// src/vite/autoTitle.ts
+var posix2 = (path) => path.split(sep).join("/");
+var dotted = (path) => /^\.{1,2}([/\\]|$)/.test(path) ? path : `./${path}`;
+function globDirectory(pattern) {
+  const segments = pattern.split("/");
+  const magic = segments.findIndex((segment) => /^!|(^|[^\\])[*?[{(]/.test(segment));
+  return magic === -1 ? dirname(pattern) : segments.slice(0, magic).join("/");
+}
+function titleParts(parts) {
+  const last = parts[parts.length - 1];
+  if (last === void 0) return parts;
+  const stripped = last.replace(/(?:[.](?:story|stories))?([.][^.]+)$/i, "");
+  if (parts.length === 1) return [stripped];
+  const nextToLast = parts[parts.length - 2];
+  if (stripped && nextToLast && stripped.toLowerCase() === nextToLast.toLowerCase()) return [...parts.slice(0, -2), stripped];
+  if (stripped && (/^(story|stories)([.][^.]+)$/i.test(last) || /^index$/i.test(stripped))) return parts.slice(0, -1);
+  return [...parts.slice(0, -1), stripped];
+}
+var titleFrom = (importPath, directory) => titleParts(importPath.replace(directory, "").split("/").filter(Boolean)).join("/");
+function autoTitle(file, root, stories) {
+  const path = posix2(relative(root, file));
+  const importPath = dotted(path);
+  const pattern = storyGlobOf(path, stories);
+  if (pattern === void 0) return titleFrom(importPath, ".");
+  const directory = dotted(posix2(relative(root, resolve(root, globDirectory(pattern))))).replace(/\/$/, "");
+  return titleFrom(importPath, directory);
+}
+
+// src/vite/foreignStories.ts
+var MAX_DEPTH = 8;
+async function settled(read, ask) {
+  const known = { values: {}, calls: {}, reexports: {} };
+  const asked = /* @__PURE__ */ new Set();
+  for (; ; ) {
+    const fresh = [];
+    const answer = (kind) => (name) => {
+      if (!asked.has(`${kind}:${name}`)) fresh.push([kind, name]);
+      return known[kind][name];
+    };
+    const result = read({ value: answer("values"), call: answer("calls"), reexport: answer("reexports") });
+    if (fresh.length === 0) return { result, known };
+    for (const [kind, name] of fresh) {
+      asked.add(`${kind}:${name}`);
+      const found = await ask(kind, name);
+      if (found !== void 0) known[kind][name] = found;
     }
-    const source = !relative(join(dir, "src"), here).startsWith("..");
-    return realms.map((realm) => join(dir, source ? `src/${realm}/index.ts` : `dist/${realm}/index.js`));
   }
-  return [];
 }
-var SHIMS = [
-  [/^@?storybook\/preview-api$/, "@weasel-js/forge/preview-api"],
-  [/^@?storybook\/test$/, "@weasel-js/forge/play"]
-];
-function storybookShims() {
-  return {
-    name: "weaselforge:storybook-shims",
-    enforce: "pre",
-    resolveId(id) {
-      const hit = SHIMS.find(([pattern]) => pattern.test(id));
-      if (!hit) return void 0;
-      return this.resolve(hit[1], fileURLToPath(import.meta.url), { skipSelf: true });
+async function foreignStories(file, wrappers, own, trace, read) {
+  const answers = /* @__PURE__ */ new Map();
+  const exported = async (at, name, called, depth) => {
+    const key = await trace.declaring(at, name);
+    if (!key) return void 0;
+    if (own.has(key)) return called && own.get(key) === "story";
+    const memo = `${key}:${called}`;
+    if (!answers.has(memo)) {
+      answers.set(memo, depth > MAX_DEPTH ? Promise.resolve(void 0) : declared(key, called, depth));
     }
+    return answers.get(memo);
   };
+  const declared = async (key, called, depth) => {
+    const at = key.slice(0, key.lastIndexOf("#"));
+    const local = key.slice(at.length + 1);
+    let scope;
+    try {
+      scope = scan(parseFile(read(at), at), /* @__PURE__ */ new Set());
+    } catch {
+      return void 0;
+    }
+    const node = scope.bindings.get(local);
+    if (!node) return void 0;
+    const { result } = await settled(
+      (foreign) => called ? isFn(node) && mayReturnStory(node, { ...scope, foreign }) : mayBeStory(node, { ...scope, foreign }),
+      asking(at, depth + 1)
+    );
+    return result;
+  };
+  const asking = (at, depth) => async (kind, name) => {
+    const mod = trace.info(at);
+    const exp = mod?.exports.get(name);
+    const from = kind === "reexports" ? exp?.kind === "from" ? exp : void 0 : mod?.imports.get(name);
+    if (!from || from.imported === "*") return void 0;
+    const target = await trace.target(from.spec, at);
+    return target ? exported(target, from.imported, kind === "calls", depth) : void 0;
+  };
+  try {
+    const program = parseFile(read(file), file);
+    return (await settled((foreign) => void indexProgram(program, file, "", wrappers, foreign), asking(file, 0))).known;
+  } catch {
+    return { values: {}, calls: {}, reexports: {} };
+  }
 }
 
-// src/vite/wrappers.ts
-function createWrapperResolver(read) {
+// src/vite/trace.ts
+function createTracer(read) {
   const modules = /* @__PURE__ */ new Map();
   const info = (file) => {
     if (!modules.has(file)) {
@@ -612,18 +842,20 @@ function createWrapperResolver(read) {
     }
     return modules.get(file) ?? null;
   };
-  return async (file, callees, resolve4) => {
-    const reads = /* @__PURE__ */ new Set();
-    const wrappers = /* @__PURE__ */ new Set();
-    let unresolved = false;
-    if (callees.length === 0) return { wrappers, reads, unresolved };
-    const target = async (spec, importer) => {
-      const id = (await resolve4(spec, importer).catch(() => null))?.split("?")[0];
-      if (!id) unresolved = true;
-      return id && !id.startsWith("\0") ? id : null;
+  return (resolve5) => {
+    const trace = {
+      reads: /* @__PURE__ */ new Set(),
+      unresolved: false,
+      info,
+      async target(spec, importer) {
+        const id = (await resolve5(spec, importer).catch(() => null))?.split("?")[0];
+        if (!id) trace.unresolved = true;
+        return id && !id.startsWith("\0") ? id : null;
+      },
+      declaring: (at, name) => declaring(at, name, 0)
     };
-    const declaring = async (at, name, depth = 0) => {
-      reads.add(at);
+    const declaring = async (at, name, depth) => {
+      trace.reads.add(at);
       const mod = info(at);
       if (!mod || depth > 32) return null;
       const exp = mod.exports.get(name);
@@ -631,39 +863,402 @@ function createWrapperResolver(read) {
         const imp = mod.imports.get(exp.local);
         if (!imp) return `${at}#${exp.local}`;
         if (imp.imported === "*") return null;
-        const next = await target(imp.spec, at);
+        const next = await trace.target(imp.spec, at);
         return next ? declaring(next, imp.imported, depth + 1) : null;
       }
       if (exp?.kind === "from") {
-        const next = await target(exp.spec, at);
+        const next = await trace.target(exp.spec, at);
         return next ? declaring(next, exp.imported, depth + 1) : null;
       }
       if (name === "default") return null;
       for (const spec of mod.stars) {
-        const next = await target(spec, at);
+        const next = await trace.target(spec, at);
         const found = next ? await declaring(next, name, depth + 1) : null;
         if (found) return found;
       }
       return null;
     };
-    const forge2 = await target("@weasel-js/forge", file);
-    if (!forge2) return { wrappers, reads, unresolved };
-    const own = new Set(
-      (await Promise.all(["meta", "story"].map((name) => declaring(forge2, name)))).filter((key) => key !== null)
+    return trace;
+  };
+}
+
+// src/vite/wrappers.ts
+var NO_FOREIGN = { values: {}, calls: {}, reexports: {} };
+function sameResolution(a, b) {
+  const key = (r) => JSON.stringify([[...r?.wrappers ?? []].sort(), r?.foreign ?? NO_FOREIGN]);
+  return key(a) === key(b);
+}
+function createWrapperResolver(read) {
+  const tracer = createTracer(read);
+  return async (file, callees, resolve5) => {
+    const trace = tracer(resolve5);
+    const wrappers = /* @__PURE__ */ new Set();
+    const direct = [...trace.info(file)?.imports.values() ?? []].some((imp) => imp.spec === "@weasel-js/forge");
+    if (callees.length === 0 && !direct) return { wrappers, foreign: NO_FOREIGN, reads: trace.reads, unresolved: false };
+    const forge2 = await trace.target("@weasel-js/forge", file);
+    const own = /* @__PURE__ */ new Map();
+    if (forge2) {
+      for (const name of ["meta", "story"]) {
+        const key = await trace.declaring(forge2, name);
+        if (key) own.set(key, name);
+      }
+      for (const callee of callees) {
+        const from = await trace.target(callee.spec, file);
+        const key = from ? await trace.declaring(from, callee.imported) : null;
+        if (key && own.has(key)) wrappers.add(callee.local);
+      }
+    }
+    const foreign = forge2 ? await foreignStories(file, wrappers, own, trace, read) : NO_FOREIGN;
+    return { wrappers, foreign, reads: trace.reads, unresolved: trace.unresolved };
+  };
+}
+
+// src/vite/indexStory.ts
+function indexStory(code, file, source, resolved) {
+  const foreign = resolved ? foreignFrom(resolved.foreign) : void 0;
+  return indexFile(code, file, autoTitle(file, source.root, source.stories), resolved?.wrappers, foreign);
+}
+async function indexStoryResolved(code, file, source, resolve5, decide = createWrapperResolver((path) => readFileSync(path, "utf8"))) {
+  const resolution = await decide(file, foreignCallees(code, file), resolve5);
+  return { entries: indexStory(code, file, source, resolution), resolution };
+}
+function ownEntries(realms) {
+  const here = fileURLToPath(import.meta.url);
+  for (let dir = dirname(here); dir !== dirname(dir); dir = dirname(dir)) {
+    const manifest = join(dir, "package.json");
+    if (!existsSync(manifest) || JSON.parse(readFileSync(manifest, "utf8")).name !== "@weasel-js/forge") {
+      continue;
+    }
+    const source = !relative(join(dir, "src"), here).startsWith("..");
+    return realms.map((realm) => join(dir, source ? `src/${realm}/index.ts` : `dist/${realm}/index.js`));
+  }
+  return [];
+}
+
+// src/vite/entries.ts
+function shellEntry(base, stories) {
+  return `import { mountWorkshop } from '@weasel-js/forge/shell';
+import '@weasel-js/labkit/styles.css';
+import '@weasel-js/forge/shell.css';
+import index from 'virtual:forge/index.js';
+import importers from 'virtual:forge/importers.js';
+import config from 'virtual:forge/shell-config.js';
+import setup from 'virtual:forge/frame-config.js';
+
+const workshop = mountWorkshop({
+  index,
+  importers,
+  setup,
+  config,
+  frameUrl: ${JSON.stringify(`${base}frame.html`)},
+  stories: ${JSON.stringify(stories)},
+});
+import.meta.hot?.on('forge:index', (next) => workshop.setIndex(next));
+// Read from source on first request, so the graph costs nothing until the page is up.
+import('virtual:forge/deps.js').then((m) => workshop.setDependencies(m.default));
+import.meta.hot?.on('forge:deps', (next) => workshop.setDependencies(next));
+// An edit to a story file, or to a module one imports, reaches here as an update of the importers module, whose
+// fresh import() URLs carry the new timestamps; the files it reaches arrive just before, so the reload waits for
+// the importers that can fetch them.
+const stale = new Set();
+import.meta.hot?.on('forge:story', ({ file }) => stale.add(file));
+import.meta.hot?.accept('virtual:forge/importers.js', (next) => {
+  if (!next) return;
+  workshop.setImporters(next.default);
+  for (const file of stale) workshop.reloadStory(file);
+  stale.clear();
+});
+`;
+}
+function frameEntry(styles) {
+  return `import { mountFrame } from '@weasel-js/forge/frame';
+import '@weasel-js/forge/frame.css';
+${styles.map((path) => `import ${JSON.stringify(path)};
+`).join("")}import index from 'virtual:forge/index.js';
+import importers from 'virtual:forge/importers.js';
+import setup from 'virtual:forge/frame-config.js';
+
+mountFrame({ index, importers, setup });
+// The importers module is shared with the workshop page, which accepts a story edit in place; a frame document
+// showing the old module reloads instead, and without this the edit would dead-end here and reload every page.
+import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
+`;
+}
+var PLATFORM = /[\\/]node_modules[\\/](@types[\\/]react(-dom)?|typescript)[\\/]/;
+async function createPropReader(root, stories, { skip } = {}) {
+  const skipped = (file) => PLATFORM.test(file) || skip?.(file) === true;
+  let tsm;
+  try {
+    tsm = (await import('typescript')).default;
+  } catch {
+    return null;
+  }
+  const { sys } = tsm;
+  const configFile = tsm.findConfigFile(root, sys.fileExists);
+  const read = configFile ? tsm.readConfigFile(configFile, sys.readFile) : void 0;
+  const parsed = read?.config ? tsm.parseJsonConfigFileContent(read.config, { ...sys, readDirectory: () => [] }, dirname(configFile)) : void 0;
+  const options = {
+    jsx: tsm.JsxEmit.ReactJSX,
+    moduleResolution: tsm.ModuleResolutionKind.Bundler,
+    module: tsm.ModuleKind.ESNext,
+    target: tsm.ScriptTarget.ESNext,
+    strict: true,
+    ...parsed?.options,
+    allowJs: true,
+    noEmit: true,
+    skipLibCheck: true
+  };
+  const host = {
+    getScriptFileNames: () => [...stories()],
+    getScriptVersion: (file) => String(sys.getModifiedTime?.(file)?.getTime() ?? 0),
+    getScriptSnapshot: (file) => {
+      const text = sys.readFile(file);
+      return text === void 0 ? void 0 : tsm.ScriptSnapshot.fromString(text);
+    },
+    getCurrentDirectory: () => root,
+    getCompilationSettings: () => options,
+    getDefaultLibFileName: tsm.getDefaultLibFilePath,
+    fileExists: sys.fileExists,
+    readFile: sys.readFile,
+    readDirectory: sys.readDirectory,
+    directoryExists: sys.directoryExists,
+    getDirectories: sys.getDirectories
+  };
+  const service = tsm.createLanguageService(host, tsm.createDocumentRegistry());
+  return {
+    read(file) {
+      const program = service.getProgram();
+      const source = program?.getSourceFile(file);
+      if (!program || !source) return null;
+      const checker = program.getTypeChecker();
+      const props = componentProps(tsm, checker, source);
+      return props ? propTable(tsm, checker, props, source, skipped) : null;
+    }
+  };
+}
+function componentProps(tsm, checker, source) {
+  const module = checker.getSymbolAtLocation(source);
+  const exported = module && checker.tryGetMemberInModuleExports("default", module);
+  if (!exported) return null;
+  const meta = checker.getTypeOfSymbolAtLocation(
+    exported.flags & tsm.SymbolFlags.Alias ? checker.getAliasedSymbol(exported) : exported,
+    source
+  );
+  const named = meta.getProperty("component");
+  if (!named) return null;
+  const component = checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(named, source));
+  for (const part of component.isUnion() ? component.types : [component]) {
+    const [call] = part.getCallSignatures();
+    const [param] = call?.getParameters() ?? [];
+    if (call) return param ? checker.getTypeOfSymbolAtLocation(param, source) : null;
+    const instance = part.getConstructSignatures()[0]?.getReturnType();
+    const held = instance?.getProperty("props");
+    if (held) return checker.getTypeOfSymbolAtLocation(held, source);
+  }
+  return null;
+}
+function propTable(tsm, checker, props, at, skipped) {
+  const argTypes = {};
+  const sources = /* @__PURE__ */ new Set();
+  for (const prop2 of checker.getPropertiesOfType(checker.getApparentType(props))) {
+    const files = (prop2.getDeclarations() ?? []).map((declaration) => declaration.getSourceFile().fileName);
+    if (files.length > 0 && files.every(skipped)) continue;
+    const argType = controlFor(
+      tsm,
+      checker.getNonNullableType(checker.getTypeOfSymbolAtLocation(prop2, at)),
+      () => writtenOrder(tsm, checker, prop2)
+    );
+    if (!argType) continue;
+    const description = tsm.displayPartsToString(prop2.getDocumentationComment(checker)).replace(/\s+/g, " ").trim();
+    argTypes[prop2.getName()] = description ? { ...argType, description } : argType;
+    for (const file of files) if (!/[\\/]node_modules[\\/]/.test(file)) sources.add(file);
+  }
+  return { argTypes, sources: [...sources] };
+}
+function controlFor(tsm, type, written) {
+  const { TypeFlags } = tsm;
+  const parts = type.isUnion() ? type.types : [type];
+  const every = (flags) => parts.every((part) => part.flags & flags);
+  if (every(TypeFlags.BooleanLike)) return { control: { type: "boolean" } };
+  if (type.flags & TypeFlags.String) return { control: { type: "text" } };
+  if (type.flags & TypeFlags.Number) return { control: { type: "number" } };
+  if (parts.length > 1 && every(TypeFlags.StringLiteral)) {
+    const options = parts.map((part) => part.value);
+    const order = written();
+    const same = order?.length === options.length && options.every((option) => order.includes(option));
+    return { options: same ? order : options };
+  }
+  return null;
+}
+function writtenOrder(tsm, checker, prop2) {
+  const [declaration, ...others] = prop2.getDeclarations() ?? [];
+  if (!declaration || others.length > 0) return null;
+  if (!tsm.isPropertySignature(declaration) && !tsm.isPropertyDeclaration(declaration)) return null;
+  const seen = /* @__PURE__ */ new Set();
+  const literals = (node) => {
+    if (!node || seen.has(node)) return null;
+    seen.add(node);
+    if (tsm.isParenthesizedTypeNode(node)) return literals(node.type);
+    if (tsm.isLiteralTypeNode(node)) {
+      if (node.literal.kind === tsm.SyntaxKind.NullKeyword) return [];
+      return tsm.isStringLiteralLike(node.literal) ? [node.literal.text] : null;
+    }
+    if (node.kind === tsm.SyntaxKind.UndefinedKeyword) return [];
+    if (tsm.isUnionTypeNode(node)) {
+      const parts = node.types.map(literals);
+      return parts.every((part) => part !== null) ? [...new Set(parts.flat())] : null;
+    }
+    if (tsm.isTypeReferenceNode(node) && !node.typeArguments) {
+      const named = checker.getSymbolAtLocation(node.typeName);
+      const target = named && named.flags & tsm.SymbolFlags.Alias ? checker.getAliasedSymbol(named) : named;
+      const [alias, ...rest] = target?.getDeclarations() ?? [];
+      if (alias && rest.length === 0 && tsm.isTypeAliasDeclaration(alias) && !alias.typeParameters) {
+        return literals(alias.type);
+      }
+    }
+    return null;
+  };
+  return literals(declaration.type);
+}
+
+// src/vite/propControls.ts
+function propControls(stories, options = {}) {
+  let root = process.cwd();
+  let reader = null;
+  return {
+    name: "weaselforge:prop-controls",
+    configResolved(config) {
+      root = config.root;
+      reader = null;
+    },
+    async transform(code, id) {
+      if (!stories().includes(id)) return void 0;
+      const props = await (reader ??= createPropReader(root, stories, options));
+      let table = null;
+      try {
+        table = props?.read(id) ?? null;
+      } catch (err) {
+        this.warn(`could not read the props for ${id}: ${err instanceof Error ? err.message : String(err)}`);
+      }
+      if (!table || Object.keys(table.argTypes).length === 0) return void 0;
+      for (const source of table.sources) this.addWatchFile(source);
+      return { code: `${code}
+export const ${PROP_ARG_TYPES_EXPORT} = ${JSON.stringify(table.argTypes)};
+`, map: null };
+    }
+  };
+}
+
+// src/vite/servePages.ts
+var PAGES2 = { "/": "shell-entry.js", "/index.html": "shell-entry.js", "/frame.html": "frame-entry.js" };
+function servePages(server, base, title) {
+  server.middlewares.use((req, res, next) => {
+    const url = req.url ?? "/";
+    const path = url.split("?")[0] ?? "/";
+    const prefix = base.endsWith("/") ? base.slice(0, -1) : base;
+    const page = path === prefix ? "/" : path.startsWith(`${prefix}/`) ? path.slice(prefix.length) : null;
+    const entry = req.method === "GET" && page !== null ? PAGES2[page] : void 0;
+    if (!entry) return next();
+    server.transformIndexHtml(url, html(entry, "serve", title())).then(
+      (doc) => {
+        res.statusCode = 200;
+        res.setHeader("Content-Type", "text/html");
+        res.end(doc);
+      },
+      (err) => next(err)
     );
-    for (const callee of callees) {
-      const from = await target(callee.spec, file);
-      const key = from ? await declaring(from, callee.imported) : null;
-      if (key && own.has(key)) wrappers.add(callee.local);
+  });
+}
+
+// src/vite/shellTitle.ts
+function shellTitle(code, file) {
+  let program;
+  try {
+    program = parseFile(code, file);
+  } catch {
+    return void 0;
+  }
+  const bindings = /* @__PURE__ */ new Map();
+  let config;
+  for (const stmt of program.body) {
+    if (stmt.type === "VariableDeclaration") {
+      for (const d of stmt.declarations) if (d.id.type === "Identifier" && d.init) bindings.set(d.id.name, d.init);
+    }
+    if (stmt.type === "ExportDefaultDeclaration") config = stmt.declaration;
+    if (stmt.type !== "ExportNamedDeclaration" || stmt.source) continue;
+    for (const spec of stmt.specifiers) {
+      if (spec.type === "ExportSpecifier" && exportedName(spec.exported) === "default") config = spec.local;
+    }
+  }
+  const wrapper = calleeOf(config, bindings);
+  return stringOf(prop(objectOf(config, bindings, new Set(wrapper ? [wrapper] : [])), "title"), bindings);
+}
+var SHIMS = [
+  [/^@?storybook\/preview-api$/, "@weasel-js/forge/preview-api"],
+  [/^@?storybook\/test$/, "@weasel-js/forge/play"]
+];
+function storybookShims() {
+  return {
+    name: "weaselforge:storybook-shims",
+    enforce: "pre",
+    resolveId(id) {
+      const hit = SHIMS.find(([pattern]) => pattern.test(id));
+      if (!hit) return void 0;
+      return this.resolve(hit[1], fileURLToPath(import.meta.url), { skipSelf: true });
     }
-    return { wrappers, reads, unresolved };
   };
 }
+var WAIT_MS = 5e3;
+var REWRITE_MS = 250;
+var watchDir = (dir, onEvent) => {
+  const watcher = watch(dir, onEvent);
+  watcher.on("error", () => {
+  });
+  watcher.unref();
+  return () => watcher.close();
+};
+function fileEventsArrive({ waitMs = WAIT_MS, watch = watchDir } = {}) {
+  const dir = mkdtempSync(join(tmpdir(), "forge-watch-"));
+  return new Promise((resolve5) => {
+    let settled2 = false;
+    let writes = 0;
+    let stop;
+    let rewrite;
+    let deadline;
+    const settle = (arrived) => {
+      if (settled2) return;
+      settled2 = true;
+      clearInterval(rewrite);
+      clearTimeout(deadline);
+      stop?.();
+      rmSync(dir, { recursive: true, force: true });
+      resolve5(arrived);
+    };
+    const write = () => writeFileSync(join(dir, "probe"), String(writes++));
+    try {
+      stop = watch(dir, () => settle(true));
+      write();
+    } catch {
+      settle(false);
+      return;
+    }
+    rewrite = setInterval(write, REWRITE_MS);
+    deadline = setTimeout(() => settle(false), waitMs);
+    rewrite.unref();
+    deadline.unref();
+  });
+}
+var SILENT = `[forge] a file written ${WAIT_MS / 1e3} s ago has not been reported by the OS file watcher, so an edit will not reach the page until file events arrive again. \`server.watch: { usePolling: true }\` serves edits without them. On macOS, look for \`fseventsd\` held at 100% CPU.`;
+async function warnWhenWatchIsSilent(server, probe = fileEventsArrive) {
+  const { watch } = server.config.server;
+  if (watch === null || watch?.usePolling) return;
+  if (!await probe()) server.config.logger.warn(SILENT);
+}
 
 // src/vite/plugin.ts
 var PREFIX = "virtual:forge/";
 var MODULES = /* @__PURE__ */ new Set(["index.js", "importers.js", "deps.js", "frame-config.js", "shell-config.js", "shell-entry.js", "frame-entry.js"]);
-var PAGES2 = { "/": "shell-entry.js", "/index.html": "shell-entry.js", "/frame.html": "frame-entry.js" };
+var SCRIPT2 = /\.[cm]?[jt]sx?$/;
 function forge(options) {
   let root = process.cwd();
   let base = "/";
@@ -682,9 +1277,9 @@ function forge(options) {
   };
   const matches = (file) => {
     const path = relative(root, file).split(sep).join("/");
-    return !path.split("/").includes("node_modules") && options.stories.some((pattern) => matchesGlob(path, pattern));
+    return !path.split("/").includes("node_modules") && storyGlobOf(path, options.stories) !== void 0;
   };
-  const read = (file) => indexFile(readFileSync(file, "utf8"), file, autoTitle(file, root, options.stories), wrappersOf.get(file)?.wrappers);
+  const read = (file) => indexStory(readFileSync(file, "utf8"), file, { root, stories: options.stories }, wrappersOf.get(file));
   const logError = (err) => logger?.error(`[forge] ${err instanceof Error ? err.message : String(err)}`);
   const files = () => {
     byFile ??= new Map(
@@ -711,9 +1306,9 @@ function forge(options) {
       } catch {
         continue;
       }
-      const before = wrappersOf.get(file)?.wrappers ?? /* @__PURE__ */ new Set();
+      const before = wrappersOf.get(file);
       wrappersOf.set(file, next);
-      if (before.size === next.wrappers.size && [...before].every((name) => next.wrappers.has(name))) continue;
+      if (sameResolution(before, next)) continue;
       try {
         current.set(file, read(file));
       } catch (err) {
@@ -722,6 +1317,26 @@ function forge(options) {
     }
   };
   const depGraph = () => deps ??= createDepGraph({ root, read: (file) => readFileSync(file, "utf8") });
+  let history = null;
+  async function graphOf(resolveImport) {
+    const graph = await depGraph().build(index(), resolveImport);
+    const sources = Object.values(graph).flatMap((entry) => entry.source === null ? [] : [entry.source]);
+    const histories = await (history ??= createHistoryReader(root)).read(sources);
+    for (const entry of Object.values(graph)) {
+      const found = entry.source === null ? void 0 : histories[entry.source];
+      if (found) entry.history = found;
+    }
+    return graph;
+  }
+  const titleUnder = (at) => {
+    if (!options.shellConfig) return void 0;
+    const file = resolve(at, options.shellConfig);
+    try {
+      return shellTitle(readFileSync(file, "utf8"), file);
+    } catch {
+      return void 0;
+    }
+  };
   const configModule = (path) => path ? `export { default } from ${JSON.stringify(resolve(root, path))};
 ` : "export default {};\n";
   const modules = {
@@ -736,48 +1351,8 @@ ${lines.join("\n")}
     },
     "frame-config.js": () => configModule(options.frameConfig),
     "shell-config.js": () => configModule(options.shellConfig),
-    "shell-entry.js": () => `import { mountWorkshop } from '@weasel-js/forge/shell';
-import '@weasel-js/labkit/styles.css';
-import '@weasel-js/forge/shell.css';
-import index from 'virtual:forge/index.js';
-import importers from 'virtual:forge/importers.js';
-import config from 'virtual:forge/shell-config.js';
-import setup from 'virtual:forge/frame-config.js';
-
-const workshop = mountWorkshop({
-  index,
-  importers,
-  setup,
-  config,
-  frameUrl: ${JSON.stringify(`${base}frame.html`)},
-  stories: ${JSON.stringify(options.stories)},
-});
-import.meta.hot?.on('forge:index', (next) => workshop.setIndex(next));
-// Read from source on first request, so the graph costs nothing until the page is up.
-import('virtual:forge/deps.js').then((m) => workshop.setDependencies(m.default));
-import.meta.hot?.on('forge:deps', (next) => workshop.setDependencies(next));
-// A story edit reaches here as an update of the importers module, whose fresh import() URLs carry the new
-// timestamps; the file it names arrives just before, so the reload waits for the importers that can fetch it.
-const stale = new Set();
-import.meta.hot?.on('forge:story', ({ file }) => stale.add(file));
-import.meta.hot?.accept('virtual:forge/importers.js', (next) => {
-  if (!next) return;
-  workshop.setImporters(next.default);
-  for (const file of stale) workshop.reloadStory(file);
-  stale.clear();
-});
-`,
-    "frame-entry.js": () => `import { mountFrame } from '@weasel-js/forge/frame';
-import '@weasel-js/forge/frame.css';
-import index from 'virtual:forge/index.js';
-import importers from 'virtual:forge/importers.js';
-import setup from 'virtual:forge/frame-config.js';
-
-mountFrame({ index, importers, setup });
-// The importers module is shared with the workshop page, which accepts a story edit in place; a frame document
-// showing the old module reloads instead, and without this the edit would dead-end here and reload every page.
-import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
-`
+    "shell-entry.js": () => shellEntry(base, options.stories),
+    "frame-entry.js": () => frameEntry((options.frameStyles ?? []).map((path) => resolve(root, path)))
   };
   const invalidate = (server, names) => {
     for (const env of Object.values(server.environments)) {
@@ -789,9 +1364,9 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
   };
   function redeps(server) {
     if (depsSent === null || depsPending) return;
-    const resolve4 = async (spec, importer) => (await server.environments.client.pluginContainer.resolveId(spec, importer))?.id ?? null;
+    const resolve5 = async (spec, importer) => (await server.environments.client.pluginContainer.resolveId(spec, importer))?.id ?? null;
     depsPending = Promise.resolve().then(async () => {
-      const graph = await depGraph().build(index(), resolve4);
+      const graph = await graphOf(resolve5);
       const json = JSON.stringify(graph);
       if (json === depsSent) return;
       depsSent = json;
@@ -801,13 +1376,28 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
       depsPending = null;
     });
   }
+  const storiesReaching = (changed) => {
+    const current = files();
+    const seen = /* @__PURE__ */ new Set();
+    const reached = /* @__PURE__ */ new Set();
+    const climb = (mod) => {
+      if (seen.has(mod)) return;
+      seen.add(mod);
+      if (mod.file && current.has(mod.file)) reached.add(mod.file);
+      if (mod.isSelfAccepting && !(mod.file && SCRIPT2.test(mod.file))) return;
+      for (const importer of mod.importers) climb(importer);
+    };
+    for (const mod of changed) climb(mod);
+    return [...reached];
+  };
   async function reindex(server, file, event) {
     const current = files();
-    if (event === "change" && current.has(file)) server.ws.send({ type: "custom", event: "forge:story", data: { file } });
     const own = event === "add" ? matches(file) : current.has(file);
     const through = [...wrappersOf].filter(([story, { reads, unresolved }]) => story !== file && (reads.has(file) || event === "add" && unresolved)).map(([story]) => story);
     if (!own && through.length === 0) return false;
     const before = JSON.stringify(index());
+    const importable = () => JSON.stringify([...current].filter(([, entries]) => entries.length > 0).map(([path]) => path));
+    const importableBefore = importable();
     if (own && event === "unlink") {
       current.delete(file);
       wrappersOf.delete(file);
@@ -825,10 +1415,13 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
     if (JSON.stringify(next) === before) return false;
     invalidate(server, ["index.js", "importers.js"]);
     server.ws.send({ type: "custom", event: "forge:index", data: next });
+    const importers = server.environments.client.moduleGraph.getModuleById(`\0${PREFIX}importers.js`);
+    if (importers && importable() !== importableBefore) await server.environments.client.reloadModule(importers);
     return true;
   }
   return [
     ...options.storybookShims === false ? [] : [storybookShims()],
+    ...options.propControls === false ? [] : [propControls(() => [...files().keys()], options.propControls === true ? void 0 : options.propControls)],
     {
       name: "weaselforge",
       config(config, { command }) {
@@ -840,7 +1433,7 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
         ];
         const optimizeDeps = { entries };
         if (command !== "build") return { optimizeDeps };
-        return { optimizeDeps, build: { rolldownOptions: { input: writePages(at) } } };
+        return { optimizeDeps, build: { rolldownOptions: { input: writePages(at, titleUnder(at)) } } };
       },
       generateBundle: {
         order: "post",
@@ -856,6 +1449,7 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
         wrappersOf.clear();
         settledAll = null;
         deps = null;
+        history = null;
         depsSent = null;
       },
       resolveId(id) {
@@ -869,17 +1463,22 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
           await settledAll;
         }
         if (name !== "deps.js") return modules[name]?.();
-        const graph = await depGraph().build(index(), async (spec, importer) => (await this.resolve(spec, importer))?.id ?? null);
+        const graph = await graphOf(async (spec, importer) => (await this.resolve(spec, importer))?.id ?? null);
         depsSent = JSON.stringify(graph);
         return `export default ${depsSent};
 `;
       },
+      hotUpdate({ modules: modules2, server }) {
+        if (this.environment.name !== "client") return;
+        for (const file of storiesReaching(modules2)) server.ws.send({ type: "custom", event: "forge:story", data: { file } });
+      },
       configureServer(server) {
         server.watcher.add([...files().keys()]);
+        void warnWhenWatchIsSilent(server);
         for (const event of ["add", "change", "unlink"]) {
           server.watcher.on(event, (path) => {
             const file = resolve(path);
-            const added = event === "add" && /\.[cm]?[jt]sx?$/.test(file) && !file.split(sep).includes("node_modules");
+            const added = event === "add" && SCRIPT2.test(file) && !file.split(sep).includes("node_modules");
             if (added) depGraph().reset();
             const read2 = added || event !== "add" && depGraph().invalidate(file);
             reindex(server, file, event).then((indexed) => {
@@ -887,22 +1486,7 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
             }, logError);
           });
         }
-        server.middlewares.use((req, res, next) => {
-          const url = req.url ?? "/";
-          const path = url.split("?")[0] ?? "/";
-          const prefix = base.endsWith("/") ? base.slice(0, -1) : base;
-          const page = path === prefix ? "/" : path.startsWith(`${prefix}/`) ? path.slice(prefix.length) : null;
-          const entry = req.method === "GET" && page !== null ? PAGES2[page] : void 0;
-          if (!entry) return next();
-          server.transformIndexHtml(url, html(entry)).then(
-            (doc) => {
-              res.statusCode = 200;
-              res.setHeader("Content-Type", "text/html");
-              res.end(doc);
-            },
-            (err) => next(err)
-          );
-        });
+        servePages(server, base, () => titleUnder(root));
       }
     }
   ];
@@ -914,7 +1498,7 @@ function forgeTest(options) {
     if (id.startsWith("\0") || id.includes("?")) return false;
     const path = relative(root, id).split(sep).join("/");
     if (path.startsWith("../") || path.split("/").includes("node_modules")) return false;
-    return options.stories.some((pattern) => matchesGlob(path, pattern));
+    return storyGlobOf(path, options.stories) !== void 0;
   };
   return [
     ...options.storybookShims === false ? [] : [storybookShims()],
@@ -933,9 +1517,14 @@ function forgeTest(options) {
       configResolved(config) {
         root = config.root;
       },
-      transform(code, id) {
+      async transform(code, id) {
         if (!matches(id)) return void 0;
-        const entries = indexFile(code, id, autoTitle(id, root, options.stories));
+        const { entries } = await indexStoryResolved(
+          code,
+          id,
+          { root, stories: options.stories },
+          async (spec, importer) => (await this.resolve(spec, importer))?.id ?? null
+        );
         const title = entries[0]?.title;
         if (title === void 0) return void 0;
         const q = (value) => JSON.stringify(value);