auto-server-split 0.0.0-stage → 1.0.0

package/dist/chunk-6OAWHATP.js

@@ -0,0 +1,4847 @@
+import {
+  BUILTIN_CLIENT_ONLY_PACKAGES,
+  BUILTIN_SERVER_SAFE_PACKAGES,
+  CSS_IN_JS_PACKAGES,
+  matchesPackageList,
+  packageNameOf
+} from "./chunk-YCSBOPV3.js";
+
+// src/analysis/skip.ts
+var SKIP_CODES = [
+  "imported-by-client",
+  "exports-non-components",
+  "state-spans-component",
+  "context-provider",
+  "css-in-js-runtime",
+  "non-serializable-prop",
+  "untyped-boundary",
+  "spread-props",
+  "conditional-hooks-or-returns",
+  "class-component",
+  "dynamic-import",
+  "render-prop",
+  "hoc",
+  "server-env-difference",
+  "no-islands",
+  "fully-interactive",
+  "below-threshold",
+  "measure-failed",
+  "output-exists",
+  "would-create-route",
+  "unsupported-pattern",
+  "self-check-failed",
+  "parse-error",
+  "internal-error"
+];
+var SKIP_TITLES = {
+  "imported-by-client": "imported by a client module",
+  "exports-non-components": "exports something other than components and types",
+  "state-spans-component": "client state spans the whole component",
+  "context-provider": "creates or provides a React Context",
+  "css-in-js-runtime": "uses runtime CSS-in-JS",
+  "non-serializable-prop": "a value crossing the boundary is not serializable",
+  "untyped-boundary": "untyped file: boundary values can't be proven serializable",
+  "spread-props": "spread props can't be proven serializable",
+  "conditional-hooks-or-returns": "conditional hooks or client-dependent early returns",
+  "class-component": "contains a class component",
+  "dynamic-import": "uses next/dynamic or React.lazy",
+  "render-prop": "uses a render prop or function-as-child",
+  hoc: "wrapped in memo/forwardRef or another higher-order component",
+  "server-env-difference": "reads an env var that differs between server and client",
+  "no-islands": "no client-only code found (the directive may be unnecessary)",
+  "fully-interactive": "nothing would stay on the server",
+  "below-threshold": "saving is below the configured threshold",
+  "measure-failed": "the saving couldn't be measured, so minBytesSaved can't be checked",
+  "output-exists": "the generated file already exists",
+  "would-create-route": "the generated file could become a route",
+  "unsupported-pattern": "uses a pattern this version does not handle",
+  "self-check-failed": "the generated code failed the self-check",
+  "parse-error": "the file could not be parsed",
+  "internal-error": "internal error (please report)"
+};
+function ok(value) {
+  return { ok: true, value };
+}
+function skip(code, message, location) {
+  return { ok: false, skip: location ? { code, message, location } : { code, message } };
+}
+
+// src/config/config.ts
+import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { createRequire } from "module";
+import path from "path";
+import { pathToFileURL } from "url";
+import { buildSync } from "esbuild";
+var DEFAULT_CONFIG = {
+  include: ["app/**", "components/**", "src/**"],
+  exclude: ["**/*.test.*", "**/*.spec.*", "**/*.stories.*"],
+  clientOnlyPackages: [],
+  serverSafeHooks: [],
+  clientFileSuffix: ".client",
+  islandsDir: void 0,
+  minBytesSaved: 2048,
+  minStaticRatio: 0.3,
+  prettier: "auto",
+  mongoose: { autoSerialize: false }
+};
+var CONFIG_FILES = [
+  "auto-split.config.ts",
+  "auto-split.config.mts",
+  "auto-split.config.mjs",
+  "auto-split.config.js",
+  "auto-split.config.json"
+];
+var ConfigError = class extends Error {
+};
+var KEYS = {
+  include: stringArray,
+  exclude: stringArray,
+  clientOnlyPackages: stringArray,
+  serverSafeHooks: stringArray,
+  clientFileSuffix: (v) => typeof v === "string" && /^\.[\w.-]+$/.test(v) ? void 0 : 'must be a string starting with "." (e.g. ".client")',
+  islandsDir: (v) => typeof v === "string" && v.length > 0 && !path.isAbsolute(v) && !v.includes("..") ? void 0 : "must be a relative directory name",
+  minBytesSaved: (v) => typeof v === "number" && v >= 0 && Number.isFinite(v) ? void 0 : "must be a non-negative number",
+  minStaticRatio: (v) => typeof v === "number" && v >= 0 && v <= 1 ? void 0 : "must be a number between 0 and 1",
+  prettier: (v) => v === "auto" || v === false ? void 0 : 'must be "auto" or false',
+  mongoose: (v) => {
+    if (typeof v !== "object" || v === null || Array.isArray(v)) return "must be an object";
+    for (const [k, val] of Object.entries(v)) {
+      if (k !== "autoSerialize") return `has an unknown key "${k}" (allowed: autoSerialize)`;
+      if (typeof val !== "boolean") return "autoSerialize must be a boolean";
+    }
+    return void 0;
+  }
+};
+function stringArray(v) {
+  return Array.isArray(v) && v.every((x) => typeof x === "string") ? void 0 : "must be an array of strings";
+}
+function validateConfig(value, source) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new ConfigError(`${source}: the config must be an object`);
+  }
+  const problems = [];
+  for (const [key, v] of Object.entries(value)) {
+    const check = KEYS[key];
+    if (!check) {
+      problems.push(`unknown key "${key}" (allowed: ${Object.keys(KEYS).join(", ")})`);
+      continue;
+    }
+    if (v === void 0) continue;
+    const problem = check(v);
+    if (problem) problems.push(`"${key}" ${problem}`);
+  }
+  if (problems.length > 0) throw new ConfigError(`${source}:
+  - ${problems.join("\n  - ")}`);
+  return value;
+}
+function resolveConfig(...layers) {
+  const out = { ...DEFAULT_CONFIG, mongoose: { ...DEFAULT_CONFIG.mongoose } };
+  for (const layer of layers) {
+    if (!layer) continue;
+    for (const [key, value] of Object.entries(layer)) {
+      if (value === void 0) continue;
+      if (key === "mongoose")
+        out.mongoose = { ...out.mongoose, ...value };
+      else out[key] = value;
+    }
+  }
+  return out;
+}
+function findConfigFile(root) {
+  return CONFIG_FILES.map((f) => path.join(root, f)).find((f) => existsSync(f));
+}
+function readJsonConfig(file) {
+  try {
+    return JSON.parse(readFileSync(file, "utf8"));
+  } catch (error) {
+    throw new ConfigError(`${path.basename(file)}: invalid JSON (${error.message})`);
+  }
+}
+async function loadConfigFile(file) {
+  const rel2 = path.basename(file);
+  let raw;
+  if (file.endsWith(".json")) {
+    raw = readJsonConfig(file);
+  } else if (file.endsWith(".ts") || file.endsWith(".mts")) {
+    const esbuild = await import("esbuild");
+    const result = await esbuild.build({
+      entryPoints: [file],
+      bundle: true,
+      write: false,
+      format: "esm",
+      platform: "node",
+      packages: "external",
+      logLevel: "silent",
+      plugins: [
+        {
+          name: "auto-split-shim",
+          setup(build) {
+            build.onResolve({ filter: /^auto-server-split$/ }, () => ({
+              path: "shim",
+              namespace: "auto-split-shim"
+            }));
+            build.onLoad({ filter: /.*/, namespace: "auto-split-shim" }, () => ({
+              contents: "export const defineConfig = (c) => c;",
+              loader: "js"
+            }));
+          }
+        }
+      ]
+    });
+    const code = result.outputFiles[0]?.text ?? "";
+    const temp = path.join(
+      path.dirname(file),
+      `.auto-split.config.${process.pid}.${Date.now()}.mjs`
+    );
+    writeFileSync(temp, code);
+    try {
+      raw = (await import(pathToFileURL(temp).href)).default;
+    } finally {
+      rmSync(temp, { force: true });
+    }
+  } else {
+    raw = (await import(pathToFileURL(file).href)).default;
+  }
+  return validateConfig(raw, rel2);
+}
+function loadConfigFileSync(file) {
+  const rel2 = path.basename(file);
+  if (file.endsWith(".json")) return validateConfig(readJsonConfig(file), rel2);
+  let code;
+  try {
+    code = buildSync({
+      entryPoints: [file],
+      bundle: true,
+      write: false,
+      format: "cjs",
+      platform: "node",
+      packages: "external",
+      logLevel: "silent",
+      // CommonJS has no import.meta; give the config the values a native import() would.
+      define: {
+        "import.meta.url": JSON.stringify(pathToFileURL(file).href),
+        "import.meta.dirname": JSON.stringify(path.dirname(file)),
+        "import.meta.filename": JSON.stringify(file)
+      }
+    }).outputFiles[0]?.text ?? "";
+  } catch (error) {
+    const first = error.errors?.[0]?.text;
+    throw new ConfigError(
+      `${rel2}: couldn't be loaded synchronously for ESLint (${first ?? String(error)})`
+    );
+  }
+  const requireFromConfig = createRequire(file);
+  const module = { exports: {} };
+  const evaluate = new Function("module", "exports", "require", "__filename", "__dirname", code);
+  evaluate(
+    module,
+    module.exports,
+    (id) => id === "auto-server-split" ? { defineConfig: (c) => c } : requireFromConfig(id),
+    file,
+    path.dirname(file)
+  );
+  const exported = module.exports;
+  return validateConfig(exported.__esModule ? exported.default : exported, rel2);
+}
+
+// src/split.ts
+import { existsSync as existsSync5, mkdirSync, realpathSync, writeFileSync as writeFileSync2 } from "fs";
+import path9 from "path";
+import { createTwoFilesPatch } from "diff";
+import fg3 from "fast-glob";
+import { ts as ts18 } from "ts-morph";
+
+// src/analysis/components.ts
+import { ts as ts2 } from "ts-morph";
+
+// src/analysis/context.ts
+function lineCol(sf, pos) {
+  const lc = sf.getLineAndCharacterOfPosition(pos);
+  return { line: lc.line + 1, column: lc.character + 1 };
+}
+function locOf(ctx, node) {
+  return lineCol(ctx.sf, node.getStart(ctx.sf));
+}
+
+// src/analysis/refs.ts
+import { ts } from "ts-morph";
+function isJsxElementLike(node) {
+  return ts.isJsxElement(node) || ts.isJsxSelfClosingElement(node) || ts.isJsxFragment(node);
+}
+function isIntrinsicTagName(name) {
+  if (ts.isIdentifier(name)) return /^[a-z]/.test(name.text) || name.text.includes("-");
+  return ts.isJsxNamespacedName(name);
+}
+function tagNameText(sf, node) {
+  if (ts.isJsxFragment(node)) return "Fragment";
+  const tag = ts.isJsxElement(node) ? node.openingElement.tagName : node.tagName;
+  return tag.getText(sf);
+}
+function isValueReference(id) {
+  const parent = id.parent;
+  if (!parent) return false;
+  if (ts.isPropertyAccessExpression(parent) && parent.name === id) return false;
+  if (ts.isQualifiedName(parent) && parent.right === id) return false;
+  if ((ts.isPropertyAssignment(parent) || ts.isPropertyDeclaration(parent) || ts.isMethodDeclaration(parent) || ts.isGetAccessorDeclaration(parent) || ts.isSetAccessorDeclaration(parent) || ts.isPropertySignature(parent) || ts.isMethodSignature(parent) || ts.isEnumMember(parent)) && parent.name === id) {
+    return false;
+  }
+  if (ts.isBindingElement(parent) && (parent.propertyName === id || parent.name === id))
+    return false;
+  if ((ts.isVariableDeclaration(parent) || ts.isParameter(parent) || ts.isFunctionDeclaration(parent) || ts.isFunctionExpression(parent) || ts.isClassDeclaration(parent) || ts.isClassExpression(parent) || ts.isEnumDeclaration(parent) || ts.isTypeAliasDeclaration(parent) || ts.isInterfaceDeclaration(parent) || ts.isTypeParameterDeclaration(parent)) && parent.name === id) {
+    return false;
+  }
+  if (ts.isJsxAttribute(parent) && parent.name === id) return false;
+  if (ts.isJsxClosingElement(parent)) return false;
+  if ((ts.isJsxOpeningElement(parent) || ts.isJsxSelfClosingElement(parent)) && parent.tagName === id) {
+    return !isIntrinsicTagName(id);
+  }
+  if (ts.isImportSpecifier(parent) || ts.isImportClause(parent) || ts.isNamespaceImport(parent) || ts.isExportSpecifier(parent) || ts.isImportEqualsDeclaration(parent)) {
+    return false;
+  }
+  if ((ts.isLabeledStatement(parent) || ts.isBreakStatement(parent) || ts.isContinueStatement(parent)) && parent.label === id) {
+    return false;
+  }
+  if (ts.isMetaProperty(parent) || ts.isJsxNamespacedName(parent)) return false;
+  return true;
+}
+function isTypeSyntax(node) {
+  return ts.isTypeNode(node) && !ts.isExpressionWithTypeArguments(node);
+}
+function forEachValueRef(node, cb, stop) {
+  const visit = (n) => {
+    if (n !== node && stop?.(n)) return;
+    if (isTypeSyntax(n)) return;
+    if (ts.isTypeAliasDeclaration(n) || ts.isInterfaceDeclaration(n)) return;
+    if (ts.isIdentifier(n)) {
+      if (isValueReference(n)) cb(n);
+      return;
+    }
+    if (ts.isJsxElement(n)) {
+      visit(n.openingElement);
+      n.children.forEach(visit);
+      return;
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+}
+function forEachIdentifier(node, cb) {
+  const visit = (n) => {
+    if (ts.isIdentifier(n)) cb(n);
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+}
+function symbolOfRef(checker, id) {
+  if (ts.isShorthandPropertyAssignment(id.parent) && id.parent.name === id) {
+    return checker.getShorthandAssignmentValueSymbol(id.parent);
+  }
+  return checker.getSymbolAtLocation(id);
+}
+function bindingIdentifiers(name) {
+  if (ts.isIdentifier(name)) return [name];
+  const out = [];
+  for (const element of name.elements) {
+    if (ts.isOmittedExpression(element)) continue;
+    out.push(...bindingIdentifiers(element.name));
+  }
+  return out;
+}
+function containsRange(outer, inner) {
+  return inner.pos >= outer.pos && inner.end <= outer.end;
+}
+function mapCallOf(fn) {
+  const parent = fn.parent;
+  if (parent && ts.isCallExpression(parent) && parent.arguments[0] === fn && ts.isPropertyAccessExpression(parent.expression) && parent.expression.name.text === "map") {
+    return parent;
+  }
+  return void 0;
+}
+function stripParens(expr) {
+  let e = expr;
+  while (ts.isParenthesizedExpression(e)) e = e.expression;
+  return e;
+}
+var HOOK_NAME_RE = /^use[A-Z]/;
+function calleeName(call) {
+  const callee = call.expression;
+  if (ts.isIdentifier(callee)) return callee.text;
+  if (ts.isPropertyAccessExpression(callee)) return callee.name.text;
+  return void 0;
+}
+
+// src/analysis/components.ts
+function componentDeclarationNode(component) {
+  return ts2.isFunctionDeclaration(component.fn) ? component.fn : component.fn.parent;
+}
+function isCapitalized(name) {
+  return /^[A-Z]/.test(name);
+}
+function hasExportModifier(node) {
+  return ts2.canHaveModifiers(node) && (ts2.getModifiers(node)?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword) ?? false);
+}
+function hasDefaultModifier(node) {
+  return ts2.canHaveModifiers(node) && (ts2.getModifiers(node)?.some((m) => m.kind === ts2.SyntaxKind.DefaultKeyword) ?? false);
+}
+function returnsJsx(fn) {
+  if (!fn.body) return false;
+  if (!ts2.isBlock(fn.body)) return containsJsx(fn.body);
+  let found = false;
+  const visit = (n) => {
+    if (found) return;
+    if (ts2.isFunctionLike(n) && n !== fn) return;
+    if (ts2.isReturnStatement(n) && n.expression && containsJsx(n.expression)) found = true;
+    ts2.forEachChild(n, visit);
+  };
+  visit(fn.body);
+  return found;
+}
+function containsJsx(node) {
+  if (isJsxElementLike(node)) return true;
+  return ts2.forEachChild(node, (c) => containsJsx(c) ? true : void 0) ?? false;
+}
+function hocCallName(expr, sf) {
+  if (ts2.isCallExpression(expr)) return expr.expression.getText(sf);
+  return void 0;
+}
+function analyzeFileShape(ctx, facts) {
+  const { sf } = ctx;
+  const components = [];
+  const moduleDecls = [];
+  const exportedNames = /* @__PURE__ */ new Map();
+  let defaultExportName;
+  for (const statement of sf.statements) {
+    if (ts2.isImportDeclaration(statement)) continue;
+    if (ts2.isExpressionStatement(statement) && ts2.isStringLiteral(statement.expression)) continue;
+    if (ts2.isTypeAliasDeclaration(statement) || ts2.isInterfaceDeclaration(statement)) {
+      moduleDecls.push({
+        statement,
+        names: [statement.name.text],
+        kind: "type",
+        exported: hasExportModifier(statement)
+      });
+      continue;
+    }
+    if (ts2.isFunctionDeclaration(statement)) {
+      const name = statement.name?.text ?? (hasDefaultModifier(statement) ? "default" : "");
+      const exported = hasExportModifier(statement);
+      if ((isCapitalized(name) || name === "default") && returnsJsx(statement)) {
+        if (statement.asteriskToken || statement.modifiers?.some((m) => m.kind === ts2.SyntaxKind.AsyncKeyword)) {
+          return skip(
+            "unsupported-pattern",
+            `${name} is an async or generator function`,
+            locOf(ctx, statement)
+          );
+        }
+        components.push({
+          name: name === "default" ? "Component" : name,
+          fn: statement,
+          statement,
+          exported: exported ? hasDefaultModifier(statement) ? "default" : "named" : "none"
+        });
+      } else {
+        if (exported) {
+          const why = isCapitalized(name) ? "doesn't return JSX, so it isn't treated as a component" : "is not a component";
+          return skip(
+            "exports-non-components",
+            `exports ${name || "a function"}, which ${why}`,
+            locOf(ctx, statement)
+          );
+        }
+        moduleDecls.push({
+          statement,
+          names: name ? [name] : [],
+          kind: "function",
+          exported: false
+        });
+      }
+      continue;
+    }
+    if (ts2.isVariableStatement(statement)) {
+      const exported = hasExportModifier(statement);
+      const isConst = (statement.declarationList.flags & ts2.NodeFlags.Const) !== 0;
+      let isComponentStatement = false;
+      for (const decl of statement.declarationList.declarations) {
+        const name = ts2.isIdentifier(decl.name) ? decl.name.text : void 0;
+        const init = decl.initializer;
+        const fn = init && (ts2.isArrowFunction(init) || ts2.isFunctionExpression(init)) ? init : void 0;
+        if (name && isCapitalized(name) && fn && returnsJsx(fn)) {
+          if (statement.declarationList.declarations.length > 1) {
+            return skip(
+              "unsupported-pattern",
+              `${name} is declared together with other variables`,
+              locOf(ctx, decl)
+            );
+          }
+          if (fn.modifiers?.some((m) => m.kind === ts2.SyntaxKind.AsyncKeyword)) {
+            return skip("unsupported-pattern", `${name} is an async function`, locOf(ctx, decl));
+          }
+          components.push({ name, fn, statement, exported: exported ? "named" : "none" });
+          isComponentStatement = true;
+          continue;
+        }
+        if (name && init && isCapitalized(name)) {
+          const hoc = hocCallName(init, sf);
+          if (hoc && /(^|\.)(memo|forwardRef)$/.test(hoc)) {
+            return skip(
+              "hoc",
+              `${name} is wrapped in ${hoc}(), which this version doesn't split`,
+              locOf(ctx, decl)
+            );
+          }
+        }
+        if (exported) {
+          return skip(
+            "exports-non-components",
+            `exports ${name ?? "a value"}, which is not a component`,
+            locOf(ctx, decl)
+          );
+        }
+      }
+      if (isComponentStatement) continue;
+      if (!isConst) {
+        return skip(
+          "unsupported-pattern",
+          "declares module-level `let`/`var` state, which would be shared across requests on the server",
+          locOf(ctx, statement)
+        );
+      }
+      const names = statement.declarationList.declarations.flatMap(
+        (d) => ts2.isIdentifier(d.name) ? [d.name.text] : []
+      );
+      if (statement.declarationList.declarations.some((d) => !ts2.isIdentifier(d.name))) {
+        return skip(
+          "unsupported-pattern",
+          "uses a destructuring declaration at module level",
+          locOf(ctx, statement)
+        );
+      }
+      moduleDecls.push({ statement, names, kind: "const", exported: false });
+      continue;
+    }
+    if (ts2.isClassDeclaration(statement)) {
+      const extendsComponent = statement.heritageClauses?.some(
+        (h) => h.types.some((t) => /(^|\.)(Component|PureComponent)$/.test(t.expression.getText(sf)))
+      );
+      if (extendsComponent)
+        return skip(
+          "class-component",
+          `${statement.name?.text ?? "a class"} is a class component`,
+          locOf(ctx, statement)
+        );
+      if (hasExportModifier(statement)) {
+        return skip(
+          "exports-non-components",
+          `exports the class ${statement.name?.text ?? ""}`.trim(),
+          locOf(ctx, statement)
+        );
+      }
+      moduleDecls.push({
+        statement,
+        names: statement.name ? [statement.name.text] : [],
+        kind: "class",
+        exported: false
+      });
+      continue;
+    }
+    if (ts2.isEnumDeclaration(statement)) {
+      if (hasExportModifier(statement)) {
+        return skip(
+          "exports-non-components",
+          `exports the enum ${statement.name.text}`,
+          locOf(ctx, statement)
+        );
+      }
+      moduleDecls.push({ statement, names: [statement.name.text], kind: "enum", exported: false });
+      continue;
+    }
+    if (ts2.isExportAssignment(statement)) {
+      const expr = statement.expression;
+      if (ts2.isIdentifier(expr)) {
+        defaultExportName = expr.text;
+        exportedNames.set(expr.text, statement);
+        continue;
+      }
+      const hoc = hocCallName(expr, sf);
+      if (hoc)
+        return skip(
+          "hoc",
+          `the default export is wrapped in ${hoc}(), which this version doesn't split`,
+          locOf(ctx, statement)
+        );
+      return skip(
+        "exports-non-components",
+        "the default export is not a component",
+        locOf(ctx, statement)
+      );
+    }
+    if (ts2.isExportDeclaration(statement)) {
+      if (statement.moduleSpecifier) {
+        if (statement.isTypeOnly) continue;
+        return skip(
+          "exports-non-components",
+          "re-exports another module; its exports can't be verified",
+          locOf(ctx, statement)
+        );
+      }
+      const clause = statement.exportClause;
+      if (clause && ts2.isNamedExports(clause)) {
+        for (const element of clause.elements) {
+          if (statement.isTypeOnly || element.isTypeOnly) continue;
+          const local = (element.propertyName ?? element.name).text;
+          exportedNames.set(local, element);
+          if (element.name.text === "default") defaultExportName = local;
+        }
+      }
+      continue;
+    }
+    return skip(
+      "unsupported-pattern",
+      "has a module-level statement that runs on import",
+      locOf(ctx, statement)
+    );
+  }
+  for (const [name, node] of exportedNames) {
+    const component = components.find((c) => c.name === name);
+    if (component) {
+      if (component.exported === "none")
+        component.exported = name === defaultExportName ? "default" : "named";
+      continue;
+    }
+    const decl = moduleDecls.find((d) => d.names.includes(name));
+    if (decl?.kind === "type") continue;
+    return skip(
+      "exports-non-components",
+      `exports ${name}, which is not a component`,
+      locOf(ctx, node)
+    );
+  }
+  for (const decl of moduleDecls) {
+    if (decl.kind !== "const" && decl.kind !== "class") continue;
+    const markers = facts.scanMarkers(
+      decl.statement,
+      (n) => ts2.isFunctionLike(n) || ts2.isClassLike(n)
+    );
+    const browser = markers.find(
+      (m) => m.kind === "browser-global" || m.kind === "hook" || m.kind === "nondeterministic"
+    );
+    if (browser) {
+      return skip(
+        "unsupported-pattern",
+        `module-level code uses ${browser.detail}; it would run on the server after the split`,
+        locOf(ctx, browser.node)
+      );
+    }
+  }
+  if (components.length === 0) {
+    return skip("unsupported-pattern", "no function component found in this file", void 0);
+  }
+  const componentDecls = /* @__PURE__ */ new Map();
+  for (const component of components) {
+    componentDecls.set(component, {
+      statement: component.statement,
+      names: [component.name],
+      kind: "function",
+      exported: component.exported !== "none",
+      component
+    });
+  }
+  return ok({ components, moduleDecls, componentDecls });
+}
+
+// src/analysis/importTable.ts
+import path2 from "path";
+import { ts as ts3 } from "ts-morph";
+var REACT_NEUTRAL = /* @__PURE__ */ new Set([
+  "default",
+  "*",
+  "Fragment",
+  "Suspense",
+  "StrictMode",
+  "Profiler",
+  "Children",
+  "cloneElement",
+  "isValidElement",
+  "createElement",
+  "cache",
+  "version"
+]);
+var REACT_SPECIAL = {
+  createContext: "context",
+  Component: "class",
+  PureComponent: "class",
+  memo: "hoc",
+  forwardRef: "hoc",
+  lazy: "lazy"
+};
+var REACT_DOM_NEUTRAL = /* @__PURE__ */ new Set([
+  "preload",
+  "preinit",
+  "preconnect",
+  "prefetchDNS",
+  "preloadModule",
+  "preinitModule"
+]);
+function buildImportTable(sf, checker, graph) {
+  const file = path2.resolve(sf.fileName);
+  const table = {
+    bindings: [],
+    bySymbol: /* @__PURE__ */ new Map(),
+    declarations: [],
+    sideEffectImports: []
+  };
+  for (const statement of sf.statements) {
+    if (!ts3.isImportDeclaration(statement) || !ts3.isStringLiteral(statement.moduleSpecifier))
+      continue;
+    table.declarations.push(statement);
+    const specifier = statement.moduleSpecifier.text;
+    const clause = statement.importClause;
+    if (!clause) {
+      table.sideEffectImports.push(statement);
+      continue;
+    }
+    const edge = graph.edgeFor(file, specifier);
+    const module = edge?.to ? { kind: "project", file: edge.to, directive: graph.nodes.get(edge.to)?.directive } : {
+      kind: "external",
+      info: edge?.external ?? {
+        specifier,
+        packageName: specifier,
+        kind: "unresolved",
+        detail: "not in module graph"
+      }
+    };
+    const add = (node, nameNode, imported, typeOnly) => {
+      const symbol = checker.getSymbolAtLocation(nameNode);
+      if (!symbol) return;
+      const binding = {
+        local: nameNode.text,
+        imported,
+        symbol,
+        declaration: statement,
+        node,
+        typeOnly: typeOnly || clause.isTypeOnly,
+        module,
+        specifier
+      };
+      table.bindings.push(binding);
+      table.bySymbol.set(symbol, binding);
+    };
+    if (clause.name) add(clause, clause.name, "default", false);
+    const bindings = clause.namedBindings;
+    if (bindings && ts3.isNamespaceImport(bindings)) add(bindings, bindings.name, "*", false);
+    if (bindings && ts3.isNamedImports(bindings)) {
+      for (const element of bindings.elements) {
+        add(element, element.name, (element.propertyName ?? element.name).text, element.isTypeOnly);
+      }
+    }
+  }
+  return table;
+}
+function classifyImportUsage(binding, member, asJsxTag, framework, projectSafety) {
+  const name = binding.imported === "default" || binding.imported === "*" ? member ?? binding.imported : binding.imported;
+  const from = binding.specifier;
+  const mod = binding.module;
+  if (mod.kind === "project") {
+    if (mod.directive === "use client") {
+      return asJsxTag ? { cls: "client-reference", reason: `${binding.local} is a Client Component from ${from}` } : {
+        cls: "client-only",
+        reason: `${binding.local} comes from the "use client" module ${from}`
+      };
+    }
+    if (mod.directive === "use server")
+      return { cls: "server-action", reason: `${binding.local} is a Server Action` };
+    const safety = projectSafety(mod.file);
+    return safety.safe ? { cls: "neutral", reason: `${from} is server-safe` } : {
+      cls: "client-only",
+      reason: `${binding.local} from ${from} is client-only (${safety.reason ?? "uses client APIs"})`
+    };
+  }
+  const info = mod.info;
+  switch (info.kind) {
+    case "react": {
+      const special = REACT_SPECIAL[name];
+      if (special) return { cls: "client-only", special, reason: `React.${name}` };
+      if (REACT_NEUTRAL.has(name)) return { cls: "neutral", reason: `React.${name}` };
+      return { cls: "client-only", reason: `React.${name} only works in Client Components` };
+    }
+    case "react-dom":
+      return REACT_DOM_NEUTRAL.has(name) ? { cls: "neutral", reason: `ReactDOM.${name}` } : { cls: "client-only", reason: `ReactDOM.${name} only works in the browser` };
+    case "framework": {
+      const rule = framework.classifyModule(from);
+      if (!rule) return { cls: "client-only", reason: `${from} is not understood` };
+      if (rule.kind === "dynamic-import")
+        return { cls: "client-only", special: "dynamic", reason: `${from}` };
+      if (rule.kind === "css-in-js")
+        return { cls: "client-only", special: "css-in-js", reason: `${from}` };
+      const cls = rule.classify(name);
+      return { cls, reason: `${name} from ${from}` };
+    }
+    case "css-in-js":
+      return {
+        cls: "client-only",
+        special: "css-in-js",
+        reason: `${from} is a runtime CSS-in-JS library`
+      };
+    case "use-client-entry":
+      return asJsxTag ? { cls: "client-reference", reason: `${binding.local} is a Client Component from ${from}` } : {
+        cls: "client-only",
+        reason: `${binding.local} comes from the "use client" package ${from}`
+      };
+    case "client-list":
+      return {
+        cls: "client-only",
+        reason: `${from} is a client-only package${info.detail ? ` (${info.detail})` : ""}`
+      };
+    case "client-only-marker":
+      return { cls: "client-only", reason: `${from} is marked client-only` };
+    case "react-unknown":
+      return {
+        cls: "client-only",
+        reason: info.detail ?? `${from} depends on React and isn't known to be server-safe`
+      };
+    case "unresolved":
+      return {
+        cls: "client-only",
+        reason: `${from} could not be resolved${info.detail ? ` (${info.detail})` : ""}`
+      };
+    case "builtin":
+    case "server-only-marker":
+      return { cls: "server-only", reason: `${from} only works on the server` };
+    case "server-safe-list":
+    case "neutral":
+    case "json":
+    case "asset":
+    case "css-module":
+    case "stylesheet":
+      return { cls: "neutral", reason: `${from} is server-safe` };
+  }
+}
+
+// src/analysis/importers.ts
+import { ts as ts5 } from "ts-morph";
+
+// src/analysis/directives.ts
+import { ts as ts4 } from "ts-morph";
+function getModuleDirective(sf) {
+  for (const statement of sf.statements) {
+    if (!ts4.isExpressionStatement(statement) || !ts4.isStringLiteral(statement.expression)) break;
+    const text = statement.expression.text;
+    if (text === "use client" || text === "use server") return { directive: text, statement };
+  }
+  return { directive: void 0, statement: void 0 };
+}
+function hasUseServerBody(fn) {
+  const body = fn.body;
+  if (!body || !ts4.isBlock(body)) return false;
+  for (const statement of body.statements) {
+    if (!ts4.isExpressionStatement(statement) || !ts4.isStringLiteral(statement.expression)) break;
+    if (statement.expression.text === "use server") return true;
+  }
+  return false;
+}
+
+// src/analysis/importers.ts
+function isInTypePosition(node) {
+  let current = node;
+  while (current.parent) {
+    const parent = current.parent;
+    if (ts5.isTypeNode(parent) && !ts5.isExpressionWithTypeArguments(parent)) return true;
+    if (ts5.isTypeQueryNode(parent)) return true;
+    if (ts5.isStatement(parent) || ts5.isSourceFile(parent)) return false;
+    current = parent;
+  }
+  return false;
+}
+function isJsxTagPosition(id) {
+  let node = id;
+  if (ts5.isPropertyAccessExpression(node.parent) && node.parent.name === node) node = node.parent;
+  const parent = node.parent;
+  return (ts5.isJsxOpeningElement(parent) || ts5.isJsxSelfClosingElement(parent) || ts5.isJsxClosingElement(parent)) && parent.tagName === node;
+}
+function checkImporters(program, graph, file, components) {
+  const checker = program.getTypeChecker();
+  const actionUsage = /* @__PURE__ */ new Map();
+  let sawSpread = false;
+  const componentDecls = new Set(components.map(componentDeclarationNode));
+  const importers = /* @__PURE__ */ new Set();
+  const queue = [file];
+  const visited = /* @__PURE__ */ new Set([file]);
+  while (queue.length > 0) {
+    const target = queue.shift();
+    const edges = graph.importersOf(target).filter((e) => e.kind !== "type").sort((a, b) => a.from.localeCompare(b.from) || a.line - b.line);
+    for (const edge of edges) {
+      const importer = edge.from;
+      const rel2 = graph.rel(importer);
+      const node = graph.nodes.get(importer);
+      if (graph.isClient(importer)) {
+        const root = graph.clientRootOf(importer);
+        const via = root && root !== importer ? `, reached from ${graph.rel(root)}` : "";
+        return skip("imported-by-client", `imported by ${rel2} (client${via})`);
+      }
+      if (!node?.inProgram) {
+        return skip(
+          "imported-by-client",
+          `imported by ${rel2}, which is outside the TypeScript project, so its usage can't be verified`
+        );
+      }
+      if (edge.kind === "dynamic") {
+        return skip("dynamic-import", `loaded with import() by ${rel2}`);
+      }
+      importers.add(importer);
+      if (edge.kind === "reexport" && !visited.has(importer)) {
+        visited.add(importer);
+        queue.push(importer);
+      }
+      const sf = program.getSourceFile(importer);
+      if (!sf) {
+        return skip(
+          "imported-by-client",
+          `imported by ${rel2}, which couldn't be loaded to verify how it uses the component`
+        );
+      }
+      let misuse;
+      const recordActionProps = (tag) => {
+        let tagNode = tag;
+        if (ts5.isPropertyAccessExpression(tagNode.parent)) tagNode = tagNode.parent;
+        const element = tagNode.parent;
+        if (!ts5.isJsxOpeningElement(element) && !ts5.isJsxSelfClosingElement(element)) return;
+        for (const attr of element.attributes.properties) {
+          if (ts5.isJsxSpreadAttribute(attr)) {
+            sawSpread = true;
+            continue;
+          }
+          const name = attr.name.getText(sf);
+          const init = attr.initializer;
+          const expr = init && ts5.isJsxExpression(init) ? init.expression : void 0;
+          const isAction = expr !== void 0 && isServerActionReference(expr, checker);
+          actionUsage.set(name, (actionUsage.get(name) ?? true) && isAction);
+        }
+      };
+      const visit = (n) => {
+        if (misuse) return;
+        if (ts5.isIdentifier(n)) {
+          const symbol = checker.getSymbolAtLocation(n);
+          const resolved = symbol && symbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+          if (resolved?.declarations?.some((d) => componentDecls.has(d))) {
+            const p = n.parent;
+            const benign = ts5.isImportSpecifier(p) || ts5.isImportClause(p) || ts5.isExportSpecifier(p) || ts5.isNamespaceImport(p) || isJsxTagPosition(n) || isInTypePosition(n);
+            if (!benign) misuse = n;
+            if (isJsxTagPosition(n)) recordActionProps(n);
+          }
+          return;
+        }
+        ts5.forEachChild(n, visit);
+      };
+      visit(sf);
+      if (misuse) {
+        const { line } = lineCol(sf, misuse.getStart(sf));
+        return skip(
+          "unsupported-pattern",
+          `${misuse.text} is used as a value in ${rel2}:${line}; only <${misuse.text} /> usage can be verified`
+        );
+      }
+    }
+  }
+  const serverActionProps = /* @__PURE__ */ new Set();
+  if (!sawSpread) {
+    for (const [name, all] of actionUsage) if (all) serverActionProps.add(name);
+  }
+  return ok({ importers: [...importers], serverActionProps });
+}
+function isServerActionReference(expr, checker) {
+  let e = expr;
+  while (ts5.isParenthesizedExpression(e)) e = e.expression;
+  if (!ts5.isIdentifier(e) && !ts5.isPropertyAccessExpression(e)) return false;
+  const symbol = checker.getSymbolAtLocation(e);
+  const resolved = symbol && symbol.flags & ts5.SymbolFlags.Alias ? checker.getAliasedSymbol(symbol) : symbol;
+  const decl = resolved?.valueDeclaration ?? resolved?.declarations?.[0];
+  if (!decl) return false;
+  const sf = decl.getSourceFile();
+  if (sf.isDeclarationFile) return false;
+  if (getModuleDirective(sf).directive === "use server") return true;
+  if (ts5.isFunctionDeclaration(decl) || ts5.isFunctionExpression(decl) || ts5.isArrowFunction(decl)) {
+    return hasUseServerBody(decl);
+  }
+  if (ts5.isVariableDeclaration(decl) && decl.initializer) {
+    const init = decl.initializer;
+    if (ts5.isArrowFunction(init) || ts5.isFunctionExpression(init)) return hasUseServerBody(init);
+  }
+  return false;
+}
+
+// src/analysis/islands.ts
+import { ts as ts8 } from "ts-morph";
+
+// src/analysis/mongoose.ts
+import { ts as ts7 } from "ts-morph";
+
+// src/analysis/serializable.ts
+import { ts as ts6 } from "ts-morph";
+var OK = { ok: true };
+var fail = (reason) => ({ ok: false, reason });
+var BUILTIN_SERIALIZABLE = /* @__PURE__ */ new Set([
+  "Date",
+  "ArrayBuffer",
+  "Int8Array",
+  "Uint8Array",
+  "Uint8ClampedArray",
+  "Int16Array",
+  "Uint16Array",
+  "Int32Array",
+  "Uint32Array",
+  "Float16Array",
+  "Float32Array",
+  "Float64Array",
+  "BigInt64Array",
+  "BigUint64Array",
+  "FormData"
+]);
+var BUILTIN_CONTAINERS = /* @__PURE__ */ new Set([
+  "Map",
+  "ReadonlyMap",
+  "Set",
+  "ReadonlySet",
+  "Promise",
+  "PromiseLike",
+  "Array",
+  "ReadonlyArray",
+  "Iterable"
+]);
+var REACT_NODE_TYPES = /* @__PURE__ */ new Set([
+  "ReactElement",
+  "ReactPortal",
+  "Element",
+  "ReactNode",
+  "AwaitedReactNode",
+  "JSXElementConstructor"
+]);
+function isFromDeclarationFile(symbol, test) {
+  const decls = symbol?.declarations ?? [];
+  return decls.some((d) => test(d.getSourceFile().fileName)) && decls.every((d) => d.getSourceFile().isDeclarationFile);
+}
+var isLibFile = (f) => /\/lib\.[a-z0-9.]*\.d\.ts$/.test(f) || /\/@types\/node\//.test(f) || /\/undici-types\//.test(f);
+var isReactTypes = (f) => /\/@types\/react\//.test(f) || /\/react\/[^/]*\.d\.ts$/.test(f);
+function checkSerializable(checker, type, options = {}) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (t, depth) => {
+    if (depth > 40) return fail("is too deeply nested to verify");
+    const flags = t.flags;
+    const text = () => checker.typeToString(t);
+    if (flags & (ts6.TypeFlags.Any | ts6.TypeFlags.Unknown)) {
+      const unresolved = "intrinsicName" in t && t.intrinsicName === "error";
+      return fail(
+        unresolved ? `has the type \`${text()}\`, which couldn't be resolved (missing import or generated types?)` : `is \`${text()}\`, which can't be proven serializable`
+      );
+    }
+    if (flags & ts6.TypeFlags.Never) return fail("is `never`");
+    if (flags & (ts6.TypeFlags.StringLike | ts6.TypeFlags.NumberLike | ts6.TypeFlags.BooleanLike | ts6.TypeFlags.BigIntLike | ts6.TypeFlags.Null | ts6.TypeFlags.Undefined | ts6.TypeFlags.Void | ts6.TypeFlags.EnumLike)) {
+      return OK;
+    }
+    if (options.primitivesOnly)
+      return fail(`has the non-primitive type \`${text()}\` in an untyped file`);
+    if (t.aliasSymbol && REACT_NODE_TYPES.has(t.aliasSymbol.getName()) && isFromDeclarationFile(t.aliasSymbol, isReactTypes)) {
+      return OK;
+    }
+    if (flags & ts6.TypeFlags.UniqueESSymbol && isSymbolForDeclaration(t.getSymbol())) return OK;
+    if (flags & ts6.TypeFlags.ESSymbolLike)
+      return fail("is a symbol (only Symbol.for symbols are serializable)");
+    if (t.isUnion()) {
+      for (const member of t.types) {
+        const v = visit(member, depth + 1);
+        if (!v.ok) return v;
+      }
+      return OK;
+    }
+    if (t.isIntersection()) {
+      for (const member of t.types) {
+        const v = visit(member, depth + 1);
+        if (!v.ok) return v;
+      }
+      return OK;
+    }
+    if (flags & ts6.TypeFlags.TypeParameter) {
+      const constraint = checker.getBaseConstraintOfType(t);
+      return constraint && constraint !== t ? visit(constraint, depth + 1) : fail(`is the unconstrained type parameter \`${text()}\``);
+    }
+    if (!(flags & ts6.TypeFlags.Object) && !(flags & ts6.TypeFlags.NonPrimitive))
+      return fail(`has the type \`${text()}\``);
+    if (flags & ts6.TypeFlags.NonPrimitive)
+      return fail("is `object`, which can't be proven serializable");
+    if (seen.has(t)) return OK;
+    seen.add(t);
+    const symbol = t.getSymbol();
+    const aliasSymbol = t.aliasSymbol;
+    const name = symbol?.getName();
+    if (aliasSymbol && REACT_NODE_TYPES.has(aliasSymbol.getName()) && isFromDeclarationFile(aliasSymbol, isReactTypes) || name && REACT_NODE_TYPES.has(name) && isFromDeclarationFile(symbol, isReactTypes)) {
+      return OK;
+    }
+    if (name && BUILTIN_SERIALIZABLE.has(name) && isFromDeclarationFile(symbol, isLibFile))
+      return OK;
+    if (checker.isArrayType(t) || checker.isTupleType(t)) {
+      for (const arg of checker.getTypeArguments(t)) {
+        const v = visit(arg, depth + 1);
+        if (!v.ok) return fail(`contains an element that ${v.reason}`);
+      }
+      return OK;
+    }
+    if (name && BUILTIN_CONTAINERS.has(name) && isFromDeclarationFile(symbol, isLibFile)) {
+      const args = t.target ? checker.getTypeArguments(t) : [];
+      for (const arg of args) {
+        const v = visit(arg, depth + 1);
+        if (!v.ok) return fail(`contains a ${name} value that ${v.reason}`);
+      }
+      return OK;
+    }
+    if (t.getCallSignatures().length > 0 || t.getConstructSignatures().length > 0) {
+      return fail(`is a function (\`${text()}\`)`);
+    }
+    if (symbol && symbol.flags & ts6.SymbolFlags.Class)
+      return fail(`is an instance of the class ${name ?? text()}`);
+    if (symbol && isFromDeclarationFile(symbol, isLibFile) && !(symbol.flags & ts6.SymbolFlags.TypeLiteral) && name !== "__object") {
+      return fail(`is a built-in \`${name}\` object, which React can't serialize`);
+    }
+    if (symbol && symbol.declarations?.some((d) => ts6.isClassLike(d)))
+      return fail(`is an instance of the class ${name}`);
+    for (const prop of checker.getPropertiesOfType(t)) {
+      if (prop.flags & ts6.SymbolFlags.Method) return fail(`has the method \`${prop.getName()}\``);
+      const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+      const propType = decl ? checker.getTypeOfSymbolAtLocation(prop, decl) : checker.getTypeOfSymbol(prop);
+      const v = visit(propType, depth + 1);
+      if (!v.ok) return fail(`has a property \`${prop.getName()}\` that ${v.reason}`);
+    }
+    for (const info of checker.getIndexInfosOfType(t)) {
+      const v = visit(info.type, depth + 1);
+      if (!v.ok) return fail(`has index values that ${v.reason}`);
+    }
+    return OK;
+  };
+  return visit(type, 0);
+}
+function isSymbolForDeclaration(symbol) {
+  const decl = symbol?.valueDeclaration;
+  if (!decl || !ts6.isVariableDeclaration(decl) || !decl.initializer) return false;
+  const init = decl.initializer;
+  return ts6.isCallExpression(init) && ts6.isPropertyAccessExpression(init.expression) && ts6.isIdentifier(init.expression.expression) && init.expression.expression.text === "Symbol" && init.expression.name.text === "for";
+}
+function isCallableType(type) {
+  if (type.isUnion()) return type.types.some(isCallableType);
+  return type.getCallSignatures().length > 0;
+}
+
+// src/analysis/mongoose.ts
+var MONGO_TYPES_RE = /\/node_modules\/(?:\.pnpm\/[^/]+\/node_modules\/)?(bson|mongodb|mongoose)\//;
+function declaredInMongoPackage(symbol) {
+  return (symbol?.declarations ?? []).some((d) => MONGO_TYPES_RE.test(d.getSourceFile().fileName));
+}
+function isObjectIdType(type) {
+  const symbol = type.getSymbol() ?? type.aliasSymbol;
+  return symbol?.getName() === "ObjectId" && declaredInMongoPackage(symbol);
+}
+function isMongooseLike(checker, type) {
+  const seen = /* @__PURE__ */ new Set();
+  const visit = (t, depth) => {
+    if (depth > 6 || seen.has(t)) return false;
+    seen.add(t);
+    if (isObjectIdType(t)) return true;
+    if (t.isUnionOrIntersection()) return t.types.some((m) => visit(m, depth + 1));
+    if (!(t.flags & ts7.TypeFlags.Object)) return false;
+    const isDoc = t.getProperty("$isNew") !== void 0 && declaredInMongoPackage(t.getProperty("$isNew"));
+    if (isDoc) return true;
+    if (checker.isArrayType(t))
+      return checker.getTypeArguments(t).some((a) => visit(a, depth + 1));
+    for (const prop of checker.getPropertiesOfType(t).slice(0, 200)) {
+      const decl = prop.valueDeclaration ?? prop.declarations?.[0];
+      if (!decl || MONGO_TYPES_RE.test(decl.getSourceFile().fileName)) continue;
+      if (visit(checker.getTypeOfSymbolAtLocation(prop, decl), depth + 1)) return true;
+    }
+    return false;
+  };
+  return visit(type, 0);
+}
+function stripNullish(type) {
+  if (!type.isUnion()) return { type, nullable: false };
+  const rest = type.types.filter((t) => !(t.flags & (ts7.TypeFlags.Null | ts7.TypeFlags.Undefined)));
+  if (rest.length === type.types.length || rest.length !== 1 || !rest[0])
+    return { type, nullable: false };
+  return { type: rest[0], nullable: true };
+}
+function pickMongooseFields(checker, name, refs, printType) {
+  const root = { kind: "branch", fields: /* @__PURE__ */ new Map() };
+  for (const ref of refs) {
+    let node = ref;
+    const path10 = [];
+    let leafType;
+    for (; ; ) {
+      const parent = node.parent;
+      if (!ts7.isPropertyAccessExpression(parent) || parent.expression !== node) break;
+      if (parent.questionDotToken)
+        return { ok: false, reason: `uses optional chaining on \`${name}\`` };
+      path10.push(parent.name.text);
+      node = parent;
+      const type = checker.getTypeAtLocation(node);
+      const { type: inner2 } = stripNullish(type);
+      if (isObjectIdType(inner2) || checkSerializable(checker, type).ok) {
+        leafType = type;
+        break;
+      }
+    }
+    if (path10.length === 0) {
+      return {
+        ok: false,
+        reason: `uses \`${name}\` as a whole (spread, passed on, or iterated), so its fields can't be picked`
+      };
+    }
+    if (!leafType) {
+      return {
+        ok: false,
+        reason: `reads \`${name}.${path10.join(".")}\`, which isn't serializable even after picking fields`
+      };
+    }
+    const { type: inner, nullable } = stripNullish(leafType);
+    const objectId = isObjectIdType(inner);
+    if (objectId) {
+      const after = node.parent;
+      if (ts7.isPropertyAccessExpression(after) && after.expression === node && after.name.text !== "toString") {
+        return {
+          ok: false,
+          reason: `calls ObjectId.${after.name.text}() on \`${name}.${path10.join(".")}\`, which a string doesn't have`
+        };
+      }
+    }
+    let branch = root;
+    for (const [i, key] of path10.entries()) {
+      const last = i === path10.length - 1;
+      const existing = branch.fields.get(key);
+      if (last) {
+        if (existing?.kind === "branch")
+          return {
+            ok: false,
+            reason: `reads \`${name}.${path10.join(".")}\` both as a value and as an object`
+          };
+        if (!existing)
+          branch.fields.set(key, {
+            kind: "leaf",
+            source: `${name}.${path10.join(".")}`,
+            type: leafType,
+            objectId,
+            nullable
+          });
+      } else {
+        if (existing?.kind === "leaf")
+          return {
+            ok: false,
+            reason: `reads \`${name}.${path10.slice(0, i + 1).join(".")}\` both as a value and as an object`
+          };
+        if (!existing) {
+          const next = { kind: "branch", fields: /* @__PURE__ */ new Map() };
+          branch.fields.set(key, next);
+          branch = next;
+        } else {
+          branch = existing;
+        }
+      }
+    }
+  }
+  const render = (node) => {
+    const exprs = [];
+    const types = [];
+    for (const [key, child] of node.fields) {
+      const prop = /^[A-Za-z_$][\w$]*$/.test(key) ? key : JSON.stringify(key);
+      if (child.kind === "branch") {
+        const inner = render(child);
+        exprs.push(`${prop}: ${inner.expr}`);
+        types.push(`${prop}: ${inner.type}`);
+      } else if (child.objectId) {
+        exprs.push(
+          child.nullable ? `${prop}: ${child.source} == null ? ${child.source} : String(${child.source})` : `${prop}: String(${child.source})`
+        );
+        types.push(
+          `${prop}: ${child.nullable ? `string | ${printNullish(child.type)}` : "string"}`
+        );
+      } else {
+        exprs.push(`${prop}: ${child.source}`);
+        types.push(`${prop}: ${printType(child.type)}`);
+      }
+    }
+    return { expr: `{ ${exprs.join(", ")} }`, type: `{ ${types.join("; ")} }` };
+  };
+  const rendered = render(root);
+  return { ok: true, value: { serverExpr: rendered.expr, typeText: rendered.type } };
+}
+function printNullish(type) {
+  if (!type.isUnion()) return "null";
+  const parts = [];
+  if (type.types.some((t) => t.flags & ts7.TypeFlags.Null)) parts.push("null");
+  if (type.types.some((t) => t.flags & ts7.TypeFlags.Undefined)) parts.push("undefined");
+  return parts.join(" | ") || "null";
+}
+
+// src/analysis/islands.ts
+var REACT_SHARED_CONTEXT_HOOKS = ["useContext", "use"];
+var UnionFind = class {
+  parent = /* @__PURE__ */ new Map();
+  find(x) {
+    let p = this.parent.get(x) ?? x;
+    if (p !== x) {
+      p = this.find(p);
+      this.parent.set(x, p);
+    }
+    return p;
+  }
+  union(a, b) {
+    const ra = this.find(a);
+    const rb = this.find(b);
+    if (ra !== rb) this.parent.set(rb, ra);
+  }
+};
+function lowestCommonAncestor(nodes) {
+  const [first, ...rest] = nodes;
+  if (!first) return void 0;
+  let lca = first;
+  for (const node of rest) {
+    if (!lca) return void 0;
+    if (node.rootIndex !== lca.rootIndex) return void 0;
+    let a = lca;
+    let b = node;
+    while (a && b && a.depth > b.depth) a = a.parent;
+    while (a && b && b.depth > a.depth) b = b.parent;
+    while (a && b && a !== b) {
+      a = a.parent;
+      b = b.parent;
+    }
+    lca = a;
+  }
+  return lca;
+}
+function isAncestorOrSelf(ancestor, node) {
+  let current = node;
+  while (current) {
+    if (current === ancestor) return true;
+    current = current.parent;
+  }
+  return false;
+}
+function pascal(text) {
+  return text.split(/[^A-Za-z0-9]+/).filter(Boolean).map((part) => part[0]?.toUpperCase() + part.slice(1)).join("");
+}
+function islandBaseName(componentName, rootTag) {
+  return `${componentName}${pascal(rootTag) || "Island"}`;
+}
+function planComponent(ctx, facts, shape, component, options = {}) {
+  const { checker, sf } = ctx;
+  const fn = component.fn;
+  const body = fn.body;
+  if (!body) return skip("unsupported-pattern", `${component.name} has no body`, locOf(ctx, fn));
+  if (fn.parameters.length > 1) {
+    return skip(
+      "unsupported-pattern",
+      `${component.name} takes more than one parameter`,
+      locOf(ctx, fn)
+    );
+  }
+  const paramSymbols = /* @__PURE__ */ new Set();
+  const serverActionParams = /* @__PURE__ */ new Set();
+  for (const param of fn.parameters) {
+    for (const id of bindingIdentifiers(param.name)) {
+      const symbol = checker.getSymbolAtLocation(id);
+      if (symbol) paramSymbols.add(symbol);
+    }
+    if (ts8.isObjectBindingPattern(param.name)) {
+      for (const element of param.name.elements) {
+        const propName = element.propertyName ?? element.name;
+        if (!ts8.isIdentifier(propName) || !ts8.isIdentifier(element.name)) continue;
+        if (!options.serverActionProps?.has(propName.text)) continue;
+        const symbol = checker.getSymbolAtLocation(element.name);
+        if (symbol) serverActionParams.add(symbol);
+      }
+    }
+  }
+  const units = [];
+  const renderRoots = [];
+  const earlyReturnConditions = [];
+  const symbolToUnit = /* @__PURE__ */ new Map();
+  const newUnit = (node, kind) => {
+    const unit = {
+      index: units.length,
+      node,
+      kind,
+      declares: /* @__PURE__ */ new Set(),
+      localDeps: /* @__PURE__ */ new Set(),
+      moduleDeps: /* @__PURE__ */ new Set(),
+      markers: [],
+      client: false
+    };
+    units.push(unit);
+    return unit;
+  };
+  if (!ts8.isBlock(body)) {
+    renderRoots.push(stripParens(body));
+  } else {
+    const statements = body.statements;
+    let sawReturn = false;
+    for (let i = 0; i < statements.length; i++) {
+      const statement = statements[i];
+      if (ts8.isEmptyStatement(statement)) continue;
+      if (sawReturn)
+        return skip(
+          "unsupported-pattern",
+          "has statements after the final return",
+          locOf(ctx, statement)
+        );
+      if (ts8.isReturnStatement(statement)) {
+        if (!statement.expression)
+          return skip("unsupported-pattern", "returns nothing", locOf(ctx, statement));
+        renderRoots.push(stripParens(statement.expression));
+        sawReturn = true;
+        continue;
+      }
+      if (ts8.isIfStatement(statement)) {
+        const then = statement.thenStatement;
+        const ret = ts8.isReturnStatement(then) ? then : ts8.isBlock(then) && then.statements.length === 1 && ts8.isReturnStatement(then.statements[0]) ? then.statements[0] : void 0;
+        if (!ret || statement.elseStatement || !ret.expression) {
+          return skip(
+            "unsupported-pattern",
+            "has an `if` statement other than a simple early return",
+            locOf(ctx, statement)
+          );
+        }
+        const unit = newUnit(statement, "early-return");
+        unit.returned = stripParens(ret.expression);
+        renderRoots.push(unit.returned);
+        earlyReturnConditions.push(statement.expression);
+        continue;
+      }
+      if (ts8.isVariableStatement(statement)) {
+        if (!(statement.declarationList.flags & ts8.NodeFlags.Const)) {
+          return skip(
+            "unsupported-pattern",
+            "declares a `let`/`var` in the component body",
+            locOf(ctx, statement)
+          );
+        }
+        const unit = newUnit(statement, "var");
+        for (const decl of statement.declarationList.declarations) {
+          for (const id of bindingIdentifiers(decl.name)) {
+            const symbol = checker.getSymbolAtLocation(id);
+            if (symbol) {
+              unit.declares.add(symbol);
+              symbolToUnit.set(symbol, unit);
+            }
+          }
+        }
+        continue;
+      }
+      if (ts8.isFunctionDeclaration(statement) && statement.name) {
+        const unit = newUnit(statement, "function");
+        const symbol = checker.getSymbolAtLocation(statement.name);
+        if (symbol) {
+          unit.declares.add(symbol);
+          symbolToUnit.set(symbol, unit);
+        }
+        continue;
+      }
+      if (ts8.isExpressionStatement(statement)) {
+        const expr = stripParens(statement.expression);
+        if (ts8.isCallExpression(expr) && facts.isHookCall(expr)) {
+          newUnit(statement, "hook-call");
+          continue;
+        }
+        return skip(
+          "unsupported-pattern",
+          "has a statement with side effects in the component body (only declarations, hook calls and early returns are supported)",
+          locOf(ctx, statement)
+        );
+      }
+      return skip(
+        "unsupported-pattern",
+        `has a \`${ts8.SyntaxKind[statement.kind]}\` in the component body`,
+        locOf(ctx, statement)
+      );
+    }
+    if (renderRoots.length === 0)
+      return skip("unsupported-pattern", `${component.name} never returns JSX`, locOf(ctx, fn));
+  }
+  const moduleDeclByStatement = /* @__PURE__ */ new Map();
+  for (const decl of shape.moduleDecls) moduleDeclByStatement.set(decl.statement, decl);
+  const componentStatements = new Set(shape.components.map((c) => c.statement));
+  const topLevelStatement = (node) => {
+    let current = node;
+    while (current && current.parent !== sf) current = current.parent;
+    return current;
+  };
+  const originOf = (id) => {
+    const info = facts.classifyRef(id);
+    switch (info.kind) {
+      case "import":
+        return { kind: "import", binding: info.binding, usage: info.usage };
+      case "browser-global":
+        return { kind: "browser-global", name: info.name };
+      case "global":
+        return { kind: "global" };
+      case "unknown":
+        return { kind: "unknown" };
+      case "file": {
+        const { symbol, declaration } = info;
+        if (paramSymbols.has(symbol)) return { kind: "param", symbol };
+        const unit = symbolToUnit.get(symbol);
+        if (unit) return { kind: "local", symbol, unit };
+        if (containsRange(fn, declaration)) return { kind: "inner", symbol, declaration };
+        const top = topLevelStatement(declaration);
+        if (top && componentStatements.has(top)) {
+          const target = shape.components.find((c) => c.statement === top);
+          if (target && componentDeclarationNode(target) === declaration)
+            return { kind: "component", symbol, component: target };
+          return { kind: "inner", symbol, declaration };
+        }
+        const decl = top ? moduleDeclByStatement.get(top) : void 0;
+        if (decl) return { kind: "module", symbol, decl };
+        return { kind: "unknown" };
+      }
+    }
+  };
+  const clientModuleDecls = /* @__PURE__ */ new Set();
+  const moduleDeclDeps = /* @__PURE__ */ new Map();
+  for (const decl of shape.moduleDecls) {
+    if (decl.kind === "type") continue;
+    const deps = /* @__PURE__ */ new Set();
+    forEachValueRef(decl.statement, (id) => {
+      const origin = originOf(id);
+      if (origin.kind === "module" && origin.decl !== decl) deps.add(origin.decl);
+    });
+    moduleDeclDeps.set(decl, deps);
+    if (facts.scanMarkers(decl.statement).length > 0) clientModuleDecls.add(decl);
+  }
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const [decl, deps] of moduleDeclDeps) {
+      if (clientModuleDecls.has(decl)) continue;
+      if ([...deps].some((d) => clientModuleDecls.has(d))) {
+        clientModuleDecls.add(decl);
+        changed = true;
+      }
+    }
+  }
+  let seenEarlyReturn = false;
+  for (const unit of units) {
+    if (unit.kind === "early-return") seenEarlyReturn = true;
+    const scanned = unit.kind === "early-return" ? unit.node.expression : unit.node;
+    unit.markers = facts.scanMarkers(scanned);
+    forEachValueRef(scanned, (id) => {
+      const origin = originOf(id);
+      if (origin.kind === "local" && origin.unit !== unit) unit.localDeps.add(origin.unit);
+      if (origin.kind === "module") unit.moduleDeps.add(origin.decl);
+      if (origin.kind === "component")
+        unit.markers.push({
+          kind: "client-import",
+          node: id,
+          detail: origin.component === component ? "recursive component reference" : `component ${id.text} used as a value`
+        });
+    });
+    for (const marker of unit.markers) {
+      if (marker.kind !== "hook") continue;
+      if (unit.kind === "early-return") {
+        return skip(
+          "conditional-hooks-or-returns",
+          `calls ${marker.detail} inside an early-return condition`,
+          locOf(ctx, marker.node)
+        );
+      }
+      if (seenEarlyReturn) {
+        return skip(
+          "conditional-hooks-or-returns",
+          `calls ${marker.detail} after an early return`,
+          locOf(ctx, marker.node)
+        );
+      }
+      const conditional = conditionalAncestor(marker.node, unit.node);
+      if (conditional) {
+        return skip(
+          "conditional-hooks-or-returns",
+          `calls ${marker.detail} ${conditional}`,
+          locOf(ctx, marker.node)
+        );
+      }
+    }
+  }
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const unit of units) {
+      if (unit.client) continue;
+      if (unit.markers.length > 0 || [...unit.localDeps].some((d) => d.client) || [...unit.moduleDeps].some((d) => clientModuleDecls.has(d))) {
+        unit.client = true;
+        changed = true;
+      }
+    }
+  }
+  for (const unit of units) {
+    if (unit.kind === "early-return" && unit.client) {
+      return skip(
+        "conditional-hooks-or-returns",
+        "returns early based on client-only state, so the server can't decide what to render",
+        locOf(ctx, unit.node)
+      );
+    }
+  }
+  const jnodes = [];
+  const jnodeOf = /* @__PURE__ */ new Map();
+  const topJNodes = renderRoots.map(() => []);
+  const build = (node, parent, rootIndex, fns) => {
+    if (isJsxElementLike(node)) {
+      const j = {
+        id: jnodes.length,
+        node,
+        parent,
+        children: [],
+        rootIndex,
+        fnBetween: fns,
+        depth: parent ? parent.depth + 1 : 0
+      };
+      jnodes.push(j);
+      jnodeOf.set(node, j);
+      if (parent) parent.children.push(j);
+      else topJNodes[rootIndex]?.push(j);
+      const inner = (n) => build(n, j, rootIndex, []);
+      if (ts8.isJsxElement(node)) {
+        ts8.forEachChild(node.openingElement, inner);
+        node.children.forEach(inner);
+      } else if (ts8.isJsxSelfClosingElement(node)) {
+        ts8.forEachChild(node, inner);
+      } else {
+        node.children.forEach(inner);
+      }
+      return;
+    }
+    const nextFns = ts8.isFunctionLike(node) ? [...fns, node] : fns;
+    ts8.forEachChild(node, (c) => build(c, parent, rootIndex, nextFns));
+  };
+  renderRoots.forEach((root, i) => build(root, void 0, i, []));
+  const isNestedJsx = (self) => (n) => n !== self && isJsxElementLike(n);
+  for (const root of renderRoots) {
+    for (const marker of facts.scanMarkers(root)) {
+      if (marker.kind === "hook") {
+        return skip(
+          "conditional-hooks-or-returns",
+          `calls ${marker.detail} inside the returned JSX`,
+          locOf(ctx, marker.node)
+        );
+      }
+    }
+  }
+  for (const j of jnodes) {
+    if (ts8.isJsxFragment(j.node)) continue;
+    const tag = ts8.isJsxElement(j.node) ? j.node.openingElement.tagName : j.node.tagName;
+    if (isIntrinsicTagName(tag)) continue;
+    if (ts8.isPropertyAccessExpression(tag) && (tag.name.text === "Provider" || tag.name.text === "Consumer")) {
+      return skip("context-provider", `renders <${tag.getText(sf)}>`, locOf(ctx, tag));
+    }
+    const tagType = checker.getTypeAtLocation(tag);
+    if (tagType.getProperty("Provider") && tagType.getProperty("Consumer")) {
+      return skip(
+        "context-provider",
+        `renders the context <${tag.getText(sf)}> as a provider`,
+        locOf(ctx, tag)
+      );
+    }
+  }
+  const anchors = [];
+  const isServerActionRef = (expr) => {
+    const e = stripParens(expr);
+    if (!ts8.isIdentifier(e)) return false;
+    const origin = originOf(e);
+    if (origin.kind === "import") return origin.usage.cls === "server-action";
+    if (origin.kind === "param") return serverActionParams.has(origin.symbol);
+    if (origin.kind === "module" && origin.decl.kind === "function") {
+      return ts8.isFunctionDeclaration(origin.decl.statement) && hasUseServerBody(origin.decl.statement);
+    }
+    return false;
+  };
+  for (const j of jnodes) {
+    const reasons = [];
+    const refs = [];
+    const stop = isNestedJsx(j.node);
+    forEachValueRef(j.node, (id) => refs.push(id), stop);
+    let tagClass = "fragment";
+    let attributes;
+    if (!ts8.isJsxFragment(j.node)) {
+      const tag = ts8.isJsxElement(j.node) ? j.node.openingElement.tagName : j.node.tagName;
+      attributes = ts8.isJsxElement(j.node) ? j.node.openingElement.attributes : j.node.attributes;
+      if (isIntrinsicTagName(tag)) tagClass = "intrinsic";
+      else {
+        let head = tag;
+        while (ts8.isPropertyAccessExpression(head)) head = head.expression;
+        const origin = ts8.isIdentifier(head) ? originOf(head) : { kind: "unknown" };
+        if (origin.kind === "import") {
+          tagClass = origin.usage.cls === "client-reference" ? "client-reference" : origin.usage.cls === "neutral" ? "server" : "client";
+          if (tagClass === "client") reasons.push(origin.usage.reason);
+        } else if (origin.kind === "param" || origin.kind === "local" || origin.kind === "inner") {
+          tagClass = "server";
+        } else if (origin.kind === "module") {
+          tagClass = clientModuleDecls.has(origin.decl) ? "client" : "server";
+          if (tagClass === "client")
+            reasons.push(`<${tag.getText(sf)}> is built from client-only code`);
+        } else if (origin.kind === "component") {
+          if (origin.component === component) {
+            return skip(
+              "unsupported-pattern",
+              `${component.name} renders itself recursively`,
+              locOf(ctx, tag)
+            );
+          }
+          tagClass = options.wholesale?.has(origin.component) ? "client-reference" : "server";
+        } else {
+          tagClass = "client";
+          reasons.push(`<${tag.getText(sf)}> can't be proven server-safe`);
+        }
+      }
+      if (tagClass === "intrinsic" && ts8.isIdentifier(tag) && tag.text === "style" && attributes.properties.some((p) => ts8.isJsxAttribute(p) && p.name.getText(sf) === "jsx")) {
+        return skip("css-in-js-runtime", "uses <style jsx> (styled-jsx)", locOf(ctx, tag));
+      }
+      for (const prop of attributes.properties) {
+        if (ts8.isJsxSpreadAttribute(prop)) {
+          const type = checker.getTypeAtLocation(prop.expression);
+          const risky = checker.getPropertiesOfType(type).find(
+            (p) => /^on[A-Z]/.test(p.getName()) || p.getName() === "ref" || isCallableType(checker.getTypeOfSymbolAtLocation(p, prop))
+          );
+          if (risky) reasons.push(`spreads a value that can carry \`${risky.getName()}\``);
+          else if (tagClass === "client-reference" && !checkSerializable(checker, type, { primitivesOnly: ctx.isJs }).ok) {
+            reasons.push("spreads non-serializable props into a Client Component");
+          }
+          continue;
+        }
+        const name = prop.name.getText(sf);
+        if (/^on[A-Z]/.test(name) || name === "ref") {
+          reasons.push(`has ${name}`);
+          continue;
+        }
+        const init = prop.initializer;
+        if (init && ts8.isJsxExpression(init) && init.expression) {
+          const expr = init.expression;
+          const type = checker.getTypeAtLocation(expr);
+          if (isCallableType(type)) {
+            const unwrapped = stripParens(expr);
+            if ((ts8.isArrowFunction(unwrapped) || ts8.isFunctionExpression(unwrapped)) && containsJsxNode(unwrapped)) {
+              return skip(
+                "render-prop",
+                `passes a render function to \`${name}\``,
+                locOf(ctx, prop)
+              );
+            }
+            const actionOk = isServerActionRef(expr) && (tagClass !== "intrinsic" || name === "action" || name === "formAction");
+            if (!actionOk) reasons.push(`passes a function to \`${name}\``);
+          } else if (tagClass === "client-reference") {
+            const verdict = checkSerializable(checker, type, { primitivesOnly: ctx.isJs });
+            if (!verdict.ok)
+              reasons.push(`passes a non-serializable \`${name}\` to a Client Component`);
+          }
+        }
+      }
+    }
+    const children = ts8.isJsxSelfClosingElement(j.node) ? [] : j.node.children;
+    for (const child of children) {
+      if (!ts8.isJsxExpression(child) || !child.expression) continue;
+      const type = checker.getTypeAtLocation(child.expression);
+      if (isCallableType(type))
+        return skip("render-prop", "uses a function as a child (render prop)", locOf(ctx, child));
+      if (tagClass === "client-reference") {
+        const verdict = checkSerializable(checker, type, { primitivesOnly: ctx.isJs });
+        if (!verdict.ok) reasons.push("passes non-serializable children to a Client Component");
+      }
+    }
+    for (const id of refs) {
+      const origin = originOf(id);
+      if (origin.kind === "local" && origin.unit.client) reasons.push(`reads ${id.text}`);
+      else if (origin.kind === "module" && clientModuleDecls.has(origin.decl))
+        reasons.push(`uses ${id.text}`);
+      else if (origin.kind === "import" && origin.usage.cls === "client-only" && !isTagRef(id))
+        reasons.push(origin.usage.reason);
+      else if (origin.kind === "browser-global") reasons.push(`uses ${origin.name}`);
+      else if (origin.kind === "unknown" && !isTagRef(id))
+        reasons.push(`uses ${id.text}, which can't be resolved`);
+    }
+    for (const marker of facts.scanMarkers(j.node, stop)) {
+      if (marker.kind === "nondeterministic") reasons.push(`calls ${marker.detail}`);
+    }
+    if (reasons.length > 0) anchors.push({ j, reasons, refs });
+  }
+  for (const root of renderRoots) {
+    if (isJsxElementLike(root)) continue;
+    let problem;
+    forEachValueRef(
+      root,
+      (id) => {
+        if (problem) return;
+        const origin = originOf(id);
+        if (origin.kind === "local" && origin.unit.client || origin.kind === "browser-global")
+          problem = id;
+      },
+      (n) => isJsxElementLike(n)
+    );
+    if (problem) {
+      return skip(
+        "state-spans-component",
+        `the returned expression itself reads client-only \`${problem.text}\``,
+        locOf(ctx, problem)
+      );
+    }
+  }
+  const closureOf = (refs) => {
+    const out = /* @__PURE__ */ new Set();
+    const stack = [];
+    for (const id of refs) {
+      const origin = originOf(id);
+      if (origin.kind === "local" && !out.has(origin.unit)) {
+        out.add(origin.unit);
+        stack.push(origin.unit);
+      }
+    }
+    while (stack.length > 0) {
+      const unit = stack.pop();
+      for (const dep of unit.localDeps) {
+        if (!out.has(dep)) {
+          out.add(dep);
+          stack.push(dep);
+        }
+      }
+    }
+    return out;
+  };
+  const clientUnits = units.filter((u) => u.client);
+  const totalJsx = jnodes.length;
+  if (anchors.length === 0) {
+    if (clientUnits.length === 0 && clientModuleDecls.size === 0) {
+      return skip(
+        "no-islands",
+        `${component.name} uses no client-only features; removing "use client" may be enough (the tool never removes it automatically)`
+      );
+    }
+    const first = clientUnits[0];
+    return skip(
+      "unsupported-pattern",
+      first ? `client-only code at line ${locOf(ctx, first.node).line} isn't connected to any rendered element` : "client-only helpers aren't connected to any rendered element",
+      first ? locOf(ctx, first.node) : void 0
+    );
+  }
+  const uf = new UnionFind();
+  const unitOwner = /* @__PURE__ */ new Map();
+  anchors.forEach((anchor, i) => {
+    for (const unit of closureOf(anchor.refs)) {
+      if (!unit.client) continue;
+      const owner = unitOwner.get(unit);
+      if (owner === void 0) unitOwner.set(unit, i);
+      else uf.union(owner, i);
+    }
+  });
+  const groupsByRoot = /* @__PURE__ */ new Map();
+  anchors.forEach((anchor, i) => {
+    const key = uf.find(i);
+    const list = groupsByRoot.get(key) ?? [];
+    list.push(anchor);
+    groupsByRoot.set(key, list);
+  });
+  const mappedRoot = (root, perItemSafe) => {
+    let current = root;
+    while (current) {
+      const opaque = current.fnBetween.find((f) => !mapCallOf(f));
+      if (opaque) {
+        return skip(
+          "render-prop",
+          "an interactive element sits inside a callback other than .map()",
+          locOf(ctx, current.node)
+        );
+      }
+      if (current.fnBetween.some((f) => mapCallOf(f))) {
+        if (perItemSafe) return ok(current);
+        const container = current.parent;
+        if (!container) {
+          return skip(
+            "state-spans-component",
+            "state shared by every list item is used by the list itself, which is the returned element",
+            locOf(ctx, current.node)
+          );
+        }
+        root = container;
+      }
+      current = current.parent;
+    }
+    return ok(root);
+  };
+  const sharedContextHooks = /* @__PURE__ */ new Set([
+    ...REACT_SHARED_CONTEXT_HOOKS,
+    ...ctx.framework.sharedContextHooks
+  ]);
+  const hasComponentHooks = (groupAnchors) => [...closureOf(groupAnchors.flatMap((a) => a.refs))].some(
+    (u) => u.markers.some(
+      (m) => m.kind === "hook" && !sharedContextHooks.has(m.detail.replace(/\(\)$/, ""))
+    )
+  );
+  let groups = [];
+  for (const groupAnchors of groupsByRoot.values()) {
+    const lca = lowestCommonAncestor(groupAnchors.map((a) => a.j));
+    if (!lca) {
+      return skip(
+        "state-spans-component",
+        "the same client state is used in different returned trees",
+        locOf(ctx, groupAnchors[0]?.j.node ?? fn)
+      );
+    }
+    const mapped = mappedRoot(lca, !hasComponentHooks(groupAnchors));
+    if (!mapped.ok) return mapped;
+    groups.push({ anchors: groupAnchors, root: mapped.value, extra: /* @__PURE__ */ new Set() });
+  }
+  const unitClosure = (start) => {
+    const out = /* @__PURE__ */ new Set();
+    const stack = [...start];
+    while (stack.length > 0) {
+      const unit = stack.pop();
+      if (out.has(unit)) continue;
+      out.add(unit);
+      stack.push(...unit.localDeps);
+    }
+    return out;
+  };
+  const unitHasOwnHooks = (u) => u.markers.some(
+    (m) => m.kind === "hook" && !sharedContextHooks.has(m.detail.replace(/\(\)$/, ""))
+  );
+  const groupHasHooks = (g) => hasComponentHooks(g.anchors) || [...unitClosure(g.extra)].some(unitHasOwnHooks);
+  const unitsOfGroup = (group) => {
+    const refs = [];
+    forEachValueRef(group.root.node, (id) => refs.push(id));
+    const units2 = closureOf(refs);
+    for (const unit of unitClosure(group.extra)) units2.add(unit);
+    return units2;
+  };
+  const attachUnreadClientUnits = () => {
+    let changed = false;
+    for (const unit of units) {
+      if (!unit.client || unit.kind === "early-return") continue;
+      const owned = groups.map((g) => unitsOfGroup(g));
+      if (owned.some((set) => set.has(unit))) continue;
+      const deps = unitClosure(unit.localDeps);
+      const owners = groups.filter((_, i) => [...deps].some((d) => d.client && owned[i]?.has(d)));
+      const [first, ...rest] = owners;
+      if (!first) continue;
+      if (rest.length > 0) {
+        const lca = lowestCommonAncestor(owners.map((g) => g.root));
+        if (!lca)
+          return skip(
+            "state-spans-component",
+            "client state is shared across returned trees",
+            locOf(ctx, unit.node)
+          );
+        const merged = [...owners.flatMap((g) => g.anchors)];
+        const mapped = mappedRoot(lca, !owners.some(groupHasHooks));
+        if (!mapped.ok) return mapped;
+        first.anchors = merged;
+        first.root = mapped.value;
+        for (const other of rest) other.extra.forEach((u) => first.extra.add(u));
+        groups = groups.filter((g) => !rest.includes(g));
+      }
+      first.extra.add(unit);
+      if (unitHasOwnHooks(unit)) {
+        const hoisted = mappedRoot(first.root, false);
+        if (!hoisted.ok) return hoisted;
+        first.root = hoisted.value;
+      }
+      changed = true;
+    }
+    return ok(changed);
+  };
+  for (let iteration = 0; iteration < 100; iteration++) {
+    const attached = attachUnreadClientUnits();
+    if (!attached.ok) return attached;
+    let changed = attached.value;
+    outer: for (const a of groups) {
+      for (const b of groups) {
+        if (a === b) continue;
+        if (isAncestorOrSelf(a.root, b.root)) {
+          a.anchors.push(...b.anchors);
+          b.extra.forEach((u) => a.extra.add(u));
+          groups = groups.filter((g) => g !== b);
+          changed = true;
+          break outer;
+        }
+      }
+    }
+    if (changed) continue;
+    const owner = /* @__PURE__ */ new Map();
+    for (const group of groups) {
+      for (const unit of unitsOfGroup(group)) {
+        if (!unit.client) continue;
+        const other = owner.get(unit);
+        if (other && other !== group) {
+          const lca = lowestCommonAncestor([other.root, group.root]);
+          if (!lca)
+            return skip(
+              "state-spans-component",
+              "client state is shared across returned trees",
+              locOf(ctx, unit.node)
+            );
+          const mapped = mappedRoot(lca, !(groupHasHooks(other) || groupHasHooks(group)));
+          if (!mapped.ok) return mapped;
+          other.anchors.push(...group.anchors);
+          group.extra.forEach((u) => other.extra.add(u));
+          other.root = mapped.value;
+          groups = groups.filter((g) => g !== group);
+          changed = true;
+          break;
+        }
+        owner.set(unit, group);
+      }
+      if (changed) break;
+    }
+    if (changed) continue;
+    for (const group of groups) {
+      const islandUnits = unitsOfGroup(group);
+      const clientDeclared = /* @__PURE__ */ new Set();
+      for (const unit of islandUnits)
+        if (unit.client) unit.declares.forEach((s) => clientDeclared.add(s));
+      let escape;
+      const check = (scope) => forEachValueRef(scope, (id) => {
+        if (escape) return;
+        const symbol = symbolOfRef(checker, id);
+        if (!symbol || !clientDeclared.has(symbol)) return;
+        if (containsRange(group.root.node, id)) return;
+        escape = { node: id, j: enclosingJNode(id, jnodeOf) };
+      });
+      for (const root of renderRoots) check(root);
+      for (const unit of units) if (!islandUnits.has(unit)) check(unit.node);
+      if (escape) {
+        if (!escape.j) {
+          return skip(
+            "state-spans-component",
+            `client-only \`${escape.node.text}\` is read outside the interactive part`,
+            locOf(ctx, escape.node)
+          );
+        }
+        const lca = lowestCommonAncestor([group.root, escape.j]);
+        if (!lca)
+          return skip(
+            "state-spans-component",
+            `client-only \`${escape.node.text}\` is read in another returned tree`,
+            locOf(ctx, escape.node)
+          );
+        const mapped = mappedRoot(lca, !groupHasHooks(group));
+        if (!mapped.ok) return mapped;
+        group.root = mapped.value;
+        changed = true;
+        break;
+      }
+    }
+    if (!changed) break;
+  }
+  for (const group of groups) {
+    if (!group.root.parent) {
+      const single = group.anchors.length === 1 && group.anchors[0]?.j === group.root;
+      if (single) {
+        return skip(
+          "fully-interactive",
+          `the root <${tagNameText(sf, group.root.node)}> itself is interactive (${group.anchors[0]?.reasons[0] ?? "client-only"}), so nothing would stay on the server`,
+          locOf(ctx, group.root.node)
+        );
+      }
+      return skip(
+        "state-spans-component",
+        `client state is used across the whole returned tree (${describeAnchors(sf, group.anchors)})`,
+        locOf(ctx, group.root.node)
+      );
+    }
+  }
+  const assigned = /* @__PURE__ */ new Map();
+  for (const group of groups)
+    for (const unit of unitsOfGroup(group)) if (unit.client) assigned.set(unit, group);
+  for (const unit of clientUnits) {
+    if (unit.kind === "early-return") continue;
+    if (!assigned.has(unit)) {
+      return skip(
+        "unsupported-pattern",
+        `client-only code at line ${locOf(ctx, unit.node).line} isn't connected to any rendered element; moving it would change when it runs`,
+        locOf(ctx, unit.node)
+      );
+    }
+  }
+  groups.sort((a, b) => a.root.node.getStart(sf) - b.root.node.getStart(sf));
+  const islands = [];
+  const copiedUnits = /* @__PURE__ */ new Set();
+  const anchorNodes = new Set(anchors.map((a) => a.j));
+  const subtreeOf = (j) => jnodes.filter((other) => isAncestorOrSelf(j, other));
+  const isStaticSubtree = (j) => {
+    if (subtreeOf(j).some((n) => anchorNodes.has(n))) return false;
+    if (facts.scanMarkers(j.node).length > 0) return false;
+    let clientRead = false;
+    forEachValueRef(j.node, (id) => {
+      if (clientRead) return;
+      const origin = originOf(id);
+      if (origin.kind === "local" && origin.unit.client || origin.kind === "module" && clientModuleDecls.has(origin.decl) || origin.kind === "import" && origin.usage.cls !== "neutral" && !(origin.usage.cls === "client-reference" && isTagRef(id)) || origin.kind === "browser-global" || origin.kind === "unknown" || origin.kind === "component" && !isTagRef(id)) {
+        clientRead = true;
+      }
+    });
+    return !clientRead;
+  };
+  const isNonTrivial = (j) => {
+    if (subtreeOf(j).length > 1) return true;
+    let importedCall = false;
+    const visit = (n) => {
+      if (importedCall) return;
+      if (ts8.isCallExpression(n)) {
+        let callee = n.expression;
+        while (ts8.isPropertyAccessExpression(callee)) callee = callee.expression;
+        if (ts8.isIdentifier(callee) && originOf(callee).kind === "import") importedCall = true;
+      }
+      ts8.forEachChild(n, visit);
+    };
+    visit(j.node);
+    return importedCall;
+  };
+  const findSlots = (root) => {
+    const found = [];
+    const visit = (j) => {
+      for (const child of j.children) {
+        const direct = child.fnBetween.length === 0 && child.node.parent === j.node;
+        if (!direct) continue;
+        if (isStaticSubtree(child)) {
+          if (isNonTrivial(child)) found.push(child);
+          continue;
+        }
+        visit(child);
+      }
+    };
+    visit(root);
+    return found;
+  };
+  for (const group of groups) {
+    const rootNode = group.root.node;
+    const rootTag = tagNameText(sf, rootNode);
+    const islandUnits = new Set([...unitsOfGroup(group)].filter((u) => u.client));
+    const props = /* @__PURE__ */ new Map();
+    const valueImports = /* @__PURE__ */ new Set();
+    const moduleDecls = /* @__PURE__ */ new Set();
+    let keyAttr;
+    if (!ts8.isJsxFragment(rootNode) && group.root.fnBetween.some((f) => mapCallOf(f))) {
+      const attrs = ts8.isJsxElement(rootNode) ? rootNode.openingElement.attributes : rootNode.attributes;
+      keyAttr = attrs.properties.find(
+        (p) => ts8.isJsxAttribute(p) && p.name.getText(sf) === "key"
+      );
+    }
+    const slotNodes = findSlots(group.root);
+    const inSlot = (node) => slotNodes.some((slot) => containsRange(slot.node, node));
+    const inIsland = (node) => containsRange(rootNode, node) && !(keyAttr && containsRange(keyAttr, node)) && !inSlot(node) || [...islandUnits].some((u) => containsRange(u.node, node));
+    const pending = [rootNode, ...[...islandUnits].map((u) => u.node)];
+    const visitedNodes = /* @__PURE__ */ new Set();
+    const moduleLevelScopes = /* @__PURE__ */ new Set();
+    const addProp = (id, symbol) => {
+      const name = symbol.getName();
+      const existing = props.get(name);
+      if (existing) {
+        if (existing.symbol !== symbol) {
+          return {
+            code: "unsupported-pattern",
+            message: `two different values named \`${name}\` would cross the boundary`,
+            location: locOf(ctx, id)
+          };
+        }
+        if (containsRange(rootNode, id) && !containsRange(rootNode, existing.refNode))
+          existing.refNode = id;
+        return void 0;
+      }
+      if (name === "key" || name === "ref") {
+        return {
+          code: "unsupported-pattern",
+          message: `a value named \`${name}\` can't be passed as a prop`,
+          location: locOf(ctx, id)
+        };
+      }
+      props.set(name, { name, symbol, type: checker.getTypeAtLocation(id), refNode: id });
+      return void 0;
+    };
+    while (pending.length > 0) {
+      const scope = pending.pop();
+      if (visitedNodes.has(scope)) continue;
+      visitedNodes.add(scope);
+      let failure;
+      forEachValueRef(scope, (id) => {
+        if (failure) return;
+        if (keyAttr && containsRange(keyAttr, id)) return;
+        if (inSlot(id)) return;
+        const origin = originOf(id);
+        switch (origin.kind) {
+          case "param":
+            failure = addProp(id, origin.symbol);
+            return;
+          case "local": {
+            const unit = origin.unit;
+            if (islandUnits.has(unit)) return;
+            if (unit.client) {
+              failure = {
+                code: "state-spans-component",
+                message: `client-only \`${id.text}\` is shared between islands`,
+                location: locOf(ctx, id)
+              };
+              return;
+            }
+            const type = checker.getTypeAtLocation(id);
+            const needsCopy = unit.kind === "function" || isCallableType(type) || !checkSerializable(checker, type, { primitivesOnly: ctx.isJs }).ok;
+            if (needsCopy) {
+              islandUnits.add(unit);
+              copiedUnits.add(unit);
+              pending.push(unit.node);
+            } else {
+              failure = addProp(id, origin.symbol);
+            }
+            return;
+          }
+          case "inner":
+            if (inIsland(origin.declaration)) return;
+            if ([...moduleLevelScopes].some(
+              (scopeNode) => containsRange(scopeNode, origin.declaration)
+            ))
+              return;
+            failure = addProp(id, origin.symbol);
+            return;
+          case "module": {
+            const decl = origin.decl;
+            if (moduleDecls.has(decl)) return;
+            const fromModuleLevel = moduleLevelScopes.has(scope);
+            if (!fromModuleLevel && decl.kind === "const" && !clientModuleDecls.has(decl)) {
+              const type = checker.getTypeAtLocation(id);
+              if (checkSerializable(checker, type, { primitivesOnly: ctx.isJs }).ok) {
+                failure = addProp(id, origin.symbol);
+                return;
+              }
+            }
+            moduleDecls.add(decl);
+            moduleLevelScopes.add(decl.statement);
+            pending.push(decl.statement);
+            return;
+          }
+          case "import":
+            if (origin.usage.cls === "server-only") {
+              failure = {
+                code: "unsupported-pattern",
+                message: `${id.text} (${origin.binding.specifier}) is server-only but the interactive part uses it`,
+                location: locOf(ctx, id)
+              };
+              return;
+            }
+            valueImports.add(origin.binding);
+            return;
+          case "component": {
+            const target = origin.component;
+            if (target === component) {
+              failure = {
+                code: "unsupported-pattern",
+                message: "an island would reference the component itself",
+                location: locOf(ctx, id)
+              };
+              return;
+            }
+            if (!isTagRef(id)) {
+              failure = {
+                code: "unsupported-pattern",
+                message: `an island uses the component ${id.text} as a value`,
+                location: locOf(ctx, id)
+              };
+              return;
+            }
+            if (options.wholesale?.has(target)) return;
+            const decl = shape.componentDecls.get(target);
+            if (!decl || moduleDecls.has(decl)) return;
+            moduleDecls.add(decl);
+            moduleLevelScopes.add(decl.statement);
+            pending.push(decl.statement);
+            return;
+          }
+          case "browser-global":
+          case "global":
+            return;
+          case "unknown":
+            failure = {
+              code: "unsupported-pattern",
+              message: `can't resolve \`${id.text}\``,
+              location: locOf(ctx, id)
+            };
+            return;
+        }
+      });
+      if (failure) return { ok: false, skip: failure };
+    }
+    for (const prop of props.values()) {
+      if (serverActionParams.has(prop.symbol)) continue;
+      const verdict = checkSerializable(checker, prop.type, { primitivesOnly: ctx.isJs });
+      if (!verdict.ok && !ctx.isJs && ctx.config.mongoose.autoSerialize && isMongooseLike(checker, prop.type)) {
+        const refs = [];
+        for (const scope of [rootNode, ...[...islandUnits].map((u) => u.node)]) {
+          forEachValueRef(scope, (id) => {
+            if (keyAttr && containsRange(keyAttr, id) || inSlot(id)) return;
+            if (symbolOfRef(checker, id) === prop.symbol) refs.push(id);
+          });
+        }
+        const picked = pickMongooseFields(
+          checker,
+          prop.name,
+          refs,
+          (t) => checker.typeToString(
+            t,
+            rootNode,
+            ts8.TypeFormatFlags.NoTruncation | ts8.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
+          )
+        );
+        if (picked.ok) {
+          prop.picked = picked.value;
+          continue;
+        }
+        return skip(
+          "non-serializable-prop",
+          `\`${prop.name}\` holds Mongoose/ObjectId data and the island ${picked.reason}`,
+          locOf(ctx, prop.refNode)
+        );
+      }
+      if (!verdict.ok) {
+        const typeText = checker.typeToString(prop.type, rootNode, ts8.TypeFormatFlags.NoTruncation);
+        const usedInSpread = isSpreadInside(rootNode, prop.symbol, checker);
+        if (ctx.isJs) {
+          return skip(
+            "untyped-boundary",
+            `\`${prop.name}\` would cross the server/client boundary, but its type in this untyped file (\`${typeText}\`) can't be proven serializable`,
+            locOf(ctx, prop.refNode)
+          );
+        }
+        return skip(
+          usedInSpread ? "spread-props" : "non-serializable-prop",
+          `\`${prop.name}\` (type \`${typeText}\`) would be passed to a Client Component, but it ${verdict.reason}`,
+          locOf(ctx, prop.refNode)
+        );
+      }
+    }
+    if (keyAttr) {
+      let clientKey;
+      forEachValueRef(keyAttr, (id) => {
+        const origin = originOf(id);
+        if (origin.kind === "local" && origin.unit.client) clientKey = id;
+      });
+      if (clientKey)
+        return skip(
+          "unsupported-pattern",
+          `the list key reads client-only \`${clientKey.text}\``,
+          locOf(ctx, clientKey)
+        );
+    }
+    islands.push({
+      name: "",
+      root: group.root,
+      rootTag,
+      keyAttr,
+      units: [...islandUnits].sort((a, b) => a.index - b.index),
+      props: [...props.values()].sort(
+        (a, b) => declarationPos(a.symbol) - declarationPos(b.symbol) || a.name.localeCompare(b.name)
+      ),
+      valueImports,
+      moduleDecls,
+      slots: slotNodes.map((j, i) => ({
+        j,
+        name: slotNodes.length === 1 && !props.has("children") ? "children" : `slot${i + 1}`
+      })),
+      line: locOf(ctx, rootNode).line
+    });
+  }
+  const removedUnits = new Set(clientUnits.filter((u) => u.kind !== "early-return"));
+  const islandRanges = islands.map((i) => i.root.node);
+  const slotRanges = islands.flatMap((i) => i.slots.map((slot) => slot.j.node));
+  const inAnySlot = (node) => slotRanges.some((r) => containsRange(r, node));
+  const serverReads = (unit) => {
+    let read = false;
+    const scan = (scope) => forEachValueRef(scope, (id) => {
+      if (read) return;
+      if (islandRanges.some((r) => containsRange(r, id)) && !inAnySlot(id)) return;
+      const symbol = symbolOfRef(checker, id);
+      if (symbol && unit.declares.has(symbol)) read = true;
+    });
+    for (const root of renderRoots) scan(root);
+    for (const cond of earlyReturnConditions) scan(cond);
+    for (const other of units) if (other !== unit && !removedUnits.has(other)) scan(other.node);
+    for (const island of islands)
+      for (const prop of island.props) if (unit.declares.has(prop.symbol)) read = true;
+    return read;
+  };
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const unit of copiedUnits) {
+      if (removedUnits.has(unit)) continue;
+      if (!serverReads(unit)) {
+        removedUnits.add(unit);
+        changed = true;
+      }
+    }
+  }
+  const movedModuleDecls = /* @__PURE__ */ new Set();
+  for (const decl of clientModuleDecls) movedModuleDecls.add(decl);
+  const staticCount = jnodes.filter(
+    (j) => !islands.some((i) => isAncestorOrSelf(i.root, j)) || islands.some((i) => i.slots.some((slot) => isAncestorOrSelf(slot.j, j)))
+  ).length;
+  return ok({
+    component,
+    islands,
+    removedUnits,
+    movedModuleDecls,
+    staticRatio: totalJsx === 0 ? 0 : staticCount / totalJsx,
+    jsxTotal: totalJsx
+  });
+}
+function declarationPos(symbol) {
+  return symbol.declarations?.[0]?.getStart() ?? Number.MAX_SAFE_INTEGER;
+}
+function containsJsxNode(node) {
+  if (isJsxElementLike(node)) return true;
+  return ts8.forEachChild(node, (c) => containsJsxNode(c) ? true : void 0) ?? false;
+}
+function isTagRef(id) {
+  let node = id;
+  while (ts8.isPropertyAccessExpression(node.parent) && node.parent.expression === node)
+    node = node.parent;
+  const parent = node.parent;
+  return (ts8.isJsxOpeningElement(parent) || ts8.isJsxSelfClosingElement(parent)) && parent.tagName === node;
+}
+function enclosingJNode(node, jnodeOf) {
+  let current = node.parent;
+  while (current) {
+    const j = jnodeOf.get(current);
+    if (j) return j;
+    current = current.parent;
+  }
+  return void 0;
+}
+function conditionalAncestor(node, stopAt) {
+  let child = node;
+  let current = node.parent;
+  while (current && current !== stopAt) {
+    if (ts8.isConditionalExpression(current) && child !== current.condition)
+      return "inside a conditional expression";
+    if (ts8.isBinaryExpression(current) && child === current.right && [
+      ts8.SyntaxKind.AmpersandAmpersandToken,
+      ts8.SyntaxKind.BarBarToken,
+      ts8.SyntaxKind.QuestionQuestionToken
+    ].includes(current.operatorToken.kind)) {
+      return "inside a logical expression";
+    }
+    if (ts8.isIfStatement(current) || ts8.isSwitchStatement(current)) return "inside a condition";
+    if (ts8.isIterationStatement(current, false)) return "inside a loop";
+    if (ts8.isFunctionLike(current)) return "inside a nested function";
+    child = current;
+    current = current.parent;
+  }
+  return void 0;
+}
+function isSpreadInside(root, symbol, checker) {
+  let found = false;
+  const visit = (n) => {
+    if (found) return;
+    if ((ts8.isJsxSpreadAttribute(n) || ts8.isSpreadAssignment(n) || ts8.isSpreadElement(n)) && ts8.isIdentifier(n.expression)) {
+      if (checker.getSymbolAtLocation(n.expression) === symbol) found = true;
+    }
+    ts8.forEachChild(n, visit);
+  };
+  visit(root);
+  return found;
+}
+function describeAnchors(sf, anchors) {
+  const tags = [...new Set(anchors.map((a) => `<${tagNameText(sf, a.j.node)}>`))];
+  return tags.slice(0, 4).join(", ") + (tags.length > 4 ? ", ..." : "");
+}
+
+// src/analysis/moduleSafety.ts
+import { ts as ts10 } from "ts-morph";
+
+// src/analysis/taint.ts
+import { ts as ts9 } from "ts-morph";
+var BROWSER_GLOBALS = /* @__PURE__ */ new Set([
+  "window",
+  "document",
+  "localStorage",
+  "sessionStorage",
+  "navigator",
+  "location",
+  "history",
+  "matchMedia",
+  "IntersectionObserver",
+  "ResizeObserver",
+  "MutationObserver",
+  "PerformanceObserver",
+  "requestAnimationFrame",
+  "cancelAnimationFrame",
+  "requestIdleCallback",
+  "cancelIdleCallback",
+  "alert",
+  "confirm",
+  "prompt",
+  "self",
+  "screen",
+  "innerWidth",
+  "innerHeight",
+  "outerWidth",
+  "outerHeight",
+  "scrollX",
+  "scrollY",
+  "pageXOffset",
+  "pageYOffset",
+  "devicePixelRatio",
+  "visualViewport",
+  "getComputedStyle",
+  "getSelection",
+  "customElements",
+  "indexedDB",
+  "caches",
+  "Notification",
+  "FileReader",
+  "Image",
+  "Audio",
+  "Worker",
+  "XMLHttpRequest",
+  "WebSocket",
+  "EventSource",
+  "DOMParser",
+  "HTMLElement",
+  "Element",
+  "CustomEvent",
+  "KeyboardEvent",
+  "MouseEvent",
+  "scrollTo",
+  "scrollBy",
+  "print",
+  "open",
+  "close",
+  "postMessage",
+  "frames",
+  "parent",
+  "top",
+  "opener",
+  "origin",
+  "event",
+  "setTimeout",
+  "setInterval",
+  "clearTimeout",
+  "clearInterval"
+]);
+function isAmbientDeclaration(decl) {
+  return decl.getSourceFile().isDeclarationFile;
+}
+var FileFacts = class {
+  constructor(sf, checker, imports, framework, projectSafety, serverSafeHooks) {
+    this.sf = sf;
+    this.checker = checker;
+    this.imports = imports;
+    this.framework = framework;
+    this.projectSafety = projectSafety;
+    this.serverSafeHooks = serverSafeHooks;
+  }
+  sf;
+  checker;
+  imports;
+  framework;
+  projectSafety;
+  serverSafeHooks;
+  classifyRef(id) {
+    const symbol = symbolOfRef(this.checker, id);
+    if (!symbol)
+      return BROWSER_GLOBALS.has(id.text) ? { kind: "browser-global", name: id.text } : { kind: "unknown" };
+    const binding = this.imports.bySymbol.get(symbol);
+    if (binding) {
+      const parent = id.parent;
+      const member = parent && ts9.isPropertyAccessExpression(parent) && parent.expression === id ? parent.name.text : void 0;
+      const asJsxTag = parent && (ts9.isJsxOpeningElement(parent) || ts9.isJsxSelfClosingElement(parent)) && parent.tagName === id || parent !== void 0 && ts9.isPropertyAccessExpression(parent) && parent.expression === id && (ts9.isJsxOpeningElement(parent.parent) || ts9.isJsxSelfClosingElement(parent.parent)) && parent.parent.tagName === parent;
+      return {
+        kind: "import",
+        binding,
+        usage: classifyImportUsage(binding, member, asJsxTag, this.framework, this.projectSafety)
+      };
+    }
+    const decl = symbol.valueDeclaration ?? symbol.declarations?.[0];
+    if (!decl) return { kind: "global" };
+    if (decl.getSourceFile() === this.sf) return { kind: "file", symbol, declaration: decl };
+    if (isAmbientDeclaration(decl)) {
+      return BROWSER_GLOBALS.has(id.text) && !(symbol.flags & ts9.SymbolFlags.Alias) ? { kind: "browser-global", name: id.text } : { kind: "global" };
+    }
+    return { kind: "unknown" };
+  }
+  isHookCall(call) {
+    const name = calleeName(call);
+    if (!name) return false;
+    if (this.serverSafeHooks.has(name)) return false;
+    if (HOOK_NAME_RE.test(name)) return true;
+    if (name === "use") {
+      const [arg] = call.arguments;
+      if (!arg) return false;
+      const type = this.checker.getTypeAtLocation(arg);
+      return type.getProperty("Provider") !== void 0 || type.getProperty("Consumer") !== void 0;
+    }
+    return false;
+  }
+  /**
+   * Client-only markers under `node`. `stop` prunes subtrees (nested JSX elements when scanning
+   * one element's own attributes and children).
+   */
+  scanMarkers(node, stop) {
+    const markers = [];
+    const visit = (n) => {
+      if (n !== node && stop?.(n)) return;
+      if (ts9.isCallExpression(n) && this.isHookCall(n)) {
+        markers.push({ kind: "hook", node: n, detail: `${calleeName(n) ?? "hook"}()` });
+      }
+      const nondeterministic = nondeterministicCall(n);
+      if (nondeterministic)
+        markers.push({ kind: "nondeterministic", node: n, detail: nondeterministic });
+      ts9.forEachChild(n, visit);
+    };
+    visit(node);
+    forEachValueRef(
+      node,
+      (id) => {
+        const info = this.classifyRef(id);
+        if (info.kind === "browser-global")
+          markers.push({ kind: "browser-global", node: id, detail: info.name });
+        else if (info.kind === "import" && info.usage.cls === "client-only") {
+          markers.push({
+            kind: "client-import",
+            node: id,
+            detail: info.usage.reason,
+            special: info.usage.special
+          });
+        } else if (info.kind === "import" && info.usage.special) {
+          markers.push({
+            kind: "client-import",
+            node: id,
+            detail: info.usage.reason,
+            special: info.usage.special
+          });
+        }
+      },
+      stop
+    );
+    return markers;
+  }
+};
+function nondeterministicCall(n) {
+  if (ts9.isNewExpression(n) && ts9.isIdentifier(n.expression) && n.expression.text === "Date" && (n.arguments?.length ?? 0) === 0) {
+    return "new Date()";
+  }
+  if (ts9.isCallExpression(n) && ts9.isPropertyAccessExpression(n.expression) && ts9.isIdentifier(n.expression.expression)) {
+    const object = n.expression.expression.text;
+    const method = n.expression.name.text;
+    if (object === "Date" && method === "now" || object === "Math" && method === "random" || object === "performance" && method === "now" || object === "crypto" && (method === "randomUUID" || method === "getRandomValues")) {
+      return `${object}.${method}()`;
+    }
+  }
+  return void 0;
+}
+function findEnvProblem(node, checker, framework) {
+  let problem;
+  const visit = (n) => {
+    if (problem) return;
+    if (ts9.isIdentifier(n) && n.text === "process" && isGlobalProcess(n, checker)) {
+      const parent = n.parent;
+      if (ts9.isPropertyAccessExpression(parent) && parent.expression === n && parent.name.text === "env") {
+        const outer = parent.parent;
+        if (ts9.isPropertyAccessExpression(outer) && outer.expression === parent) {
+          const name = outer.name.text;
+          if (!framework.isClientVisibleEnv(name)) {
+            problem = {
+              node: outer,
+              message: `reads process.env.${name}, which is defined on the server but not in the browser bundle`
+            };
+          }
+          return;
+        }
+        if (ts9.isElementAccessExpression(outer) && outer.expression === parent && ts9.isStringLiteralLike(outer.argumentExpression)) {
+          const name = outer.argumentExpression.text;
+          if (!framework.isClientVisibleEnv(name)) {
+            problem = {
+              node: outer,
+              message: `reads process.env["${name}"], which is defined on the server but not in the browser bundle`
+            };
+          }
+          return;
+        }
+        problem = {
+          node: parent,
+          message: "reads process.env dynamically; its value differs between the server and the browser"
+        };
+        return;
+      }
+      if (!(ts9.isTypeOfExpression(parent) || ts9.isTypeQueryNode(parent))) {
+        problem = {
+          node: n,
+          message: "reads `process`, which differs between the server and the browser"
+        };
+      }
+      return;
+    }
+    ts9.forEachChild(n, visit);
+  };
+  visit(node);
+  return problem;
+}
+function isGlobalProcess(id, checker) {
+  if (ts9.isPropertyAccessExpression(id.parent) && id.parent.name === id) return false;
+  const symbol = checker.getSymbolAtLocation(id);
+  const decl = symbol?.valueDeclaration ?? symbol?.declarations?.[0];
+  return !decl || decl.getSourceFile().isDeclarationFile;
+}
+
+// src/analysis/moduleSafety.ts
+var ModuleSafety = class {
+  constructor(getProgram, graph, framework, serverSafeHooks) {
+    this.getProgram = getProgram;
+    this.graph = graph;
+    this.framework = framework;
+    this.serverSafeHooks = serverSafeHooks;
+  }
+  getProgram;
+  graph;
+  framework;
+  serverSafeHooks;
+  cache = /* @__PURE__ */ new Map();
+  inProgress = /* @__PURE__ */ new Set();
+  check = (file) => {
+    const cached = this.cache.get(file);
+    if (cached) return cached;
+    if (this.inProgress.has(file)) return { safe: true };
+    this.inProgress.add(file);
+    try {
+      const result = this.compute(file);
+      this.cache.set(file, result);
+      return result;
+    } finally {
+      this.inProgress.delete(file);
+    }
+  };
+  compute(file) {
+    const node = this.graph.nodes.get(file);
+    const rel2 = this.graph.rel(file);
+    if (!node || !node.inProgram)
+      return { safe: false, reason: `${rel2} is outside the TypeScript project` };
+    if (node.directive === "use client")
+      return { safe: false, reason: `${rel2} is a "use client" module` };
+    if (node.directive === "use server") return { safe: true };
+    const program = this.getProgram();
+    const sf = program.getSourceFile(file);
+    if (!sf) return { safe: false, reason: `${rel2} is not in the program` };
+    const checker = program.getTypeChecker();
+    for (const statement of sf.statements) {
+      if (ts10.isImportDeclaration(statement) && !statement.importClause && ts10.isStringLiteral(statement.moduleSpecifier)) {
+        const spec = statement.moduleSpecifier.text;
+        if (!/\.(css|scss|sass|less)$/.test(spec)) {
+          return { safe: false, reason: `${rel2} has a side-effect import of ${spec}` };
+        }
+      }
+      if (ts10.isExportDeclaration(statement) && statement.moduleSpecifier && !statement.isTypeOnly) {
+        const edge = this.graph.edgeFor(file, statement.moduleSpecifier.text);
+        if (edge?.to) {
+          const target = this.graph.nodes.get(edge.to);
+          if (target?.directive !== "use client" && target?.directive !== "use server") {
+            const inner = this.check(edge.to);
+            if (!inner.safe)
+              return { safe: false, reason: inner.reason ?? `${rel2} re-exports client code` };
+          }
+        } else if (edge?.external && !["neutral", "server-safe-list", "json", "asset", "use-client-entry"].includes(
+          edge.external.kind
+        )) {
+          return { safe: false, reason: `${rel2} re-exports ${edge.specifier}` };
+        }
+      }
+    }
+    const imports = buildImportTable(sf, checker, this.graph);
+    const facts = new FileFacts(
+      sf,
+      checker,
+      imports,
+      this.framework,
+      this.check,
+      this.serverSafeHooks
+    );
+    const markers = facts.scanMarkers(sf);
+    const first = markers[0];
+    if (first) {
+      const line = sf.getLineAndCharacterOfPosition(first.node.getStart(sf)).line + 1;
+      return { safe: false, reason: `${rel2}:${line} uses ${first.detail}` };
+    }
+    const env = findEnvProblem(sf, checker, this.framework);
+    if (env) return { safe: false, reason: `${rel2} ${env.message}` };
+    let reason;
+    const visit = (n) => {
+      if (reason) return;
+      if (ts10.isJsxAttribute(n)) {
+        const name = n.name.getText(sf);
+        if (/^on[A-Z]/.test(name) || name === "ref") reason = `${rel2} attaches ${name} handlers`;
+      }
+      if (ts10.isClassDeclaration(n) && n.heritageClauses?.some((h) => /Component/.test(h.getText(sf)))) {
+        reason = `${rel2} declares a class component`;
+      }
+      ts10.forEachChild(n, visit);
+    };
+    visit(sf);
+    if (reason) return { safe: false, reason };
+    return { safe: true };
+  }
+};
+
+// src/frameworks/next.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "fs";
+import path3 from "path";
+import { ts as ts11 } from "ts-morph";
+var perName = (classify) => ({
+  kind: "per-name",
+  classify
+});
+var hooksClient = (name) => /^use[A-Z]/.test(name) ? "client-only" : "neutral";
+var NAVIGATION_SERVER_SAFE = /* @__PURE__ */ new Set([
+  "redirect",
+  "permanentRedirect",
+  "notFound",
+  "forbidden",
+  "unauthorized",
+  "RedirectType",
+  "unstable_rethrow"
+]);
+var nextAdapter = {
+  name: "next",
+  classifyModule(specifier) {
+    if (specifier === "next/dynamic") return { kind: "dynamic-import" };
+    if (specifier === "styled-jsx" || specifier.startsWith("styled-jsx/"))
+      return { kind: "css-in-js" };
+    if (["next/link", "next/image", "next/script", "next/form", "next/legacy/image"].includes(
+      specifier
+    )) {
+      return perName(
+        (name) => name === "default" || /^[A-Z]/.test(name) ? "client-reference" : "neutral"
+      );
+    }
+    if (specifier === "next/navigation") {
+      return perName((name) => NAVIGATION_SERVER_SAFE.has(name) ? "neutral" : "client-only");
+    }
+    if (specifier === "next/router" || specifier === "next/head" || specifier === "next/amp") {
+      return perName(() => "client-only");
+    }
+    if (["next/headers", "next/server", "next/cache", "next/after", "next/og"].includes(specifier)) {
+      return perName(() => "server-only");
+    }
+    if (specifier.startsWith("next/font/")) return perName(() => "neutral");
+    if (specifier === "next" || specifier === "next/types") return perName(hooksClient);
+    if (specifier.startsWith("next/")) return perName(() => "client-only");
+    return void 0;
+  },
+  isClientVisibleEnv(name) {
+    return name.startsWith("NEXT_PUBLIC_") || name === "NODE_ENV";
+  },
+  mustStayClientFiles: ["error", "global-error"],
+  sharedContextHooks: [
+    "usePathname",
+    "useSearchParams",
+    "useParams",
+    "useRouter",
+    "useSelectedLayoutSegment",
+    "useSelectedLayoutSegments"
+  ]
+};
+var NEXT_ROUTE_FILE_BASENAMES = ["page", "route"];
+var DEFAULT_PAGE_EXTENSIONS = ["tsx", "ts", "jsx", "js"];
+function readPageExtensions(root) {
+  const candidates = [
+    "next.config.ts",
+    "next.config.mjs",
+    "next.config.js",
+    "next.config.cjs",
+    "next.config.mts"
+  ];
+  const file = candidates.map((c) => path3.join(root, c)).find((f) => existsSync2(f));
+  if (!file) return { ok: true, extensions: DEFAULT_PAGE_EXTENSIONS };
+  const text = readFileSync2(file, "utf8");
+  if (!text.includes("pageExtensions")) return { ok: true, extensions: DEFAULT_PAGE_EXTENSIONS };
+  const sf = ts11.createSourceFile(file, text, ts11.ScriptTarget.Latest, true);
+  let found;
+  let unreadable = false;
+  const visit = (node) => {
+    if (ts11.isPropertyAssignment(node) && node.name.getText(sf) === "pageExtensions" || ts11.isShorthandPropertyAssignment(node) && node.name.text === "pageExtensions") {
+      const init = ts11.isPropertyAssignment(node) ? node.initializer : void 0;
+      if (init && ts11.isArrayLiteralExpression(init) && init.elements.every(ts11.isStringLiteralLike)) {
+        found = init.elements.map((e) => e.text);
+      } else {
+        unreadable = true;
+      }
+    }
+    ts11.forEachChild(node, visit);
+  };
+  visit(sf);
+  if (unreadable || !found) {
+    return {
+      ok: false,
+      reason: `${path3.basename(file)} sets pageExtensions in a way that can't be read statically`
+    };
+  }
+  return { ok: true, extensions: found };
+}
+function couldBecomeRoute(root, absPath, pageExtensions) {
+  const rel2 = path3.relative(root, absPath).split(path3.sep);
+  if (rel2[0] === "pages" || rel2[0] === "src" && rel2[1] === "pages") return true;
+  const base = path3.basename(absPath);
+  return pageExtensions.some(
+    (ext) => NEXT_ROUTE_FILE_BASENAMES.some((name) => base === `${name}.${ext}`)
+  );
+}
+
+// src/project/loadProject.ts
+import { existsSync as existsSync3 } from "fs";
+import path4 from "path";
+import fg from "fast-glob";
+import { Project, ts as ts12 } from "ts-morph";
+var IGNORED_DIRS = [
+  "node_modules",
+  ".next",
+  ".git",
+  "dist",
+  "out",
+  "build",
+  "coverage",
+  ".turbo",
+  ".vercel"
+];
+var IGNORE_GLOBS = IGNORED_DIRS.map((d) => `**/${d}/**`);
+var DEFAULT_COMPILER_OPTIONS = {
+  target: ts12.ScriptTarget.ES2022,
+  lib: ["lib.dom.d.ts", "lib.dom.iterable.d.ts", "lib.esnext.d.ts"],
+  module: ts12.ModuleKind.ESNext,
+  moduleResolution: ts12.ModuleResolutionKind.Bundler,
+  jsx: ts12.JsxEmit.ReactJSX,
+  strict: true,
+  skipLibCheck: true,
+  allowJs: true,
+  esModuleInterop: true,
+  isolatedModules: true,
+  resolveJsonModule: true,
+  noEmit: true
+};
+function loadProject(root, options = {}) {
+  const configFile = options.tsconfig ?? ["tsconfig.json", "jsconfig.json"].map((f) => path4.join(root, f)).find((f) => existsSync3(f));
+  if (configFile) {
+    const isJsConfig = path4.basename(configFile) === "jsconfig.json";
+    const project2 = new Project({
+      tsConfigFilePath: configFile,
+      skipAddingFilesFromTsConfig: options.lazy === true,
+      ...isJsConfig ? { compilerOptions: { allowJs: true, checkJs: false } } : {}
+    });
+    const compilerOptions = project2.getCompilerOptions();
+    if (!options.lazy) return { project: project2, root, configFile, compilerOptions };
+    const parsed = ts12.parseJsonConfigFileContent(
+      ts12.readConfigFile(configFile, ts12.sys.readFile).config,
+      ts12.sys,
+      path4.dirname(configFile),
+      isJsConfig ? { allowJs: true } : void 0,
+      configFile
+    );
+    const lazyFileNames = parsed.fileNames.map((f) => path4.resolve(f));
+    for (const file of lazyFileNames) if (file.endsWith(".d.ts")) project2.addSourceFileAtPath(file);
+    return { project: project2, root, configFile, compilerOptions, lazyFileNames };
+  }
+  const project = new Project({ compilerOptions: DEFAULT_COMPILER_OPTIONS });
+  const files = fg.sync(["**/*.{ts,tsx,js,jsx,mts,cts}"], {
+    cwd: root,
+    ignore: IGNORE_GLOBS,
+    absolute: true,
+    dot: false
+  });
+  if (options.lazy)
+    return {
+      project,
+      root,
+      configFile: void 0,
+      compilerOptions: DEFAULT_COMPILER_OPTIONS,
+      lazyFileNames: files.map((f) => path4.resolve(f))
+    };
+  for (const file of files) project.addSourceFileAtPath(file);
+  project.resolveSourceFileDependencies();
+  return { project, root, configFile: void 0, compilerOptions: project.getCompilerOptions() };
+}
+function setSourceText(sf, text) {
+  sf.applyTextChanges([{ span: { start: 0, length: sf.getFullText().length }, newText: text }]);
+}
+function ensureLoaded(loaded, files) {
+  if (!loaded.lazyFileNames) return;
+  let added = false;
+  for (const file of files) {
+    if (!loaded.project.getSourceFile(file) && existsSync3(file)) {
+      loaded.project.addSourceFileAtPath(file);
+      added = true;
+    }
+  }
+  if (added) loaded.project.resolveSourceFileDependencies();
+}
+function projectSourceFiles(loaded) {
+  return loaded.project.getSourceFiles().map((sf) => sf.compilerNode).filter((sf) => !sf.isDeclarationFile && !sf.fileName.includes("/node_modules/"));
+}
+
+// src/project/moduleGraph.ts
+import { readFileSync as readFileSync3 } from "fs";
+import path5 from "path";
+import fg2 from "fast-glob";
+import { ts as ts13 } from "ts-morph";
+var SOURCE_EXT_RE = /\.(tsx?|jsx?|mts|cts|mjs|cjs)$/;
+var ModuleGraph = class {
+  constructor(root) {
+    this.root = root;
+  }
+  root;
+  nodes = /* @__PURE__ */ new Map();
+  importers = /* @__PURE__ */ new Map();
+  /** Client-graph membership: file -> the module it was first reached from (null for "use client" roots). */
+  clientParent = /* @__PURE__ */ new Map();
+  addNode(node) {
+    this.nodes.set(node.file, node);
+  }
+  finalize() {
+    for (const node of this.nodes.values()) {
+      for (const edge of node.edges) {
+        if (!edge.to) continue;
+        const list = this.importers.get(edge.to) ?? [];
+        list.push(edge);
+        this.importers.set(edge.to, list);
+      }
+    }
+    const queue = [];
+    for (const node of this.nodes.values()) {
+      if (node.directive === "use client") {
+        this.clientParent.set(node.file, null);
+        queue.push(node.file);
+      }
+    }
+    while (queue.length > 0) {
+      const file = queue.shift();
+      for (const edge of this.nodes.get(file)?.edges ?? []) {
+        if (!edge.to || edge.kind === "type" || this.clientParent.has(edge.to)) continue;
+        this.clientParent.set(edge.to, file);
+        queue.push(edge.to);
+      }
+    }
+  }
+  importersOf(file) {
+    return this.importers.get(file) ?? [];
+  }
+  isClient(file) {
+    return this.clientParent.has(file);
+  }
+  /** The "use client" module that pulls `file` into the client graph, if it's not a root itself. */
+  clientRootOf(file) {
+    let current = file;
+    let guard = 0;
+    while (current && guard++ < 1e4) {
+      const parent = this.clientParent.get(current);
+      if (parent === null) return current;
+      current = parent;
+    }
+    return void 0;
+  }
+  edgesFrom(file) {
+    return this.nodes.get(file)?.edges ?? [];
+  }
+  edgeFor(file, specifier) {
+    return this.edgesFrom(file).find((e) => e.specifier === specifier && e.kind !== "dynamic");
+  }
+  rel(file) {
+    return path5.relative(this.root, file).split(path5.sep).join("/");
+  }
+};
+function collectImports(sf) {
+  const out = [];
+  const lineOf = (node) => sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1;
+  for (const statement of sf.statements) {
+    if (ts13.isImportDeclaration(statement) && ts13.isStringLiteral(statement.moduleSpecifier)) {
+      const typeOnly = statement.importClause?.isTypeOnly === true;
+      out.push({
+        specifier: statement.moduleSpecifier.text,
+        kind: typeOnly ? "type" : "static",
+        line: lineOf(statement)
+      });
+    } else if (ts13.isExportDeclaration(statement) && statement.moduleSpecifier && ts13.isStringLiteral(statement.moduleSpecifier)) {
+      out.push({
+        specifier: statement.moduleSpecifier.text,
+        kind: statement.isTypeOnly ? "type" : "reexport",
+        line: lineOf(statement)
+      });
+    } else if (ts13.isImportEqualsDeclaration(statement) && ts13.isExternalModuleReference(statement.moduleReference)) {
+      const expr = statement.moduleReference.expression;
+      if (ts13.isStringLiteral(expr))
+        out.push({ specifier: expr.text, kind: "static", line: lineOf(statement) });
+    }
+  }
+  const visit = (node) => {
+    if (ts13.isCallExpression(node)) {
+      const [arg] = node.arguments;
+      if (arg && ts13.isStringLiteralLike(arg)) {
+        if (node.expression.kind === ts13.SyntaxKind.ImportKeyword)
+          out.push({ specifier: arg.text, kind: "dynamic", line: lineOf(node) });
+        else if (ts13.isIdentifier(node.expression) && node.expression.text === "require") {
+          out.push({ specifier: arg.text, kind: "static", line: lineOf(node) });
+        }
+      }
+    }
+    if (ts13.isImportTypeNode(node)) return;
+    ts13.forEachChild(node, visit);
+  };
+  visit(sf);
+  return out;
+}
+var MDX_IMPORT_RE = /^\s*(?:import|export)\s+(?:[^'"]*?\s+from\s+)?['"]([^'"]+)['"]/gm;
+function buildModuleGraph(loaded, classifier) {
+  const graph = new ModuleGraph(loaded.root);
+  const options = { ...loaded.compilerOptions, allowJs: true };
+  const host = ts13.sys;
+  const cache2 = ts13.createModuleResolutionCache(loaded.root, (f) => f, options);
+  const resolve = (specifier, from) => {
+    const result = ts13.resolveModuleName(specifier, from, options, host, cache2).resolvedModule;
+    if (!result || result.isExternalLibraryImport) return void 0;
+    const resolved = path5.resolve(result.resolvedFileName);
+    if (resolved.includes(`${path5.sep}node_modules${path5.sep}`) || resolved.endsWith(".d.ts"))
+      return void 0;
+    return resolved;
+  };
+  const addFile = (file, sf, inProgram, mdxText) => {
+    const raw = sf ? collectImports(sf) : [...(mdxText ?? "").matchAll(MDX_IMPORT_RE)].map((m) => ({
+      specifier: m[1] ?? "",
+      kind: "static",
+      line: (mdxText ?? "").slice(0, m.index).split("\n").length
+    }));
+    const edges = raw.map((imp) => {
+      const to = resolve(imp.specifier, file);
+      return {
+        from: file,
+        specifier: imp.specifier,
+        kind: imp.kind,
+        to,
+        external: to ? void 0 : classifier.classify(imp.specifier, file),
+        line: imp.line
+      };
+    });
+    graph.addNode({
+      file,
+      directive: sf ? getModuleDirective(sf).directive : void 0,
+      inProgram,
+      edges
+    });
+  };
+  if (loaded.lazyFileNames) {
+    const allowJs = loaded.compilerOptions.allowJs === true;
+    const queue = [...loaded.lazyFileNames];
+    for (const file of queue) {
+      if (graph.nodes.has(file) || !SOURCE_EXT_RE.test(file)) continue;
+      if (file.endsWith(".d.ts") || file.includes(`${path5.sep}node_modules${path5.sep}`)) continue;
+      let text;
+      try {
+        text = readFileSync3(file, "utf8");
+      } catch {
+        continue;
+      }
+      const kind = /\.(tsx|jsx)$/.test(file) ? ts13.ScriptKind.TSX : /\.(js|mjs|cjs)$/.test(file) ? ts13.ScriptKind.JS : ts13.ScriptKind.TS;
+      addFile(file, ts13.createSourceFile(file, text, ts13.ScriptTarget.Latest, true, kind), true);
+      for (const edge of graph.nodes.get(file)?.edges ?? []) {
+        if (edge.to && (allowJs || !/\.(jsx?|mjs|cjs)$/.test(edge.to))) queue.push(edge.to);
+      }
+    }
+  } else {
+    for (const sf of projectSourceFiles(loaded)) addFile(path5.resolve(sf.fileName), sf, true);
+  }
+  const extra = fg2.sync(["**/*.{ts,tsx,js,jsx,mjs,cjs,mts,cts,mdx}"], {
+    cwd: loaded.root,
+    ignore: [...IGNORE_GLOBS, "**/*.d.ts"],
+    absolute: true
+  });
+  for (const file of extra.map((f) => path5.resolve(f))) {
+    if (graph.nodes.has(file)) continue;
+    let text;
+    try {
+      text = readFileSync3(file, "utf8");
+    } catch {
+      continue;
+    }
+    if (file.endsWith(".mdx")) addFile(file, void 0, false, text);
+    else if (SOURCE_EXT_RE.test(file)) {
+      const kind = /\.(tsx|jsx)$/.test(file) ? ts13.ScriptKind.TSX : ts13.ScriptKind.TS;
+      addFile(file, ts13.createSourceFile(file, text, ts13.ScriptTarget.Latest, true, kind), false);
+    }
+  }
+  graph.finalize();
+  return graph;
+}
+
+// src/project/packages.ts
+import { existsSync as existsSync4, openSync, readFileSync as readFileSync4, readSync, closeSync, statSync } from "fs";
+import { builtinModules } from "module";
+import path6 from "path";
+var STYLESHEET_RE = /\.(css|scss|sass|less|styl|pcss)$/;
+var CSS_MODULE_RE = /\.module\.(css|scss|sass|less|styl|pcss)$/;
+var ASSET_RE = /\.(svg|png|jpe?g|gif|webp|avif|ico|bmp|mp4|webm|mp3|wav|woff2?|ttf|otf)$/;
+var PackageClassifier = class {
+  constructor(framework, extraClientOnly) {
+    this.framework = framework;
+    this.extraClientOnly = extraClientOnly;
+  }
+  framework;
+  extraClientOnly;
+  cache = /* @__PURE__ */ new Map();
+  /** Classifies a non-relative specifier (or an unresolved relative one with an asset extension). */
+  classify(specifier, fromFile) {
+    const key = `${path6.dirname(fromFile)}\0${specifier}`;
+    const cached = this.cache.get(key);
+    if (cached) return cached;
+    const info = {
+      specifier,
+      packageName: packageNameOf(specifier),
+      ...this.compute(specifier, fromFile)
+    };
+    this.cache.set(key, info);
+    return info;
+  }
+  compute(specifier, fromFile) {
+    if (CSS_MODULE_RE.test(specifier)) return { kind: "css-module" };
+    if (STYLESHEET_RE.test(specifier)) return { kind: "stylesheet" };
+    if (specifier.endsWith(".json")) return { kind: "json" };
+    if (ASSET_RE.test(specifier)) return { kind: "asset" };
+    if (specifier.startsWith(".") || specifier.startsWith("/")) return { kind: "unresolved" };
+    const name = packageNameOf(specifier);
+    if (specifier.startsWith("node:") || builtinModules.includes(name) || builtinModules.includes(specifier)) {
+      return { kind: "builtin" };
+    }
+    if (name === "react") return { kind: "react" };
+    if (name === "react-dom") return { kind: "react-dom" };
+    if (specifier === "server-only") return { kind: "server-only-marker" };
+    if (specifier === "client-only") return { kind: "client-only-marker" };
+    if (this.framework.classifyModule(specifier)) return { kind: "framework" };
+    if (matchesPackageList(specifier, CSS_IN_JS_PACKAGES)) return { kind: "css-in-js" };
+    if (matchesPackageList(specifier, this.extraClientOnly))
+      return { kind: "client-list", detail: "clientOnlyPackages config" };
+    if (matchesPackageList(specifier, BUILTIN_SERVER_SAFE_PACKAGES))
+      return { kind: "server-safe-list" };
+    if (matchesPackageList(specifier, BUILTIN_CLIENT_ONLY_PACKAGES)) return { kind: "client-list" };
+    const pkgDir = findPackageDir(name, path6.dirname(fromFile));
+    if (!pkgDir) return { kind: "unresolved", detail: `package ${name} is not installed` };
+    const pkg = readPackageJson(pkgDir);
+    if (!pkg) return { kind: "unresolved", detail: `can't read ${name}/package.json` };
+    const entry = resolveEntry(pkgDir, pkg, specifier.slice(name.length));
+    if (entry && startsWithUseClient(entry)) return { kind: "use-client-entry" };
+    const deps = { ...pkg.dependencies, ...pkg.peerDependencies, ...pkg.optionalDependencies };
+    if ("react" in deps || "react-dom" in deps || "next" in deps || "preact" in deps) {
+      return {
+        kind: "react-unknown",
+        detail: `${name} depends on React and isn't known to be server-safe`
+      };
+    }
+    return { kind: "neutral" };
+  }
+};
+function findPackageDir(name, fromDir) {
+  let dir = fromDir;
+  for (; ; ) {
+    const candidate = path6.join(dir, "node_modules", name);
+    if (existsSync4(path6.join(candidate, "package.json"))) return candidate;
+    const parent = path6.dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+}
+function readPackageJson(dir) {
+  try {
+    return JSON.parse(readFileSync4(path6.join(dir, "package.json"), "utf8"));
+  } catch {
+    return void 0;
+  }
+}
+var CONDITIONS = ["browser", "import", "module", "default", "require"];
+function pickConditional(value) {
+  if (typeof value === "string") return value;
+  if (Array.isArray(value)) {
+    for (const v of value) {
+      const picked = pickConditional(v);
+      if (picked) return picked;
+    }
+    return void 0;
+  }
+  if (value && typeof value === "object") {
+    const record = value;
+    for (const condition of CONDITIONS) {
+      if (condition in record) {
+        const picked = pickConditional(record[condition]);
+        if (picked) return picked;
+      }
+    }
+  }
+  return void 0;
+}
+function resolveEntry(pkgDir, pkg, subpath) {
+  const key = subpath ? `.${subpath}` : ".";
+  let target;
+  if (pkg.exports !== void 0) {
+    const exportsField = pkg.exports;
+    const isSubpathMap = exportsField !== null && typeof exportsField === "object" && !Array.isArray(exportsField) && Object.keys(exportsField).some((k) => k.startsWith("."));
+    if (isSubpathMap) {
+      const map = exportsField;
+      if (key in map) target = pickConditional(map[key]);
+      else {
+        for (const [pattern, value] of Object.entries(map)) {
+          const star = pattern.indexOf("*");
+          if (star === -1) continue;
+          const prefix = pattern.slice(0, star);
+          const suffix = pattern.slice(star + 1);
+          if (key.startsWith(prefix) && key.endsWith(suffix)) {
+            const matched = key.slice(prefix.length, key.length - suffix.length);
+            target = pickConditional(value)?.replace("*", matched);
+            break;
+          }
+        }
+      }
+    } else if (key === ".") {
+      target = pickConditional(exportsField);
+    }
+  } else if (key === ".") {
+    target = pkg.module ?? pkg.main ?? "index.js";
+  } else {
+    target = subpath.slice(1);
+  }
+  if (!target) return void 0;
+  const base = path6.join(pkgDir, target);
+  for (const candidate of [base, `${base}.js`, `${base}.mjs`, path6.join(base, "index.js")]) {
+    if (existsSync4(candidate) && statSync(candidate).isFile()) return candidate;
+  }
+  return void 0;
+}
+function startsWithUseClient(file) {
+  let fd;
+  try {
+    fd = openSync(file, "r");
+    const buffer = Buffer.alloc(1024);
+    const read = readSync(fd, buffer, 0, buffer.length, 0);
+    const head = buffer.subarray(0, read).toString("utf8").replace(/^\uFEFF/, "").replace(/^(\s|\/\/[^\n]*\n|\/\*[\s\S]*?\*\/)*/, "");
+    return /^(['"])use client\1/.test(head) || /^(['"])use strict\1;?\s*(['"])use client\2/.test(head);
+  } catch {
+    return false;
+  } finally {
+    if (fd !== void 0) closeSync(fd);
+  }
+}
+
+// src/transform/emit.ts
+import MagicString from "magic-string";
+import { ts as ts16 } from "ts-morph";
+
+// src/transform/text.ts
+import { ts as ts14 } from "ts-morph";
+function detectStyle(sf) {
+  let quote = '"';
+  let semi = true;
+  const first = sf.statements.find((s) => ts14.isImportDeclaration(s) || ts14.isExpressionStatement(s));
+  if (first) {
+    const text = first.getText(sf);
+    semi = text.trimEnd().endsWith(";");
+    const literal = ts14.isImportDeclaration(first) ? first.moduleSpecifier : first.expression;
+    const raw = literal.getText(sf);
+    if (raw.startsWith("'")) quote = "'";
+  }
+  let indent = "  ";
+  let smallest = Number.POSITIVE_INFINITY;
+  for (const match of sf.text.matchAll(/\n([ \t]+)\S/g)) {
+    const ws = match[1] ?? "";
+    if (ws.startsWith("	")) {
+      indent = "	";
+      break;
+    }
+    if (ws.length < smallest) {
+      smallest = ws.length;
+      indent = " ".repeat(ws.length);
+    }
+  }
+  return { quote, semi, indent };
+}
+function lineEndingOf(text) {
+  const i = text.indexOf("\n");
+  return i > 0 && text[i - 1] === "\r" ? "\r\n" : "\n";
+}
+function hasMixedLineEndings(text) {
+  return text.includes("\r\n") && /(?:^|[^\r])\n/.test(text);
+}
+function withLineEnding(text, eol) {
+  return text.replace(/\r?\n/g, eol);
+}
+function lineStartOf(text, pos) {
+  const i = text.lastIndexOf("\n", pos - 1);
+  return i === -1 ? 0 : i + 1;
+}
+function lineEndOf(text, pos) {
+  const i = text.indexOf("\n", pos);
+  return i === -1 ? text.length : i;
+}
+function indentationOfLine(text, pos) {
+  const start = lineStartOf(text, pos);
+  const match = /^[ \t]*/.exec(text.slice(start));
+  return match?.[0] ?? "";
+}
+function hasMultilineLiteral(node, sf) {
+  let found = false;
+  const visit = (n) => {
+    if (found) return;
+    if ((ts14.isTemplateLiteral(n) || ts14.isStringLiteral(n) || ts14.isNoSubstitutionTemplateLiteral(n)) && n.getText(sf).includes("\n")) {
+      found = true;
+      return;
+    }
+    ts14.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
+function reindent(text, fromIndent, toIndent) {
+  const lines = text.split("\n");
+  return lines.map((line, i) => {
+    if (i === 0) return line;
+    if (line.trim() === "") return "";
+    if (line.startsWith(fromIndent)) return toIndent + line.slice(fromIndent.length);
+    return toIndent + line.trimStart();
+  }).join("\n");
+}
+function statementLineRange(sf, node) {
+  const text = sf.text;
+  let start = node.getStart(sf);
+  const comments = ts14.getLeadingCommentRanges(text, node.getFullStart()) ?? [];
+  for (const comment of comments) {
+    const before2 = text.slice(lineStartOf(text, comment.pos), comment.pos);
+    if (before2.trim() === "") {
+      start = Math.min(start, comment.pos);
+      break;
+    }
+  }
+  const end = node.getEnd();
+  const lineStart = lineStartOf(text, start);
+  const lineEnd = lineEndOf(text, end);
+  const before = text.slice(lineStart, start);
+  const after = text.slice(end, lineEnd);
+  if (before.trim() === "" && after.trim() === "") {
+    return { start: lineStart, end: Math.min(text.length, lineEnd + 1), whole: true };
+  }
+  return { start, end, whole: false };
+}
+
+// src/transform/typeRefs.ts
+import { ts as ts15 } from "ts-morph";
+function typeReferenceHeads(node) {
+  const out = [];
+  const head = (name) => {
+    let current = name;
+    while (ts15.isQualifiedName(current) || ts15.isPropertyAccessExpression(current)) {
+      current = ts15.isQualifiedName(current) ? current.left : current.expression;
+    }
+    return ts15.isIdentifier(current) ? current : void 0;
+  };
+  const visit = (n) => {
+    if (ts15.isTypeReferenceNode(n)) {
+      const id = head(n.typeName);
+      if (id) out.push(id);
+    } else if (ts15.isExpressionWithTypeArguments(n) && ts15.isHeritageClause(n.parent)) {
+      const id = head(n.expression);
+      if (id) out.push(id);
+    } else if (ts15.isTypeQueryNode(n)) {
+      const id = head(n.exprName);
+      if (id) out.push(id);
+    }
+    ts15.forEachChild(n, visit);
+  };
+  visit(node);
+  return out;
+}
+var TypeRefCollector = class {
+  constructor(sf, checker, imports, moduleDecls, islandContent) {
+    this.sf = sf;
+    this.checker = checker;
+    this.imports = imports;
+    this.moduleDecls = moduleDecls;
+    this.islandContent = islandContent;
+  }
+  sf;
+  checker;
+  imports;
+  moduleDecls;
+  islandContent;
+  deps = { imports: /* @__PURE__ */ new Set(), moduleDecls: /* @__PURE__ */ new Set(), synthetic: /* @__PURE__ */ new Map() };
+  classify(symbol, name, node) {
+    if (!symbol) return void 0;
+    const binding = this.imports.bySymbol.get(symbol);
+    if (binding) {
+      this.deps.imports.add(binding);
+      return void 0;
+    }
+    const decl = symbol.declarations?.[0];
+    if (!decl) return void 0;
+    if (decl.getSourceFile() !== this.sf) return void 0;
+    if (this.islandContent.some((c) => containsRange(c, decl))) return void 0;
+    let top = decl;
+    while (top.parent && top.parent !== this.sf) top = top.parent;
+    const moduleDecl = this.moduleDecls.find((d) => d.statement === top);
+    if (moduleDecl) {
+      if (!this.deps.moduleDecls.has(moduleDecl)) {
+        this.deps.moduleDecls.add(moduleDecl);
+        if (!moduleDecl.exported) {
+          const failure = this.collectFromNode(moduleDecl.statement);
+          if (failure) return failure;
+        }
+      }
+      return void 0;
+    }
+    return {
+      message: `the type \`${name}\` is declared inside the component and can't be referenced from the island`,
+      node
+    };
+  }
+  /** Type names used inside a node that moves into the island. */
+  collectFromNode(node, exclude = []) {
+    for (const id of typeReferenceHeads(node)) {
+      if (exclude.some((e) => containsRange(e, id))) continue;
+      const failure = this.classify(this.checker.getSymbolAtLocation(id), id.text, id);
+      if (failure) return failure;
+    }
+    return void 0;
+  }
+  /**
+   * Type names inside a printed type (from checker.typeToString at `location`). `import("x").Y`
+   * forms become `import type { Y } from "x"` when x is a package name.
+   */
+  collectFromPrinted(printed, location) {
+    let text = printed;
+    const importTypeRe = /import\("([^"]+)"\)\.([A-Za-z_$][\w$]*)/g;
+    for (const match of printed.matchAll(importTypeRe)) {
+      const spec = match[1] ?? "";
+      const name = match[2] ?? "";
+      if (spec.startsWith(".") || spec.startsWith("/")) {
+        return { message: `can't name the type \`${name}\` from ${spec} in the generated file` };
+      }
+      const names = this.deps.synthetic.get(spec) ?? /* @__PURE__ */ new Set();
+      names.add(name);
+      this.deps.synthetic.set(spec, names);
+      text = text.replace(match[0], name);
+    }
+    const parsed = ts15.createSourceFile(
+      "__type.ts",
+      `type __T = ${text};`,
+      ts15.ScriptTarget.Latest,
+      true
+    );
+    const inScope = /* @__PURE__ */ new Map();
+    for (const symbol of this.checker.getSymbolsInScope(
+      location,
+      ts15.SymbolFlags.Type | ts15.SymbolFlags.Namespace | ts15.SymbolFlags.Alias
+    )) {
+      if (!inScope.has(symbol.getName())) inScope.set(symbol.getName(), symbol);
+    }
+    for (const id of typeReferenceHeads(parsed)) {
+      if (id.text === "__T") continue;
+      if (ts15.isTypeQueryNode(id.parent) || ts15.isQualifiedName(id.parent) && ts15.isTypeQueryNode(id.parent.parent)) {
+        return {
+          message: `a prop's type refers to the value \`${id.text}\` (typeof), which can't be named in the generated file`
+        };
+      }
+      if ([...this.deps.synthetic.values()].some((s) => s.has(id.text))) continue;
+      const symbol = inScope.get(id.text);
+      if (!symbol) {
+        return {
+          message: `can't name the type \`${id.text}\` in the generated file (it isn't imported here)`
+        };
+      }
+      const failure = this.classify(symbol, id.text, void 0);
+      if (failure) return failure;
+    }
+    return { text };
+  }
+};
+
+// src/transform/emit.ts
+function mergeRanges(ranges) {
+  const sorted = [...ranges].sort((a, b) => a.start - b.start);
+  const out = [];
+  for (const r of sorted) {
+    const last = out[out.length - 1];
+    if (last && r.start <= last.end) last.end = Math.max(last.end, r.end);
+    else out.push({ ...r });
+  }
+  return out;
+}
+var inAny = (ranges, pos) => ranges.some((r) => pos >= r.start && pos < r.end);
+function assignNames(plans, taken, renames) {
+  const islands = plans.flatMap((plan) => plan.islands.map((island) => ({ plan, island })));
+  for (const { plan, island } of islands) {
+    const base = islandBaseName(plan.component.name, island.rootTag);
+    let name = base;
+    for (let n = 2; taken.has(name); n++) name = `${base}${n}`;
+    taken.add(name);
+    island.name = name;
+  }
+  for (const { island } of islands) {
+    const renamed = renames[island.name];
+    if (renamed === void 0 || renamed === island.name) continue;
+    if (!/^[A-Z][A-Za-z0-9_$]*$/.test(renamed)) return `"${renamed}" is not a valid component name`;
+    if (taken.has(renamed)) return `"${renamed}" is already used in this file`;
+    taken.delete(island.name);
+    taken.add(renamed);
+    island.name = renamed;
+  }
+  return void 0;
+}
+function importClauseText(entries, allTypeOnly) {
+  const def = entries.find((e) => e.binding.imported === "default");
+  const ns = entries.find((e) => e.binding.imported === "*");
+  const named = entries.filter(
+    (e) => e.binding.imported !== "default" && e.binding.imported !== "*"
+  );
+  const parts = [];
+  if (def) parts.push(def.binding.local);
+  if (ns) parts.push(`* as ${ns.binding.local}`);
+  if (named.length > 0) {
+    const items = named.map((e) => {
+      const prefix = e.typeOnly && !allTypeOnly ? "type " : "";
+      const name = e.binding.imported === e.binding.local ? e.binding.local : `${e.binding.imported} as ${e.binding.local}`;
+      return prefix + name;
+    });
+    parts.push(`{ ${items.join(", ")} }`);
+  }
+  return parts.join(", ");
+}
+function importStatement(decl, sf, entries, style, specifierText) {
+  const allTypeOnly = entries.every((e) => e.typeOnly);
+  const attributes = decl.attributes ? ` ${decl.attributes.getText(sf)}` : "";
+  const semi = style.semi ? ";" : "";
+  const def = entries.find((e) => e.binding.imported === "default");
+  const rest = entries.filter((e) => e !== def);
+  if (allTypeOnly && def && rest.length > 0) {
+    return [
+      `import type ${def.binding.local} from ${specifierText}${attributes}${semi}`,
+      `import type ${importClauseText(rest, true)} from ${specifierText}${attributes}${semi}`
+    ];
+  }
+  return [
+    `import ${allTypeOnly ? "type " : ""}${importClauseText(entries, allTypeOnly)} from ${specifierText}${attributes}${semi}`
+  ];
+}
+function emitSplit(input) {
+  const { ctx, shape, imports, plans } = input;
+  const { sf, checker } = ctx;
+  const text = sf.text;
+  const style = detectStyle(sf);
+  const q = style.quote;
+  const semi = style.semi ? ";" : "";
+  const taken = /* @__PURE__ */ new Set();
+  for (const b of imports.bindings) taken.add(b.local);
+  for (const d of shape.moduleDecls) d.names.forEach((n) => taken.add(n));
+  for (const c of shape.components) taken.add(c.name);
+  const nameProblem = assignNames(plans, taken, input.renames ?? {});
+  if (nameProblem) return skip("unsupported-pattern", nameProblem);
+  const islands = plans.flatMap((p) => p.islands);
+  const islandContent = islands.flatMap((i) => [
+    i.root.node,
+    ...i.units.map((u) => u.node)
+  ]);
+  const collector = new TypeRefCollector(sf, checker, imports, shape.moduleDecls, islandContent);
+  const valueImports = /* @__PURE__ */ new Set();
+  const movedComponents = input.movedComponents ?? [];
+  const copiedDecls = new Set(movedComponents);
+  for (const decl of movedComponents) islandContent.push(decl.statement);
+  for (const island of islands) {
+    island.valueImports.forEach((b) => valueImports.add(b));
+    island.moduleDecls.forEach((d) => copiedDecls.add(d));
+  }
+  const allDecls = [...shape.moduleDecls, ...shape.componentDecls.values()];
+  for (const decl of copiedDecls)
+    if (decl.component && !islandContent.includes(decl.statement))
+      islandContent.push(decl.statement);
+  const declQueue = [...copiedDecls];
+  while (declQueue.length > 0) {
+    const decl = declQueue.pop();
+    let failure;
+    forEachValueRef(decl.statement, (id) => {
+      const symbol = symbolOfRef(checker, id);
+      if (!symbol) return;
+      const binding = imports.bySymbol.get(symbol);
+      if (binding) {
+        valueImports.add(binding);
+        return;
+      }
+      const d = symbol.declarations?.[0];
+      if (!d || d.getSourceFile() !== sf || containsRange(decl.statement, d)) return;
+      const other = allDecls.find((m) => containsRange(m.statement, d));
+      if (other && !copiedDecls.has(other)) {
+        copiedDecls.add(other);
+        if (other.component) islandContent.push(other.statement);
+        declQueue.push(other);
+      } else if (!other) {
+        failure = `copied helper refers to \`${id.text}\`, which can't be moved`;
+      }
+    });
+    if (failure) return skip("unsupported-pattern", failure, locOf(ctx, decl.statement));
+  }
+  const slotNodes = islands.flatMap((i) => i.slots.map((slot) => slot.j.node));
+  for (const node of islandContent) {
+    const failure = collector.collectFromNode(node, slotNodes);
+    if (failure)
+      return skip(
+        "unsupported-pattern",
+        failure.message,
+        failure.node ? locOf(ctx, failure.node) : void 0
+      );
+  }
+  for (const decl of copiedDecls) {
+    const failure = collector.collectFromNode(decl.statement);
+    if (failure) return skip("unsupported-pattern", failure.message, locOf(ctx, decl.statement));
+  }
+  const extraTypeImports = /* @__PURE__ */ new Map();
+  let reactNodeType = "ReactNode";
+  if (!ctx.isJs && islands.some((i) => i.slots.length > 0)) {
+    const fromReact = (b) => b.module.kind === "external" && b.module.info.kind === "react";
+    const named = imports.bindings.find((b) => fromReact(b) && b.imported === "ReactNode");
+    const namespace = imports.bindings.find(
+      (b) => fromReact(b) && (b.imported === "*" || b.imported === "default")
+    );
+    if (named) {
+      reactNodeType = named.local;
+      collector.deps.imports.add(named);
+    } else if (namespace) {
+      reactNodeType = `${namespace.local}.ReactNode`;
+      collector.deps.imports.add(namespace);
+    } else if (taken.has("ReactNode")) {
+      return skip(
+        "unsupported-pattern",
+        "`ReactNode` is already declared in this file, so slot props can't be typed"
+      );
+    } else {
+      extraTypeImports.set("react", ["ReactNode"]);
+    }
+  }
+  const signatures = /* @__PURE__ */ new Map();
+  for (const island of islands) {
+    if (island.props.length === 0 && island.slots.length === 0) {
+      signatures.set(island, "");
+      continue;
+    }
+    const names = [
+      ...island.props.map((p) => p.name),
+      ...island.slots.map((slot) => slot.name)
+    ].join(", ");
+    if (ctx.isJs) {
+      signatures.set(island, `{ ${names} }`);
+      continue;
+    }
+    const members = [];
+    for (const prop of island.props) {
+      if (prop.picked) {
+        const result2 = collector.collectFromPrinted(prop.picked.typeText, island.root.node);
+        if ("message" in result2)
+          return skip(
+            "unsupported-pattern",
+            `prop \`${prop.name}\`: ${result2.message}`,
+            locOf(ctx, prop.refNode)
+          );
+        members.push(`${prop.name}: ${result2.text}`);
+        continue;
+      }
+      const printed = checker.typeToString(
+        prop.type,
+        island.root.node,
+        ts16.TypeFormatFlags.NoTruncation | ts16.TypeFormatFlags.UseAliasDefinedOutsideCurrentScope
+      );
+      const result = collector.collectFromPrinted(printed, island.root.node);
+      if ("message" in result)
+        return skip(
+          "unsupported-pattern",
+          `prop \`${prop.name}\`: ${result.message}`,
+          locOf(ctx, prop.refNode)
+        );
+      members.push(`${prop.name}: ${result.text}`);
+    }
+    for (const slot of island.slots) members.push(`${slot.name}: ${reactNodeType}`);
+    signatures.set(island, `{ ${names} }: { ${members.join("; ")} }`);
+  }
+  const allCopied = /* @__PURE__ */ new Set([...copiedDecls]);
+  for (const decl of collector.deps.moduleDecls) if (!decl.exported) allCopied.add(decl);
+  const exportedTypeImports = [...collector.deps.moduleDecls].filter((d) => d.exported).flatMap((d) => d.names);
+  const islandLines = [];
+  const directiveQuote = q;
+  islandLines.push(`${directiveQuote}use client${directiveQuote}${semi}`);
+  for (const decl of imports.declarations) {
+    const entries = [];
+    for (const binding of imports.bindings) {
+      if (binding.declaration !== decl) continue;
+      const usedAsValue = valueImports.has(binding);
+      const usedAsType = collector.deps.imports.has(binding);
+      if (!usedAsValue && !usedAsType) continue;
+      entries.push({ binding, typeOnly: binding.typeOnly || !usedAsValue });
+    }
+    if (entries.length === 0) continue;
+    const spec = decl.moduleSpecifier;
+    const rebased = input.rebaseSpecifier(spec.text);
+    const specText = rebased === spec.text ? spec.getText(sf) : `${q}${rebased}${q}`;
+    const all = imports.bindings.filter((b) => b.declaration === decl);
+    const sameAsOriginal = rebased === spec.text && entries.length === all.length && entries.every((e) => e.typeOnly === e.binding.typeOnly);
+    const extra = extraTypeImports.get(spec.text);
+    if (extra && !entries.every((e) => e.typeOnly) && decl.importClause?.namedBindings && !ts16.isNamespaceImport(decl.importClause.namedBindings)) {
+      extraTypeImports.delete(spec.text);
+      const clause = importClauseText(entries, false).replace(
+        / \}$/,
+        `, ${extra.map((n) => `type ${n}`).join(", ")} }`
+      );
+      islandLines.push(
+        `import ${clause} from ${specText}${decl.attributes ? ` ${decl.attributes.getText(sf)}` : ""}${semi}`
+      );
+      continue;
+    }
+    if (sameAsOriginal) islandLines.push(decl.getText(sf));
+    else islandLines.push(...importStatement(decl, sf, entries, style, specText));
+  }
+  for (const [spec, names] of extraTypeImports) {
+    islandLines.push(`import type { ${names.join(", ")} } from ${q}${spec}${q}${semi}`);
+  }
+  if (exportedTypeImports.length > 0) {
+    islandLines.push(
+      `import type { ${exportedTypeImports.join(", ")} } from ${q}${input.originalSpecifier}${q}${semi}`
+    );
+  }
+  for (const [spec, names] of collector.deps.synthetic) {
+    islandLines.push(`import type { ${[...names].join(", ")} } from ${q}${spec}${q}${semi}`);
+  }
+  const blocks = [islandLines.join("\n")];
+  const moved = new Set(movedComponents);
+  for (const decl of [...allDecls].sort(
+    (a, b) => a.statement.getStart(sf) - b.statement.getStart(sf)
+  )) {
+    if (!allCopied.has(decl)) continue;
+    let declText = statementSource(decl.statement, sf);
+    if (decl.component) declText = withoutExportModifiers(decl.statement, sf);
+    if (moved.has(decl)) declText = `export ${declText}`;
+    blocks.push(declText);
+  }
+  for (const island of islands) {
+    blocks.push(renderIsland(island, signatures.get(island) ?? "", sf, style));
+  }
+  const islandText = `${blocks.join("\n\n")}
+`;
+  const ms = new MagicString(text);
+  const removed = [];
+  const directive = getModuleDirective(sf).statement;
+  if (directive) {
+    let end = directive.getEnd();
+    while (end < text.length && /\s/.test(text[end] ?? "")) end++;
+    removed.push({ start: directive.getStart(sf), end });
+  }
+  const unitRanges = [];
+  for (const plan of plans) {
+    for (const unit of plan.removedUnits) unitRanges.push(statementLineRange(sf, unit.node));
+  }
+  for (const r of mergeRanges(unitRanges)) removed.push(collapseBlankLines(text, r));
+  const replacedRoots = islands.map((i) => ({
+    start: i.root.node.getStart(sf),
+    end: i.root.node.getEnd()
+  }));
+  const keptInside = slotNodes.map((n) => ({ start: n.getStart(sf), end: n.getEnd() }));
+  const moduleRemovals = /* @__PURE__ */ new Set();
+  for (const plan of plans) plan.movedModuleDecls.forEach((d) => moduleRemovals.add(d));
+  for (const decl of movedComponents) {
+    removed.push(collapseBlankLines(text, statementLineRange(sf, decl.statement)));
+  }
+  const baseRemoved = () => [
+    ...removed,
+    ...replacedRoots,
+    ...[...moduleRemovals].map((d) => statementLineRange(sf, d.statement))
+  ];
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const decl of allCopied) {
+      if (moduleRemovals.has(decl) || decl.exported || moved.has(decl)) continue;
+      if (!isReferencedOutside(decl, sf, checker, baseRemoved(), keptInside)) {
+        moduleRemovals.add(decl);
+        changed = true;
+      }
+    }
+  }
+  for (const decl of moduleRemovals) {
+    if (isReferencedOutside(decl, sf, checker, baseRemoved(), keptInside)) {
+      return skip(
+        "unsupported-pattern",
+        `client-only helper ${decl.names.join(", ")} is still used by the server part`,
+        locOf(ctx, decl.statement)
+      );
+    }
+    removed.push(collapseBlankLines(text, statementLineRange(sf, decl.statement)));
+  }
+  const allRemoved = [...removed, ...replacedRoots];
+  const keyRanges = islands.flatMap(
+    (i) => i.keyAttr ? [{ start: i.keyAttr.getStart(sf), end: i.keyAttr.getEnd() }] : []
+  );
+  const remainingUse = /* @__PURE__ */ new Map();
+  forEachIdentifier(sf, (id) => {
+    const pos = id.getStart(sf);
+    if (inAny(allRemoved, pos) && !inAny(keyRanges, pos) && !inAny(keptInside, pos)) return;
+    const symbol = symbolOfRef(checker, id);
+    const binding = symbol ? imports.bySymbol.get(symbol) : void 0;
+    if (!binding) return;
+    if (containsRange(binding.declaration, id)) return;
+    const use = remainingUse.get(binding) ?? { value: false, type: false };
+    if (isInTypePosition2(id)) use.type = true;
+    else use.value = true;
+    remainingUse.set(binding, use);
+  });
+  let lastKeptImport;
+  for (const decl of imports.declarations) {
+    const all = imports.bindings.filter((b) => b.declaration === decl);
+    if (!decl.importClause) {
+      lastKeptImport = decl;
+      continue;
+    }
+    const kept = all.filter((b) => remainingUse.has(b));
+    const range = statementLineRange(sf, decl);
+    if (kept.length === 0) {
+      removed.push(range);
+      ms.remove(range.start, range.end);
+      continue;
+    }
+    lastKeptImport = decl;
+    const valueUsed = kept.some((b) => remainingUse.get(b)?.value && !b.typeOnly);
+    const moduleIsNeutral = kept.every((b) => isNeutralModule(b));
+    const needsTypeOnly = !valueUsed && !decl.importClause.isTypeOnly && !moduleIsNeutral;
+    if (kept.length === all.length && !needsTypeOnly) continue;
+    const entries = kept.map((b) => ({ binding: b, typeOnly: b.typeOnly || needsTypeOnly }));
+    const spec = decl.moduleSpecifier.getText(sf);
+    ms.overwrite(
+      decl.getStart(sf),
+      decl.getEnd(),
+      importStatement(decl, sf, entries, style, spec).join("\n")
+    );
+  }
+  if (directive) ms.remove(directive.getStart(sf), removed[0]?.end ?? directive.getEnd());
+  for (const r of mergeRanges(unitRanges)) {
+    const collapsed = collapseBlankLines(text, r);
+    ms.remove(collapsed.start, collapsed.end);
+  }
+  for (const decl of moduleRemovals) {
+    const r = collapseBlankLines(text, statementLineRange(sf, decl.statement));
+    ms.remove(r.start, r.end);
+  }
+  for (const island of islands) {
+    const attrs = [];
+    if (island.keyAttr) attrs.push(island.keyAttr.getText(sf));
+    for (const prop of island.props)
+      attrs.push(`${prop.name}={${prop.picked ? prop.picked.serverExpr : prop.name}}`);
+    const rootStart = island.root.node.getStart(sf);
+    const slotIndent = indentationOfLine(text, rootStart) + style.indent;
+    const slotSource = (node) => {
+      const start = node.getStart(sf);
+      const raw = text.slice(start, node.getEnd());
+      return hasMultilineLiteral(node, sf) ? raw : reindent(raw, indentationOfLine(text, start), slotIndent);
+    };
+    let usage;
+    const [onlySlot] = island.slots;
+    if (island.slots.length === 1 && onlySlot?.name === "children") {
+      const open = `<${island.name}${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""}>`;
+      usage = `${open}
+${slotIndent}${slotSource(onlySlot.j.node)}
+${indentationOfLine(text, rootStart)}</${island.name}>`;
+    } else {
+      for (const slot of island.slots) attrs.push(`${slot.name}={${slotSource(slot.j.node)}}`);
+      usage = `<${island.name}${attrs.length > 0 ? ` ${attrs.join(" ")}` : ""} />`;
+    }
+    ms.overwrite(rootStart, island.root.node.getEnd(), usage);
+  }
+  for (const decl of movedComponents) {
+    const r = collapseBlankLines(text, statementLineRange(sf, decl.statement));
+    ms.remove(r.start, r.end);
+  }
+  const importedBack = movedComponents.filter(
+    (decl) => isReferencedOutside(decl, sf, checker, [...removed, ...replacedRoots], keptInside)
+  ).flatMap((decl) => decl.names);
+  const importNames = [...islands.map((i) => i.name), ...importedBack];
+  if (importNames.length === 0)
+    return skip("unsupported-pattern", "nothing would be imported from the island file");
+  const importLine = `import { ${importNames.join(", ")} } from ${q}${input.islandSpecifier}${q}${semi}`;
+  const firstImport = imports.declarations[0];
+  if (lastKeptImport) ms.appendLeft(lastKeptImport.getEnd(), `
+${importLine}`);
+  else if (firstImport) {
+    ms.prependRight(statementLineRange(sf, firstImport).start, `${importLine}
+`);
+  } else {
+    const firstKept = sf.statements.find((s) => s !== directive && !inAny(removed, s.getStart(sf)));
+    const at = firstKept ? lineStartOf(text, firstKept.getStart(sf)) : text.length;
+    ms.prependRight(at, `${importLine}
+
+`);
+  }
+  return ok({ serverText: ms.toString(), islandText, islands });
+}
+function statementSource(statement, sf) {
+  const range = statementLineRange(sf, statement);
+  return sf.text.slice(range.start, statement.getEnd()).replace(/^\s*\n/, "");
+}
+function withoutExportModifiers(statement, sf) {
+  const range = statementLineRange(sf, statement);
+  const base = range.start;
+  const ms = new MagicString(sf.text.slice(base, statement.getEnd()));
+  const modifiers = ts16.canHaveModifiers(statement) ? ts16.getModifiers(statement) ?? [] : [];
+  for (const modifier of modifiers) {
+    if (modifier.kind !== ts16.SyntaxKind.ExportKeyword && modifier.kind !== ts16.SyntaxKind.DefaultKeyword)
+      continue;
+    let end = modifier.getEnd();
+    while (/\s/.test(sf.text[end] ?? "")) end++;
+    ms.remove(modifier.getStart(sf) - base, end - base);
+  }
+  return ms.toString().replace(/^\s*\n/, "");
+}
+function isNeutralModule(binding) {
+  if (binding.module.kind === "project") return binding.module.directive !== "use client";
+  return [
+    "neutral",
+    "server-safe-list",
+    "json",
+    "asset",
+    "css-module",
+    "stylesheet",
+    "react",
+    "builtin",
+    "server-only-marker"
+  ].includes(binding.module.info.kind);
+}
+function isInTypePosition2(id) {
+  let node = id;
+  while (node.parent) {
+    if (ts16.isTypeNode(node.parent) && !ts16.isExpressionWithTypeArguments(node.parent)) return true;
+    if (ts16.isTypeAliasDeclaration(node.parent) || ts16.isInterfaceDeclaration(node.parent))
+      return true;
+    if (ts16.isExpression(node.parent) || ts16.isStatement(node.parent)) return false;
+    node = node.parent;
+  }
+  return false;
+}
+function isReferencedOutside(decl, sf, checker, removed, kept = []) {
+  const symbols = /* @__PURE__ */ new Set();
+  for (const name of decl.names) {
+    const nameNode = decl.statement.name;
+    if (nameNode && ts16.isIdentifier(nameNode)) {
+      const s = checker.getSymbolAtLocation(nameNode);
+      if (s) symbols.add(s);
+    }
+    if (ts16.isVariableStatement(decl.statement)) {
+      for (const d of decl.statement.declarationList.declarations) {
+        if (ts16.isIdentifier(d.name) && d.name.text === name) {
+          const s = checker.getSymbolAtLocation(d.name);
+          if (s) symbols.add(s);
+        }
+      }
+    }
+  }
+  let found = false;
+  forEachIdentifier(sf, (id) => {
+    if (found) return;
+    if (containsRange(decl.statement, id)) return;
+    const pos = id.getStart(sf);
+    if (inAny(removed, pos) && !inAny(kept, pos)) return;
+    const symbol = symbolOfRef(checker, id);
+    if (symbol && symbols.has(symbol)) found = true;
+  });
+  return found;
+}
+function collapseBlankLines(text, range) {
+  const { start } = range;
+  let { end } = range;
+  const prevLineEnd = start - 1;
+  const prevLine = prevLineEnd >= 0 ? text.slice(lineStartOf(text, prevLineEnd), prevLineEnd) : "";
+  const isBlankAt = (pos) => pos < text.length && text.slice(pos, lineEndOf(text, pos)).trim() === "";
+  if (start > 0 && text[start - 1] === "\n") {
+    if (prevLine.trimEnd().endsWith("{") || prevLine.trimEnd().endsWith("(")) {
+      while (end < text.length && isBlankAt(end) && text[lineEndOf(text, end)] === "\n")
+        end = lineEndOf(text, end) + 1;
+    } else if (prevLine.trim() === "" && isBlankAt(end) && text[lineEndOf(text, end)] === "\n") {
+      end = lineEndOf(text, end) + 1;
+    }
+  }
+  return { start, end };
+}
+function renderIsland(island, signature, sf, style) {
+  const text = sf.text;
+  const semi = style.semi ? ";" : "";
+  const ind = style.indent;
+  const lines = [`export function ${island.name}(${signature}) {`];
+  const blankAfter = (node) => {
+    const rest = text.slice(node.getEnd());
+    const gap = /^[^\S\n]*(?:\/\/[^\n]*)?\n([^\S\n]*\n)/.exec(rest);
+    return gap !== null;
+  };
+  island.units.forEach((unit, i) => {
+    lines.push(renderUnit(unit, sf, ind));
+    const next = island.units[i + 1];
+    const separated = next ? /\n[^\S\n]*\n/.test(text.slice(unit.node.getEnd(), statementLineRange(sf, next.node).start)) : blankAfter(unit.node);
+    if (separated) lines.push("");
+  });
+  const root = island.root.node;
+  const rootStart = root.getStart(sf);
+  const ms = new MagicString(text);
+  for (const slot of island.slots) {
+    ms.overwrite(slot.j.node.getStart(sf), slot.j.node.getEnd(), `{${slot.name}}`);
+  }
+  if (island.keyAttr) {
+    let start = island.keyAttr.getStart(sf);
+    while (start > 0 && /[ \t]/.test(text[start - 1] ?? "")) start--;
+    ms.remove(start, island.keyAttr.getEnd());
+  }
+  let rootText = ms.slice(rootStart, root.getEnd());
+  const multiline = rootText.includes("\n");
+  if (!multiline) {
+    lines.push(`${ind}return ${rootText}${semi}`);
+  } else {
+    if (!hasMultilineLiteral(root, sf))
+      rootText = reindent(rootText, indentationOfLine(text, rootStart), ind + ind);
+    lines.push(`${ind}return (`, `${ind}${ind}${rootText}`, `${ind})${semi}`);
+  }
+  lines.push("}");
+  return lines.join("\n");
+}
+function renderUnit(unit, sf, ind) {
+  const text = sf.text;
+  const range = statementLineRange(sf, unit.node);
+  const start = range.whole ? range.start : unit.node.getStart(sf);
+  let chunk = text.slice(start, unit.node.getEnd());
+  const lineIndent = indentationOfLine(text, unit.node.getStart(sf));
+  chunk = chunk.replace(/^[ \t]*/, "");
+  if (!hasMultilineLiteral(unit.node, sf)) chunk = reindent(chunk, lineIndent, ind);
+  return `${ind}${chunk}`;
+}
+
+// src/transform/format.ts
+import { createRequire as createRequire2 } from "module";
+import path7 from "path";
+import { pathToFileURL as pathToFileURL2 } from "url";
+var cache = /* @__PURE__ */ new Map();
+function loadPrettier(root) {
+  let pending = cache.get(root);
+  if (!pending) {
+    pending = (async () => {
+      try {
+        const require2 = createRequire2(path7.join(root, "package.json"));
+        const entry = require2.resolve("prettier");
+        const mod = await import(pathToFileURL2(entry).href);
+        return typeof mod.format === "function" ? mod : mod.default;
+      } catch {
+        return void 0;
+      }
+    })();
+    cache.set(root, pending);
+  }
+  return pending;
+}
+async function formatWithProjectPrettier(root, file, text) {
+  const prettier = await loadPrettier(root);
+  if (!prettier) return text;
+  const configFile = await prettier.resolveConfigFile(file);
+  if (!configFile || path7.relative(root, configFile).startsWith("..")) return text;
+  const options = await prettier.resolveConfig(file, { config: configFile }) ?? {};
+  return prettier.format(text, { ...options, filepath: file });
+}
+
+// src/verify/selfCheck.ts
+import path8 from "path";
+import { ts as ts17 } from "ts-morph";
+function diagnosticsOf(program, sf, bucket) {
+  const out = /* @__PURE__ */ new Map();
+  const all = [...program.getSyntacticDiagnostics(sf), ...program.getSemanticDiagnostics(sf)];
+  for (const d of all) {
+    const key = `${bucket}|TS${d.code}|${ts17.flattenDiagnosticMessageText(d.messageText, " ")}`;
+    out.set(key, (out.get(key) ?? 0) + 1);
+  }
+  return out;
+}
+function merge(into, from) {
+  for (const [k, v] of from) into.set(k, (into.get(k) ?? 0) + v);
+}
+function selfCheck(input) {
+  const { loaded, file, islandFile } = input;
+  const project = loaded.project;
+  const original = project.getSourceFile(file);
+  if (!original) return skip("self-check-failed", "the original file is not in the project");
+  const originalText = original.getFullText();
+  const before = /* @__PURE__ */ new Map();
+  {
+    const program = project.getProgram().compilerObject;
+    const sf = program.getSourceFile(file);
+    if (sf) merge(before, diagnosticsOf(program, sf, "self"));
+    for (const importer of input.importers) {
+      const isf = program.getSourceFile(importer);
+      if (isf) merge(before, diagnosticsOf(program, isf, importer));
+    }
+  }
+  let islandWrapper;
+  try {
+    setSourceText(original, input.serverText);
+    islandWrapper = project.createSourceFile(islandFile, input.islandText, { overwrite: false });
+    const program = project.getProgram().compilerObject;
+    const checker = program.getTypeChecker();
+    const serverSf = program.getSourceFile(file);
+    const islandSf = program.getSourceFile(islandFile);
+    if (!serverSf || !islandSf)
+      return skip("self-check-failed", "generated files are missing from the program");
+    for (const sf of [serverSf, islandSf]) {
+      const syntax = program.getSyntacticDiagnostics(sf);
+      const first = syntax[0];
+      if (first) {
+        return skip(
+          "self-check-failed",
+          `${path8.basename(sf.fileName)} doesn't parse: ${ts17.flattenDiagnosticMessageText(first.messageText, " ")}`
+        );
+      }
+    }
+    const after = /* @__PURE__ */ new Map();
+    merge(after, diagnosticsOf(program, serverSf, "self"));
+    merge(after, diagnosticsOf(program, islandSf, "self"));
+    for (const importer of input.importers) {
+      const isf = program.getSourceFile(importer);
+      if (isf) merge(after, diagnosticsOf(program, isf, importer));
+    }
+    const added = [];
+    for (const [key, count] of after) {
+      if (count > (before.get(key) ?? 0)) added.push(key.split("|").slice(1).join(": "));
+    }
+    if (added.length > 0) {
+      return skip(
+        "self-check-failed",
+        `typechecking the output found new errors: ${added.slice(0, 3).join("; ")}`
+      );
+    }
+    if (getModuleDirective(serverSf).directive === "use client") {
+      return skip("self-check-failed", 'the rewritten file still starts with "use client"');
+    }
+    const imports = buildImportTable(serverSf, checker, input.graph);
+    const facts = new FileFacts(
+      serverSf,
+      checker,
+      imports,
+      input.framework,
+      input.moduleSafety.check,
+      input.serverSafeHooks
+    );
+    const islandSymbols = new Set(
+      imports.bindings.filter((b) => b.specifier === input.islandSpecifier).map((b) => b.symbol)
+    );
+    for (const marker of facts.scanMarkers(serverSf)) {
+      if (marker.kind === "client-import" && islandSymbols.size > 0 && isIslandTag(marker.node, checker, islandSymbols))
+        continue;
+      return skip(
+        "self-check-failed",
+        `the rewritten file still uses client-only code (${marker.detail})`
+      );
+    }
+    let problem;
+    const visit = (n) => {
+      if (problem) return;
+      if (ts17.isJsxOpeningElement(n) || ts17.isJsxSelfClosingElement(n)) {
+        const intrinsic = isIntrinsicTagName(n.tagName);
+        const crossesBoundary = !intrinsic && isClientReferenceTag(n.tagName, facts, islandSymbols, checker);
+        for (const attr of n.attributes.properties) {
+          if (ts17.isJsxSpreadAttribute(attr)) {
+            if (crossesBoundary && !checkSerializable(checker, checker.getTypeAtLocation(attr.expression), {
+              primitivesOnly: input.isJs
+            }).ok) {
+              problem = `spread props on <${n.tagName.getText(serverSf)}> are not serializable`;
+            }
+            continue;
+          }
+          const name = attr.name.getText(serverSf);
+          if (intrinsic && (/^on[A-Z]/.test(name) || name === "ref")) {
+            problem = `<${n.tagName.getText(serverSf)}> still has ${name}`;
+            return;
+          }
+          const init = attr.initializer;
+          if (!init || !ts17.isJsxExpression(init) || !init.expression) continue;
+          const type = checker.getTypeAtLocation(init.expression);
+          const action = isServerActionExpr(init.expression, facts, input.serverActionProps);
+          if (isCallableType(type) && !action) {
+            problem = `<${n.tagName.getText(serverSf)}> receives a function in ${name}`;
+            return;
+          }
+          if (crossesBoundary && !action) {
+            const verdict = checkSerializable(checker, type, { primitivesOnly: input.isJs });
+            if (!verdict.ok) {
+              problem = `prop ${name} of <${n.tagName.getText(serverSf)}> ${verdict.reason}`;
+              return;
+            }
+          }
+        }
+      }
+      ts17.forEachChild(n, visit);
+    };
+    visit(serverSf);
+    if (problem) return skip("self-check-failed", problem);
+    for (const statement of islandSf.statements) {
+      if (!ts17.isImportDeclaration(statement) || !ts17.isStringLiteral(statement.moduleSpecifier))
+        continue;
+      if (statement.importClause?.isTypeOnly) continue;
+      const spec = statement.moduleSpecifier.text;
+      const resolved = ts17.resolveModuleName(
+        spec,
+        islandFile,
+        { ...loaded.compilerOptions, allowJs: true },
+        ts17.sys
+      ).resolvedModule;
+      if (resolved && !resolved.isExternalLibraryImport && !resolved.resolvedFileName.includes("/node_modules/"))
+        continue;
+      const info = input.classifier.classify(spec, islandFile);
+      if (info.kind === "builtin" || info.kind === "server-only-marker") {
+        return skip("self-check-failed", `the island file imports the server-only module ${spec}`);
+      }
+      if (info.kind === "framework") {
+        const rule = input.framework.classifyModule(spec);
+        if (rule?.kind === "per-name") {
+          const names = namedImports(statement);
+          if (names.some((n) => rule.classify(n) === "server-only")) {
+            return skip(
+              "self-check-failed",
+              `the island file imports the server-only module ${spec}`
+            );
+          }
+        }
+      }
+    }
+    return ok(void 0);
+  } finally {
+    setSourceText(original, originalText);
+    if (islandWrapper) project.removeSourceFile(islandWrapper);
+  }
+}
+function namedImports(decl) {
+  const clause = decl.importClause;
+  if (!clause) return [];
+  const out = [];
+  if (clause.name) out.push("default");
+  const b = clause.namedBindings;
+  if (b && ts17.isNamedImports(b))
+    for (const e of b.elements) out.push((e.propertyName ?? e.name).text);
+  if (b && ts17.isNamespaceImport(b)) out.push("*");
+  return out;
+}
+function isIslandTag(node, checker, islandSymbols) {
+  if (!ts17.isIdentifier(node)) return false;
+  const symbol = checker.getSymbolAtLocation(node);
+  return symbol !== void 0 && islandSymbols.has(symbol);
+}
+function isClientReferenceTag(tag, facts, islandSymbols, checker) {
+  let head = tag;
+  while (ts17.isPropertyAccessExpression(head)) head = head.expression;
+  if (!ts17.isIdentifier(head)) return true;
+  const symbol = checker.getSymbolAtLocation(head);
+  if (symbol && islandSymbols.has(symbol)) return true;
+  const info = facts.classifyRef(head);
+  if (info.kind === "import") return info.usage.cls !== "neutral";
+  return info.kind !== "file";
+}
+function isServerActionExpr(expr, facts, serverActionProps) {
+  const e = stripParens(expr);
+  if (!ts17.isIdentifier(e)) return false;
+  const info = facts.classifyRef(e);
+  if (info.kind === "import") return info.usage.cls === "server-action";
+  if (info.kind === "file" && serverActionProps && ts17.isBindingElement(info.declaration)) {
+    const element = info.declaration;
+    const propName = element.propertyName ?? element.name;
+    const inParameter = ts17.isObjectBindingPattern(element.parent) && ts17.isParameter(element.parent.parent);
+    return inParameter && ts17.isIdentifier(propName) && serverActionProps.has(propName.text);
+  }
+  return false;
+}
+
+// src/split.ts
+var STYLESHEET_RE2 = /\.(css|scss|sass|less|styl|pcss)$/;
+function createRunContext(root, config, options = {}) {
+  const framework = nextAdapter;
+  const loaded = loadProject(root, {
+    lazy: options.lazy ?? false,
+    ...options.tsconfig ? { tsconfig: options.tsconfig } : {}
+  });
+  const classifier = new PackageClassifier(framework, config.clientOnlyPackages);
+  const graph = buildModuleGraph(loaded, classifier);
+  const serverSafeHooks = new Set(config.serverSafeHooks);
+  const moduleSafety = new ModuleSafety(
+    () => loaded.project.getProgram().compilerObject,
+    graph,
+    framework,
+    serverSafeHooks
+  );
+  return {
+    root,
+    config,
+    framework,
+    loaded,
+    graph,
+    classifier,
+    moduleSafety,
+    serverSafeHooks,
+    pageExtensions: readPageExtensions(root),
+    measurer: void 0
+  };
+}
+async function runSplit(options = {}) {
+  const root = realpathSync(path9.resolve(options.root ?? process.cwd()));
+  const configFile = options.noConfigFile ? void 0 : options.configFile ? path9.resolve(root, options.configFile) : findConfigFile(root);
+  const fileConfig = configFile ? await loadConfigFile(configFile) : void 0;
+  const config = resolveConfig(fileConfig, options.config);
+  const run = createRunContext(root, config);
+  if (options.measure !== false) {
+    const { BundleMeasurer } = await import("./bundleSize-KPGJRR3B.js");
+    run.measurer = new BundleMeasurer(root, run.graph, run.loaded.configFile);
+  }
+  const { graph } = run;
+  const targets = selectTargets(root, options.paths, config);
+  const files = [];
+  for (const file of targets) {
+    const node = graph.nodes.get(file);
+    if (node?.directive !== "use client") continue;
+    const result = await processFile(run, file);
+    files.push(result);
+    options.onFile?.(result);
+  }
+  if (options.write) {
+    for (const result of files) {
+      if (result.status !== "split") continue;
+      for (const [rel2, content] of Object.entries(result.outputs)) {
+        const abs = path9.join(root, rel2);
+        mkdirSync(path9.dirname(abs), { recursive: true });
+        writeFileSync2(abs, content);
+      }
+    }
+  }
+  return {
+    files,
+    filesScanned: targets.length,
+    rerun: (relFile, renames) => processFile(run, path9.resolve(root, relFile), renames)
+  };
+}
+function selectTargets(root, paths, config) {
+  const ignore = [...IGNORE_GLOBS, ...config.exclude];
+  const sourceGlob = "**/*.{tsx,jsx,ts,js,mts,mjs}";
+  let files;
+  if (paths && paths.length > 0) {
+    files = [];
+    for (const p of paths) {
+      const abs = path9.resolve(root, p);
+      if (!existsSync5(abs)) continue;
+      if (/\.(tsx|jsx|ts|js|mts|mjs)$/.test(abs) && !abs.endsWith(".d.ts")) files.push(abs);
+      else
+        files.push(
+          ...fg3.sync([sourceGlob], { cwd: abs, ignore: [...ignore, "**/*.d.ts"], absolute: true })
+        );
+    }
+  } else {
+    files = fg3.sync(
+      config.include.map((g) => g.endsWith("/**") ? `${g}/*` : g),
+      { cwd: root, ignore: [...ignore, "**/*.d.ts"], absolute: true }
+    );
+  }
+  return [...new Set(files.map((f) => path9.resolve(f)))].filter((f) => /\.(tsx|jsx|ts|js|mts|mjs)$/.test(f)).sort();
+}
+function rel(root, file) {
+  return path9.relative(root, file).split(path9.sep).join("/");
+}
+async function processFile(run, file, renames = {}) {
+  const relFile = rel(run.root, file);
+  const base = {
+    file: relFile,
+    status: "skipped",
+    islands: [],
+    staticRatio: 0,
+    diff: "",
+    outputs: {}
+  };
+  try {
+    const planned = await planFile(run, file, renames);
+    if (!planned.ok) return { ...base, skipped: planned.skip };
+    const value = planned.value;
+    const diff = Object.entries(value.outputs).map(([relPath, content]) => {
+      const isOriginal = relPath === relFile;
+      return createTwoFilesPatch(
+        isOriginal ? `a/${relPath}` : "/dev/null",
+        `b/${relPath}`,
+        isOriginal ? value.originalText : "",
+        content,
+        void 0,
+        void 0,
+        { context: 3 }
+      );
+    }).join("");
+    return {
+      file: relFile,
+      status: "split",
+      islands: value.islands,
+      staticRatio: value.staticRatio,
+      ...value.bytesSaved ? { bytesSaved: value.bytesSaved } : {},
+      ...value.measureError ? { measureError: value.measureError } : {},
+      diff,
+      outputs: value.outputs
+    };
+  } catch (error) {
+    const err = error;
+    return {
+      ...base,
+      skipped: { code: "internal-error", message: `${err.message}
+${err.stack ?? ""}` }
+    };
+  }
+}
+function analyzeFile(run, file, renames = {}) {
+  const { loaded, graph, config, framework, root } = run;
+  const node = graph.nodes.get(file);
+  if (!node?.inProgram) {
+    return skip(
+      "unsupported-pattern",
+      "the file is not part of the TypeScript program (for .js/.jsx files, enable allowJs or add a jsconfig.json)"
+    );
+  }
+  const baseName = path9.basename(file).replace(/\.[^.]+$/, "");
+  if (framework.mustStayClientFiles.includes(baseName)) {
+    return skip(
+      "unsupported-pattern",
+      `Next.js requires ${path9.basename(file)} to be a Client Component`
+    );
+  }
+  const program = loaded.project.getProgram().compilerObject;
+  const sf = program.getSourceFile(file);
+  if (!sf) return skip("parse-error", "the file could not be loaded");
+  const syntax = program.getSyntacticDiagnostics(sf)[0];
+  if (syntax) {
+    const lc = sf.getLineAndCharacterOfPosition(syntax.start ?? 0);
+    return skip("parse-error", ts18.flattenDiagnosticMessageText(syntax.messageText, " "), {
+      line: lc.line + 1,
+      column: lc.character + 1
+    });
+  }
+  const checker = program.getTypeChecker();
+  const isJs = /\.(jsx?|mjs|cjs)$/.test(file);
+  const ctx = {
+    program,
+    checker,
+    sf,
+    file,
+    graph,
+    config,
+    framework,
+    isJs,
+    moduleSafety: run.moduleSafety
+  };
+  const ext = path9.extname(file);
+  const dir = config.islandsDir ? path9.join(path9.dirname(file), config.islandsDir) : path9.dirname(file);
+  const islandFile = path9.join(dir, `${path9.basename(file, ext)}${config.clientFileSuffix}${ext}`);
+  if (existsSync5(islandFile) || loaded.project.getSourceFile(islandFile)) {
+    return skip(
+      "output-exists",
+      `${rel(root, islandFile)} already exists; existing files are never merged into`
+    );
+  }
+  if (!run.pageExtensions.ok) return skip("would-create-route", run.pageExtensions.reason);
+  if (couldBecomeRoute(root, islandFile, run.pageExtensions.extensions)) {
+    return skip(
+      "would-create-route",
+      `${rel(root, islandFile)} could be picked up as a Next.js route`
+    );
+  }
+  const imports = buildImportTable(sf, checker, graph);
+  const facts = new FileFacts(
+    sf,
+    checker,
+    imports,
+    framework,
+    run.moduleSafety.check,
+    run.serverSafeHooks
+  );
+  for (const decl of imports.sideEffectImports) {
+    const spec = decl.moduleSpecifier.text;
+    if (!STYLESHEET_RE2.test(spec)) {
+      return skip(
+        "unsupported-pattern",
+        `has a side-effect import of ${spec}, which would then run on the server only`,
+        locOf(ctx, decl)
+      );
+    }
+  }
+  const fileSkip = specialApiSkip(ctx, facts);
+  if (fileSkip) return { ok: false, skip: fileSkip };
+  const env = findEnvProblem(sf, checker, framework);
+  if (env) return skip("server-env-difference", env.message, locOf(ctx, env.node));
+  const shape = analyzeFileShape(ctx, facts);
+  if (!shape.ok) return shape;
+  const components = shape.value.components;
+  const importerCheck = checkImporters(program, graph, file, components);
+  if (!importerCheck.ok) return importerCheck;
+  const wholesale = /* @__PURE__ */ new Set();
+  let plans = [];
+  let unchanged = [];
+  for (let pass = 0; pass <= components.length; pass++) {
+    plans = [];
+    unchanged = [];
+    let grew = false;
+    for (const component of components) {
+      if (wholesale.has(component)) continue;
+      const plan = planComponent(ctx, facts, shape.value, component, {
+        serverActionProps: importerCheck.value.serverActionProps,
+        wholesale
+      });
+      if (plan.ok) {
+        plans.push(plan.value);
+        continue;
+      }
+      const code = plan.skip.code;
+      if (code === "no-islands") {
+        unchanged.push(component);
+        continue;
+      }
+      const movable = (code === "fully-interactive" || code === "state-spans-component") && component.exported === "none" && components.length > 1;
+      if (movable) {
+        wholesale.add(component);
+        grew = true;
+        continue;
+      }
+      const prefix = components.length > 1 ? `${component.name}: ` : "";
+      return { ok: false, skip: { ...plan.skip, message: `${prefix}${plan.skip.message}` } };
+    }
+    if (!grew) break;
+  }
+  if (plans.length === 0 && wholesale.size === 0) {
+    return skip(
+      "no-islands",
+      `${components.map((c) => c.name).join(", ")} ${components.length === 1 ? "uses" : "use"} no client-only features; removing "use client" may be enough (the tool never removes it automatically)`
+    );
+  }
+  if (components.every((c) => wholesale.has(c) || c.exported === "none") && plans.length === 0) {
+    return skip(
+      "fully-interactive",
+      "every component in the file is interactive; nothing would stay on the server"
+    );
+  }
+  const jsxCounts = (c) => countJsx(c.fn);
+  const jsxTotal = plans.reduce((n, p) => n + p.jsxTotal, 0) + [...wholesale].reduce((n, c) => n + jsxCounts(c), 0) + unchanged.reduce((n, c) => n + jsxCounts(c), 0);
+  const staticJsx = plans.reduce((n, p) => n + p.staticRatio * p.jsxTotal, 0) + unchanged.reduce((n, c) => n + jsxCounts(c), 0);
+  const staticRatio = jsxTotal === 0 ? 0 : staticJsx / jsxTotal;
+  if (staticRatio < config.minStaticRatio) {
+    return skip(
+      "below-threshold",
+      `only ${Math.round(staticRatio * 100)}% of the JSX would stay on the server (minStaticRatio is ${Math.round(config.minStaticRatio * 100)}%)`
+    );
+  }
+  const islandSpecifier = relativeSpecifier(path9.dirname(file), islandFile);
+  const originalSpecifier = relativeSpecifier(dir, file);
+  const emitted = emitSplit({
+    renames,
+    ctx,
+    shape: shape.value,
+    imports,
+    plans,
+    islandSpecifier,
+    originalSpecifier,
+    movedComponents: [...wholesale].flatMap((c) => {
+      const decl = shape.value.componentDecls.get(c);
+      return decl ? [decl] : [];
+    }),
+    rebaseSpecifier: (spec) => spec.startsWith(".") && dir !== path9.dirname(file) ? relativeSpecifier(dir, path9.resolve(path9.dirname(file), spec), true) : spec
+  });
+  if (!emitted.ok) return emitted;
+  const eol = lineEndingOf(sf.text);
+  const serverText = hasMixedLineEndings(sf.text) ? emitted.value.serverText : withLineEnding(emitted.value.serverText, eol);
+  const islandText = withLineEnding(emitted.value.islandText, eol);
+  const movedInfo = [...wholesale].map((c) => ({
+    name: c.name,
+    rootTag: rootTagOf(c, sf),
+    props: [],
+    line: sf.getLineAndCharacterOfPosition(c.statement.getStart(sf)).line + 1,
+    moved: true
+  }));
+  const islands = [
+    ...emitted.value.islands.map((i) => ({
+      name: i.name,
+      rootTag: i.rootTag,
+      props: [...i.props.map((p) => p.name), ...i.slots.map((slot) => slot.name)],
+      line: i.line
+    })),
+    ...movedInfo
+  ].sort((a, b) => a.line - b.line);
+  const main = components.find((c) => c.exported === "default") ?? components.find((c) => c.exported !== "none") ?? components[0];
+  return ok({
+    file,
+    islandFile,
+    islandSpecifier,
+    serverText,
+    islandText,
+    islands,
+    staticRatio,
+    importers: importerCheck.value.importers,
+    serverActionProps: importerCheck.value.serverActionProps,
+    isJs,
+    originalText: sf.text,
+    componentName: main?.name ?? path9.basename(file, ext)
+  });
+}
+function checkAnalyzed(run, analyzed, serverText = analyzed.serverText, islandText = analyzed.islandText) {
+  return selfCheck({
+    loaded: run.loaded,
+    graph: run.graph,
+    framework: run.framework,
+    classifier: run.classifier,
+    moduleSafety: run.moduleSafety,
+    serverSafeHooks: run.serverSafeHooks,
+    file: analyzed.file,
+    islandFile: analyzed.islandFile,
+    islandSpecifier: analyzed.islandSpecifier,
+    serverText,
+    islandText,
+    importers: analyzed.importers,
+    serverActionProps: analyzed.serverActionProps,
+    isJs: analyzed.isJs
+  });
+}
+async function planFile(run, file, renames) {
+  const { config, root } = run;
+  const analyzed = analyzeFile(run, file, renames);
+  if (!analyzed.ok) return analyzed;
+  const a = analyzed.value;
+  let serverText = a.serverText;
+  let islandText = a.islandText;
+  if (config.prettier === "auto") {
+    serverText = await formatWithProjectPrettier(root, file, serverText);
+    islandText = await formatWithProjectPrettier(root, a.islandFile, islandText);
+  }
+  const checked = checkAnalyzed(run, a, serverText, islandText);
+  if (!checked.ok) return checked;
+  const saving = measureAnalyzed(run, a, islandText);
+  if (!saving.ok) return saving;
+  return ok({
+    outputs: { [rel(root, file)]: serverText, [rel(root, a.islandFile)]: islandText },
+    islands: a.islands,
+    staticRatio: a.staticRatio,
+    ...saving.value,
+    originalText: a.originalText
+  });
+}
+function measureAnalyzed(run, analyzed, islandText = analyzed.islandText) {
+  const { measurer, config } = run;
+  if (!measurer) return ok({});
+  const measured = measurer.measure(
+    analyzed.file,
+    analyzed.originalText,
+    analyzed.islandFile,
+    islandText
+  );
+  const threshold = formatBytes(config.minBytesSaved);
+  if ("error" in measured) {
+    if (config.minBytesSaved === 0) return ok({ measureError: measured.error });
+    return skip(
+      "measure-failed",
+      `the saving couldn't be measured (${measured.error}), so minBytesSaved (${threshold}) can't be checked; set minBytesSaved to 0 or pass --no-measure to split without an estimate`
+    );
+  }
+  const { bytesSaved } = measured;
+  if (bytesSaved.conservative < config.minBytesSaved) {
+    return skip(
+      "below-threshold",
+      `saves an estimated ${formatBytes(bytesSaved.conservative)} gzip (minBytesSaved is ${threshold})`
+    );
+  }
+  return ok({ bytesSaved });
+}
+function specialApiSkip(ctx, facts) {
+  for (const marker of facts.scanMarkers(ctx.sf)) {
+    const loc = locOf(ctx, marker.node);
+    switch (marker.special) {
+      case "css-in-js":
+        return {
+          code: "css-in-js-runtime",
+          message: `uses ${marker.detail}; runtime CSS-in-JS is always skipped`,
+          location: loc
+        };
+      case "context":
+        return {
+          code: "context-provider",
+          message: "creates a React Context (createContext)",
+          location: loc
+        };
+      case "class":
+        return {
+          code: "class-component",
+          message: "uses React.Component / PureComponent",
+          location: loc
+        };
+      case "hoc":
+        return {
+          code: "hoc",
+          message: `uses ${marker.detail}, which this version doesn't split`,
+          location: loc
+        };
+      case "lazy":
+      case "dynamic":
+        return {
+          code: "dynamic-import",
+          message: `uses ${marker.detail}, which this version doesn't split`,
+          location: loc
+        };
+      default:
+        break;
+    }
+  }
+  let dynamicImport;
+  const visit = (n) => {
+    if (dynamicImport) return;
+    if (ts18.isCallExpression(n) && n.expression.kind === ts18.SyntaxKind.ImportKeyword)
+      dynamicImport = n;
+    ts18.forEachChild(n, visit);
+  };
+  visit(ctx.sf);
+  if (dynamicImport)
+    return {
+      code: "dynamic-import",
+      message: "uses import(), which this version doesn't split",
+      location: locOf(ctx, dynamicImport)
+    };
+  return void 0;
+}
+function rootTagOf(component, sf) {
+  let tag = component.name;
+  const visit = (n) => {
+    if (ts18.isJsxElement(n) || ts18.isJsxSelfClosingElement(n) || ts18.isJsxFragment(n)) {
+      tag = tagNameText(sf, n);
+      return true;
+    }
+    return ts18.forEachChild(n, visit) ?? false;
+  };
+  if (component.fn.body) visit(component.fn.body);
+  return tag;
+}
+function countJsx(node) {
+  let n = 0;
+  const visit = (child) => {
+    if (ts18.isJsxElement(child) || ts18.isJsxSelfClosingElement(child) || ts18.isJsxFragment(child)) n++;
+    ts18.forEachChild(child, visit);
+  };
+  visit(node);
+  return n;
+}
+function relativeSpecifier(fromDir, toFile, keepExtension = false) {
+  let target = path9.relative(fromDir, toFile).split(path9.sep).join("/");
+  if (!keepExtension) target = target.replace(/\.(tsx|ts|jsx|js|mts|mjs)$/, "");
+  return target.startsWith(".") ? target : `./${target}`;
+}
+function formatBytes(bytes) {
+  return bytes >= 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${bytes} B`;
+}
+
+export {
+  SKIP_CODES,
+  SKIP_TITLES,
+  ConfigError,
+  resolveConfig,
+  findConfigFile,
+  loadConfigFileSync,
+  setSourceText,
+  ensureLoaded,
+  createRunContext,
+  runSplit,
+  analyzeFile,
+  checkAnalyzed,
+  measureAnalyzed,
+  formatBytes
+};
+//# sourceMappingURL=chunk-6OAWHATP.js.map