@fluixi/compiler 1.0.0-alpha.82 → 1.0.0-alpha.84

package/dist/resolve/write-globals.mjs

@@ -1,22 +1,306 @@
-import{mkdirSync as K,readFileSync as S,writeFileSync as V}from"node:fs";import{dirname as N,relative as k,sep as L,resolve as h}from"node:path";var B=e=>"components"in e;function E(e,t){return e.replace(/\$(\d+)/g,(r,s)=>t[Number(s)]??r)}function F(e,t){return typeof t=="string"?{module:t,export:e}:t}function M(e=[]){let t=new Map,r=[],s=[];for(let i of e){if(!B(i)){s.push(i);continue}for(let[l,u]of Object.entries(i.components)){let p=F(l,u),d=t.get(l);if(d&&d.module!==p.module){let m=r.find(R=>R.name===l);m?m.modules.push(p.module):r.push({name:l,modules:[d.module,p.module]});continue}t.set(l,p)}}let n=new Map;return{resolve:i=>{if(n.has(i))return n.get(i);let l=t.get(i);if(!l)for(let u of s){let p=i.match(new RegExp(u.match.source,u.match.flags.replace("g","")));if(p){l={module:E(u.module,p),export:u.export?E(u.export,p):i};break}}return n.set(i,l),l},names:()=>[...t.keys()],conflicts:()=>r}}var C=["Show","For","Index","Switch","Match","Portal","Dynamic","ErrorBoundary"],y=["Suspense","SuspenseList","Await"],w=["Router","Outlet","Redirect","Link"],te=[...C,...y,...w],ne=new Set([...C,...y]);function I(e={}){let{controlFlowModule:t="@fluixi/dom",coreModule:r="@fluixi/core",routerModule:s="@fluixi/core/router"}=e,n={};for(let c of C)n[c]=t;for(let c of y)n[c]=r;for(let c of w)n[c]=s;return n}var f="@fluixi/reactive/signal",v={$signal:{export:"signal",module:f,returns:"signal-handle"},$memo:{export:"memo",module:f,returns:"memo-handle"},$effect:{export:"effect",module:f,returns:"effect"},$store:{export:"store",module:"@fluixi/reactive/store",returns:"store-handle"},$resource:{export:"resource",module:f,returns:"resource-handle"},$selector:{export:"createSelector",module:f,returns:"memo-accessor"},$deferred:{export:"createDeferred",module:f,returns:"memo-accessor"},$untrack:{export:"untrack",module:f,returns:"plain"},$untrackStore:{export:"untrackStore",module:"@fluixi/reactive/store",returns:"plain"}};var re=new RegExp(`\\$(?:${Object.keys(v).map(e=>e.slice(1)).join("|")})\\s*\\(`);var U=new Set(["Text","Image","Option","Audio","Comment","Range","Selection","Notification","Event","Document","Element","Node","Screen","Window","Location","History","Storage","Response","Request","Headers"]);function H(e){if(e.startsWith(".")||e.startsWith("/")||/^[~@]\//.test(e))return;let t=e.split("/");return e.startsWith("@")?t.slice(0,2).join("/"):t[0]}function O(e){return`_${e.replace(/[^A-Za-z0-9]/g,"_")}`}function j(e,t={}){let{available:r,builtins:s=!0,intrinsics:n=!0,generator:c="@fluixi/compiler",specifier:i=o=>o}=t,l=[...e];s&&l.push({components:I()});let u=M(l),p=r?new Set(r):void 0,d=[],m=[],R=[],b=new Map;for(let o of[...u.names()].sort()){let a=u.resolve(o);if(!a)continue;let g=H(a.module);U.has(o)?m.push(o):p&&g&&!p.has(g)?R.push(o):(d.push(o),b.set(o,a))}let D=n?[...new Set(Object.values(v).map(o=>o.module))]:[],$=[...new Set([...d.map(o=>b.get(o).module),...D])].sort().map(o=>`import * as ${O(o)} from '${i(o)}';`),_=d.map(o=>{let a=b.get(o),g=O(a.module);return a.export==="default"?`  const ${o}: typeof ${g}.default;`:`  export import ${o} = ${g}.${a.export};`}),G=m.length>0?`//
+// src/resolve/write-globals.ts
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, relative, sep, resolve as resolvePath } from "node:path";
+
+// src/resolve/component-resolver.ts
+var isMapRule = (rule) => "components" in rule;
+function substitute(template, match) {
+  return template.replace(/\$(\d+)/g, (whole, index) => {
+    const group = match[Number(index)];
+    return group ?? whole;
+  });
+}
+function normalise(name, entry) {
+  return typeof entry === "string" ? { module: entry, export: name } : entry;
+}
+function createComponentResolver(rules = []) {
+  const exact = /* @__PURE__ */ new Map();
+  const conflicts = [];
+  const patterns = [];
+  for (const rule of rules) {
+    if (!isMapRule(rule)) {
+      patterns.push(rule);
+      continue;
+    }
+    for (const [name, entry] of Object.entries(rule.components)) {
+      const resolved = normalise(name, entry);
+      const existing = exact.get(name);
+      if (existing && existing.module !== resolved.module) {
+        const conflict = conflicts.find((c) => c.name === name);
+        if (conflict) conflict.modules.push(resolved.module);
+        else conflicts.push({ name, modules: [existing.module, resolved.module] });
+        continue;
+      }
+      exact.set(name, resolved);
+    }
+  }
+  const cache = /* @__PURE__ */ new Map();
+  const resolve = (name) => {
+    if (cache.has(name)) return cache.get(name);
+    let result = exact.get(name);
+    if (!result) {
+      for (const rule of patterns) {
+        const match = name.match(new RegExp(rule.match.source, rule.match.flags.replace("g", "")));
+        if (!match) continue;
+        result = {
+          module: substitute(rule.module, match),
+          export: rule.export ? substitute(rule.export, match) : name
+        };
+        break;
+      }
+    }
+    cache.set(name, result);
+    return result;
+  };
+  return {
+    resolve,
+    names: () => [...exact.keys()],
+    conflicts: () => conflicts
+  };
+}
+
+// src/resolve/builtins.ts
+var DOM_CONTROL_FLOW = [
+  "Show",
+  "For",
+  "Index",
+  "Switch",
+  "Match",
+  "Portal",
+  "Dynamic",
+  "ErrorBoundary"
+];
+var CORE_CONTROL_FLOW = ["Suspense", "SuspenseList", "Await"];
+var ROUTER_COMPONENTS = ["Router", "Outlet", "Redirect", "Link"];
+var BUILTIN_COMPONENTS = [
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW,
+  ...ROUTER_COMPONENTS
+];
+var RESERVED_COMPONENTS = /* @__PURE__ */ new Set([
+  ...DOM_CONTROL_FLOW,
+  ...CORE_CONTROL_FLOW
+]);
+function builtinComponentMap(modules = {}) {
+  const {
+    controlFlowModule = "@fluixi/dom",
+    coreModule = "@fluixi/core",
+    routerModule = "@fluixi/core/router"
+  } = modules;
+  const map = {};
+  for (const name of DOM_CONTROL_FLOW) map[name] = controlFlowModule;
+  for (const name of CORE_CONTROL_FLOW) map[name] = coreModule;
+  for (const name of ROUTER_COMPONENTS) map[name] = routerModule;
+  return map;
+}
+
+// src/analyze/intrinsics.ts
+var REACTIVE_MODULE = "@fluixi/reactive/signal";
+var INTRINSICS = {
+  $signal: { export: "signal", module: REACTIVE_MODULE, returns: "signal-handle" },
+  $memo: { export: "memo", module: REACTIVE_MODULE, returns: "memo-handle" },
+  $effect: { export: "effect", module: REACTIVE_MODULE, returns: "effect" },
+  $store: { export: "store", module: "@fluixi/reactive/store", returns: "store-handle" },
+  $resource: { export: "resource", module: REACTIVE_MODULE, returns: "resource-handle" },
+  // No short runtime form for these yet, so the intrinsic stands for the `create*`
+  // name. Still worth having — no import to write — and when a shorter form is
+  // designed, the change is this line rather than a compiler pass.
+  $selector: { export: "createSelector", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  $deferred: { export: "createDeferred", module: REACTIVE_MODULE, returns: "memo-accessor" },
+  // Not value constructors, but the compiler has to know them: they change what a read
+  // does. `untrack` suppresses dependency collection, which is exactly the kind of thing
+  // dependency analysis must not guess at.
+  $untrack: { export: "untrack", module: REACTIVE_MODULE, returns: "plain" },
+  $untrackStore: { export: "untrackStore", module: "@fluixi/reactive/store", returns: "plain" }
+};
+var INTRINSIC_CALL = new RegExp(`\\$(?:${Object.keys(INTRINSICS).map((n) => n.slice(1)).join("|")})\\s*\\(`);
+
+// src/resolve/component-globals.ts
+var DOM_GLOBALS = /* @__PURE__ */ new Set([
+  "Text",
+  "Image",
+  "Option",
+  "Audio",
+  "Comment",
+  "Range",
+  "Selection",
+  "Notification",
+  "Event",
+  "Document",
+  "Element",
+  "Node",
+  "Screen",
+  "Window",
+  "Location",
+  "History",
+  "Storage",
+  "Response",
+  "Request",
+  "Headers"
+]);
+function packageOf(specifier) {
+  if (specifier.startsWith(".") || specifier.startsWith("/")) return void 0;
+  if (/^[~@]\//.test(specifier)) return void 0;
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function namespaceAlias(module) {
+  return `_${module.replace(/[^A-Za-z0-9]/g, "_")}`;
+}
+function componentGlobals(rules, options = {}) {
+  const {
+    available: availableList,
+    builtins = true,
+    intrinsics = true,
+    generator = "@fluixi/compiler",
+    specifier = (module) => module
+  } = options;
+  const all = [...rules];
+  if (builtins) {
+    all.push({ components: builtinComponentMap() });
+  }
+  const resolver = createComponentResolver(all);
+  const available = availableList ? new Set(availableList) : void 0;
+  const declared = [];
+  const shadowedByDom = [];
+  const unavailable = [];
+  const resolved = /* @__PURE__ */ new Map();
+  for (const name of [...resolver.names()].sort()) {
+    const target = resolver.resolve(name);
+    if (!target) continue;
+    const pkg = packageOf(target.module);
+    if (DOM_GLOBALS.has(name)) shadowedByDom.push(name);
+    else if (available && pkg && !available.has(pkg)) unavailable.push(name);
+    else {
+      declared.push(name);
+      resolved.set(name, target);
+    }
+  }
+  const intrinsicModules = intrinsics ? [...new Set(Object.values(INTRINSICS).map((i) => i.module))] : [];
+  const modules = [
+    .../* @__PURE__ */ new Set([...declared.map((name) => resolved.get(name).module), ...intrinsicModules])
+  ].sort();
+  const imports = modules.map(
+    (m) => `import * as ${namespaceAlias(m)} from '${specifier(m)}';`
+  );
+  const lines = declared.map((name) => {
+    const target = resolved.get(name);
+    const ns = namespaceAlias(target.module);
+    return target.export === "default" ? `  const ${name}: typeof ${ns}.default;` : `  export import ${name} = ${ns}.${target.export};`;
+  });
+  const note = shadowedByDom.length > 0 ? `//
 // Import these explicitly — lib.dom already declares the name, so an ambient
 // declaration cannot win:
-`+m.map(o=>{let a=u.resolve(o)?.module;return`//   import { ${o} } from '${a?i(a):""}';
-`}).join(""):"",P=n?Object.entries(v).map(([o,a])=>`  const ${o}: typeof ${O(a.module)}.${a.export};`):[],x=e.filter(o=>"match"in o).length,W=x>0?`//
-// ${x} pattern rule${x===1?"":"s"} cannot be declared:
+` + shadowedByDom.map((n) => {
+    const module = resolver.resolve(n)?.module;
+    return `//   import { ${n} } from '${module ? specifier(module) : ""}';
+`;
+  }).join("") : "";
+  const intrinsicLines = intrinsics ? Object.entries(INTRINSICS).map(
+    ([name, intrinsic]) => `  const ${name}: typeof ${namespaceAlias(intrinsic.module)}.${intrinsic.export};`
+  ) : [];
+  const patternRules = rules.filter((rule) => "match" in rule).length;
+  const patternNote = patternRules > 0 ? `//
+// ${patternRules} pattern rule${patternRules === 1 ? "" : "s"} cannot be declared:
 // a pattern matches unboundedly many names, so there is no list to emit. Those
 // tags still resolve at build time; declare them by hand if the editor needs them.
-`:"";return{source:`// GENERATED by ${c} — do not edit.
+` : "";
+  const source = `// GENERATED by ${generator} — do not edit.
 //
 // The components \`resolve\` supplies without an import. This describes what the
 // compiler already does; it does not enable it.
-`+G+W+($.length>0?`
-${$.join(`
-`)}
-`:`
-`)+`
+` + note + patternNote + (imports.length > 0 ? `
+${imports.join("\n")}
+` : "\n") + `
 declare global {
-${[..._,...P].join(`
-`)}
+${[...lines, ...intrinsicLines].join("\n")}
+}
+`;
+  return { source, declared, shadowedByDom, unavailable, patternRules };
+}
+
+// src/resolve/write-globals.ts
+var GENERATED_MARKER = "GENERATED by @fluixi/compiler";
+var DEFAULT_GLOBALS_PATH = "fluixi.d.ts";
+function coveredByInclude(root, target) {
+  let config;
+  try {
+    const raw = readFileSync(resolvePath(root, "tsconfig.json"), "utf8");
+    config = JSON.parse(raw.replace(/^\s*\/\/.*$/gm, ""));
+  } catch {
+    return void 0;
+  }
+  if (config.extends !== void 0) return void 0;
+  if (!Array.isArray(config.include)) return true;
+  const relative2 = relativePosix(root, target);
+  return config.include.some((entry) => {
+    if (typeof entry !== "string") return false;
+    const pattern = entry.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*\//g, "(?:.*/)?").replace(/\*/g, "[^/]*");
+    return new RegExp(`^${pattern}(?:/.*)?$`).test(relative2);
+  });
+}
+function relativePosix(from, to) {
+  return relative(from, to).split(sep).join("/");
+}
+function forTypeScript(module, outDir, root) {
+  if (!module.startsWith("/")) return module;
+  const absolute = resolvePath(root, module.slice(1));
+  let rel = relative(outDir, absolute).split(sep).join("/");
+  if (!rel.startsWith(".")) rel = `./${rel}`;
+  return rel.replace(/\.(tsx|ts|jsx|mts|cts)$/, ".js");
+}
+function projectDependencies(root) {
+  try {
+    const manifest = JSON.parse(readFileSync(resolvePath(root, "package.json"), "utf8"));
+    return [
+      ...Object.keys(manifest.dependencies ?? {}),
+      ...Object.keys(manifest.devDependencies ?? {}),
+      ...Object.keys(manifest.peerDependencies ?? {})
+    ];
+  } catch {
+    return void 0;
+  }
+}
+function writeComponentGlobals(options, root) {
+  if (options.globals === false) return { status: "skipped", reason: "disabled" };
+  const rules = options.resolve ?? [];
+  const target = resolvePath(root, options.globals ?? DEFAULT_GLOBALS_PATH);
+  let existing;
+  try {
+    existing = readFileSync(target, "utf8");
+  } catch {
+    existing = void 0;
+  }
+  if (existing !== void 0 && !existing.includes(GENERATED_MARKER)) {
+    return { status: "skipped", reason: "foreign-file", path: target };
+  }
+  const { source, declared } = componentGlobals(rules, {
+    available: projectDependencies(root),
+    specifier: (module) => forTypeScript(module, dirname(target), root)
+  });
+  if (existing === source) {
+    return {
+      status: "unchanged",
+      path: target,
+      declared: declared.length,
+      warning: warnIfUnreachable(root, target)
+    };
+  }
+  mkdirSync(dirname(target), { recursive: true });
+  writeFileSync(target, source);
+  return {
+    status: "written",
+    path: target,
+    declared: declared.length,
+    warning: warnIfUnreachable(root, target)
+  };
+}
+function warnIfUnreachable(root, target) {
+  if (coveredByInclude(root, target) !== false) return void 0;
+  const relative2 = relativePosix(root, target);
+  return `[fluixi] ${relative2} is not covered by "include" in tsconfig.json, so TypeScript will ignore it and every resolved component stays "Cannot find name". Add "${relative2}" to "include".`;
 }
-`,declared:d,shadowedByDom:m,unavailable:R,patternRules:x}}var J="GENERATED by @fluixi/compiler",q="fluixi.d.ts";function z(e,t){let r;try{let n=S(h(e,"tsconfig.json"),"utf8");r=JSON.parse(n.replace(/^\s*\/\/.*$/gm,""))}catch{return}if(r.extends!==void 0)return;if(!Array.isArray(r.include))return!0;let s=A(e,t);return r.include.some(n=>{if(typeof n!="string")return!1;let c=n.replace(/[.+^${}()|[\]\\]/g,"\\$&").replace(/\*\*\//g,"(?:.*/)?").replace(/\*/g,"[^/]*");return new RegExp(`^${c}(?:/.*)?$`).test(s)})}function A(e,t){return k(e,t).split(L).join("/")}function Z(e,t,r){if(!e.startsWith("/"))return e;let s=h(r,e.slice(1)),n=k(t,s).split(L).join("/");return n.startsWith(".")||(n=`./${n}`),n.replace(/\.(tsx|ts|jsx|mts|cts)$/,".js")}function Q(e){try{let t=JSON.parse(S(h(e,"package.json"),"utf8"));return[...Object.keys(t.dependencies??{}),...Object.keys(t.devDependencies??{}),...Object.keys(t.peerDependencies??{})]}catch{return}}function me(e,t){if(e.globals===!1)return{status:"skipped",reason:"disabled"};let r=e.resolve??[],s=h(t,e.globals??q),n;try{n=S(s,"utf8")}catch{n=void 0}if(n!==void 0&&!n.includes(J))return{status:"skipped",reason:"foreign-file",path:s};let{source:c,declared:i}=j(r,{available:Q(t),specifier:l=>Z(l,N(s),t)});return n===c?{status:"unchanged",path:s,declared:i.length,warning:T(t,s)}:(K(N(s),{recursive:!0}),V(s,c),{status:"written",path:s,declared:i.length,warning:T(t,s)})}function T(e,t){if(z(e,t)!==!1)return;let r=A(e,t);return`[fluixi] ${r} is not covered by "include" in tsconfig.json, so TypeScript will ignore it and every resolved component stays "Cannot find name". Add "${r}" to "include".`}export{q as DEFAULT_GLOBALS_PATH,me as writeComponentGlobals};
+export {
+  DEFAULT_GLOBALS_PATH,
+  writeComponentGlobals
+};

package/dist/server-fns-4ZXN6DYU.mjs

@@ -0,0 +1,78 @@
+/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+import {
+  MagicString
+} from "./chunk-R2VHAZAX.mjs";
+import {
+  serverFnId
+} from "./chunk-FSSWUXUR.mjs";
+import "./chunk-3YKZ4GNH.mjs";
+
+// src/transform/server-fns.ts
+import { parse } from "@babel/parser";
+var RUNTIME = "@fluixi/start/server-fn";
+var FUNCTION_TYPES = /* @__PURE__ */ new Set([
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "ArrowFunctionExpression"
+]);
+function directive(node) {
+  if (!FUNCTION_TYPES.has(node.type)) return null;
+  const body = node.body;
+  if (!body || body.type !== "BlockStatement") return null;
+  for (const d of body.directives ?? []) {
+    if (d.value?.value === "use server") return d;
+  }
+  return null;
+}
+function findServerFns(node, out) {
+  if (!node || typeof node !== "object") return;
+  if (Array.isArray(node)) {
+    for (const child of node) findServerFns(child, out);
+    return;
+  }
+  if (typeof node.type === "string") {
+    const found = directive(node);
+    if (found) {
+      out.push({ fn: node, directive: found });
+      return;
+    }
+  }
+  for (const key of Object.keys(node)) {
+    if (key === "loc" || key === "leadingComments" || key === "trailingComments") continue;
+    findServerFns(node[key], out);
+  }
+}
+function transformServerFns(code, options) {
+  if (!code.includes("use server")) return null;
+  const ast = parse(code, {
+    sourceType: "module",
+    plugins: ["jsx", "typescript"],
+    errorRecovery: true
+  });
+  const found = [];
+  findServerFns(ast.program, found);
+  if (found.length === 0) return null;
+  const helper = options.ssr ? "$$registerServerFn" : "$$createServerReference";
+  const out = new MagicString(code);
+  found.forEach(({ fn, directive: dir }, index) => {
+    const id = serverFnId(options.filename, options.root, index);
+    const declaration = fn.type === "FunctionDeclaration";
+    if (!options.ssr) {
+      const stub = `${helper}(${JSON.stringify(id)})`;
+      out.overwrite(fn.start, fn.end, declaration ? `const ${fn.id.name} = ${stub};` : stub);
+      return;
+    }
+    out.remove(dir.start, dir.end);
+    out.appendLeft(fn.start, declaration ? `const ${fn.id.name} = ${helper}(${JSON.stringify(id)}, ` : `${helper}(${JSON.stringify(id)}, `);
+    out.appendRight(fn.end, declaration ? ");" : ")");
+  });
+  out.prepend(`import { ${helper} } from ${JSON.stringify(options.runtimeModule ?? RUNTIME)};
+`);
+  return {
+    code: out.toString(),
+    map: out.generateMap({ source: options.filename, includeContent: true, hires: true })
+  };
+}
+export {
+  transformServerFns
+};

package/dist/server-functions-V6D6DRIA.mjs

@@ -0,0 +1,82 @@
+/*! @fluixi/compiler v1.0.0-alpha.84 | (c) 2026 Ibrahima Touré and Fluixi contributors | MIT */
+import {
+  serverFnId
+} from "./chunk-FSSWUXUR.mjs";
+import "./chunk-3YKZ4GNH.mjs";
+
+// src/frontend/babel/server-functions.ts
+import { transformSync } from "@babel/core";
+var RUNTIME = "@fluixi/start/server-fn";
+function serverFunctionsBabelPlugin({ types: t }) {
+  return {
+    name: "fluixi-server-functions",
+    visitor: {
+      Program: {
+        enter(_path, state) {
+          state.fxIndex = 0;
+          state.fxUsed = null;
+        },
+        exit(path, state) {
+          if (!state.fxUsed) return;
+          path.unshiftContainer(
+            "body",
+            t.importDeclaration(
+              [t.importSpecifier(t.identifier(state.fxUsed), t.identifier(state.fxUsed))],
+              t.stringLiteral(state.opts.runtimeModule || RUNTIME)
+            )
+          );
+        }
+      },
+      "FunctionDeclaration|FunctionExpression|ArrowFunctionExpression": (path, state) => {
+        const body = path.node.body;
+        if (!t.isBlockStatement(body)) return;
+        const dirs = body.directives || [];
+        const di = dirs.findIndex((d) => d.value.value === "use server");
+        if (di < 0) return;
+        body.directives.splice(di, 1);
+        const id = serverFnId(
+          state.opts.filename || state.filename || "unknown",
+          state.opts.root,
+          state.fxIndex++
+        );
+        const ssr = !!state.opts.ssr;
+        const helper = ssr ? "$$registerServerFn" : "$$createServerReference";
+        state.fxUsed = helper;
+        const replacement = ssr ? t.callExpression(t.identifier(helper), [
+          t.stringLiteral(id),
+          path.isFunctionDeclaration() ? t.functionExpression(
+            null,
+            path.node.params,
+            body,
+            path.node.generator,
+            path.node.async
+          ) : path.node
+        ]) : t.callExpression(t.identifier(helper), [t.stringLiteral(id)]);
+        if (path.isFunctionDeclaration()) {
+          path.replaceWith(
+            t.variableDeclaration("const", [t.variableDeclarator(path.node.id, replacement)])
+          );
+        } else {
+          path.replaceWith(replacement);
+        }
+        path.skip();
+      }
+    }
+  };
+}
+function transformServerFunctions(code, opts) {
+  if (!code.includes("use server")) return null;
+  const result = transformSync(code, {
+    filename: opts.filename,
+    configFile: false,
+    babelrc: false,
+    sourceMaps: true,
+    parserOpts: { plugins: ["typescript", "jsx"] },
+    plugins: [[serverFunctionsBabelPlugin, opts]]
+  });
+  if (!result?.code) return null;
+  return { code: result.code, map: result.map };
+}
+export {
+  transformServerFunctions
+};

package/dist/transform/bindings.cjs

@@ -1 +1,71 @@
-"use strict";var s=Object.defineProperty;var c=Object.getOwnPropertyDescriptor;var l=Object.getOwnPropertyNames;var d=Object.prototype.hasOwnProperty;var f=(e,t)=>{for(var a in t)s(e,a,{get:t[a],enumerable:!0})},N=(e,t,a,i)=>{if(t&&typeof t=="object"||typeof t=="function")for(let n of l(t))!d.call(e,n)&&n!==a&&s(e,n,{get:()=>t[n],enumerable:!(i=c(t,n))||i.enumerable});return e};var u=e=>N(s({},"__esModule",{value:!0}),e);var p={};f(p,{moduleBindings:()=>m});module.exports=u(p);function r(e,t){if(e)switch(e.type){case"Identifier":t.add(e.name);return;case"ObjectPattern":for(let a of e.properties)a.type==="RestElement"?r(a.argument,t):r(a.value,t);return;case"ArrayPattern":for(let a of e.elements)r(a,t);return;case"AssignmentPattern":r(e.left,t);return;case"RestElement":r(e.argument,t);return}}function o(e,t){switch(e.type){case"ImportDeclaration":for(let a of e.specifiers)r(a.local,t);return;case"VariableDeclaration":for(let a of e.declarations)r(a.id,t);return;case"FunctionDeclaration":case"ClassDeclaration":r(e.id,t);return;case"ExportNamedDeclaration":case"ExportDefaultDeclaration":e.declaration&&o(e.declaration,t);return}}function m(e){let t=new Set;for(let a of e.body)o(a,t);return t}
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/transform/bindings.ts
+var bindings_exports = {};
+__export(bindings_exports, {
+  moduleBindings: () => moduleBindings
+});
+module.exports = __toCommonJS(bindings_exports);
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function declared(node, out) {
+  switch (node.type) {
+    case "ImportDeclaration":
+      for (const s of node.specifiers) patternNames(s.local, out);
+      return;
+    case "VariableDeclaration":
+      for (const d of node.declarations) patternNames(d.id, out);
+      return;
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+      patternNames(node.id, out);
+      return;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration":
+      if (node.declaration) declared(node.declaration, out);
+      return;
+  }
+}
+function moduleBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) declared(statement, names);
+  return names;
+}

package/dist/transform/bindings.d.cts

@@ -0,0 +1,16 @@
+/**
+ * Names bound at module scope.
+ *
+ * Injected imports are skipped when the name already exists, so a file with its
+ * own `Show` keeps it. Only module scope matters: a `const insert = …` inside a
+ * function shadows our import there but cannot collide with it, which is the same
+ * answer `path.scope.hasBinding` gives on the Program path.
+ *
+ * Missing a binding emits a duplicate declaration — a syntax error. Reporting one
+ * that isn't there drops an import the code needs. Both are loud, neither is
+ * subtle, and the corpus in bindings.spec.ts covers the patterns that bind.
+ */
+/** Collect the names bound at the top level of a parsed module. */
+export declare function moduleBindings(program: {
+    body: unknown[];
+}): Set<string>;

package/dist/transform/bindings.mjs

@@ -1 +1,50 @@
-function r(e,t){if(e)switch(e.type){case"Identifier":t.add(e.name);return;case"ObjectPattern":for(let a of e.properties)a.type==="RestElement"?r(a.argument,t):r(a.value,t);return;case"ArrayPattern":for(let a of e.elements)r(a,t);return;case"AssignmentPattern":r(e.left,t);return;case"RestElement":r(e.argument,t);return}}function n(e,t){switch(e.type){case"ImportDeclaration":for(let a of e.specifiers)r(a.local,t);return;case"VariableDeclaration":for(let a of e.declarations)r(a.id,t);return;case"FunctionDeclaration":case"ClassDeclaration":r(e.id,t);return;case"ExportNamedDeclaration":case"ExportDefaultDeclaration":e.declaration&&n(e.declaration,t);return}}function s(e){let t=new Set;for(let a of e.body)n(a,t);return t}export{s as moduleBindings};
+// src/transform/bindings.ts
+function patternNames(node, out) {
+  if (!node) return;
+  switch (node.type) {
+    case "Identifier":
+      out.add(node.name);
+      return;
+    case "ObjectPattern":
+      for (const p of node.properties) {
+        if (p.type === "RestElement") patternNames(p.argument, out);
+        else patternNames(p.value, out);
+      }
+      return;
+    case "ArrayPattern":
+      for (const e of node.elements) patternNames(e, out);
+      return;
+    case "AssignmentPattern":
+      patternNames(node.left, out);
+      return;
+    case "RestElement":
+      patternNames(node.argument, out);
+      return;
+  }
+}
+function declared(node, out) {
+  switch (node.type) {
+    case "ImportDeclaration":
+      for (const s of node.specifiers) patternNames(s.local, out);
+      return;
+    case "VariableDeclaration":
+      for (const d of node.declarations) patternNames(d.id, out);
+      return;
+    case "FunctionDeclaration":
+    case "ClassDeclaration":
+      patternNames(node.id, out);
+      return;
+    case "ExportNamedDeclaration":
+    case "ExportDefaultDeclaration":
+      if (node.declaration) declared(node.declaration, out);
+      return;
+  }
+}
+function moduleBindings(program) {
+  const names = /* @__PURE__ */ new Set();
+  for (const statement of program.body) declared(statement, names);
+  return names;
+}
+export {
+  moduleBindings
+};