@weasel-js/forge 1.9.2 → 1.9.4

package/dist/vite/index.js

@@ -1,19 +1,21 @@
+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 { resolve, sep, relative, dirname, join, basename, matchesGlob } from 'path';
 import { parse } from '@babel/parser';
 import { fileURLToPath } from 'url';
 
 // 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 +28,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 +49,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?$/;
@@ -365,11 +339,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 +438,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 +534,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 +558,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 +567,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 +581,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 +642,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 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);
+  const pattern = storyGlobOf(path, stories);
+  if (pattern === void 0) return titleFrom(importPath, ".");
+  const directory = dotted(posix(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 +754,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 (resolve4) => {
+    const trace = {
+      reads: /* @__PURE__ */ new Set(),
+      unresolved: false,
+      info,
+      async target(spec, importer) {
+        const id = (await resolve4(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,38 +775,121 @@ 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)
-    );
-    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);
+    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, resolve4) => {
+    const trace = tracer(resolve4);
+    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, resolve4, decide = createWrapperResolver((path) => readFileSync(path, "utf8"))) {
+  const resolution = await decide(file, foreignCallees(code, file), resolve4);
+  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/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 };
   };
 }
 
 // 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 SCRIPT2 = /\.[cm]?[jt]sx?$/;
 var PAGES2 = { "/": "shell-entry.js", "/index.html": "shell-entry.js", "/frame.html": "frame-entry.js" };
 function forge(options) {
   let root = process.cwd();
@@ -682,9 +909,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 +938,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 +949,15 @@ function forge(options) {
     }
   };
   const depGraph = () => deps ??= createDepGraph({ root, read: (file) => readFileSync(file, "utf8") });
+  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 = {
@@ -756,8 +992,9 @@ 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.
+// 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) => {
@@ -769,7 +1006,8 @@ import.meta.hot?.accept('virtual:forge/importers.js', (next) => {
 `,
     "frame-entry.js": () => `import { mountFrame } from '@weasel-js/forge/frame';
 import '@weasel-js/forge/frame.css';
-import index from 'virtual:forge/index.js';
+${(options.frameStyles ?? []).map((path) => `import ${JSON.stringify(resolve(root, path))};
+`).join("")}import index from 'virtual:forge/index.js';
 import importers from 'virtual:forge/importers.js';
 import setup from 'virtual:forge/frame-config.js';
 
@@ -801,13 +1039,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,6 +1078,8 @@ 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 [
@@ -840,7 +1095,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",
@@ -874,12 +1129,16 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
         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()]);
         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) => {
@@ -894,7 +1153,7 @@ import.meta.hot?.accept('virtual:forge/importers.js', () => location.reload());
           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(
+          server.transformIndexHtml(url, html(entry, "serve", titleUnder(root))).then(
             (doc) => {
               res.statusCode = 200;
               res.setHeader("Content-Type", "text/html");
@@ -914,7 +1173,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 +1192,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);