@ai-matrx/code-runtime 0.1.4

package/dist/index.cjs

@@ -0,0 +1,1196 @@
+"use client";
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  GATE_LISTS: () => GATE_LISTS,
+  SCOPE_ENTRIES: () => SCOPE_ENTRIES,
+  buildDangerousGlobalStubs: () => buildDangerousGlobalStubs,
+  buildScope: () => buildScope,
+  compile: () => compile,
+  compileAsync: () => compileAsync,
+  compileSource: () => compileSource,
+  componentSourceGate: () => componentSourceGate,
+  coreEntryPaths: () => coreEntryPaths,
+  createCompileCache: () => createCompileCache,
+  createUnresolvedImportStandIn: () => createUnresolvedImportStandIn,
+  defaultCompileCache: () => defaultCompileCache,
+  defaultComponentEntries: () => defaultComponentEntries,
+  describeUnresolved: () => describeUnresolved,
+  detectEntries: () => detectEntries,
+  executeGraph: () => executeGraph,
+  gate: () => gate,
+  getScopeEntry: () => getScopeEntry,
+  kindComponentCompiler: () => kindComponentCompiler,
+  listScopeEntries: () => listScopeEntries,
+  listScopeEntryPaths: () => listScopeEntryPaths,
+  prepareScope: () => prepareScope,
+  provideScopeModules: () => provideScopeModules,
+  readUnresolvedImportMark: () => readUnresolvedImportMark,
+  resetScopeModules: () => resetScopeModules,
+  transformFiles: () => transformFiles
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/gate-lists.json
+var gate_lists_default = {
+  _comment: [
+    "CANONICAL, MACHINE-READABLE source-gate lists for stored code compiled by @ai-matrx/code-runtime.",
+    "ONE list per rule, sorted, byte-comparable across runtimes. Three guards keep the copies honest:",
+    "  - src/gate.test.ts asserts allowedImports equals listScopeEntryPaths() sorted",
+    "    (the documented scope registry is the truth);",
+    "  - aidream packages/matrx-ai/tests/test_component_source_gate_parity.py asserts the Python",
+    "    twins in kind_shared.py equal these arrays;",
+    "  - the database trigger's parity test asserts the trigger names every entry of every",
+    "    security list below."
+  ],
+  allowedImports: [
+    "@/applets",
+    "@/components/Markdown",
+    "@/components/MarkdownStream",
+    "@/components/agent-copy/CopyButtons",
+    "@/components/agent-copy/CopyForAiButton",
+    "@/components/kind-kit/KindHeaderBar",
+    "@/components/kind-kit/KindPanel",
+    "@/components/kind-kit/KindPanelGrid",
+    "@/components/kind-kit/SortableList",
+    "@/components/kind-kit/StreamingSkeleton",
+    "@/components/kind-kit/TagList",
+    "@/components/mardown",
+    "@/components/markdown",
+    "@/components/official/icons/IconResolver",
+    "@/components/ui/accordion",
+    "@/components/ui/alert",
+    "@/components/ui/avatar",
+    "@/components/ui/badge",
+    "@/components/ui/button",
+    "@/components/ui/card",
+    "@/components/ui/checkbox",
+    "@/components/ui/collapsible",
+    "@/components/ui/dialog",
+    "@/components/ui/dropdown-menu",
+    "@/components/ui/input",
+    "@/components/ui/label",
+    "@/components/ui/popover",
+    "@/components/ui/progress",
+    "@/components/ui/radio-group",
+    "@/components/ui/scroll-area",
+    "@/components/ui/select",
+    "@/components/ui/separator",
+    "@/components/ui/sheet",
+    "@/components/ui/skeleton",
+    "@/components/ui/slider",
+    "@/components/ui/switch",
+    "@/components/ui/table",
+    "@/components/ui/tabs",
+    "@/components/ui/textarea",
+    "@/components/ui/tooltip",
+    "@/lib/utils",
+    "@ai-matrx/applets/react",
+    "@ai-matrx/design-system",
+    "@ai-matrx/design-system/controls",
+    "@ai-matrx/icons",
+    "@react-three/fiber",
+    "date-fns",
+    "lodash",
+    "lucide-react",
+    "motion/react",
+    "react",
+    "react-katex",
+    "react-pdf",
+    "recharts",
+    "three",
+    "xlsx"
+  ],
+  bannedGlobals: [
+    "EventSource",
+    "WebSocket",
+    "XMLHttpRequest",
+    "fetch",
+    "importScripts",
+    "localStorage",
+    "sessionStorage"
+  ],
+  bannedCallables: [
+    "Function",
+    "eval"
+  ],
+  bannedMemberAccess: [
+    "EventSource",
+    "Function",
+    "WebSocket",
+    "XMLHttpRequest",
+    "cookie",
+    "eval",
+    "fetch",
+    "importScripts",
+    "sendBeacon"
+  ],
+  bannedMemberCalls: [
+    "constructor"
+  ],
+  bannedComputedAccess: [
+    "globalThis",
+    "self",
+    "window"
+  ],
+  bannedSyntax: [
+    "dynamicImport"
+  ]
+};
+
+// src/gate.ts
+var GATE_ALLOWED_IMPORTS = gate_lists_default.allowedImports;
+var GATE_BANNED_GLOBALS = gate_lists_default.bannedGlobals;
+var GATE_BANNED_CALLABLES = gate_lists_default.bannedCallables;
+var GATE_BANNED_MEMBER_ACCESS = gate_lists_default.bannedMemberAccess;
+var GATE_BANNED_MEMBER_CALLS = gate_lists_default.bannedMemberCalls;
+var GATE_BANNED_COMPUTED_ACCESS = gate_lists_default.bannedComputedAccess;
+var GATE_BANNED_SYNTAX = gate_lists_default.bannedSyntax;
+var GATE_LISTS = gate_lists_default;
+var IMPORT_RE = /^\s*import\s+(?:[^'"]*?\s+from\s+)?['"]([^'"]+)['"]/gm;
+var EXPORT_FROM_RE = /^\s*export\s+(?:\*|\{[^}]*\})\s+from\s+['"]([^'"]+)['"]/gm;
+var DYNAMIC_IMPORT_RE = /(?<![.\w$])import\s*\(/g;
+function escapeForRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function lineAt(source, index) {
+  let line = 1;
+  for (let i = 0; i < index && i < source.length; i++) {
+    if (source.charCodeAt(i) === 10) line++;
+  }
+  return line;
+}
+function resolveRelativePath(fromFile, specifier) {
+  const base = fromFile.split("/").slice(0, -1);
+  for (const part of specifier.split("/")) {
+    if (part === "" || part === ".") continue;
+    if (part === "..") base.pop();
+    else base.push(part);
+  }
+  return base.join("/");
+}
+var RESOLVE_SUFFIXES = ["", ".tsx", ".ts", ".jsx", ".js", ".json", "/index.tsx", "/index.ts", "/index.jsx", "/index.js"];
+function resolveRelativeFile(files, fromFile, specifier) {
+  const target = resolveRelativePath(fromFile, specifier);
+  for (const suffix of RESOLVE_SUFFIXES) {
+    const candidate = `${target}${suffix}`;
+    if (Object.prototype.hasOwnProperty.call(files, candidate)) return candidate;
+  }
+  return null;
+}
+var ALLOWED_SENTENCE = "Rewrite it using only the documented scope (react, lucide-react, recharts, @ai-matrx/design-system/controls, @ai-matrx/design-system, @/lib/utils, @/components/ui/*, @/components/kind-kit/*, CopyButtons/CopyForAiButton, Markdown) or a file of this component.";
+function importFindings(files, file, source) {
+  const out = [];
+  const allowed = new Set(GATE_ALLOWED_IMPORTS);
+  for (const re of [IMPORT_RE, EXPORT_FROM_RE]) {
+    re.lastIndex = 0;
+    let match;
+    while ((match = re.exec(source)) !== null) {
+      const path = match[1] ?? "";
+      const line = lineAt(source, match.index + match[0].indexOf(path));
+      if (path.startsWith("./") || path.startsWith("../")) {
+        if (!resolveRelativeFile(files, file, path)) {
+          out.push({
+            rule: "relative-import-missing",
+            file,
+            line,
+            severity: "refuse",
+            message: `This file imports "${path}", but no file of this component has that name. Add the file or fix the path.`
+          });
+        }
+        continue;
+      }
+      if (!allowed.has(path)) {
+        out.push({
+          rule: "import-not-allowed",
+          file,
+          line,
+          severity: "refuse",
+          message: `This component imports "${path}", which is outside the sandbox scope, so it would render as a marked placeholder. ${ALLOWED_SENTENCE}`
+        });
+      }
+    }
+  }
+  DYNAMIC_IMPORT_RE.lastIndex = 0;
+  const dyn = DYNAMIC_IMPORT_RE.exec(source);
+  if (dyn) {
+    out.push({
+      rule: "dynamicImport",
+      file,
+      line: lineAt(source, dyn.index),
+      severity: "refuse",
+      message: "This component uses a dynamic import(). The in-page compiler has no module loader, so the call would either fail at render or reach code nobody vetted. Import from the scope at the top of the file instead."
+    });
+  }
+  return out;
+}
+function bannedGlobalMessage(name) {
+  return `This component uses "${name}", which components stored in the database may not use. They run inside the signed-in page, so anything that reaches the network, browser storage, or the JavaScript evaluator could read or send the reader's data. Render what the Shape hands you in props.data and use a Shape action for anything the component needs from the server.`;
+}
+function bannedMemberCallMessage(name) {
+  return `This component uses ".${name}(", which components stored in the database may not use. Calling a value's constructor reaches the JavaScript evaluator, so it could run code nobody reviewed inside the signed-in page. Write the logic out directly instead.`;
+}
+function bannedComputedAccessMessage(name) {
+  return `This component uses "${name}[", which components stored in the database may not use. Looking a property up by a computed name hides which browser capability the component reaches, so no review can tell whether it is safe. Name what you need directly, or use props.data and a Shape action for anything the component needs from the server.`;
+}
+function globalFindings(file, code) {
+  const out = [];
+  const push = (rule, re, message) => {
+    const m = re.exec(code);
+    if (m) out.push({ rule, file, line: lineAt(code, m.index), severity: "refuse", message });
+  };
+  for (const name of GATE_BANNED_GLOBALS) {
+    push("bannedGlobal", new RegExp(`(?<![.\\w$])${escapeForRegExp(name)}\\b`), bannedGlobalMessage(name));
+  }
+  for (const name of GATE_BANNED_CALLABLES) {
+    const e = escapeForRegExp(name);
+    push("bannedCallable", new RegExp(`\\bnew\\s+${e}\\s*\\(|(?<![.\\w$])${e}\\s*\\(`), bannedGlobalMessage(name));
+  }
+  for (const name of GATE_BANNED_MEMBER_ACCESS) {
+    push("bannedMemberAccess", new RegExp(`\\.\\s*${escapeForRegExp(name)}\\b`), bannedGlobalMessage(name));
+  }
+  for (const name of GATE_BANNED_MEMBER_CALLS) {
+    push("bannedMemberCall", new RegExp(`\\.\\s*${escapeForRegExp(name)}\\s*\\(`), bannedMemberCallMessage(name));
+  }
+  for (const name of GATE_BANNED_COMPUTED_ACCESS) {
+    const e = escapeForRegExp(name);
+    push("bannedComputedAccess", new RegExp(`(?<![.\\w$])${e}\\s*\\[|\\.\\s*${e}\\s*\\[`), bannedComputedAccessMessage(name));
+  }
+  return out;
+}
+function gate(files) {
+  const out = [];
+  for (const [file, source] of Object.entries(files)) {
+    if (/\.(html?|json|css|md)$/i.test(file)) continue;
+    const code = source ?? "";
+    out.push(...importFindings(files, file, code), ...globalFindings(file, code));
+  }
+  return out;
+}
+function componentSourceGate(source, options) {
+  if ((options?.flavor ?? "").toLowerCase() === "html") return null;
+  const finding = gate({ "component.tsx": source ?? "" }).find((f) => f.severity === "refuse");
+  return finding ? finding.message : null;
+}
+
+// src/scope/entries.ts
+var REACT_EXPORTS = [
+  "useState",
+  "useEffect",
+  "useMemo",
+  "useCallback",
+  "useRef",
+  "useReducer",
+  "useContext",
+  "useId",
+  "useTransition",
+  "useDeferredValue",
+  "useLayoutEffect",
+  "Fragment"
+];
+function ui(name, exports, description) {
+  return { path: `@/components/ui/${name}`, strategy: "named", exports, core: true, owner: "package", description };
+}
+function markdownAlias(path, description) {
+  return { path, strategy: "named", exportMap: { default: "MarkdownStream" }, core: true, owner: "host", description };
+}
+function kindKit(name, exports, description) {
+  return { path: `@/components/kind-kit/${name}`, strategy: "named", exports, owner: "host", description };
+}
+var SCOPE_ENTRIES = [
+  // ── Core ─────────────────────────────────────────────────────────────────
+  { path: "react", strategy: "named", exports: REACT_EXPORTS, exportMap: { default: "React" }, core: true, owner: "package", description: "React core (hooks, Fragment)" },
+  { path: "lucide-react", strategy: "spread", safeProxy: true, core: true, owner: "package", description: "Lucide icons; a missing name renders a marked placeholder" },
+  { path: "@ai-matrx/icons", strategy: "named", exports: ["DynamicIcon", "renderIcon", "getIconComponent"], core: true, owner: "package", description: "DynamicIcon: any icon by string name" },
+  { path: "@/components/official/icons/IconResolver", strategy: "named", exports: ["DynamicIcon", "renderIcon", "getIconComponent"], core: true, owner: "package", description: "Legacy alias of @ai-matrx/icons" },
+  { path: "@/lib/utils", strategy: "named", exports: ["cn"], core: true, owner: "package", description: "cn(): className merge" },
+  // ── The primary UI set ───────────────────────────────────────────────────
+  { path: "@ai-matrx/design-system/controls", strategy: "spread", core: true, owner: "package", description: "THE controls: Button, Field, SearchField, Select, SegmentedControl, Tabs, Badge, Switch, Textarea, EmptyState\u2026" },
+  { path: "@ai-matrx/design-system", strategy: "spread", owner: "package", description: "Design-system surfaces: Card, Dialog, Popover, Tooltip, Table, Accordion\u2026" },
+  // ── Copy actions ─────────────────────────────────────────────────────────
+  { path: "@/components/agent-copy/CopyButtons", strategy: "named", exports: ["CopyButtons"], owner: "host", description: "Copy / Copy-for-AI / JSON / Export bar from caller-supplied builders" },
+  { path: "@/components/agent-copy/CopyForAiButton", strategy: "named", exports: ["CopyForAiButton"], owner: "host", description: "Single Copy-for-AI action" },
+  // ── kind-kit ─────────────────────────────────────────────────────────────
+  kindKit("SortableList", ["SortableList"], "Drag-to-reorder list with arrow fallback and onRemove"),
+  kindKit("KindPanelGrid", ["KindPanelGrid"], "Content-aware auto-fit grid of equal-height panels"),
+  kindKit("KindPanel", ["KindPanel"], "Compact panel: header + overflow menu, subline, body, footer"),
+  kindKit("KindHeaderBar", ["KindHeaderBar"], "Kind title + stats + copy bar"),
+  kindKit("StreamingSkeleton", ["StreamingSkeleton", "useStreamingValue", "streamList", "streamText"], "Streaming skeletons + tolerant partial-value reads"),
+  kindKit("TagList", ["KeywordChip", "TagList"], "Wrapping chips with select, remove, inline edit, add"),
+  // ── Markdown (one renderer, four spellings stored code uses) ─────────────
+  markdownAlias("@/components/MarkdownStream", "MarkdownStream: the one markdown renderer"),
+  markdownAlias("@/components/Markdown", "MarkdownStream (legacy path)"),
+  markdownAlias("@/components/markdown", "MarkdownStream (lowercase path)"),
+  markdownAlias("@/components/mardown", "MarkdownStream (common misspelling)"),
+  // ── Legacy UI aliases (each = the design-system export the app re-exports) ─
+  ui("button", ["Button"], "Button"),
+  ui("input", ["Input"], "Input"),
+  ui("textarea", ["Textarea"], "Textarea"),
+  ui("card", ["Card", "CardAction", "CardContent", "CardDescription", "CardFooter", "CardHeader", "CardTitle"], "Card family"),
+  ui("label", ["Label"], "Label"),
+  ui("select", ["Select", "SelectContent", "SelectGroup", "SelectItem", "SelectLabel", "SelectScrollDownButton", "SelectScrollUpButton", "SelectSeparator", "SelectValue", "selectTriggerVariants", "SelectTrigger", "SelectTriggerLegacy"], "Select family"),
+  ui("slider", ["Slider"], "Slider"),
+  ui("switch", ["Switch"], "Switch"),
+  ui("tabs", ["Tabs", "TabsContent", "TabsList", "TabsTrigger", "TabsTriggerCore", "TabsListLegacy", "TabsTriggerLegacy", "TabsTriggerCoreLegacy"], "Tabs family"),
+  ui("badge", ["Badge"], "Badge"),
+  ui("tooltip", ["Tooltip", "TooltipContent", "TooltipProvider", "TooltipTrigger"], "Tooltip family"),
+  ui("accordion", ["Accordion", "AccordionContent", "AccordionItem", "AccordionTrigger", "useAccordionSize"], "Accordion family"),
+  ui("collapsible", ["Collapsible", "CollapsibleContent", "CollapsibleTrigger"], "Collapsible family"),
+  ui("progress", ["Progress"], "Progress bar"),
+  ui("separator", ["Separator"], "Separator"),
+  ui("scroll-area", ["ScrollArea", "ScrollBar"], "ScrollArea"),
+  ui("dialog", ["Dialog", "DialogClose", "DialogContent", "DialogContentPrimitive", "DialogDescription", "DialogFooter", "DialogHeader", "DialogOverlay", "DialogPortal", "DialogTitle", "DialogTrigger", "useDialogContainer"], "Dialog family"),
+  ui("sheet", ["Sheet", "SheetPortal", "SheetOverlay", "SheetTrigger", "SheetClose", "SheetContent", "SheetHeader", "SheetFooter", "SheetTitle", "SheetDescription"], "Sheet family"),
+  ui("dropdown-menu", ["DropdownMenu", "DropdownMenuCheckboxItem", "DropdownMenuContent", "DropdownMenuGroup", "DropdownMenuItem", "DropdownMenuLabel", "DropdownMenuPortal", "DropdownMenuRadioGroup", "DropdownMenuRadioItem", "DropdownMenuSeparator", "DropdownMenuShortcut", "DropdownMenuSub", "DropdownMenuSubContent", "DropdownMenuSubTrigger", "DropdownMenuTrigger"], "Dropdown menu family"),
+  ui("table", ["Table", "TableBody", "TableCaption", "TableCell", "TableFooter", "TableHead", "TableHeader", "TableRow"], "Table family"),
+  ui("checkbox", ["Checkbox"], "Checkbox"),
+  ui("radio-group", ["RadioGroup", "RadioGroupItem"], "Radio group"),
+  ui("popover", ["Popover", "PopoverTrigger", "PopoverContent", "PopoverAnchor"], "Popover family"),
+  ui("avatar", ["Avatar", "AvatarFallback", "AvatarImage"], "Avatar family"),
+  ui("alert", ["Alert", "AlertDescription", "AlertTitle", "alertVariants"], "Alert family"),
+  ui("skeleton", ["Skeleton"], "Skeleton"),
+  // ── Applet parts ─────────────────────────────────────────────────────────
+  { path: "@/applets", strategy: "named", exports: ["DataPage", "Applet"], owner: "host", description: "A table-built page and a nested Applet (legacy path; becomes @ai-matrx/applets/react)" },
+  { path: "@ai-matrx/applets/react", strategy: "spread", owner: "host", description: "The Applet hooks: useRows, useJob, useValue, useAction, <Kind>, <Pages>, navigate\u2026" },
+  // ── Heavy libraries (loaded only when referenced) ────────────────────────
+  { path: "recharts", strategy: "spread", owner: "package", provides: ["ResponsiveContainer", "LineChart", "BarChart", "AreaChart", "PieChart", "RadarChart", "ScatterChart", "ComposedChart", "RadialBarChart"], description: "Charts (recharts)" },
+  { path: "motion/react", strategy: "spread", owner: "host", provides: ["motion", "AnimatePresence", "useAnimate", "useInView"], description: "Animation (motion)" },
+  { path: "react-katex", strategy: "spread", owner: "host", provides: ["BlockMath", "InlineMath"], description: "Math typesetting (KaTeX)" },
+  { path: "react-pdf", strategy: "named", exports: ["Document", "Page", "Outline"], owner: "host", provides: ["Document", "Page", "Outline"], description: "PDF viewing (react-pdf)" },
+  { path: "xlsx", strategy: "namespace", namespaceName: "XLSX", owner: "host", provides: ["XLSX"], description: "Workbooks (xlsx)" },
+  { path: "@react-three/fiber", strategy: "spread", owner: "host", provides: ["Canvas", "useFrame", "useThree", "useLoader"], description: "3D React renderer" },
+  { path: "three", strategy: "namespace", namespaceName: "THREE", owner: "host", provides: ["THREE"], description: "3D engine (three.js)" },
+  { path: "date-fns", strategy: "namespace", namespaceName: "dateFns", owner: "host", provides: ["dateFns"], description: "Date utilities (date-fns)" },
+  { path: "lodash", strategy: "namespace", namespaceName: "_", owner: "host", provides: ["_"], description: "Utility helpers (lodash)" }
+];
+var BY_PATH = new Map(SCOPE_ENTRIES.map((e) => [e.path, e]));
+function getScopeEntry(path) {
+  return BY_PATH.get(path);
+}
+function listScopeEntryPaths() {
+  return SCOPE_ENTRIES.map((e) => e.path);
+}
+function listScopeEntries() {
+  return SCOPE_ENTRIES;
+}
+function defaultComponentEntries() {
+  return SCOPE_ENTRIES.filter((e) => !e.provides || e.path === "recharts").map((e) => e.path);
+}
+function coreEntryPaths() {
+  return SCOPE_ENTRIES.filter((e) => e.core).map((e) => e.path);
+}
+function detectEntries(files) {
+  const needed = new Set(coreEntryPaths());
+  const code = Object.values(files).join("\n");
+  const imported = /* @__PURE__ */ new Set();
+  for (const m of code.matchAll(/from\s+['"]([^'"]+)['"]/g)) if (m[1]) imported.add(m[1]);
+  for (const entry of SCOPE_ENTRIES) {
+    if (entry.core) continue;
+    if (imported.has(entry.path)) needed.add(entry.path);
+    else if (entry.provides?.some((id) => new RegExp(`(?<![\\w$.])${id.replace(/[$]/g, "\\$")}\\b`).test(code))) {
+      needed.add(entry.path);
+    }
+  }
+  return SCOPE_ENTRIES.map((e) => e.path).filter((p) => needed.has(p));
+}
+
+// src/scope/build.ts
+var ReactModule2 = __toESM(require("react"), 1);
+
+// src/scope/modules.ts
+var ReactModule = __toESM(require("react"), 1);
+var LucideModule = __toESM(require("lucide-react"), 1);
+var IconsModule = __toESM(require("@ai-matrx/icons"), 1);
+var DesignSystem = __toESM(require("@ai-matrx/design-system"), 1);
+var Controls = __toESM(require("@ai-matrx/design-system/controls"), 1);
+var STORE_KEY = /* @__PURE__ */ Symbol.for("ai-matrx.code-runtime.modules");
+function store() {
+  const g = globalThis;
+  let s = g[STORE_KEY];
+  if (!s) {
+    s = { announced: /* @__PURE__ */ new Set(), provided: /* @__PURE__ */ new Map(), loaded: /* @__PURE__ */ new Map(), pending: /* @__PURE__ */ new Map(), failed: /* @__PURE__ */ new Map() };
+    g[STORE_KEY] = s;
+  }
+  return s;
+}
+var ds = DesignSystem;
+var controls = Controls;
+var LEGACY_UI_MODULE = {
+  ...ds,
+  Button: controls.Button,
+  Textarea: controls.Textarea,
+  Switch: controls.Switch,
+  SelectTrigger: controls.SelectTrigger,
+  SelectTriggerLegacy: ds.SelectTrigger,
+  TabsList: controls.TabsList,
+  TabsTrigger: controls.TabsTrigger,
+  TabsListLegacy: ds.TabsList,
+  TabsTriggerLegacy: ds.TabsTrigger
+};
+function packageLoader(path) {
+  if (path === "react") return () => ReactModule;
+  if (path === "lucide-react") return () => LucideModule;
+  if (path === "@ai-matrx/icons" || path === "@/components/official/icons/IconResolver") return () => IconsModule;
+  if (path === "@ai-matrx/design-system") return () => DesignSystem;
+  if (path === "@ai-matrx/design-system/controls") return () => Controls;
+  if (path === "@/lib/utils") return () => ({ cn: ds.cn });
+  if (path.startsWith("@/components/ui/")) return () => LEGACY_UI_MODULE;
+  if (path === "recharts") return () => import("recharts");
+  return null;
+}
+function provideScopeModules(map) {
+  const s = store();
+  for (const [path, loader] of Object.entries(map)) {
+    if (!getScopeEntry(path)) {
+      throw new Error(
+        `[code-runtime] "${path}" is not a documented scope entry. Add it to the registry in @ai-matrx/code-runtime (scope/entries.ts) with a description first.`
+      );
+    }
+    s.provided.set(path, loader);
+    s.loaded.delete(path);
+    s.pending.delete(path);
+    s.failed.delete(path);
+  }
+}
+function isPromiseLike(value) {
+  return !!value && typeof value.then === "function";
+}
+function loaderFor(path) {
+  return store().provided.get(path) ?? packageLoader(path);
+}
+function readScopeModule(path) {
+  const s = store();
+  if (s.loaded.has(path)) return { state: "ready", module: s.loaded.get(path) };
+  const failed = s.failed.get(path);
+  if (failed) return { state: "failed", message: failed };
+  if (s.pending.has(path)) return { state: "pending" };
+  const loader = loaderFor(path);
+  if (!loader) return { state: "missing" };
+  try {
+    const value = loader();
+    if (isPromiseLike(value)) {
+      const promise = Promise.resolve(value).then(
+        (mod) => {
+          s.loaded.set(path, mod);
+          s.pending.delete(path);
+          return mod;
+        },
+        (err) => {
+          s.failed.set(path, err instanceof Error ? err.message : String(err));
+          s.pending.delete(path);
+          return void 0;
+        }
+      );
+      s.pending.set(path, promise);
+      return { state: "pending" };
+    }
+    s.loaded.set(path, value);
+    return { state: "ready", module: value };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    s.failed.set(path, message);
+    return { state: "failed", message };
+  }
+}
+async function prepareScopeModules(paths) {
+  const s = store();
+  for (const path of paths) readScopeModule(path);
+  await Promise.all(paths.map((p) => s.pending.get(p)).filter((p) => !!p));
+}
+function announceFailedModule(path, message) {
+  const s = store();
+  if (s.announced.has(path)) return;
+  s.announced.add(path);
+  console.error(`[code-runtime] The scope entry "${path}" failed to load (${message}); code that imports it renders marked placeholders.`);
+}
+function resetScopeModules() {
+  const s = store();
+  s.announced.clear();
+  s.provided.clear();
+  s.loaded.clear();
+  s.pending.clear();
+  s.failed.clear();
+}
+
+// src/scope/stand-in.ts
+var React = __toESM(require("react"), 1);
+var UNRESOLVED_IMPORT_MARK = /* @__PURE__ */ Symbol.for("matrx.sandbox.unresolvedImport");
+function readUnresolvedImportMark(value) {
+  if (!value || typeof value !== "object" && typeof value !== "function") return null;
+  const mark = value[UNRESOLVED_IMPORT_MARK];
+  return mark && typeof mark === "object" ? mark : null;
+}
+function createUnresolvedImportStandIn(identifier, importPath = null) {
+  const tip = importPath ? `Not found: ${identifier} in "${importPath}"` : `Not found: ${identifier}`;
+  const StandIn = React.forwardRef(({ children }, ref) => {
+    const chip = React.createElement(
+      "span",
+      {
+        ref,
+        title: tip,
+        "aria-label": tip,
+        role: "note",
+        "data-unresolved-import": identifier,
+        "data-import-path": importPath ?? void 0,
+        className: "inline-flex items-center gap-0.5 rounded border border-dashed border-destructive/60 px-1 align-middle font-mono text-[10px] leading-4 text-destructive"
+      },
+      React.createElement(
+        "svg",
+        {
+          width: 10,
+          height: 10,
+          viewBox: "0 0 24 24",
+          fill: "none",
+          stroke: "currentColor",
+          strokeWidth: 2.5,
+          strokeLinecap: "round",
+          strokeLinejoin: "round",
+          "aria-hidden": true
+        },
+        React.createElement("path", { d: "m21.73 18-8-14a2 2 0 0 0-3.48 0l-8 14A2 2 0 0 0 4 21h16a2 2 0 0 0 1.73-3" }),
+        React.createElement("line", { x1: 12, y1: 9, x2: 12, y2: 13 }),
+        React.createElement("line", { x1: 12, y1: 17, x2: 12.01, y2: 17 })
+      ),
+      identifier
+    );
+    return children == null ? chip : React.createElement(React.Fragment, null, chip, children);
+  });
+  StandIn.displayName = `UnresolvedImport(${identifier})`;
+  Object.defineProperty(StandIn, UNRESOLVED_IMPORT_MARK, {
+    value: { identifier, importPath },
+    enumerable: false
+  });
+  return StandIn;
+}
+function describeUnresolved(entry) {
+  if (entry.identifier === "*") return `"${entry.importPath}" (not in this scope)`;
+  return entry.importPath ? `${entry.identifier} from "${entry.importPath}"` : entry.identifier;
+}
+function stripLiteralsForScan(code) {
+  return code.replace(/"(?:[^"\\]|\\.)*"/g, '""').replace(/'(?:[^'\\]|\\.)*'/g, "''").replace(/`(?:[^`\\]|\\.)*`/gs, "``");
+}
+function extractJsxComponentIdentifiers(codeForScanning) {
+  const components = /* @__PURE__ */ new Set();
+  const patterns = [
+    // `(?![\w$.])`: `<C.Button>` names the namespace `C`, which is an
+    // import or a declaration, never a bare missing component.
+    /React\.createElement\s*\(\s*([A-Z][a-zA-Z0-9]*)(?![\w$.])/g,
+    /\.default\.createElement\s*\(\s*([A-Z][a-zA-Z0-9]*)(?![\w$.])/g,
+    /\bjsxs?\s*\(\s*([A-Z][a-zA-Z0-9]*)(?![\w$.])/g
+  ];
+  for (const pattern of patterns) {
+    let match;
+    while ((match = pattern.exec(codeForScanning)) !== null) {
+      if (match[1]) components.add(match[1]);
+    }
+  }
+  return components;
+}
+var PATCH_SCOPE_SKIP_IDENTIFIERS = /* @__PURE__ */ new Set([
+  "React",
+  "Object",
+  "Array",
+  "String",
+  "Number",
+  "Boolean",
+  "Date",
+  "Math",
+  "JSON",
+  "Promise",
+  "Error",
+  "TypeError",
+  "RangeError",
+  "RegExp",
+  "Map",
+  "Set",
+  "WeakMap",
+  "WeakSet",
+  "Symbol",
+  "Proxy",
+  "Reflect",
+  "Intl",
+  "URL",
+  "FormData",
+  "Headers",
+  "Request",
+  "Response",
+  "AbortController",
+  "HTMLElement",
+  "SVGElement",
+  "Event",
+  "MouseEvent",
+  "KeyboardEvent",
+  "HTMLInputElement",
+  "HTMLTextAreaElement",
+  "HTMLSelectElement",
+  "HTMLButtonElement",
+  "HTMLDivElement",
+  "HTMLFormElement",
+  "Node",
+  "Element",
+  "Document",
+  "Window",
+  "Infinity",
+  "NaN",
+  "Fragment"
+]);
+
+// src/scope/build.ts
+function recordUnresolved(state, entry) {
+  if (!state.unresolved.some((e) => e.identifier === entry.identifier && e.importPath === entry.importPath)) {
+    state.unresolved.push(entry);
+  }
+}
+function asRecord(value) {
+  return value && (typeof value === "object" || typeof value === "function") ? value : {};
+}
+function ownKeys(mod) {
+  try {
+    return Object.keys(mod);
+  } catch {
+    return [];
+  }
+}
+function createSafeModuleProxy(importPath, moduleExports, state) {
+  const target = { ...moduleExports, __esModule: true };
+  return new Proxy(target, {
+    get(t, prop) {
+      if (typeof prop !== "string") return Reflect.get(t, prop);
+      if (prop in t) return t[prop];
+      if (prop.startsWith("_") || prop === "default" || prop === "then") return void 0;
+      if (/^[A-Z]/.test(prop)) {
+        const fallback = createUnresolvedImportStandIn(prop, importPath);
+        t[prop] = fallback;
+        recordUnresolved(state, { identifier: prop, importPath });
+        return fallback;
+      }
+      return void 0;
+    },
+    has(t, prop) {
+      if (typeof prop === "string" && /^[A-Z]/.test(prop)) return true;
+      return prop in t;
+    }
+  });
+}
+function moduleView(entry, mod, state) {
+  if (entry.strategy === "namespace") {
+    const ns = asRecord(mod.default ?? mod);
+    return { ...ns, default: ns, __esModule: true };
+  }
+  if (entry.safeProxy) return createSafeModuleProxy(entry.path, mod, state);
+  const view = { ...mod, __esModule: true };
+  for (const [moduleKey, scopeKey] of Object.entries(entry.exportMap ?? {})) {
+    const value = moduleKey === "default" ? mod.default ?? mod : mod[moduleKey];
+    view[scopeKey] = value;
+    if (moduleKey === "default") view.default = value;
+  }
+  if (!("default" in view)) view.default = mod.default;
+  return view;
+}
+function applyToFlatScope(entry, mod, values) {
+  if (entry.strategy === "namespace") {
+    if (entry.namespaceName) values[entry.namespaceName] = mod.default ?? mod;
+    return;
+  }
+  if (entry.strategy === "spread") {
+    for (const key of ownKeys(mod)) {
+      if (key === "default" || key === "__esModule") continue;
+      values[key] = mod[key];
+    }
+    return;
+  }
+  for (const name of entry.exports ?? []) values[name] = mod[name];
+  for (const [moduleKey, scopeKey] of Object.entries(entry.exportMap ?? {})) {
+    values[scopeKey] = moduleKey === "default" ? mod.default ?? mod : mod[moduleKey];
+  }
+}
+function buildDangerousGlobalStubs() {
+  const stubs = {};
+  for (const name of [...gate_lists_default.bannedGlobals, ...gate_lists_default.bannedCallables]) {
+    stubs[name] = function bannedGlobal() {
+      throw new Error(
+        `This component tried to use "${name}". Components stored in the database run inside the signed-in page and may not reach the network, browser storage, or the JavaScript evaluator. Render what the Shape hands you in props.data, and use a Shape action for anything you need from the server.`
+      );
+    };
+  }
+  return stubs;
+}
+function buildScopeState(spec) {
+  const state = { values: {}, modules: /* @__PURE__ */ new Map(), safeProxyPaths: /* @__PURE__ */ new Map(), unresolved: [], pending: [] };
+  const R = ReactModule2;
+  state.values.React = R;
+  for (const hook of ["useState", "useEffect", "useMemo", "useCallback", "useRef"]) state.values[hook] = R[hook];
+  state.modules.set("react", { ...R, default: R, __esModule: true });
+  for (const path of spec.entries ?? []) {
+    const entry = getScopeEntry(path);
+    if (!entry) {
+      recordUnresolved(state, { identifier: "*", importPath: path });
+      continue;
+    }
+    const read = readScopeModule(path);
+    if (read.state === "pending") {
+      state.pending.push(path);
+      continue;
+    }
+    if (read.state === "missing") {
+      continue;
+    }
+    if (read.state === "failed") {
+      announceFailedModule(path, read.message);
+      continue;
+    }
+    const mod = asRecord(read.module);
+    const view = moduleView(entry, mod, state);
+    state.modules.set(path, view);
+    if (entry.safeProxy) {
+      state.safeProxyPaths.set(path, { proxy: view, keys: new Set(ownKeys(mod)) });
+    }
+    applyToFlatScope(entry, mod, state.values);
+  }
+  if (state.values.MarkdownStream && !state.values.Markdown) state.values.Markdown = state.values.MarkdownStream;
+  if (!state.values.DynamicIcon) {
+    const icons = readScopeModule("@ai-matrx/icons");
+    if (icons.state === "ready") {
+      const m = asRecord(icons.module);
+      state.values.DynamicIcon = m.DynamicIcon;
+      state.values.renderIcon = m.renderIcon;
+      state.values.getIconComponent = m.getIconComponent;
+    }
+  }
+  const overrides = spec.overrides ?? {};
+  Object.assign(state.values, overrides);
+  if (Object.keys(overrides).length > 0) {
+    for (const [path, view] of state.modules) {
+      const entry = getScopeEntry(path);
+      for (const [moduleKey, scopeKey] of Object.entries(entry?.exportMap ?? {})) {
+        if (!(scopeKey in overrides)) continue;
+        view[scopeKey] = overrides[scopeKey];
+        if (moduleKey === "default") view.default = overrides[scopeKey];
+        else view[moduleKey] = overrides[scopeKey];
+      }
+      for (const name of entry?.exports ?? []) {
+        if (name in overrides) view[name] = overrides[name];
+      }
+    }
+  }
+  if (spec.shadowDangerousGlobals) Object.assign(state.values, buildDangerousGlobalStubs());
+  return state;
+}
+function buildScope(spec) {
+  return { ...buildScopeState(spec).values };
+}
+function patchMissingJsx(identifiers, state, declared, skip) {
+  for (const identifier of identifiers) {
+    if (skip.has(identifier) || identifier in state.values || declared.has(identifier)) continue;
+    let provided = false;
+    for (const [, { proxy, keys }] of state.safeProxyPaths) {
+      if (!keys.has(identifier)) continue;
+      const value = proxy[identifier];
+      if (value !== void 0) {
+        state.values[identifier] = value;
+        const mark = readUnresolvedImportMark(value);
+        if (mark) recordUnresolved(state, mark);
+        provided = true;
+        break;
+      }
+    }
+    if (provided) continue;
+    state.values[identifier] = createUnresolvedImportStandIn(identifier);
+    recordUnresolved(state, { identifier, importPath: null });
+  }
+}
+
+// src/execute-core.ts
+var IDENTIFIER_RE = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+function missingModule(path) {
+  const target = { __esModule: true };
+  return new Proxy(target, {
+    get(t, prop) {
+      if (typeof prop !== "string") return Reflect.get(t, prop);
+      if (prop in t) return t[prop];
+      if (prop === "then" || prop.startsWith("_")) return void 0;
+      if (prop === "default" || /^[A-Z]/.test(prop)) {
+        const fallback = createUnresolvedImportStandIn(prop === "default" ? path.split("/").pop() ?? path : prop, path);
+        t[prop] = fallback;
+        return fallback;
+      }
+      return void 0;
+    }
+  });
+}
+function bindImports(mod, allFiles, state) {
+  for (const binding of mod.importBindings) {
+    const { source, imported, local } = binding;
+    if (source.startsWith("./") || source.startsWith("../")) {
+      if (!resolveRelativeFile(allFiles, mod.file, source)) {
+        recordUnresolved(state, { identifier: imported === "*" ? `* as ${local}` : imported, importPath: source });
+      }
+      continue;
+    }
+    const view = state.modules.get(source);
+    if (!view) {
+      recordUnresolved(state, {
+        identifier: imported === "*" ? `* as ${local}` : imported === "default" ? local : imported,
+        importPath: source
+      });
+      continue;
+    }
+    if (imported === "*") continue;
+    if (imported === "default") {
+      if (view.default === void 0) {
+        view.default = createUnresolvedImportStandIn(local, source);
+        recordUnresolved(state, { identifier: local, importPath: source });
+      }
+      continue;
+    }
+    let present;
+    try {
+      present = view[imported] !== void 0;
+    } catch {
+      present = false;
+    }
+    if (!present) {
+      if (/^[A-Z]/.test(imported)) view[imported] = createUnresolvedImportStandIn(imported, source);
+      recordUnresolved(state, { identifier: imported === local ? local : `${imported} as ${local}`, importPath: source });
+    }
+  }
+}
+var CONVENTIONAL_NAMES = /^(App|Main|Page|Component|Demo|Example|Root)$/;
+function pickCandidate(candidates, rule) {
+  if (rule === "conventional") {
+    const preferred = [...candidates].reverse().find((name) => CONVENTIONAL_NAMES.test(name));
+    if (preferred) return preferred;
+  }
+  return candidates[candidates.length - 1];
+}
+function reportOnce(options, unresolved) {
+  if (unresolved.length === 0) return;
+  const origin = options?.origin ?? "code-runtime";
+  if (options?.onUnresolved) {
+    try {
+      options.onUnresolved(origin, unresolved);
+    } catch {
+    }
+    return;
+  }
+  console.warn(`[code-runtime] ${origin}: ${unresolved.map(describeUnresolved).join(", ")} could not be resolved; each renders as a marked placeholder.`);
+}
+function executeGraph(graph, spec, options) {
+  const state = buildScopeState(spec);
+  const blocking = state.pending.filter((path) => {
+    const entry = getScopeEntry(path);
+    return Object.values(graph.modules).some(
+      (m) => m.importBindings.some((b) => b.source === path) || (entry?.provides ?? []).some((id) => new RegExp(`(?<![\\w$.])${id.replace(/[$]/g, "\\$")}\\b`).test(m.code))
+    );
+  });
+  if (blocking.length > 0) {
+    return {
+      ok: false,
+      error: {
+        code: "scope_not_ready",
+        message: `The scope entries ${blocking.join(", ")} are still loading. Call prepareScope(spec) before compiling.`,
+        retryable: true
+      }
+    };
+  }
+  const fileSet = new Set(Object.keys(graph.modules));
+  const allFiles = Object.fromEntries([...fileSet].map((f) => [f, ""]));
+  for (const mod of Object.values(graph.modules)) bindImports(mod, allFiles, state);
+  for (const mod of Object.values(graph.modules)) {
+    const ids = extractJsxComponentIdentifiers(stripLiteralsForScan(mod.code));
+    patchMissingJsx(ids, state, new Set(mod.declaredTopLevel), PATCH_SCOPE_SKIP_IDENTIFIERS);
+  }
+  const cache = /* @__PURE__ */ new Map();
+  let current = graph.entry;
+  const run = (file) => {
+    const cached = cache.get(file);
+    if (cached) return cached.exports;
+    const mod = graph.modules[file];
+    if (!mod) return missingModule(file);
+    const module2 = { exports: {} };
+    const record = { exports: module2.exports, done: false };
+    cache.set(file, record);
+    const declared = new Set(mod.declaredTopLevel);
+    const paramNames = Object.keys(state.values).filter(
+      (k) => IDENTIFIER_RE.test(k) && !k.startsWith("__") && !declared.has(k) && k !== "require" && k !== "module" && k !== "exports"
+    );
+    const paramValues = paramNames.map((k) => state.values[k]);
+    const requireFn = (specifier) => {
+      if (specifier.startsWith("./") || specifier.startsWith("../")) {
+        const target = resolveRelativeFile(allFiles, file, specifier);
+        if (!target) return missingModule(specifier);
+        const prev = current;
+        current = target;
+        try {
+          return run(target);
+        } finally {
+          current = prev;
+        }
+      }
+      return state.modules.get(specifier) ?? missingModule(specifier);
+    };
+    const candidate = file === graph.entry ? pickCandidate(mod.componentCandidates, options?.componentCandidate) : void 0;
+    const tail = candidate ? `
+;return typeof ${candidate} !== "undefined" ? ${candidate} : undefined;` : "";
+    const factory = new Function(...paramNames, "require", "module", "exports", `${mod.code}${tail}`);
+    const returned = factory(...paramValues, requireFn, module2, module2.exports);
+    if (module2.exports !== record.exports) record.exports = module2.exports;
+    if (returned !== void 0 && record.exports.default === void 0) {
+      record.exports.__candidate = returned;
+    }
+    record.done = true;
+    return record.exports;
+  };
+  try {
+    const exportsOfEntry = run(graph.entry);
+    const Component = exportsOfEntry.default ?? exportsOfEntry.__candidate;
+    const unresolved = [...state.unresolved];
+    reportOnce(options, unresolved);
+    if (typeof Component !== "function" && !(Component && typeof Component === "object" && "$$typeof" in Component)) {
+      return {
+        ok: false,
+        error: {
+          code: "no_component",
+          message: "This code compiled but returned nothing to render. Export a React component as the default export of the entry file.",
+          retryable: false,
+          diagnostic: graph.entry
+        }
+      };
+    }
+    return {
+      ok: true,
+      Component,
+      unresolved: unresolved.map(describeUnresolved),
+      unresolvedImports: unresolved
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      ok: false,
+      error: {
+        code: "evaluation_error",
+        message: fileSet.size > 1 ? `${current}: ${message}` : message,
+        retryable: false,
+        diagnostic: current
+      }
+    };
+  }
+}
+
+// src/transform-core.ts
+var import_standalone = require("@babel/standalone");
+function collectImportsPlugin(sink) {
+  return function collectImports() {
+    return {
+      name: "code-runtime-collect-imports",
+      visitor: {
+        ImportDeclaration(path) {
+          const { node } = path;
+          if (node.importKind === "type") return;
+          const source = node.source?.value ?? "";
+          for (const specifier of node.specifiers ?? []) {
+            if (specifier.importKind === "type") continue;
+            const local = specifier.local?.name;
+            if (!local) continue;
+            if (specifier.type === "ImportNamespaceSpecifier") sink.push({ local, source, imported: "*" });
+            else if (specifier.type === "ImportDefaultSpecifier") sink.push({ local, source, imported: "default" });
+            else sink.push({ local, source, imported: specifier.imported?.name ?? specifier.imported?.value ?? local });
+          }
+        }
+      }
+    };
+  };
+}
+function collectTopLevelPlugin(declared, candidates) {
+  return function collectTopLevel() {
+    return {
+      name: "code-runtime-collect-top-level",
+      visitor: {
+        Program: {
+          enter(path) {
+            for (const [name, binding] of Object.entries(path.scope.bindings)) {
+              const kind = binding?.kind;
+              if (kind === "module" || kind === "param") continue;
+              declared.add(name);
+              if (/^[A-Z]/.test(name)) candidates.push(name);
+            }
+          }
+        }
+      }
+    };
+  };
+}
+function languageOf(file) {
+  const m = /\.([a-z]+)$/i.exec(file);
+  const ext = (m?.[1] ?? "tsx").toLowerCase();
+  if (ext === "ts" || ext === "mts" || ext === "cts") return "ts";
+  if (ext === "tsx") return "tsx";
+  if (ext === "jsx") return "jsx";
+  if (ext === "js" || ext === "mjs" || ext === "cjs") return "js";
+  if (ext === "json") return "json";
+  return "text";
+}
+function transformModule(file, source) {
+  const lang = languageOf(file);
+  if (lang === "json") {
+    JSON.parse(source);
+    return { file, code: `module.exports = ${source};`, declaredTopLevel: [], componentCandidates: [], importBindings: [] };
+  }
+  if (lang === "text") {
+    return { file, code: `module.exports = ${JSON.stringify(source)};`, declaredTopLevel: [], componentCandidates: [], importBindings: [] };
+  }
+  const declared = /* @__PURE__ */ new Set();
+  const candidates = [];
+  const importBindings = [];
+  const filename = lang === "js" ? file.replace(/\.(m|c)?js$/i, ".jsx") : file;
+  const result = (0, import_standalone.transform)(source, {
+    filename: /\.[a-z]+$/i.test(filename) ? filename : `${filename}.tsx`,
+    presets: [["react", { runtime: "classic" }], "typescript"],
+    plugins: [
+      collectImportsPlugin(importBindings),
+      collectTopLevelPlugin(declared, candidates),
+      ["transform-modules-commonjs", { strictMode: false }]
+    ],
+    sourceType: "module",
+    babelrc: false,
+    configFile: false
+  });
+  return {
+    file,
+    code: result?.code ?? "",
+    declaredTopLevel: [...declared],
+    componentCandidates: candidates,
+    importBindings
+  };
+}
+function transformFiles(files, entry) {
+  if (!Object.prototype.hasOwnProperty.call(files, entry)) {
+    return {
+      ok: false,
+      error: { code: "entry_missing", message: `The entry file "${entry}" is not one of this component's files.`, retryable: false }
+    };
+  }
+  const modules = {};
+  for (const [file, source] of Object.entries(files)) {
+    try {
+      modules[file] = transformModule(file, source ?? "");
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return {
+        ok: false,
+        error: {
+          code: "compile_error",
+          message: Object.keys(files).length > 1 ? `${file}: ${message}` : message,
+          retryable: false,
+          diagnostic: file
+        }
+      };
+    }
+  }
+  return { ok: true, graph: { entry, modules } };
+}
+
+// src/compile.ts
+function compile(files, entry, scope, options) {
+  const transformed = transformFiles(files, entry);
+  if (!transformed.ok) return transformed;
+  return executeGraph(transformed.graph, scope, options);
+}
+function prepareScope(spec) {
+  return prepareScopeModules(spec.entries);
+}
+async function compileAsync(files, entry, scope, options) {
+  await prepareScope(scope);
+  return compile(files, entry, scope, options);
+}
+function compileSource(code, scope, options) {
+  return compile({ "component.tsx": code }, "component.tsx", scope, options);
+}
+
+// src/cache.ts
+function createCompileCache() {
+  const entries = /* @__PURE__ */ new Map();
+  const keyOf = (id, version) => `${id}\0${version ?? ""}`;
+  return {
+    get(id, version, compileFn) {
+      const key = keyOf(id, version);
+      const hit = entries.get(key);
+      if (hit) return hit;
+      const result = compileFn();
+      if (result.ok || !result.error.retryable) entries.set(key, result);
+      return result;
+    },
+    peek(id, version) {
+      return entries.get(keyOf(id, version));
+    },
+    invalidate(id) {
+      const prefix = `${id}\0`;
+      for (const key of [...entries.keys()]) if (key.startsWith(prefix)) entries.delete(key);
+    },
+    clear() {
+      entries.clear();
+    },
+    get size() {
+      return entries.size;
+    }
+  };
+}
+var DEFAULT_KEY = /* @__PURE__ */ Symbol.for("ai-matrx.code-runtime.cache");
+function defaultCompileCache() {
+  const g = globalThis;
+  let cache = g[DEFAULT_KEY];
+  if (!cache) {
+    cache = createCompileCache();
+    g[DEFAULT_KEY] = cache;
+  }
+  return cache;
+}
+
+// src/kind.ts
+function kindComponentCompiler(options = {}) {
+  return (args) => {
+    if (!args.code || !args.code.trim()) return { Component: null, error: null };
+    const compileOptions = { origin: options.origin?.() ?? "kind-component" };
+    if (options.onUnresolved) compileOptions.onUnresolved = options.onUnresolved;
+    const result = compileSource(
+      args.code,
+      {
+        entries: args.allowedImports,
+        shadowDangerousGlobals: true,
+        ...options.overrides ? { overrides: options.overrides } : {}
+      },
+      compileOptions
+    );
+    return result.ok ? { Component: result.Component, error: null } : { Component: null, error: result.error.message };
+  };
+}
+//# sourceMappingURL=index.cjs.map