@ai-matrx/code-runtime 0.1.4

package/dist/execute.js

@@ -0,0 +1,858 @@
+"use client";
+
+// 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;
+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;
+}
+
+// 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
+import * as ReactModule2 from "react";
+
+// src/scope/modules.ts
+import * as ReactModule from "react";
+import * as LucideModule from "lucide-react";
+import * as IconsModule from "@ai-matrx/icons";
+import * as DesignSystem from "@ai-matrx/design-system";
+import * as Controls from "@ai-matrx/design-system/controls";
+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
+import * as React from "react";
+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 module = { exports: {} };
+    const record = { exports: module.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, module, module.exports);
+    if (module.exports !== record.exports) record.exports = module.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
+      }
+    };
+  }
+}
+export {
+  SCOPE_ENTRIES,
+  buildDangerousGlobalStubs,
+  buildScope,
+  coreEntryPaths,
+  createUnresolvedImportStandIn,
+  defaultComponentEntries,
+  describeUnresolved,
+  detectEntries,
+  executeGraph,
+  getScopeEntry,
+  listScopeEntries,
+  listScopeEntryPaths,
+  prepareScopeModules,
+  provideScopeModules,
+  readUnresolvedImportMark,
+  resetScopeModules
+};
+//# sourceMappingURL=execute.js.map