@june-ai/june-ui 0.1.0 → 0.1.1

package/dist/index.js

@@ -1,24 +1,1086 @@
-// src/JuneUI.tsx
+// src/renderer/renderer.tsx
 import { Renderer } from "@openuidev/react-lang";
-import { openuiLibrary } from "@openuidev/react-ui";
+import {
+  Fragment,
+  useCallback,
+  useMemo as useMemo2,
+  useRef
+} from "react";
+
+// src/errors/errors.ts
+var JuneError = class _JuneError extends Error {
+  constructor(code, message, options = {}) {
+    super(message);
+    Object.setPrototypeOf(this, _JuneError.prototype);
+    this.name = "JuneError";
+    this.code = code;
+    this.details = options.details;
+    if (options.cause !== void 0) {
+      this.cause = options.cause;
+    }
+  }
+};
+function isJuneError(value) {
+  return value instanceof JuneError;
+}
+function toJuneError(error, fallbackCode, message) {
+  if (error instanceof JuneError) return error;
+  const text = message ?? (error instanceof Error ? error.message : String(error));
+  return new JuneError(fallbackCode, text, { cause: error });
+}
+
+// src/actions/action-handler.ts
+function firstString(...values) {
+  for (const v of values) if (typeof v === "string" && v.length > 0) return v;
+  return null;
+}
+var defaultParseActionEvent = (event) => {
+  if (!event || typeof event !== "object") return null;
+  const e = event;
+  const name = firstString(e.type, e.name, e.action);
+  if (!name) return null;
+  return { name, payload: e.params ?? e.payload ?? e.data };
+};
+async function runAction(event, options) {
+  const { actions, parseEvent = defaultParseActionEvent, confirm, onError, onUnhandled } = options;
+  const parsed = parseEvent(event);
+  const action = parsed && Object.prototype.hasOwnProperty.call(actions, parsed.name) ? actions[parsed.name] : void 0;
+  if (!parsed || !action) {
+    onUnhandled?.(event);
+    return "unhandled";
+  }
+  const { name } = parsed;
+  let payload = parsed.payload;
+  if (action.schema) {
+    const result = action.schema.safeParse(payload);
+    if (!result.success) {
+      onError?.(
+        new JuneError("ACTION_VALIDATION_ERROR", `Invalid payload for action "${name}"`, {
+          details: result.error
+        })
+      );
+      return "failed";
+    }
+    payload = result.data;
+  }
+  try {
+    if (action.sensitive || action.confirm) {
+      const ask = action.confirm ?? confirm;
+      if (!ask) {
+        onError?.(
+          new JuneError(
+            "ACTION_REJECTED",
+            `Action "${name}" requires confirmation but no confirm handler was provided`
+          )
+        );
+        return "rejected";
+      }
+      const approved = await ask({ name, payload, description: action.description });
+      if (!approved) return "rejected";
+    }
+    await action.handler(payload, { name, event });
+    return "handled";
+  } catch (error) {
+    onError?.(toJuneError(error, "ACTION_ERROR"));
+    return "failed";
+  }
+}
+function createActionHandler(options) {
+  return (event) => {
+    void runAction(event, options);
+  };
+}
+
+// src/themes/theme-provider.tsx
+import {
+  useMemo,
+  useSyncExternalStore
+} from "react";
+
+// src/core/context.ts
+import { createContext, useContext } from "react";
+var JuneContext = createContext({
+  mode: "light",
+  theme: "light"
+});
+function useJuneTheme() {
+  return useContext(JuneContext);
+}
+
+// src/themes/dark.ts
+var darkTheme = {
+  "--june-background": "#0b0f19",
+  "--june-foreground": "#f3f4f6",
+  "--june-muted": "#9ca3af",
+  "--june-border": "#1f2937",
+  "--june-accent": "#818cf8",
+  "--june-danger": "#f87171",
+  "--june-radius": "8px",
+  "--june-font-family": "system-ui, -apple-system, 'Segoe UI', sans-serif"
+};
+
+// src/themes/light.ts
+var lightTheme = {
+  "--june-background": "#ffffff",
+  "--june-foreground": "#111827",
+  "--june-muted": "#6b7280",
+  "--june-border": "#e5e7eb",
+  "--june-accent": "#4f46e5",
+  "--june-danger": "#b91c1c",
+  "--june-radius": "8px",
+  "--june-font-family": "system-ui, -apple-system, 'Segoe UI', sans-serif"
+};
+
+// src/themes/theme-provider.tsx
 import { jsx } from "react/jsx-runtime";
-function JuneUI({
-  response,
-  isStreaming = false,
-  onAction,
-  onError
+var QUERY = "(prefers-color-scheme: dark)";
+function subscribe(onChange) {
+  if (typeof window === "undefined" || !window.matchMedia) return () => {
+  };
+  const mq = window.matchMedia(QUERY);
+  mq.addEventListener("change", onChange);
+  return () => mq.removeEventListener("change", onChange);
+}
+function getSnapshot() {
+  if (typeof window === "undefined") return "light";
+  return window.matchMedia?.(QUERY)?.matches ? "dark" : "light";
+}
+function getServerSnapshot() {
+  return "light";
+}
+function useResolvedTheme(mode) {
+  const system = useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot);
+  return mode === "system" ? system : mode;
+}
+function JuneThemeProvider({
+  mode = "light",
+  vars,
+  className,
+  style,
+  children
 }) {
-  return /* @__PURE__ */ jsx(
-    Renderer,
+  const resolved = useResolvedTheme(mode);
+  const mergedStyle = useMemo(() => {
+    const base = resolved === "dark" ? darkTheme : lightTheme;
+    return { ...base, ...vars, colorScheme: resolved, ...style };
+  }, [resolved, vars, style]);
+  const context = useMemo(() => ({ mode, theme: resolved }), [mode, resolved]);
+  return /* @__PURE__ */ jsx(JuneContext.Provider, { value: context, children: /* @__PURE__ */ jsx(
+    "div",
     {
-      library: openuiLibrary,
-      response,
-      isStreaming,
-      onAction,
-      onError
+      className: className ? `june-ui-root ${className}` : "june-ui-root",
+      "data-june-theme": resolved,
+      style: mergedStyle,
+      children
+    }
+  ) });
+}
+
+// src/utils/normalize-program.ts
+var ATTACHABLE = /* @__PURE__ */ new Set([
+  "Accordion",
+  "AreaChart",
+  "BarChart",
+  "Buttons",
+  "Button",
+  "Callout",
+  "Card",
+  "CardHeader",
+  "Carousel",
+  "CodeBlock",
+  "CompositeCardBlock",
+  "ContextCardBlock",
+  "EditableTable",
+  "EntityList",
+  "Form",
+  "HorizontalBarChart",
+  "IconButton",
+  "Image",
+  "ImageBlock",
+  "ImageGallery",
+  "InlineHeader",
+  "LineChart",
+  "ListBlock",
+  "MarkDownRenderer",
+  "Modal",
+  "OverviewCardBlock",
+  "PieChart",
+  "RadarChart",
+  "RadialChart",
+  "ScatterChart",
+  "Separator",
+  "SingleStackedBarChart",
+  "SnippetCardBlock",
+  "Stack",
+  "Steps",
+  "Table",
+  "Tabs",
+  "TagBlock",
+  "TextCallout",
+  "TextContent",
+  "VisualCardBlock"
+]);
+function normalizeProgram(source) {
+  const rewritten = rewriteCalls(source);
+  return attachOrphans(rewritten);
+}
+function rewriteCalls(source) {
+  let out = "";
+  let i = 0;
+  let quote = false;
+  while (i < source.length) {
+    const ch = source[i];
+    if (quote) {
+      out += ch;
+      if (ch === "\\") {
+        i += 1;
+        if (i < source.length) out += source[i];
+      } else if (ch === '"') {
+        quote = false;
+      }
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      quote = true;
+      out += ch;
+      i += 1;
+      continue;
+    }
+    const call = readCall(source, i);
+    if (call) {
+      const next = rewriteKnownCall(call);
+      if (next !== null) {
+        out += next;
+        i = call.end;
+        continue;
+      }
+    }
+    out += ch;
+    i += 1;
+  }
+  return out === source ? source : out;
+}
+function rewriteKnownCall(call) {
+  if (call.callee === "Grid") {
+    const args = call.args.map((arg) => rewriteCalls(arg));
+    const children = args.length === 0 ? "[]" : args.length === 1 ? args[0] : null;
+    if (children !== null) {
+      return `Stack(${children}, "row", "m", "stretch", "start", true)`;
     }
+    return `Stack(${args.join(", ")})`;
+  }
+  if (call.callee === "Card") {
+    const args = call.args.map((arg) => rewriteCalls(arg));
+    if (args.length >= 2 && isStringLiteral(args[0]) && isStringLiteral(args[1])) {
+      const children = `[TextContent(${args[0]}, "small"), TextContent(${args[1]}, "large-heavy")]`;
+      return `Card(${[children, ...args.slice(2)].join(", ")})`;
+    }
+    if (args.some((arg, index) => arg !== call.args[index])) {
+      return `Card(${args.join(", ")})`;
+    }
+  }
+  return null;
+}
+function readCall(source, index) {
+  if (index > 0 && /[A-Za-z0-9_$]/.test(source[index - 1])) return null;
+  const match = /^(Grid|Card)\s*\(/.exec(source.slice(index));
+  if (!match) return null;
+  const open = index + match[0].length - 1;
+  const close = findMatchingParen(source, open);
+  if (close < 0) return null;
+  const args = splitArgs(source.slice(open + 1, close));
+  if (!args) return null;
+  return { callee: match[1], args, end: close + 1 };
+}
+function findMatchingParen(source, open) {
+  let depth = 0;
+  let quote = false;
+  for (let i = open; i < source.length; i += 1) {
+    const ch = source[i];
+    if (quote) {
+      if (ch === "\\") i += 1;
+      else if (ch === '"') quote = false;
+      continue;
+    }
+    if (ch === '"') quote = true;
+    else if (ch === "(") depth += 1;
+    else if (ch === ")") {
+      depth -= 1;
+      if (depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function splitArgs(inner) {
+  const args = [];
+  let start = 0;
+  let depth = 0;
+  let quote = false;
+  for (let i = 0; i < inner.length; i += 1) {
+    const ch = inner[i];
+    if (quote) {
+      if (ch === "\\") i += 1;
+      else if (ch === '"') quote = false;
+      continue;
+    }
+    if (ch === '"') quote = true;
+    else if (ch === "(" || ch === "[" || ch === "{") depth += 1;
+    else if (ch === ")" || ch === "]" || ch === "}") depth -= 1;
+    else if (ch === "," && depth === 0) {
+      args.push(inner.slice(start, i).trim());
+      start = i + 1;
+    }
+  }
+  if (quote || depth !== 0) return null;
+  const last = inner.slice(start).trim();
+  if (last) args.push(last);
+  return args;
+}
+function isStringLiteral(value) {
+  return /^"(?:\\.|[^"\\])*"$/.test(value.trim());
+}
+function attachOrphans(source) {
+  let text = source;
+  let stmts = parseStatements(text);
+  if (!stmts) return source;
+  const taken = new Set(stmts.map((stmt) => stmt.name));
+  const extraRoots = stmts.filter((stmt) => stmt.name === "root").slice(1);
+  if (extraRoots.length > 0) {
+    const edits = extraRoots.map((stmt) => {
+      const body2 = fresh(taken, "rootBlock");
+      const stmtText = text.slice(stmt.start, stmt.end);
+      return {
+        start: stmt.start,
+        end: stmt.end,
+        text: stmtText.replace(/^(\s*)root\b/, `$1${body2}`)
+      };
+    });
+    text = applyEdits(text, edits);
+    stmts = parseStatements(text);
+    if (!stmts) return source;
+  }
+  const orphans = stmts.filter(
+    (stmt) => stmt.name !== "root" && ATTACHABLE.has(calleeOf(stmt.rhs) ?? "") && !referencedByOther(stmt.name, stmts)
+  );
+  if (orphans.length === 0) return source;
+  const names = orphans.map((stmt) => stmt.name);
+  const root = stmts.find((stmt) => stmt.name === "root");
+  if (!root) return `root = Stack([${names.join(", ")}])
+${text}`;
+  const rawRhs = text.slice(root.rhsStart, root.end);
+  const lead = /^\s*/.exec(rawRhs)?.[0] ?? "";
+  const spliced = spliceFirstArray(rawRhs.trim(), names);
+  if (spliced !== null) {
+    return text.slice(0, root.rhsStart) + lead + spliced + text.slice(root.end);
+  }
+  const body = fresh(new Set(stmts.map((stmt) => stmt.name)), "rootBody");
+  const wrapped = `root = Stack([${body}, ${names.join(", ")}])
+${body} = ${rawRhs.trim()}`;
+  return text.slice(0, root.start) + wrapped + text.slice(root.end);
+}
+function spliceFirstArray(rhs, names) {
+  const match = /^([A-Za-z_]\w*)\s*\(/.exec(rhs);
+  if (!match || match[1] !== "Stack" && match[1] !== "Card") return null;
+  const openParen = match[0].length - 1;
+  let paren = 0;
+  let quote = false;
+  let arrayStart = -1;
+  let arrayDepth = 0;
+  let arrayEnd = -1;
+  for (let i = openParen; i < rhs.length; i += 1) {
+    const ch = rhs[i];
+    if (quote) {
+      if (ch === "\\") i += 1;
+      else if (ch === '"') quote = false;
+      continue;
+    }
+    if (ch === '"') quote = true;
+    else if (ch === "(") paren += 1;
+    else if (ch === ")") {
+      paren -= 1;
+      if (paren === 0) break;
+    } else if (ch === "[") {
+      if (paren === 1 && arrayStart < 0) {
+        arrayStart = i;
+        arrayDepth = 1;
+      } else if (arrayStart >= 0 && arrayEnd < 0) {
+        arrayDepth += 1;
+      }
+    } else if (ch === "]" && arrayStart >= 0 && arrayEnd < 0) {
+      arrayDepth -= 1;
+      if (arrayDepth === 0) arrayEnd = i;
+    }
+  }
+  if (arrayStart < 0 || arrayEnd < 0) return null;
+  const inner = rhs.slice(arrayStart + 1, arrayEnd).trim();
+  const merged = inner === "" ? names.join(", ") : `${inner.replace(/,\s*$/, "")}, ${names.join(", ")}`;
+  return rhs.slice(0, arrayStart + 1) + merged + rhs.slice(arrayEnd);
+}
+function referencedByOther(name, stmts) {
+  const pattern = new RegExp(
+    `(?<![A-Za-z0-9_$.])${name.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}(?![A-Za-z0-9_])`
   );
+  return stmts.some((stmt) => stmt.name !== name && pattern.test(stripStrings(stmt.rhs)));
+}
+function calleeOf(rhs) {
+  const match = /^([A-Za-z_]\w*)\s*\(/.exec(rhs.trim());
+  return match ? match[1] : null;
+}
+function stripStrings(text) {
+  return text.replace(/"(?:\\.|[^"\\])*"/g, '""');
+}
+function fresh(taken, base) {
+  let name = base;
+  let n = 2;
+  while (taken.has(name)) {
+    name = `${base}${n}`;
+    n += 1;
+  }
+  taken.add(name);
+  return name;
+}
+function applyEdits(source, edits) {
+  const ordered = [...edits].sort((a, b) => b.start - a.start);
+  let text = source;
+  for (const edit of ordered) {
+    text = text.slice(0, edit.start) + edit.text + text.slice(edit.end);
+  }
+  return text;
+}
+function parseStatements(source) {
+  const lines = source.split("\n");
+  const stmts = [];
+  let offset = 0;
+  let depth = 0;
+  let quote = false;
+  let current = null;
+  const scan2 = (line) => {
+    for (let i = 0; i < line.length; i += 1) {
+      const ch = line[i];
+      if (quote) {
+        if (ch === "\\") i += 1;
+        else if (ch === '"') quote = false;
+      } else if (ch === '"') {
+        quote = true;
+      } else if (ch === "(" || ch === "[" || ch === "{") {
+        depth += 1;
+      } else if (ch === ")" || ch === "]" || ch === "}") {
+        depth = Math.max(0, depth - 1);
+      }
+    }
+  };
+  for (let li = 0; li < lines.length; li += 1) {
+    const line = lines[li];
+    const lineStart = offset;
+    const lineEnd = offset + line.length;
+    offset = lineEnd + (li < lines.length - 1 ? 1 : 0);
+    if (current && depth > 0) {
+      scan2(line);
+      if (depth === 0) {
+        stmts.push({
+          name: current.name,
+          rhs: source.slice(current.rhsStart, lineEnd).trim(),
+          start: current.start,
+          end: lineEnd,
+          rhsStart: current.rhsStart
+        });
+        current = null;
+      }
+      continue;
+    }
+    const trimmed = line.trim();
+    if (trimmed === "" || trimmed.startsWith("```")) continue;
+    const match = /^(\s*)(\$?[A-Za-z_]\w*)\s*=/.exec(line);
+    if (!match) return null;
+    const eq = line.indexOf("=");
+    const rhsStart = lineStart + eq + 1;
+    depth = 0;
+    quote = false;
+    scan2(line);
+    if (depth === 0) {
+      stmts.push({
+        name: match[2],
+        rhs: line.slice(eq + 1).trim(),
+        start: lineStart,
+        end: lineEnd,
+        rhsStart
+      });
+    } else {
+      current = { name: match[2], start: lineStart, rhsStart };
+    }
+  }
+  if (current || depth !== 0) return null;
+  return stmts;
+}
+
+// src/utils/split-response.ts
+var STATEMENT_START = /^\$?[A-Za-z_]\w*\s*=/;
+var PENDING_IDENTIFIER = /^\s*\$?[A-Za-z_]\w*\s*$/;
+function scan(line, state) {
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (state.quote) {
+      if (ch === "\\") i++;
+      else if (ch === state.quote) state.quote = null;
+    } else if (ch === '"') {
+      state.quote = ch;
+    } else if (ch === "(" || ch === "[" || ch === "{") {
+      state.depth++;
+    } else if (ch === ")" || ch === "]" || ch === "}") {
+      state.depth = Math.max(0, state.depth - 1);
+    }
+  }
+  state.quote = null;
+}
+function splitResponse(source, options = {}) {
+  let input = source;
+  if (options.streaming && !input.endsWith("\n")) {
+    const cut = input.lastIndexOf("\n");
+    if (PENDING_IDENTIFIER.test(input.slice(cut + 1))) input = input.slice(0, cut + 1);
+  }
+  const before = [];
+  const after = [];
+  const ui = [];
+  const state = { depth: 0, quote: null };
+  let text = [];
+  let seenUi = false;
+  let sawFence = false;
+  const flushText = () => {
+    const joined = text.join(" ").trim();
+    text = [];
+    if (joined) (seenUi ? after : before).push(joined);
+  };
+  for (const line of input.split(/\r?\n/)) {
+    const trimmed = line.trim();
+    if (trimmed.startsWith("```")) {
+      sawFence = true;
+      continue;
+    }
+    if (state.depth > 0) {
+      ui.push(line);
+      scan(line, state);
+      continue;
+    }
+    if (STATEMENT_START.test(trimmed)) {
+      flushText();
+      seenUi = true;
+      ui.push(line);
+      scan(line, state);
+      continue;
+    }
+    if (trimmed === "") {
+      flushText();
+      continue;
+    }
+    text.push(trimmed);
+  }
+  flushText();
+  return {
+    before,
+    ui: ui.join("\n"),
+    after,
+    pure: !sawFence && before.length === 0 && after.length === 0
+  };
+}
+
+// src/renderer/error-boundary.tsx
+import { Component } from "react";
+import { jsx as jsx2 } from "react/jsx-runtime";
+function keysChanged(a = [], b = []) {
+  return a.length !== b.length || a.some((v, i) => !Object.is(v, b[i]));
+}
+var JuneErrorBoundary = class extends Component {
+  constructor() {
+    super(...arguments);
+    this.state = { error: null };
+    this.reset = () => {
+      this.setState({ error: null });
+    };
+  }
+  static getDerivedStateFromError(error) {
+    return { error };
+  }
+  componentDidCatch(error, info) {
+    this.props.onError?.(error, info);
+  }
+  componentDidUpdate(prev) {
+    if (this.state.error && keysChanged(prev.resetKeys, this.props.resetKeys)) {
+      this.reset();
+    }
+  }
+  render() {
+    const { error } = this.state;
+    if (!error) return this.props.children;
+    const { fallback } = this.props;
+    if (typeof fallback === "function") return fallback({ error, reset: this.reset });
+    if (fallback !== void 0) return fallback;
+    return /* @__PURE__ */ jsx2("div", { role: "alert", "data-june-error": "", children: "Something went wrong while rendering this UI." });
+  }
+};
+
+// src/renderer/renderer.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+function JuneRenderer(props) {
+  const {
+    library,
+    response,
+    isStreaming = false,
+    mixedContent = true,
+    renderText,
+    theme = "light",
+    themeVars,
+    className,
+    style,
+    actions,
+    confirmAction,
+    parseActionEvent,
+    onAction,
+    onError,
+    onJuneError,
+    loadingFallback = null,
+    emptyFallback = null,
+    errorFallback,
+    resetKeys,
+    ...rendererProps
+  } = props;
+  const latest = useRef({
+    actions,
+    confirmAction,
+    parseActionEvent,
+    onAction,
+    onError,
+    onJuneError
+  });
+  latest.current = {
+    actions,
+    confirmAction,
+    parseActionEvent,
+    onAction,
+    onError,
+    onJuneError
+  };
+  const handleAction = useCallback((event) => {
+    const l = latest.current;
+    l.onAction?.(event);
+    if (l.actions) {
+      void runAction(event, {
+        actions: l.actions,
+        parseEvent: l.parseActionEvent,
+        confirm: l.confirmAction,
+        onError: (e) => l.onJuneError?.(e)
+      });
+    }
+  }, []);
+  const handleParserErrors = useCallback((errors) => {
+    const list = Array.isArray(errors) ? errors : [];
+    const l = latest.current;
+    l.onError?.(list);
+    const real = list.filter((e) => e?.severity !== "warning");
+    if (real.length > 0) {
+      l.onJuneError?.(
+        new JuneError("PARSE_ERROR", `OpenUI reported ${real.length} error(s)`, { details: real })
+      );
+    }
+    if (list.length > 0 && !l.onError && !l.onJuneError) {
+      console.warn("[june-ui] OpenUI reported errors:", list);
+    }
+  }, []);
+  const handleBoundaryError = useCallback((error, info) => {
+    latest.current.onJuneError?.(
+      new JuneError("RENDER_ERROR", error.message, {
+        cause: error,
+        details: { componentStack: info.componentStack }
+      })
+    );
+  }, []);
+  const parts = useMemo2(
+    () => mixedContent && response ? splitResponse(response, { streaming: isStreaming }) : null,
+    [mixedContent, response, isStreaming]
+  );
+  const uiText = useMemo2(() => {
+    const raw = parts && !parts.pure ? parts.ui : response;
+    if (!mixedContent || isStreaming || typeof raw !== "string" || raw.length === 0) return raw;
+    return normalizeProgram(raw);
+  }, [parts, response, mixedContent, isStreaming]);
+  const hasUi = typeof uiText === "string" && uiText.trim().length > 0;
+  const before = parts?.before ?? [];
+  const after = parts?.after ?? [];
+  const hasText = before.length + after.length > 0;
+  const text = (value, index, key) => /* @__PURE__ */ jsx3(Fragment, { children: renderText ? renderText(value, index) : /* @__PURE__ */ jsx3("p", { className: "june-text", children: value }) }, key);
+  return /* @__PURE__ */ jsx3(JuneThemeProvider, { mode: theme, vars: themeVars, className, style, children: /* @__PURE__ */ jsxs(
+    JuneErrorBoundary,
+    {
+      fallback: errorFallback,
+      onError: handleBoundaryError,
+      resetKeys: resetKeys ?? [response],
+      children: [
+        before.map((t, i) => text(t, i, `b${i}`)),
+        hasUi && /* @__PURE__ */ jsx3(
+          Renderer,
+          {
+            ...rendererProps,
+            library,
+            response: uiText,
+            isStreaming,
+            onAction: handleAction,
+            onError: handleParserErrors
+          }
+        ),
+        after.map((t, i) => text(t, before.length + i, `a${i}`)),
+        !hasUi && !hasText && (isStreaming ? loadingFallback : emptyFallback)
+      ]
+    }
+  ) });
+}
+
+// src/components/library.ts
+import { createLibrary, defineComponent } from "@openuidev/react-lang";
+var defineJuneComponent = defineComponent;
+function createJuneLibrary(options) {
+  const { allow, deny, ...rest } = options;
+  const input = rest;
+  const raw = input;
+  const components = raw.components ?? [];
+  const names = /* @__PURE__ */ new Set();
+  for (const component of components) {
+    if (typeof component?.name !== "string" || component.name.length === 0) {
+      throw new JuneError("LIBRARY_ERROR", "Every component needs a non-empty string name");
+    }
+    if (names.has(component.name)) {
+      throw new JuneError("LIBRARY_ERROR", `Duplicate component name "${component.name}"`);
+    }
+    names.add(component.name);
+  }
+  const allowSet = allow ? new Set(allow) : null;
+  const denySet = deny ? new Set(deny) : null;
+  if (allowSet) {
+    for (const n of allowSet) {
+      if (!names.has(n)) throw new JuneError("LIBRARY_ERROR", `Allowed component "${n}" is not registered`);
+    }
+  }
+  const keep = components.filter((c) => {
+    const n = c.name;
+    return (!allowSet || allowSet.has(n)) && !(denySet && denySet.has(n));
+  });
+  if (raw.root !== void 0 && !keep.some((c) => c.name === raw.root)) {
+    throw new JuneError("LIBRARY_ERROR", `Root component "${raw.root}" is missing after filtering`);
+  }
+  try {
+    const unfiltered = keep.length === components.length;
+    return createLibrary(
+      unfiltered ? input : { ...input, components: keep }
+    );
+  } catch (error) {
+    throw new JuneError("LIBRARY_ERROR", "OpenUI rejected the component library", { cause: error });
+  }
+}
+
+// src/actions/define-action.ts
+function defineJuneAction(definition) {
+  if (typeof definition.handler !== "function") {
+    throw new JuneError("ACTION_VALIDATION_ERROR", "defineJuneAction requires a handler function");
+  }
+  return Object.freeze({ ...definition, __june: "action" });
+}
+
+// src/streaming/use-june-stream.ts
+import { useCallback as useCallback2, useEffect, useMemo as useMemo3, useRef as useRef2, useState } from "react";
+
+// src/streaming/stream-handler.ts
+function isReadableStream(source) {
+  return typeof source.getReader === "function";
+}
+async function* iterateReadable(stream, signal) {
+  const reader = stream.getReader();
+  const onAbort = () => {
+    void reader.cancel().catch(() => {
+    });
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) return;
+      yield value;
+    }
+  } finally {
+    signal?.removeEventListener("abort", onAbort);
+    try {
+      reader.releaseLock();
+    } catch {
+    }
+  }
+}
+function toAsyncIterable(source, signal) {
+  return isReadableStream(source) ? iterateReadable(source, signal) : source;
+}
+function abortedError(partial) {
+  return new JuneError("STREAM_ABORTED", "Stream was aborted", { details: { partial } });
+}
+async function consumeStream(source, options = {}) {
+  const { signal, onText, allowEmpty = false } = options;
+  if (signal?.aborted) throw abortedError("");
+  const decoder = new TextDecoder();
+  let text = "";
+  let received = false;
+  const push = (delta) => {
+    if (!delta) return;
+    received = true;
+    text += delta;
+    onText?.(delta, text);
+  };
+  try {
+    for await (const chunk of toAsyncIterable(source, signal)) {
+      if (signal?.aborted) break;
+      push(typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true }));
+    }
+    push(decoder.decode());
+  } catch (error) {
+    if (signal?.aborted) throw abortedError(text);
+    if (error instanceof JuneError) throw error;
+    throw new JuneError("STREAM_ERROR", "Stream was interrupted", {
+      cause: error,
+      details: { partial: text }
+    });
+  }
+  if (signal?.aborted) throw abortedError(text);
+  if (!received && !allowEmpty) {
+    throw new JuneError("STREAM_EMPTY", "Stream completed without any content");
+  }
+  return text;
+}
+
+// src/streaming/sse-adapter.ts
+var BOUNDARY = /\r\n\r\n|\n\n|\r\r/;
+function parseFrame(raw) {
+  let event = "message";
+  const data = [];
+  for (const line of raw.split(/\r\n|\n|\r/)) {
+    if (!line || line.startsWith(":")) continue;
+    const i = line.indexOf(":");
+    const field = i === -1 ? line : line.slice(0, i);
+    let value = i === -1 ? "" : line.slice(i + 1);
+    if (value.startsWith(" ")) value = value.slice(1);
+    if (field === "event") event = value;
+    else if (field === "data") data.push(value);
+  }
+  if (data.length === 0 && event === "message") return null;
+  return { event, data: data.join("\n") };
+}
+async function* sseToText(source, options = {}) {
+  const { extract, doneSentinel = "[DONE]", signal } = options;
+  const decoder = new TextDecoder();
+  let buffer = "";
+  const handle = (raw) => {
+    const frame = parseFrame(raw);
+    if (!frame) return { done: false, text: null };
+    if (frame.event === "error") {
+      throw new JuneError("STREAM_ERROR", frame.data || "Server sent an error event", {
+        details: frame
+      });
+    }
+    if (doneSentinel !== null && frame.data === doneSentinel) {
+      return { done: true, text: null };
+    }
+    const text = extract ? extract(frame.data, frame.event) : frame.data;
+    return { done: false, text: text ? text : null };
+  };
+  for await (const chunk of toAsyncIterable(source, signal)) {
+    buffer += typeof chunk === "string" ? chunk : decoder.decode(chunk, { stream: true });
+    let match;
+    while ((match = BOUNDARY.exec(buffer)) !== null) {
+      const raw = buffer.slice(0, match.index);
+      buffer = buffer.slice(match.index + match[0].length);
+      const result = handle(raw);
+      if (result.done) return;
+      if (result.text) yield result.text;
+    }
+  }
+  buffer += decoder.decode();
+  if (buffer.trim()) {
+    const result = handle(buffer);
+    if (!result.done && result.text) yield result.text;
+  }
+}
+function jsonFieldExtractor(path) {
+  const keys = path.split(".");
+  return (data) => {
+    try {
+      let current = JSON.parse(data);
+      for (const key of keys) {
+        if (current === null || typeof current !== "object") return null;
+        current = current[key];
+      }
+      return typeof current === "string" ? current : null;
+    } catch {
+      return null;
+    }
+  };
+}
+
+// src/streaming/fetch-adapter.ts
+async function fetchStream(input, options = {}) {
+  const { sse, ...init } = options;
+  let response;
+  try {
+    response = await fetch(input, init);
+  } catch (error) {
+    if (init.signal?.aborted) {
+      throw new JuneError("STREAM_ABORTED", "Request was aborted", { cause: error });
+    }
+    throw new JuneError("NETWORK_ERROR", "Network request failed", { cause: error });
+  }
+  if (!response.ok) {
+    throw new JuneError("NETWORK_ERROR", `Request failed with status ${response.status}`, {
+      details: { status: response.status, statusText: response.statusText }
+    });
+  }
+  if (!response.body) {
+    throw new JuneError("STREAM_EMPTY", "Response has no body");
+  }
+  const body = response.body;
+  if (sse) {
+    return sseToText(body, {
+      ...sse === true ? {} : sse,
+      signal: init.signal ?? void 0
+    });
+  }
+  return body;
+}
+
+// src/streaming/use-june-stream.ts
+var FLUSH_MS = 16;
+var INITIAL = {
+  response: "",
+  isStreaming: false,
+  status: "idle",
+  error: null
+};
+function useJuneStream(options = {}) {
+  const [state, setState] = useState(INITIAL);
+  const optionsRef = useRef2(options);
+  optionsRef.current = options;
+  const controllerRef = useRef2(null);
+  const runIdRef = useRef2(0);
+  const textRef = useRef2("");
+  const timerRef = useRef2(null);
+  const clearTimer = useCallback2(() => {
+    if (timerRef.current !== null) {
+      clearTimeout(timerRef.current);
+      timerRef.current = null;
+    }
+  }, []);
+  const schedule = useCallback2(() => {
+    if (timerRef.current !== null) return;
+    timerRef.current = setTimeout(() => {
+      timerRef.current = null;
+      const text = textRef.current;
+      setState(
+        (s) => s.status !== "streaming" || s.response === text ? s : { ...s, response: text }
+      );
+    }, FLUSH_MS);
+  }, []);
+  const start = useCallback2(
+    async (input) => {
+      controllerRef.current?.abort();
+      const controller = new AbortController();
+      controllerRef.current = controller;
+      const runId = ++runIdRef.current;
+      const stale = () => runId !== runIdRef.current;
+      textRef.current = "";
+      clearTimer();
+      setState({ response: "", isStreaming: true, status: "streaming", error: null });
+      try {
+        const source = typeof input === "function" ? await input(controller.signal) : input;
+        if (stale()) return null;
+        const text = await consumeStream(source, {
+          signal: controller.signal,
+          allowEmpty: optionsRef.current.allowEmpty,
+          onText: (_delta, full) => {
+            if (stale()) return;
+            textRef.current = full;
+            schedule();
+          }
+        });
+        if (stale()) return null;
+        clearTimer();
+        setState({ response: text, isStreaming: false, status: "done", error: null });
+        optionsRef.current.onComplete?.(text);
+        return text;
+      } catch (caught) {
+        if (stale()) return null;
+        clearTimer();
+        const error = toJuneError(caught, "STREAM_ERROR");
+        const aborted = controller.signal.aborted || error.code === "STREAM_ABORTED";
+        setState({
+          response: textRef.current,
+          // keep partial output
+          isStreaming: false,
+          status: aborted ? "aborted" : "error",
+          error: aborted ? null : error
+        });
+        if (!aborted) optionsRef.current.onError?.(error);
+        return null;
+      }
+    },
+    [clearTimer, schedule]
+  );
+  const startFetch = useCallback2(
+    (input, fetchOptions) => start((signal) => fetchStream(input, { ...fetchOptions, signal })),
+    [start]
+  );
+  const abort = useCallback2(() => {
+    controllerRef.current?.abort();
+  }, []);
+  const reset = useCallback2(() => {
+    controllerRef.current?.abort();
+    runIdRef.current++;
+    textRef.current = "";
+    clearTimer();
+    setState(INITIAL);
+  }, [clearTimer]);
+  useEffect(
+    () => () => {
+      runIdRef.current++;
+      controllerRef.current?.abort();
+      clearTimer();
+    },
+    [clearTimer]
+  );
+  return useMemo3(
+    () => ({ ...state, start, startFetch, abort, reset }),
+    [state, start, startFetch, abort, reset]
+  );
+}
+
+// src/core/JuneUI.tsx
+import { openuiLibrary } from "@openuidev/react-ui";
+import { jsx as jsx4 } from "react/jsx-runtime";
+function JuneUI({ library = openuiLibrary, ...props }) {
+  return /* @__PURE__ */ jsx4(JuneRenderer, { library, ...props });
 }
 export {
-  JuneUI
+  JuneError,
+  JuneErrorBoundary,
+  JuneRenderer,
+  JuneThemeProvider,
+  JuneUI,
+  consumeStream,
+  createActionHandler,
+  createJuneLibrary,
+  darkTheme,
+  defaultParseActionEvent,
+  defineJuneAction,
+  defineJuneComponent,
+  fetchStream,
+  isJuneError,
+  jsonFieldExtractor,
+  lightTheme,
+  runAction,
+  sseToText,
+  toJuneError,
+  useJuneStream,
+  useJuneTheme,
+  useResolvedTheme
 };