@stacksjs/stx 0.2.95 → 0.2.97

package/dist/craft-compiler.js

@@ -1,2 +1,810 @@
-// @bun
-import{Bo as a,Co as b,Do as c,Eo as d}from"./chunk-n98x35xd.js";import"./chunk-xv34zbp4.js";export{d as default,c as createHotReloadServer,b as compileToNative,a as NATIVE_COMPONENTS};
+const NATIVE_COMPONENTS = new Map([
+  ["craft-button", {
+    name: "Button",
+    zigType: "craft.Button",
+    props: [
+      { name: "variant", type: "string", required: !1, default: "primary" },
+      { name: "disabled", type: "boolean", required: !1, default: !1 },
+      { name: "onclick", type: "callback", required: !1 }
+    ],
+    children: "single"
+  }],
+  ["craft-text-input", {
+    name: "TextInput",
+    zigType: "craft.TextInput",
+    props: [
+      { name: "value", type: "string", required: !1, default: "" },
+      { name: "placeholder", type: "string", required: !1 },
+      { name: "disabled", type: "boolean", required: !1, default: !1 },
+      { name: "onchange", type: "callback", required: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-textarea", {
+    name: "TextArea",
+    zigType: "craft.TextArea",
+    props: [
+      { name: "value", type: "string", required: !1, default: "" },
+      { name: "placeholder", type: "string", required: !1 },
+      { name: "rows", type: "number", required: !1, default: 3 },
+      { name: "disabled", type: "boolean", required: !1, default: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-checkbox", {
+    name: "Checkbox",
+    zigType: "craft.Checkbox",
+    props: [
+      { name: "checked", type: "boolean", required: !1, default: !1 },
+      { name: "label", type: "string", required: !1 },
+      { name: "disabled", type: "boolean", required: !1, default: !1 },
+      { name: "onchange", type: "callback", required: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-select", {
+    name: "Select",
+    zigType: "craft.Select",
+    props: [
+      { name: "value", type: "string", required: !1 },
+      { name: "options", type: "array", required: !0 },
+      { name: "disabled", type: "boolean", required: !1, default: !1 },
+      { name: "onchange", type: "callback", required: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-slider", {
+    name: "Slider",
+    zigType: "craft.Slider",
+    props: [
+      { name: "value", type: "number", required: !1, default: 0 },
+      { name: "min", type: "number", required: !1, default: 0 },
+      { name: "max", type: "number", required: !1, default: 100 },
+      { name: "step", type: "number", required: !1, default: 1 },
+      { name: "onchange", type: "callback", required: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-toggle", {
+    name: "Toggle",
+    zigType: "craft.Toggle",
+    props: [
+      { name: "checked", type: "boolean", required: !1, default: !1 },
+      { name: "disabled", type: "boolean", required: !1, default: !1 },
+      { name: "onchange", type: "callback", required: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-modal", {
+    name: "Modal",
+    zigType: "craft.Modal",
+    props: [
+      { name: "open", type: "boolean", required: !1, default: !1 },
+      { name: "title", type: "string", required: !1 },
+      { name: "closable", type: "boolean", required: !1, default: !0 },
+      { name: "onclose", type: "callback", required: !1 }
+    ],
+    children: "multiple"
+  }],
+  ["craft-alert", {
+    name: "Alert",
+    zigType: "craft.Alert",
+    props: [
+      { name: "variant", type: "string", required: !1, default: "info" },
+      { name: "title", type: "string", required: !1 },
+      { name: "dismissible", type: "boolean", required: !1, default: !1 }
+    ],
+    children: "single"
+  }],
+  ["craft-progress", {
+    name: "ProgressBar",
+    zigType: "craft.ProgressBar",
+    props: [
+      { name: "value", type: "number", required: !1, default: 0 },
+      { name: "max", type: "number", required: !1, default: 100 },
+      { name: "indeterminate", type: "boolean", required: !1, default: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-spinner", {
+    name: "Spinner",
+    zigType: "craft.Spinner",
+    props: [
+      { name: "size", type: "number", required: !1, default: 24 }
+    ],
+    children: "none"
+  }],
+  ["craft-avatar", {
+    name: "Avatar",
+    zigType: "craft.Avatar",
+    props: [
+      { name: "src", type: "string", required: !1 },
+      { name: "alt", type: "string", required: !1 },
+      { name: "size", type: "number", required: !1, default: 40 }
+    ],
+    children: "none"
+  }],
+  ["craft-badge", {
+    name: "Badge",
+    zigType: "craft.Badge",
+    props: [
+      { name: "variant", type: "string", required: !1, default: "default" }
+    ],
+    children: "single"
+  }],
+  ["craft-card", {
+    name: "Card",
+    zigType: "craft.Card",
+    props: [
+      { name: "padding", type: "number", required: !1, default: 16 }
+    ],
+    children: "multiple"
+  }],
+  ["craft-sidebar", {
+    name: "Sidebar",
+    zigType: "craft.NativeSidebar",
+    props: [
+      { name: "id", type: "string", required: !1 },
+      { name: "variant", type: "string", required: !1, default: "desktop" },
+      { name: "material", type: "string", required: !1, default: "sidebar" },
+      { name: "backgroundEffect", type: "string", required: !1, default: "shimmer" },
+      { name: "allowsVibrancy", type: "boolean", required: !1, default: !0 },
+      { name: "materialOpacity", type: "number", required: !1, default: 0.68 },
+      { name: "minWidth", type: "number", required: !1, default: 240 },
+      { name: "maxWidth", type: "number", required: !1, default: 340 },
+      { name: "canCollapse", type: "boolean", required: !1, default: !0 },
+      { name: "selectedItem", type: "string", required: !1 },
+      { name: "sections", type: "array", required: !1 }
+    ],
+    children: "multiple",
+    platform: ["macos"],
+    fallback: "aside"
+  }],
+  ["craft-sidebar-section", {
+    name: "SidebarSection",
+    zigType: "craft.NativeSidebarSection",
+    props: [
+      { name: "id", type: "string", required: !0 },
+      { name: "title", type: "string", required: !1 },
+      { name: "header", type: "string", required: !1 }
+    ],
+    children: "multiple",
+    platform: ["macos"],
+    fallback: "section"
+  }],
+  ["craft-sidebar-item", {
+    name: "SidebarItem",
+    zigType: "craft.NativeSidebarItem",
+    props: [
+      { name: "id", type: "string", required: !0 },
+      { name: "label", type: "string", required: !0 },
+      { name: "icon", type: "string", required: !1 },
+      { name: "badge", type: "string", required: !1 },
+      { name: "tintColor", type: "color", required: !1 }
+    ],
+    children: "none",
+    platform: ["macos"],
+    fallback: "button"
+  }],
+  ["craft-accordion", {
+    name: "Accordion",
+    zigType: "craft.Accordion",
+    props: [
+      { name: "title", type: "string", required: !0 },
+      { name: "open", type: "boolean", required: !1, default: !1 }
+    ],
+    children: "multiple"
+  }],
+  ["craft-tabs", {
+    name: "TabView",
+    zigType: "craft.TabView",
+    props: [
+      { name: "activeTab", type: "number", required: !1, default: 0 },
+      { name: "ontabchange", type: "callback", required: !1 }
+    ],
+    children: "multiple"
+  }],
+  ["craft-tooltip", {
+    name: "Tooltip",
+    zigType: "craft.Tooltip",
+    props: [
+      { name: "content", type: "string", required: !0 },
+      { name: "position", type: "string", required: !1, default: "top" }
+    ],
+    children: "single"
+  }],
+  ["craft-date-picker", {
+    name: "DatePicker",
+    zigType: "craft.DatePicker",
+    props: [
+      { name: "value", type: "string", required: !1 },
+      { name: "min", type: "string", required: !1 },
+      { name: "max", type: "string", required: !1 },
+      { name: "onchange", type: "callback", required: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-time-picker", {
+    name: "TimePicker",
+    zigType: "craft.TimePicker",
+    props: [
+      { name: "value", type: "string", required: !1 },
+      { name: "onchange", type: "callback", required: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-color-picker", {
+    name: "ColorPicker",
+    zigType: "craft.ColorPicker",
+    props: [
+      { name: "value", type: "color", required: !1, default: "#000000" },
+      { name: "onchange", type: "callback", required: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-data-table", {
+    name: "DataTable",
+    zigType: "craft.DataTable",
+    props: [
+      { name: "data", type: "array", required: !0 },
+      { name: "columns", type: "array", required: !0 },
+      { name: "sortable", type: "boolean", required: !1, default: !1 },
+      { name: "paginated", type: "boolean", required: !1, default: !1 }
+    ],
+    children: "none"
+  }],
+  ["craft-virtual-list", {
+    name: "VirtualList",
+    zigType: "craft.VirtualList",
+    props: [
+      { name: "items", type: "array", required: !0 },
+      { name: "itemHeight", type: "number", required: !1, default: 48 },
+      { name: "renderItem", type: "callback", required: !0 }
+    ],
+    children: "none"
+  }],
+  ["craft-tree-view", {
+    name: "TreeView",
+    zigType: "craft.TreeView",
+    props: [
+      { name: "data", type: "object", required: !0 },
+      { name: "expandable", type: "boolean", required: !1, default: !0 }
+    ],
+    children: "none"
+  }]
+]);
+export async function compileToNative(template, config = {}) {
+  const startTime = performance.now(), fullConfig = {
+    target: config.target || "universal",
+    format: config.format || "zig",
+    optimize: config.optimize ?? !0,
+    treeShake: config.treeShake ?? !0,
+    hotReload: config.hotReload ?? !1,
+    debug: config.debug ?? !1,
+    sourceMaps: config.sourceMaps ?? !1,
+    bundle: config.bundle ?? !0,
+    minify: config.minify ?? !1,
+    components: config.components || NATIVE_COMPONENTS
+  }, parsed = typeof template === "string" ? parseTemplate(template) : template, ir = convertToNativeIR(parsed.tree, fullConfig), dependencies = analyzeDependencies(ir), optimizedIR = fullConfig.treeShake ? treeShake(ir, dependencies) : ir, platformCode = new Map;
+  if (fullConfig.target === "universal") {
+    const targets = ["macos", "windows", "linux", "ios", "android"];
+    for (const target of targets) {
+      const code = generateNativeCode(optimizedIR, { ...fullConfig, target });
+      platformCode.set(target, code);
+    }
+  } else {
+    const code = generateNativeCode(optimizedIR, fullConfig);
+    platformCode.set(fullConfig.target, code);
+  }
+  const code = generateEntryCode(optimizedIR, fullConfig, platformCode), manifest = generateManifest(parsed, optimizedIR, fullConfig), stats = {
+    compilationTime: performance.now() - startTime,
+    totalComponents: countComponents(parsed.tree),
+    nativeComponents: countNativeComponents(optimizedIR),
+    webComponents: countComponents(parsed.tree) - countNativeComponents(optimizedIR),
+    bundleSize: code.length,
+    treeShakenSize: fullConfig.treeShake ? calculateTreeShakenSize(ir, optimizedIR) : code.length,
+    warnings: [],
+    errors: []
+  };
+  let sourceMaps;
+  if (fullConfig.sourceMaps)
+    sourceMaps = generateSourceMaps(parsed, optimizedIR);
+  return {
+    code,
+    platformCode,
+    dependencies,
+    manifest,
+    sourceMaps,
+    stats
+  };
+}
+function parseTemplate(template) {
+  const tree = {
+    type: "fragment",
+    children: []
+  }, bodyMatch = template.match(/<body[^>]*>([\s\S]*?)<\/body>/i), content = bodyMatch ? bodyMatch[1] : template;
+  parseHTMLIntoTree(content, tree);
+  return {
+    id: generateId(),
+    hash: hashString(template),
+    tree,
+    scripts: extractScriptBlocks(template),
+    styles: extractStyleBlocks(template),
+    staticParts: new Map,
+    dynamicParts: new Map,
+    dependencies: [],
+    metadata: {
+      hasSlots: !1,
+      hasDynamicContent: template.includes("{{"),
+      hasEventHandlers: template.includes("onclick") || template.includes("onchange"),
+      hasAsyncContent: !1,
+      componentCount: 0,
+      maxDepth: 0,
+      estimatedSize: template.length
+    }
+  };
+}
+function parseHTMLIntoTree(content, parent) {
+  const tagRegex = /<(@?[\w-]+)([^>]*)(?:\/>|>([\s\S]*?)<\/\1>)/g;
+  let match;
+  while ((match = tagRegex.exec(content)) !== null) {
+    const [, tag, attrs, innerContent] = match, isCraft = tag.startsWith("@craft-"), node = {
+      type: isCraft ? "component" : "element",
+      tag: isCraft ? tag.slice(1) : tag,
+      props: parseAttributeString(attrs),
+      children: [],
+      componentName: isCraft ? tag.slice(1) : void 0
+    };
+    if (innerContent) {
+      const textContent = innerContent.replace(/<[^>]+>/g, "").trim();
+      if (textContent) {
+        node.children = node.children ?? [];
+        node.children.push({
+          type: "text",
+          text: textContent
+        });
+      }
+      parseHTMLIntoTree(innerContent, node);
+    }
+    parent.children = parent.children ?? [];
+    parent.children.push(node);
+  }
+}
+function parseAttributeString(attrs) {
+  const props = {}, attrRegex = /([\w-:@]+)(?:=["']([^"']*)["'])?/g;
+  let match;
+  while ((match = attrRegex.exec(attrs)) !== null) {
+    const [, name, value] = match;
+    props[name] = value ?? !0;
+  }
+  return props;
+}
+function convertToNativeIR(tree, config) {
+  return transformNode(tree, config);
+}
+function transformNode(node, config) {
+  const componentDef = node.componentName ? config.components?.get(node.componentName) : void 0;
+  let zigType = "craft.View";
+  if (componentDef)
+    zigType = componentDef.zigType;
+  else if (node.type === "text")
+    zigType = "craft.Text";
+  else if (node.tag)
+    zigType = mapHTMLToZig(node.tag);
+  const props = {};
+  if (node.props)
+    for (const [key, value] of Object.entries(node.props))
+      props[key] = transformValue(value);
+  const children = [];
+  if (node.children)
+    for (const child of node.children)
+      children.push(transformNode(child, config));
+  const events = new Map;
+  if (node.props) {
+    for (const [key, value] of Object.entries(node.props))
+      if (key.startsWith("on") && typeof value === "string")
+        events.set(key.slice(2).toLowerCase(), value);
+  }
+  const styles = extractStyles(node);
+  return {
+    type: determineIRType(node, componentDef),
+    zigType,
+    props,
+    children,
+    events,
+    styles,
+    id: node.hydrationKey,
+    key: node.props?.key
+  };
+}
+function mapHTMLToZig(tag) {
+  return {
+    div: "craft.View",
+    span: "craft.Text",
+    p: "craft.Text",
+    h1: "craft.Text",
+    h2: "craft.Text",
+    h3: "craft.Text",
+    h4: "craft.Text",
+    h5: "craft.Text",
+    h6: "craft.Text",
+    button: "craft.Button",
+    input: "craft.TextInput",
+    textarea: "craft.TextArea",
+    select: "craft.Select",
+    img: "craft.Image",
+    a: "craft.Link",
+    ul: "craft.List",
+    ol: "craft.List",
+    li: "craft.ListItem",
+    form: "craft.Form",
+    label: "craft.Label",
+    nav: "craft.View",
+    header: "craft.View",
+    footer: "craft.View",
+    main: "craft.View",
+    section: "craft.View",
+    article: "craft.View",
+    aside: "craft.View"
+  }[tag.toLowerCase()] || "craft.View";
+}
+function transformValue(value) {
+  if (typeof value === "string") {
+    if (value.startsWith("{{") && value.endsWith("}}"))
+      return {
+        type: "binding",
+        path: value.slice(2, -2).trim()
+      };
+    if (value.includes("(") && value.includes(")"))
+      return {
+        type: "callback",
+        handler: value
+      };
+    return { type: "literal", value };
+  }
+  if (typeof value === "number" || typeof value === "boolean")
+    return { type: "literal", value };
+  return { type: "literal", value: String(value) };
+}
+function determineIRType(node, componentDef) {
+  if (componentDef) {
+    const name = componentDef.name.toLowerCase();
+    if (name.includes("button"))
+      return "button";
+    if (name.includes("input") || name.includes("text"))
+      return "input";
+    if (name.includes("image") || name.includes("avatar"))
+      return "image";
+    if (name.includes("list") || name.includes("table"))
+      return "list";
+    if (name.includes("scroll"))
+      return "scroll";
+    return "custom";
+  }
+  if (node.type === "text")
+    return "text";
+  const tag = node.tag?.toLowerCase();
+  if (tag === "button")
+    return "button";
+  if (tag === "input" || tag === "textarea")
+    return "input";
+  if (tag === "img")
+    return "image";
+  if (tag === "ul" || tag === "ol")
+    return "list";
+  return "view";
+}
+function extractStyles(node) {
+  const style = node.props?.style, layout = {}, appearance = {};
+  if (style) {
+    const styleProps = style.split(";").filter(Boolean);
+    for (const prop of styleProps) {
+      const [key, value] = prop.split(":").map((s) => s.trim());
+      if (!key || !value)
+        continue;
+      switch (key) {
+        case "display":
+          layout.display = value;
+          break;
+        case "flex-direction":
+          layout.flexDirection = value;
+          break;
+        case "justify-content":
+          layout.justifyContent = mapJustifyContent(value);
+          break;
+        case "align-items":
+          layout.alignItems = mapAlignItems(value);
+          break;
+        case "gap":
+          layout.gap = Number.parseInt(value, 10);
+          break;
+        case "padding":
+          layout.padding = Number.parseInt(value, 10);
+          break;
+        case "margin":
+          layout.margin = Number.parseInt(value, 10);
+          break;
+        case "width":
+          layout.width = value === "auto" ? "auto" : Number.parseInt(value, 10);
+          break;
+        case "height":
+          layout.height = value === "auto" ? "auto" : Number.parseInt(value, 10);
+          break;
+        case "background-color":
+        case "background":
+          appearance.backgroundColor = value;
+          break;
+        case "border-color":
+          appearance.borderColor = value;
+          break;
+        case "border-width":
+          appearance.borderWidth = Number.parseInt(value, 10);
+          break;
+        case "border-radius":
+          appearance.borderRadius = Number.parseInt(value, 10);
+          break;
+        case "opacity":
+          appearance.opacity = Number.parseFloat(value);
+          break;
+      }
+    }
+  }
+  return { layout, appearance };
+}
+function mapJustifyContent(value) {
+  return {
+    "flex-start": "start",
+    "flex-end": "end",
+    center: "center",
+    "space-between": "between",
+    "space-around": "around"
+  }[value] || "start";
+}
+function mapAlignItems(value) {
+  return {
+    "flex-start": "start",
+    "flex-end": "end",
+    center: "center",
+    stretch: "stretch"
+  }[value] || "start";
+}
+function analyzeDependencies(ir) {
+  const deps = [], visited = new Set;
+  function walk(node, parentId) {
+    const id = node.id || generateId();
+    if (visited.has(id))
+      return;
+    visited.add(id);
+    const dep = {
+      id,
+      type: "component",
+      path: node.zigType,
+      dependencies: parentId ? [parentId] : [],
+      size: estimateNodeSize(node),
+      isStatic: isStaticNode(node)
+    };
+    deps.push(dep);
+    for (const child of node.children)
+      walk(child, id);
+  }
+  walk(ir);
+  return deps;
+}
+function estimateNodeSize(node) {
+  let size = 100;
+  size += Object.keys(node.props).length * 20;
+  size += node.events.size * 50;
+  return size;
+}
+function isStaticNode(node) {
+  for (const value of Object.values(node.props))
+    if (value.type !== "literal")
+      return !1;
+  return node.events.size === 0;
+}
+function treeShake(ir, _deps) {
+  return ir;
+}
+function calculateTreeShakenSize(_original, optimized) {
+  let size = 0;
+  function walk(node) {
+    size += estimateNodeSize(node);
+    for (const child of node.children)
+      walk(child);
+  }
+  walk(optimized);
+  return size;
+}
+function generateNativeCode(ir, config) {
+  switch (config.format) {
+    case "zig":
+      return generateZigCode(ir, config);
+    case "typescript":
+      return generateTypeScriptCode(ir, config);
+    case "json":
+      return JSON.stringify(ir, null, config.minify ? 0 : 2);
+    default:
+      return generateZigCode(ir, config);
+  }
+}
+function generateZigCode(ir, config) {
+  const lines = [];
+  lines.push("// Auto-generated by stx compiler");
+  lines.push("// Target: " + config.target);
+  lines.push("");
+  lines.push('const std = @import("std");');
+  lines.push('const craft = @import("craft");');
+  lines.push("");
+  lines.push("pub fn render(allocator: std.mem.Allocator) !craft.Element {");
+  lines.push("    return try build(allocator);");
+  lines.push("}");
+  lines.push("");
+  generateZigNode(ir, lines, 0);
+  return lines.join(`
+`);
+}
+function generateZigNode(node, lines, depth) {
+  const indent = "    ".repeat(depth);
+  if (depth === 0)
+    lines.push("fn build(allocator: std.mem.Allocator) !craft.Element {");
+  const varName = `node_${depth}`;
+  lines.push(`${indent}    var ${varName} = try ${node.zigType}.init(allocator);`);
+  for (const [key, value] of Object.entries(node.props))
+    if (value.type === "literal") {
+      const zigValue = typeof value.value === "string" ? `"${value.value}"` : String(value.value);
+      lines.push(`${indent}    ${varName}.set${capitalize(key)}(${zigValue});`);
+    }
+  for (let i = 0;i < node.children.length; i++) {
+    const child = node.children[i];
+    if (child.type === "text") {
+      const text = child.props.text?.type === "literal" ? String(child.props.text.value) : "";
+      lines.push(`${indent}    try ${varName}.addChild(try craft.Text.init(allocator, "${text}"));`);
+    } else {
+      generateZigNode(child, lines, depth + 1);
+      lines.push(`${indent}    try ${varName}.addChild(node_${depth + 1});`);
+    }
+  }
+  if (depth === 0) {
+    lines.push(`    return ${varName}.element();`);
+    lines.push("}");
+  }
+}
+function generateTypeScriptCode(ir, config) {
+  const lines = [];
+  lines.push("// Auto-generated by stx compiler");
+  lines.push("// Target: " + config.target);
+  lines.push("");
+  lines.push('import { Craft } from "@stacksjs/craft";');
+  lines.push("");
+  lines.push("export function render(): Craft.Element {");
+  lines.push("  return " + generateTSNode(ir, 1) + ";");
+  lines.push("}");
+  return lines.join(`
+`);
+}
+function generateTSNode(node, depth) {
+  const indent = "  ".repeat(depth), props = [];
+  for (const [key, value] of Object.entries(node.props))
+    if (value.type === "literal") {
+      const tsValue = typeof value.value === "string" ? `"${value.value}"` : String(value.value);
+      props.push(`${key}: ${tsValue}`);
+    }
+  const propsStr = props.length > 0 ? `{ ${props.join(", ")} }` : "{}", children = node.children.map((child) => child.type === "text" ? `"${child.props.text?.type === "literal" ? child.props.text.value : ""}"` : generateTSNode(child, depth + 1)), childrenStr = children.length > 0 ? `,
+${indent}  [${children.join(`,
+${indent}    `)}]` : "";
+  return `Craft.create("${node.zigType}", ${propsStr}${childrenStr})`;
+}
+function generateEntryCode(ir, config, platformCode) {
+  if (config.target === "universal") {
+    const lines = [];
+    lines.push("// Universal entry point");
+    lines.push("");
+    for (const [platform, code] of platformCode) {
+      lines.push(`// --- ${platform.toUpperCase()} ---`);
+      lines.push(`#if ${platform.toUpperCase()}`);
+      lines.push(code);
+      lines.push("#endif");
+      lines.push("");
+    }
+    return lines.join(`
+`);
+  }
+  return platformCode.get(config.target) || generateNativeCode(ir, config);
+}
+function generateManifest(parsed, ir, _config) {
+  const components = [];
+  function walk(node) {
+    components.push({
+      name: node.zigType,
+      hash: hashString(JSON.stringify(node.props)),
+      props: Object.keys(node.props),
+      events: Array.from(node.events.keys()),
+      slots: [],
+      isNative: node.zigType.startsWith("craft.")
+    });
+    for (const child of node.children)
+      walk(child);
+  }
+  walk(ir);
+  return {
+    version: "1.0.0",
+    components,
+    entry: parsed.id,
+    assets: [],
+    styles: parsed.styles
+  };
+}
+function generateSourceMaps(_parsed, _ir) {
+  return JSON.stringify({
+    version: 3,
+    file: "output.zig",
+    sources: ["input.stx"],
+    mappings: ""
+  });
+}
+let idCounter = 0;
+function generateId() {
+  return `id_${++idCounter}`;
+}
+function hashString(str) {
+  let hash = 0;
+  for (let i = 0;i < str.length; i++) {
+    const char = str.charCodeAt(i);
+    hash = (hash << 5) - hash + char;
+    hash = hash & hash;
+  }
+  return Math.abs(hash).toString(36);
+}
+function capitalize(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+}
+function extractScriptBlocks(template) {
+  const scripts = [], scriptRegex = /<script[^>]*>([\s\S]*?)<\/script>/gi;
+  let match;
+  while ((match = scriptRegex.exec(template)) !== null)
+    scripts.push(match[1]);
+  return scripts;
+}
+function extractStyleBlocks(template) {
+  const styles = [], styleRegex = /<style[^>]*>([\s\S]*?)<\/style>/gi;
+  let match;
+  while ((match = styleRegex.exec(template)) !== null)
+    styles.push(match[1]);
+  return styles;
+}
+function countComponents(node) {
+  let count = node.type === "component" ? 1 : 0;
+  if (node.children)
+    for (const child of node.children)
+      count += countComponents(child);
+  return count;
+}
+function countNativeComponents(node) {
+  let count = node.zigType.startsWith("craft.") ? 1 : 0;
+  for (const child of node.children)
+    count += countNativeComponents(child);
+  return count;
+}
+export function createHotReloadServer(_config) {
+  return {
+    start: async () => {
+      console.log("[craft-compiler] Hot reload server started");
+    },
+    stop: async () => {
+      console.log("[craft-compiler] Hot reload server stopped");
+    },
+    notifyChange: (path) => {
+      console.log(`[craft-compiler] File changed: ${path}`);
+    }
+  };
+}
+
+export {
+  NATIVE_COMPONENTS
+};
+const craftCompiler = {
+  compileToNative,
+  createHotReloadServer,
+  NATIVE_COMPONENTS
+};
+export default craftCompiler;