diff --git a/examples/invoices-structured-output/.gitignore b/examples/invoices-structured-output/.gitignore
new file mode 100644
index 000000000..5ef6a5207
--- /dev/null
+++ b/examples/invoices-structured-output/.gitignore
@@ -0,0 +1,41 @@
+# See https://help.github.com/articles/ignoring-files/ for more about ignoring files.
+
+# dependencies
+/node_modules
+/.pnp
+.pnp.*
+.yarn/*
+!.yarn/patches
+!.yarn/plugins
+!.yarn/releases
+!.yarn/versions
+
+# testing
+/coverage
+
+# next.js
+/.next/
+/out/
+
+# production
+/build
+
+# misc
+.DS_Store
+*.pem
+
+# debug
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+.pnpm-debug.log*
+
+# env files (can opt-in for committing if needed)
+.env*
+
+# vercel
+.vercel
+
+# typescript
+*.tsbuildinfo
+next-env.d.ts
diff --git a/examples/invoices-structured-output/README.md b/examples/invoices-structured-output/README.md
new file mode 100644
index 000000000..31ef7f4e5
--- /dev/null
+++ b/examples/invoices-structured-output/README.md
@@ -0,0 +1,40 @@
+# Invoice Structured Output Example
+
+A Next.js app demonstrating `@openuidev/structured-output` — the standalone OpenUI Lang library for schema-driven structured output from LLMs.
+
+## What it does
+
+1. **Select an invoice format** — Standard, Freelance, or International
+2. **Describe the invoice** — or use the provided sample prompt
+3. **Watch the LLM stream** — the raw OpenUI Lang appears on the left as tokens arrive
+4. **See parsed JSON** — the streaming parser progressively builds the validated JSON on the right
+
+The backend generates a system prompt from the Zod schema using `schema.prompt()`, sends it to the LLM, and streams back the raw OpenUI Lang. The frontend uses `schema.streamingParser()` to parse and validate the output in real time.
+
+## Setup
+
+```bash
+# From the monorepo root
+pnpm install
+
+# Add your OpenRouter API key
+cp examples/invoices-structured-output/.env.example examples/invoices-structured-output/.env.local
+# Edit .env.local with your key
+
+# Run the dev server
+pnpm --filter invoices-structured-output dev
+```
+
+## Invoice Formats
+
+| Format | Description |
+| --- | --- |
+| **Standard** | Simple business invoice with line items, tax rate, and totals |
+| **Freelance** | Consulting invoice with hourly time entries and project details |
+| **International** | Multi-currency invoice with addresses, tax breakdown, and shipping |
+
+## Key files
+
+- `src/app/schemas.ts` — Invoice type definitions using `defineType` and `createSchema`
+- `src/app/api/generate/route.ts` — API route that generates the prompt and streams LLM output
+- `src/app/page.tsx` — Frontend with format picker, streaming display, and parsed JSON view
diff --git a/examples/invoices-structured-output/eslint.config.mjs b/examples/invoices-structured-output/eslint.config.mjs
new file mode 100644
index 000000000..05e726d1b
--- /dev/null
+++ b/examples/invoices-structured-output/eslint.config.mjs
@@ -0,0 +1,18 @@
+import { defineConfig, globalIgnores } from "eslint/config";
+import nextVitals from "eslint-config-next/core-web-vitals";
+import nextTs from "eslint-config-next/typescript";
+
+const eslintConfig = defineConfig([
+  ...nextVitals,
+  ...nextTs,
+  // Override default ignores of eslint-config-next.
+  globalIgnores([
+    // Default ignores of eslint-config-next:
+    ".next/**",
+    "out/**",
+    "build/**",
+    "next-env.d.ts",
+  ]),
+]);
+
+export default eslintConfig;
diff --git a/examples/invoices-structured-output/next.config.ts b/examples/invoices-structured-output/next.config.ts
new file mode 100644
index 000000000..596190563
--- /dev/null
+++ b/examples/invoices-structured-output/next.config.ts
@@ -0,0 +1,8 @@
+import type { NextConfig } from "next";
+
+const nextConfig: NextConfig = {
+  transpilePackages: ["@openuidev/structured-output"],
+  serverExternalPackages: ["openai"],
+};
+
+export default nextConfig;
diff --git a/examples/invoices-structured-output/package.json b/examples/invoices-structured-output/package.json
new file mode 100644
index 000000000..86ea4d38f
--- /dev/null
+++ b/examples/invoices-structured-output/package.json
@@ -0,0 +1,29 @@
+{
+  "name": "invoices-structured-output",
+  "version": "0.1.0",
+  "private": true,
+  "scripts": {
+    "dev": "next dev",
+    "build": "next build",
+    "start": "next start",
+    "lint": "eslint"
+  },
+  "dependencies": {
+    "@openuidev/structured-output": "workspace:^",
+    "next": "16.1.6",
+    "openai": "^6.27.0",
+    "react": "19.2.3",
+    "react-dom": "19.2.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@tailwindcss/postcss": "^4",
+    "@types/node": "^20",
+    "@types/react": "^19",
+    "@types/react-dom": "^19",
+    "eslint": "^9",
+    "eslint-config-next": "16.1.6",
+    "tailwindcss": "^4",
+    "typescript": "^5"
+  }
+}
diff --git a/examples/invoices-structured-output/postcss.config.mjs b/examples/invoices-structured-output/postcss.config.mjs
new file mode 100644
index 000000000..61e36849c
--- /dev/null
+++ b/examples/invoices-structured-output/postcss.config.mjs
@@ -0,0 +1,7 @@
+const config = {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};
+
+export default config;
diff --git a/examples/invoices-structured-output/src/app/api/generate/route.ts b/examples/invoices-structured-output/src/app/api/generate/route.ts
new file mode 100644
index 000000000..1d442d69e
--- /dev/null
+++ b/examples/invoices-structured-output/src/app/api/generate/route.ts
@@ -0,0 +1,82 @@
+import { NextRequest } from "next/server";
+import OpenAI from "openai";
+import { invoiceSchemaMap } from "../../schemas";
+
+let _client: OpenAI | null = null;
+function getClient() {
+  if (!_client) {
+    _client = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });
+  }
+  return _client;
+}
+
+const BUSINESS_PREAMBLE = `You are an expert accounting assistant that generates structured invoice data.
+Given a description of an invoice, extract or generate all relevant fields with realistic data.
+Use plausible business names, dates, amounts, and tax calculations.
+All monetary amounts should be numbers (not strings). Dates should be in YYYY-MM-DD format.
+Ensure line item amounts equal quantity × unitPrice. Ensure totals are arithmetically correct.`;
+
+export async function POST(req: NextRequest) {
+  const { userPrompt } = (await req.json()) as {
+    userPrompt: string;
+  };
+
+  const systemPrompt = invoiceSchemaMap.prompt({
+    preamble: BUSINESS_PREAMBLE,
+    additionalRules: [
+      "All dates must be YYYY-MM-DD format",
+      "Monetary amounts must be numbers with up to 2 decimal places",
+      "NEVER use arithmetic expressions like 8*125 or 10+20 — always write the pre-computed numeric result (e.g. 1000, 30)",
+      "Ensure mathematical consistency: subtotal = sum of item amounts, total = subtotal + tax + shipping",
+    ],
+  });
+
+  console.log(systemPrompt);
+
+  const stream = await getClient().chat.completions.create({
+    model: "gpt-5",
+    stream: true,
+    messages: [
+      { role: "system", content: systemPrompt },
+      { role: "user", content: userPrompt },
+    ],
+    reasoning_effort: "minimal",
+  });
+
+  const encoder = new TextEncoder();
+
+  const readable = new ReadableStream({
+    async start(controller) {
+      const send = (type: string, content: string) =>
+        controller.enqueue(encoder.encode(JSON.stringify({ type, content }) + "\n"));
+
+      try {
+        for await (const chunk of stream) {
+          const delta = chunk.choices?.[0]?.delta as Record<string, unknown> | undefined;
+          if (!delta) continue;
+
+          const thinking =
+            (delta.reasoning as string | undefined) ??
+            (delta.reasoning_content as string | undefined);
+          if (thinking) send("thinking", thinking);
+
+          const content = delta.content as string | undefined;
+          if (content) send("content", content);
+        }
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Stream error";
+        send("error", message);
+      } finally {
+        controller.close();
+      }
+    },
+  });
+
+  return new Response(readable, {
+    headers: {
+      "Content-Type": "application/x-ndjson; charset=utf-8",
+      "Transfer-Encoding": "chunked",
+      "Cache-Control": "no-cache",
+    },
+  });
+}
diff --git a/examples/invoices-structured-output/src/app/favicon.ico b/examples/invoices-structured-output/src/app/favicon.ico
new file mode 100644
index 000000000..718d6fea4
Binary files /dev/null and b/examples/invoices-structured-output/src/app/favicon.ico differ
diff --git a/examples/invoices-structured-output/src/app/globals.css b/examples/invoices-structured-output/src/app/globals.css
new file mode 100644
index 000000000..4d985b6e1
--- /dev/null
+++ b/examples/invoices-structured-output/src/app/globals.css
@@ -0,0 +1,5 @@
+@import "tailwindcss";
+
+html {
+  font-size: 150%;
+}
diff --git a/examples/invoices-structured-output/src/app/layout.tsx b/examples/invoices-structured-output/src/app/layout.tsx
new file mode 100644
index 000000000..d1e2d8562
--- /dev/null
+++ b/examples/invoices-structured-output/src/app/layout.tsx
@@ -0,0 +1,19 @@
+import type { Metadata } from "next";
+import "./globals.css";
+
+export const metadata: Metadata = {
+  title: "Invoice Structured Output",
+  description: "Generate structured invoice data using OpenUI Lang and streaming LLM output",
+};
+
+export default function RootLayout({
+  children,
+}: Readonly<{
+  children: React.ReactNode;
+}>) {
+  return (
+    <html lang="en" className="dark">
+      <body className="antialiased">{children}</body>
+    </html>
+  );
+}
diff --git a/examples/invoices-structured-output/src/app/page.tsx b/examples/invoices-structured-output/src/app/page.tsx
new file mode 100644
index 000000000..e86b9c350
--- /dev/null
+++ b/examples/invoices-structured-output/src/app/page.tsx
@@ -0,0 +1,392 @@
+"use client";
+
+import { useState, useRef, useCallback, useEffect } from "react";
+import type { ParseResult } from "@openuidev/structured-output";
+import { invoiceMeta, invoiceSchemaMap, type InvoiceFormat } from "./schemas";
+
+type GenerationState = "idle" | "streaming" | "done" | "error";
+
+const FORMAT_ICONS: Record<InvoiceFormat, string> = {
+  standard: "receipt",
+  freelance: "schedule",
+  international: "public",
+};
+
+export default function Page() {
+  const [format, setFormat] = useState<InvoiceFormat>("standard");
+  const [userPrompt, setUserPrompt] = useState(invoiceMeta.standard.samplePrompt);
+  const [state, setState] = useState<GenerationState>("idle");
+  const [rawOutput, setRawOutput] = useState("");
+  const [thinking, setThinking] = useState("");
+  const [parsedResult, setParsedResult] = useState<ParseResult<unknown> | null>(null);
+  const [errorMessage, setErrorMessage] = useState("");
+  const [jsonTab, setJsonTab] = useState<"result" | "schema" | "systemPrompt">("result");
+
+  const abortRef = useRef<AbortController | null>(null);
+  const scrollRef = useRef<HTMLDivElement>(null);
+
+  // Auto-scroll output when streaming
+  useEffect(() => {
+    if (state === "streaming" && scrollRef.current) {
+      scrollRef.current.scrollTop = scrollRef.current.scrollHeight;
+    }
+  }, [rawOutput, thinking, parsedResult, state]);
+
+  const handleGenerate = useCallback(async () => {
+    const entry = invoiceMeta[format];
+    const prompt = userPrompt.trim() || entry.samplePrompt;
+
+    abortRef.current?.abort();
+    const controller = new AbortController();
+    abortRef.current = controller;
+
+    setState("streaming");
+    setRawOutput("");
+    setThinking("");
+    setParsedResult(null);
+    setErrorMessage("");
+
+    try {
+      const res = await fetch("/api/generate", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ format, userPrompt: prompt }),
+        signal: controller.signal,
+      });
+
+      if (!res.ok) {
+        const err = await res.json();
+        throw new Error(err.error ?? `HTTP ${res.status}`);
+      }
+
+      const reader = res.body?.getReader();
+      if (!reader) throw new Error("No response body");
+
+      const decoder = new TextDecoder();
+      const parser = invoiceSchemaMap.streamingParser();
+      let accContent = "";
+      let accThinking = "";
+      let lineBuf = "";
+
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+
+        lineBuf += decoder.decode(value, { stream: true });
+        const lines = lineBuf.split("\n");
+        lineBuf = lines.pop() ?? "";
+
+        for (const line of lines) {
+          if (!line.trim()) continue;
+          try {
+            const evt = JSON.parse(line) as { type: string; content: string };
+            if (evt.type === "thinking") {
+              accThinking += evt.content;
+              setThinking(accThinking);
+            } else if (evt.type === "content") {
+              accContent += evt.content;
+              setRawOutput(accContent);
+              const result = parser.push(evt.content);
+              setParsedResult({ ...result });
+            } else if (evt.type === "error") {
+              throw new Error(evt.content);
+            }
+          } catch (e) {
+            if (e instanceof SyntaxError) continue;
+            throw e;
+          }
+        }
+      }
+
+      const finalResult = parser.getResult();
+      setParsedResult({ ...finalResult });
+      setState("done");
+    } catch (err) {
+      if ((err as Error).name === "AbortError") return;
+      setErrorMessage((err as Error).message);
+      setState("error");
+    }
+  }, [format, userPrompt]);
+
+  const handleStop = useCallback(() => {
+    abortRef.current?.abort();
+    setState("done");
+  }, []);
+
+  const copyToClipboard = (text: string) => {
+    navigator.clipboard.writeText(text);
+  };
+
+  return (
+    <div className="min-h-screen bg-zinc-950 text-zinc-100 font-sans selection:bg-indigo-500/30 selection:text-indigo-200 flex flex-col">
+
+      {/* Header */}
+      <header className="border-b border-white/5 bg-zinc-900/50 backdrop-blur-xl sticky top-0 z-10">
+        <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 h-16 flex items-center justify-between">
+          <div className="flex items-center gap-3">
+            <div className="bg-indigo-500/20 p-2 rounded-lg">
+              <span className="material-symbols-rounded text-indigo-400 text-xl block">
+                description
+              </span>
+            </div>
+            <div>
+              <h1 className="text-sm font-semibold tracking-wide text-zinc-100">
+                Invoice Extractor
+              </h1>
+              <p className="text-xs text-zinc-500 hidden sm:block max-w-90">
+                Natural language to structured output. Select an invoice type and click on &quot;Extract Invoice&quot; to see the structured JSON result.
+              </p>
+            </div>
+          </div>
+          <div className="flex items-center gap-4">
+            <a
+              href="https://github.com/openuidev/structured-output"
+              target="_blank"
+              rel="noopener noreferrer"
+              className="text-xs font-medium text-zinc-500 hover:text-zinc-300 transition-colors"
+            >
+              View on GitHub
+            </a>
+          </div>
+        </div>
+      </header>
+
+      <main className="flex-1 max-w-7xl mx-auto w-full p-4 sm:p-6 lg:p-8 grid grid-cols-1 lg:grid-cols-12 gap-8 items-start">
+        {/* Left Column: Input & Selection */}
+        <section className="lg:col-span-5 flex flex-col gap-6 lg:sticky lg:top-24 max-h-[calc(100vh-8rem)] overflow-y-auto pr-1">
+
+          <div className="space-y-4">
+            <div className="flex items-center justify-between">
+              <h2 className="text-xs font-semibold uppercase tracking-wider text-zinc-500 flex items-center gap-2">
+                <span className="w-1.5 h-1.5 rounded-full bg-pink-500"></span>
+                Invoice in natural language
+              </h2>
+              <button
+                onClick={() => setUserPrompt("")}
+                className="text-xs text-zinc-500 hover:text-zinc-300 transition-colors"
+                title="Clear input"
+              >
+                Clear
+              </button>
+            </div>
+
+            {/* Unified Input Card */}
+            <div className="bg-zinc-900/60 rounded-xl border border-white/10 overflow-hidden flex flex-col transition-colors focus-within:border-indigo-500/50 focus-within:ring-1 focus-within:ring-indigo-500/20">
+              <textarea
+                value={userPrompt}
+                readOnly
+                placeholder="Select an invoice template below..."
+                className="w-full h-48 lg:h-56 bg-transparent px-4 py-4 text-sm text-zinc-100 placeholder-zinc-600 focus:outline-none resize-none transition-all leading-relaxed cursor-default"
+              />
+
+              <div className="border-t border-white/5 bg-zinc-900/40 p-1 flex gap-1">
+                {(Object.keys(invoiceMeta) as InvoiceFormat[]).map((key) => {
+                  const meta = invoiceMeta[key];
+                  const selected = format === key;
+                  return (
+                    <button
+                      key={key}
+                      onClick={() => {
+                        setFormat(key);
+                        setUserPrompt(meta.samplePrompt);
+                      }}
+                      title={meta.description}
+                      className={`flex-1 flex flex-col items-center justify-center gap-1.5 py-2 px-2 rounded-lg transition-all duration-200 ${selected
+                        ? "bg-zinc-800 text-indigo-400 shadow-sm ring-1 ring-white/10"
+                        : "hover:bg-zinc-800/50 text-zinc-500 hover:text-zinc-300"
+                        }`}
+                    >
+                      <span className="text-[10px] font-medium uppercase tracking-wide">
+                        {meta.label}
+                      </span>
+                    </button>
+                  );
+                })}
+              </div>
+            </div>
+
+            <div className="flex gap-3 pt-2">
+              {state === "streaming" ? (
+                <button
+                  onClick={handleStop}
+                  className="flex-1 rounded-lg border border-red-500/20 bg-red-500/10 px-4 py-3 text-sm font-medium text-red-400 hover:bg-red-500/20 transition-all active:scale-[0.98]"
+                >
+                  <span className="flex items-center justify-center gap-2">
+                    <span className="material-symbols-rounded text-lg">stop_circle</span>
+                    Stop Generation
+                  </span>
+                </button>
+              ) : (
+                <button
+                  onClick={handleGenerate}
+                  disabled={!userPrompt}
+                  className="flex-1 rounded-lg bg-indigo-600 px-4 py-3 text-sm font-medium text-white hover:bg-indigo-500 shadow-lg shadow-indigo-500/20 transition-all active:scale-[0.98] disabled:opacity-50 disabled:cursor-not-allowed"
+                >
+                  <span className="flex items-center justify-center gap-2">
+                    <span className="material-symbols-rounded text-lg">auto_awesome</span>
+                    Extract Invoice
+                  </span>
+                </button>
+              )}
+            </div>
+
+          </div>
+        </section>
+
+        {/* Right Column: Output */}
+        <section className="lg:col-span-7 flex flex-col h-full min-h-[500px]">
+          {errorMessage && (
+            <div className="mb-6 rounded-xl border border-red-500/20 bg-red-500/10 px-4 py-3 text-sm text-red-300 flex items-start gap-3">
+              <span className="material-symbols-rounded text-red-400 mt-0.5">error</span>
+              <div>
+                <strong className="block font-medium text-red-400 mb-0.5">Extraction Failed</strong>
+                {errorMessage}
+              </div>
+            </div>
+          )}
+
+          <div className="flex-1 grid grid-rows-2 gap-4 h-[calc(100vh-8rem)]">
+            {/* Top: JSON Result */}
+            <div className="flex flex-col bg-zinc-900 rounded-2xl border border-white/10 overflow-hidden shadow-xl">
+              <div className="flex items-center justify-between border-b border-white/5 bg-zinc-900/50 p-2 pl-4">
+                <div className="flex items-center gap-1 rounded-md bg-zinc-800/60 p-1">
+                  <button
+                    onClick={() => setJsonTab("result")}
+                    className={`px-2 py-1 text-[11px] font-medium rounded transition-colors ${jsonTab === "result" ? "bg-zinc-700 text-zinc-100" : "text-zinc-400 hover:text-zinc-200"
+                      }`}
+                  >
+                    JSON Result
+                  </button>
+                  <button
+                    onClick={() => setJsonTab("schema")}
+                    className={`px-2 py-1 text-[11px] font-medium rounded transition-colors ${jsonTab === "schema" ? "bg-zinc-700 text-zinc-100" : "text-zinc-400 hover:text-zinc-200"
+                      }`}
+                  >
+                    JSON Schema
+                  </button>
+                  <button
+                    onClick={() => setJsonTab("systemPrompt")}
+                    className={`px-2 py-1 text-[11px] font-medium rounded transition-colors ${jsonTab === "systemPrompt" ? "bg-zinc-700 text-zinc-100" : "text-zinc-400 hover:text-zinc-200"
+                      }`}
+                  >
+                    System Prompt
+                  </button>
+                </div>
+                <div className="flex items-center gap-2">
+                  <div className="flex items-center gap-2 text-xs px-2">
+                    {state === "streaming" && (
+                      <span className="flex items-center gap-1.5 text-emerald-400">
+                        <span className="w-1.5 h-1.5 rounded-full bg-emerald-400 animate-pulse" />
+                        Processing
+                      </span>
+                    )}
+                    {state === "done" && (
+                      <span className="flex items-center gap-1.5 text-zinc-500">
+                        <span className="w-1.5 h-1.5 rounded-full bg-blue-500" />
+                        {parsedResult?.meta.statementCount ?? 0} statements
+                      </span>
+                    )}
+                  </div>
+                  <div className="h-4 w-px bg-white/10" />
+                  <button
+                    onClick={() =>
+                      copyToClipboard(
+                        jsonTab === "result"
+                          ? JSON.stringify(parsedResult?.root, null, 2) || ""
+                          : jsonTab === "schema"
+                            ? JSON.stringify(invoiceSchemaMap.schemas[format].toJSONSchema(), null, 2)
+                            : invoiceSchemaMap.schemas[format].prompt(),
+                      )
+                    }
+                    className="p-1.5 text-zinc-500 hover:text-zinc-300 hover:bg-white/5 rounded transition-colors"
+                    title={
+                      jsonTab === "result"
+                        ? "Copy JSON Result"
+                        : jsonTab === "schema"
+                          ? "Copy JSON Schema"
+                          : "Copy System Prompt"
+                    }
+                  >
+                    <span className="material-symbols-rounded text-lg">content_copy</span>
+                  </button>
+                </div>
+              </div>
+
+              <div className="relative flex-1 bg-zinc-950/50 overflow-hidden">
+                <div className="absolute inset-0 overflow-auto p-4 font-mono text-xs leading-relaxed">
+                  {jsonTab === "result" ? (
+                    <>
+                      {parsedResult?.root ? (
+                        <pre className="text-emerald-300/90 whitespace-pre-wrap break-words">
+                          {JSON.stringify(parsedResult.root, null, 2)}
+                        </pre>
+                      ) : (
+                        <div className="flex flex-col items-center justify-center h-full text-zinc-600">
+                          {state === "streaming" ? (
+                            <span className="animate-pulse">Parsing JSON...</span>
+                          ) : (
+                            <span>No valid JSON extracted yet.</span>
+                          )}
+                        </div>
+                      )}
+
+                      {state === "done" && parsedResult?.meta.validationErrors.length ? (
+                        <div className="mt-8 pt-8 border-t border-dashed border-amber-900/30">
+                          <h4 className="text-amber-500 font-bold mb-4 flex items-center gap-2">
+                            <span className="material-symbols-rounded text-lg">warning</span>
+                            Validation Issues ({parsedResult.meta.validationErrors.length})
+                          </h4>
+                          <ul className="space-y-2">
+                            {parsedResult.meta.validationErrors.map((e, i) => (
+                              <li key={i} className="bg-amber-950/20 border border-amber-900/30 rounded p-3 text-amber-200/70">
+                                <code className="text-amber-400 block mb-1">{e.path || "root"}</code>
+                                {e.message}
+                              </li>
+                            ))}
+                          </ul>
+                        </div>
+                      ) : null}
+                    </>
+                  ) : jsonTab === "schema" ? (
+                    <pre className="text-zinc-300 whitespace-pre-wrap break-all">
+                      {`// Note: This JSON schema is for display only and is not sent to the LLM.\n${JSON.stringify(
+                        invoiceSchemaMap.schemas[format].toJSONSchema(),
+                        null,
+                        2,
+                      )}`}
+                    </pre>
+                  ) : (
+                    <pre className="text-zinc-300 whitespace-pre-wrap break-words">
+                      {invoiceSchemaMap.schemas[format].prompt()}
+                    </pre>
+                  )}
+                </div>
+              </div>
+            </div>
+
+            {/* Bottom: Raw Output */}
+            <div className="flex flex-col bg-zinc-900 rounded-2xl border border-white/10 overflow-hidden shadow-xl">
+              <div className="flex items-center justify-between border-b border-white/5 bg-zinc-900/50 p-2 pl-4">
+                <span className="text-xs font-medium text-zinc-400 uppercase tracking-wider">Raw Output</span>
+                <button
+                  onClick={() => copyToClipboard(rawOutput || "")}
+                  className="p-1.5 text-zinc-500 hover:text-zinc-300 hover:bg-white/5 rounded transition-colors"
+                  title="Copy Raw Output"
+                >
+                  <span className="material-symbols-rounded text-lg">content_copy</span>
+                </button>
+              </div>
+              <div className="relative flex-1 bg-zinc-950/50 overflow-hidden" ref={scrollRef}>
+                <div className="absolute inset-0 overflow-auto p-4 font-mono text-xs leading-relaxed">
+                  <pre className="text-zinc-300 whitespace-pre-wrap break-all">
+                    {rawOutput || <span className="text-zinc-700 italic">Waiting for output...</span>}
+                  </pre>
+                </div>
+              </div>
+            </div>
+          </div>
+        </section>
+      </main>
+    </div>
+  );
+}
diff --git a/examples/invoices-structured-output/src/app/schemas.ts b/examples/invoices-structured-output/src/app/schemas.ts
new file mode 100644
index 000000000..8777f4515
--- /dev/null
+++ b/examples/invoices-structured-output/src/app/schemas.ts
@@ -0,0 +1,160 @@
+import { createSchema, createSchemaMap, defineType } from "@openuidev/structured-output";
+import { z } from "zod";
+
+// ── Shared child types ──────────────────────────────────────────────────────
+
+const LineItem = defineType({
+  name: "LineItem",
+  description: "A single line item on an invoice",
+  props: z.object({
+    description: z.string(),
+    quantity: z.number(),
+    unitPrice: z.number(),
+    amount: z.number(),
+  }),
+});
+
+const Address = defineType({
+  name: "Address",
+  description: "A mailing address",
+  props: z.object({
+    street: z.string(),
+    city: z.string(),
+    state: z.string().optional(),
+    zip: z.string(),
+    country: z.string(),
+  }),
+});
+
+const TimeEntry = defineType({
+  name: "TimeEntry",
+  description: "A time-based billing entry",
+  props: z.object({
+    date: z.string(),
+    description: z.string(),
+    hours: z.number(),
+    rate: z.number(),
+    amount: z.number(),
+  }),
+});
+
+const TaxBreakdown = defineType({
+  name: "TaxBreakdown",
+  description: "A tax line item",
+  props: z.object({
+    taxName: z.string(),
+    rate: z.number(),
+    amount: z.number(),
+  }),
+});
+
+// ── 1. Standard Invoice ─────────────────────────────────────────────────────
+
+const StandardInvoice = defineType({
+  name: "StandardInvoice",
+  description: "A standard business invoice with line items",
+  props: z.object({
+    invoiceNumber: z.string(),
+    issueDate: z.string(),
+    dueDate: z.string(),
+    from: z.string(),
+    to: z.string(),
+    items: z.array(LineItem.ref),
+    subtotal: z.number(),
+    taxRate: z.number(),
+    taxAmount: z.number(),
+    total: z.number(),
+    notes: z.string().optional(),
+  }),
+});
+
+export const standardInvoiceSchema = createSchema({
+  types: [LineItem, StandardInvoice],
+  root: "StandardInvoice",
+});
+
+// ── 2. Freelance Invoice ────────────────────────────────────────────────────
+
+const FreelanceInvoice = defineType({
+  name: "FreelanceInvoice",
+  description: "A freelance/consulting invoice with hourly time entries",
+  props: z.object({
+    invoiceNumber: z.string(),
+    issueDate: z.string(),
+    dueDate: z.string(),
+    freelancerName: z.string(),
+    clientName: z.string(),
+    projectName: z.string(),
+    entries: z.array(TimeEntry.ref),
+    totalHours: z.number(),
+    subtotal: z.number(),
+    total: z.number(),
+    paymentTerms: z.string().optional(),
+  }),
+});
+
+export const freelanceInvoiceSchema = createSchema({
+  types: [TimeEntry, FreelanceInvoice],
+  root: "FreelanceInvoice",
+});
+
+// ── 3. International Invoice ────────────────────────────────────────────────
+
+const InternationalInvoice = defineType({
+  name: "InternationalInvoice",
+  description:
+    "An international invoice with multiple currencies, tax breakdown, and shipping address",
+  props: z.object({
+    invoiceNumber: z.string(),
+    issueDate: z.string(),
+    dueDate: z.string(),
+    currency: z.enum(["USD", "EUR", "GBP", "JPY", "CAD", "AUD"]),
+    seller: Address.ref,
+    buyer: Address.ref,
+    items: z.array(LineItem.ref),
+    subtotal: z.number(),
+    taxes: z.array(TaxBreakdown.ref),
+    shippingCost: z.number().optional(),
+    total: z.number(),
+    exchangeRate: z.number().optional(),
+  }),
+});
+
+export const internationalInvoiceSchema = createSchema({
+  types: [LineItem, Address, TaxBreakdown, InternationalInvoice],
+  root: "InternationalInvoice",
+});
+
+// ── Schema map + metadata ───────────────────────────────────────────────────
+
+export type InvoiceFormat = "standard" | "freelance" | "international";
+
+export const invoiceMeta: Record<
+  InvoiceFormat,
+  { label: string; description: string; samplePrompt: string }
+> = {
+  standard: {
+    label: "Invoice Type 1",
+    description: "Simple business invoice with line items, tax, and totals",
+    samplePrompt:
+      "Generate a standard invoice from Acme Corp to Widget LLC for 3 items: 10 steel bolts at $2.50 each, 5 rubber gaskets at $8.00 each, and 2 copper pipes at $15.75 each. Tax rate is 8.5%. Invoice #INV-2025-0042, issued today, due in 30 days.",
+  },
+  freelance: {
+    label: "Invoice Type 2",
+    description: "Hourly consulting invoice with time entries and project details",
+    samplePrompt:
+      "Generate a freelance invoice from Sarah Chen (UI/UX Designer) to TechStart Inc for the 'Mobile App Redesign' project. She worked 8 hours on wireframes on March 3rd, 12 hours on high-fidelity mockups on March 5-6, and 4 hours on design review on March 10. Her rate is $125/hour. Invoice #SC-2025-007, issued today, due net-15.",
+  },
+  international: {
+    label: "Invoice Type 3",
+    description: "Multi-currency invoice with addresses, tax breakdown, and shipping",
+    samplePrompt:
+      "Generate an international invoice in EUR from Schmidt Manufacturing GmbH (Industriestraße 42, Munich, Bavaria, 80331, Germany) to Dupont Industries SA (23 Rue de Rivoli, Paris, 75001, France). Items: 100 precision bearings at €12.50, 50 titanium rods at €45.00. Taxes: German VAT at 19%, French import duty at 2.5%. Shipping cost €250. Invoice #INT-2025-EU-089, issued today, due in 45 days.",
+  },
+};
+
+export const invoiceSchemaMap = createSchemaMap({
+  standard: standardInvoiceSchema,
+  freelance: freelanceInvoiceSchema,
+  international: internationalInvoiceSchema,
+});
diff --git a/examples/invoices-structured-output/tsconfig.json b/examples/invoices-structured-output/tsconfig.json
new file mode 100644
index 000000000..cf9c65d3e
--- /dev/null
+++ b/examples/invoices-structured-output/tsconfig.json
@@ -0,0 +1,34 @@
+{
+  "compilerOptions": {
+    "target": "ES2017",
+    "lib": ["dom", "dom.iterable", "esnext"],
+    "allowJs": true,
+    "skipLibCheck": true,
+    "strict": true,
+    "noEmit": true,
+    "esModuleInterop": true,
+    "module": "esnext",
+    "moduleResolution": "bundler",
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "jsx": "react-jsx",
+    "incremental": true,
+    "plugins": [
+      {
+        "name": "next"
+      }
+    ],
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": [
+    "next-env.d.ts",
+    "**/*.ts",
+    "**/*.tsx",
+    ".next/types/**/*.ts",
+    ".next/dev/types/**/*.ts",
+    "**/*.mts"
+  ],
+  "exclude": ["node_modules"]
+}
diff --git a/lang/js/README.md b/lang/js/README.md
new file mode 100644
index 000000000..919c4b837
--- /dev/null
+++ b/lang/js/README.md
@@ -0,0 +1,164 @@
+# @openuidev/structured-outputs
+
+A standalone, framework-agnostic library for using OpenUI Lang as a general-purpose structured output format. No React, no UI rendering — only schema definition, prompt generation, parsing, and Zod validation.
+
+## Installation
+
+```bash
+pnpm add @openuidev/structured-outputs zod
+```
+
+## Quick Start
+
+```ts
+import { z } from "zod";
+import { defineModel, createSchema } from "@openuidev/structured-outputs";
+
+// Define models with Zod schemas
+const Contact = defineModel({
+  name: "Contact",
+  description: "A person's contact information",
+  schema: z.object({
+    name: z.string(),
+    email: z.string(),
+    phone: z.string().optional(),
+  }),
+});
+
+// Create a schema — Contact is the root
+const schema = createSchema([Contact]);
+
+// Generate system prompt for your LLM
+const systemPrompt = schema.prompt();
+
+// Parse the LLM's response
+const result = schema.parse('root = Contact("Alice", "alice@example.com", "+1234567890")');
+// result.root → { name: "Alice", email: "alice@example.com", phone: "+1234567890" }
+// result.meta.rootType → "Contact"
+```
+
+## Nested Models
+
+Use `.ref` to reference child models in parent schemas. Sub-models are **discovered automatically** — you only pass the root model(s) to `createSchema`:
+
+```ts
+const LineItem = defineModel({
+  name: "LineItem",
+  description: "Invoice line item",
+  schema: z.object({
+    description: z.string(),
+    quantity: z.number(),
+    unitPrice: z.number(),
+  }),
+});
+
+const Invoice = defineModel({
+  name: "Invoice",
+  description: "An invoice with line items",
+  schema: z.object({
+    invoiceNumber: z.string(),
+    items: z.array(LineItem.ref),  // LineItem referenced via .ref
+  }),
+});
+
+// Only pass Invoice — LineItem is auto-discovered from Invoice.schema
+const schema = createSchema([Invoice]);
+```
+
+## Multi-Root Schemas
+
+Pass multiple root models to `createSchema` to handle more than one possible output type:
+
+```ts
+const Receipt = defineModel({
+  name: "Receipt",
+  description: "A purchase receipt",
+  schema: z.object({
+    store: z.string(),
+    total: z.number(),
+  }),
+});
+
+const schema = createSchema([Invoice, Receipt]);
+// schema.root → ["Invoice", "Receipt"]
+
+// Prompt instructs the LLM to use one of the root types
+const prompt = schema.prompt();
+
+// Parse — meta.rootType tells you which root was matched
+const r1 = schema.parse('root = Invoice("INV-001", [])');
+// r1.meta.rootType → "Invoice"
+
+const r2 = schema.parse('root = Receipt("Shop", 42)');
+// r2.meta.rootType → "Receipt"
+```
+
+## Streaming
+
+```ts
+const parser = schema.streamingParser();
+
+// Feed chunks as they arrive from the LLM
+let result = parser.push('root = Invoice("INV-001", [i1])\n');
+result = parser.push('i1 = LineItem("Widget", 5, 10.00)');
+
+console.log(result.root);
+// { invoiceNumber: "INV-001", items: [{ description: "Widget", quantity: 5, unitPrice: 10 }] }
+```
+
+## API
+
+### `defineModel(config)`
+
+Define a named model with a Zod schema and description.
+
+```ts
+interface DefinedModel<T extends z.ZodObject<any>> {
+  name: string
+  description: string
+  schema: T        // Zod schema describing the model
+  ref: T           // Use in parent schemas: z.array(Child.ref)
+}
+```
+
+### `createSchema(rootModels)`
+
+Create a schema from an array of root models. Sub-models are discovered automatically by traversing each root's `schema` fields. Returns a `Schema` object with:
+
+- `prompt(options?)` — Generate a system prompt for your LLM
+- `parse(input)` — Parse an OpenUI Lang string into a typed object
+- `streamingParser()` — Create a streaming parser for incremental parsing
+- `toJSONSchema()` — Get the JSON Schema representation
+- `models` — Record of all models (roots + discovered sub-models)
+- `root` — Root model name(s): `string` (single), `string[]` (multi), or `undefined` (none)
+
+### `ParseResult`
+
+```ts
+interface ParseResult<T = unknown> {
+  root: T | null
+  meta: {
+    rootType: string | null      // which root model was matched
+    incomplete: boolean          // true if input was truncated
+    unresolved: string[]         // references used but not yet defined
+    statementCount: number
+    validationErrors: ValidationError[]
+  }
+}
+```
+
+## Key Differences from `@openuidev/react-lang`
+
+| Concern | `react-lang` | `structured-outputs` |
+|---|---|---|
+| Define | `defineComponent` | `defineModel` |
+| Schema field | `props` | `schema` |
+| `ParseResult.root` | `ElementNode` (component tree) | Plain typed JS object via Zod |
+| Sub-type discovery | Manual — pass all types | Automatic from root schema traversal |
+| Multi-root | Not present | Native: `createSchema([A, B])` |
+| Prompt preamble | UI-focused | Data-extraction focused |
+| React dependency | `peerDependency: react >=19` | None |
+
+## License
+
+MIT
diff --git a/lang/js/eslint.config.cjs b/lang/js/eslint.config.cjs
new file mode 100644
index 000000000..19228948b
--- /dev/null
+++ b/lang/js/eslint.config.cjs
@@ -0,0 +1,57 @@
+const eslint = require("@eslint/js");
+const tseslint = require("@typescript-eslint/eslint-plugin");
+const typescript = require("@typescript-eslint/parser");
+const prettier = require("eslint-config-prettier");
+const unusedImports = require("eslint-plugin-unused-imports");
+const eslintPluginPrettier = require("eslint-plugin-prettier");
+
+module.exports = [
+  {
+    files: ["**/*.{ts,tsx}"],
+    languageOptions: {
+      parser: typescript,
+      parserOptions: {
+        project: "./tsconfig.eslint.json",
+        sourceType: "module",
+      },
+    },
+    plugins: {
+      "@typescript-eslint": tseslint,
+      "unused-imports": unusedImports,
+      prettier: eslintPluginPrettier,
+    },
+    rules: {
+      "@typescript-eslint/interface-name-prefix": "off",
+      "@typescript-eslint/explicit-function-return-type": "off",
+      "@typescript-eslint/explicit-module-boundary-types": "off",
+      "@typescript-eslint/no-explicit-any": "off",
+      "no-undefined": "off",
+      "@typescript-eslint/no-unused-vars": [
+        "error",
+        {
+          vars: "all",
+          varsIgnorePattern: "^_",
+          args: "after-used",
+          argsIgnorePattern: "^_",
+        },
+      ],
+      "@typescript-eslint/no-use-before-define": [
+        "error",
+        {
+          functions: false,
+          classes: false,
+          variables: false,
+        },
+      ],
+      "unused-imports/no-unused-imports": "error",
+      "no-console": [
+        "error",
+        {
+          allow: ["error", "warn", "info"],
+        },
+      ],
+      ...eslintPluginPrettier.configs.recommended.rules,
+    },
+  },
+  prettier,
+];
diff --git a/lang/js/package.json b/lang/js/package.json
new file mode 100644
index 000000000..804286f21
--- /dev/null
+++ b/lang/js/package.json
@@ -0,0 +1,58 @@
+{
+  "name": "@openuidev/lang",
+  "version": "0.1.0",
+  "description": "OpenUI Lang — schema definition, prompt generation, parsing, and Zod validation for structured outputs and generative UI",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "exports": {
+    "./structured-outputs": {
+      "import": "./dist/structured-outputs/index.js",
+      "types": "./dist/structured-outputs/index.d.ts"
+    }
+  },
+  "scripts": {
+    "build": "tsc -p .",
+    "watch": "tsc -p . --watch",
+    "lint:check": "eslint ./src",
+    "lint:fix": "eslint ./src --fix",
+    "format:fix": "prettier --write ./src",
+    "format:check": "prettier --check ./src",
+    "prepare": "pnpm run build",
+    "ci": "pnpm run lint:check && pnpm run format:check",
+    "test": "vitest run"
+  },
+  "keywords": [
+    "openui",
+    "structured-outputs",
+    "generative-ui",
+    "llm",
+    "parser",
+    "zod",
+    "schema",
+    "ai",
+    "data-extraction",
+    "prompt-generation",
+    "openui-lang"
+  ],
+  "homepage": "https://openui.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/thesysdev/openui.git",
+    "directory": "lang/js"
+  },
+  "bugs": {
+    "url": "https://github.com/thesysdev/openui/issues"
+  },
+  "author": "engineering@thesys.dev",
+  "dependencies": {
+    "zod": "^4.0.0"
+  },
+  "devDependencies": {
+    "vitest": "^3.0.0",
+    "typescript": "^5.9.3"
+  }
+}
diff --git a/lang/js/src/__tests__/defineModel.test.ts b/lang/js/src/__tests__/defineModel.test.ts
new file mode 100644
index 000000000..feb1752a3
--- /dev/null
+++ b/lang/js/src/__tests__/defineModel.test.ts
@@ -0,0 +1,403 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { createSchema, defineModel } from "../index";
+
+describe("defineModel", () => {
+  it("creates a Model with name, description, and schema", () => {
+    const Contact = defineModel({
+      name: "Contact",
+      description: "A person's contact info",
+      schema: z.object({
+        name: z.string(),
+        email: z.string(),
+      }),
+    });
+
+    expect(Contact.name).toBe("Contact");
+    expect(Contact.description).toBe("A person's contact info");
+    expect(Contact.schema).toBeDefined();
+    expect(Contact.ref).toBeDefined();
+  });
+
+  it("registers the schema in z.globalRegistry with id and description", () => {
+    const RegisteredModel = defineModel({
+      name: "RegisteredModel",
+      description: "Test registration",
+      schema: z.object({ value: z.string() }),
+    });
+
+    const meta = z.globalRegistry.get(RegisteredModel.schema);
+    expect(meta?.id).toBe("RegisteredModel");
+    expect((meta as any)?.description).toBe("Test registration");
+  });
+
+  it("ref can be used in parent schemas", () => {
+    const Item = defineModel({
+      name: "LineItemDM",
+      description: "Invoice line item",
+      schema: z.object({
+        description: z.string(),
+        amount: z.number(),
+      }),
+    });
+
+    const Invoice = defineModel({
+      name: "InvoiceDM",
+      description: "Invoice with line items",
+      schema: z.object({
+        number: z.string(),
+        items: z.array(Item.ref),
+      }),
+    });
+
+    expect(Invoice.schema.shape.items).toBeDefined();
+  });
+});
+
+describe("createSchema + defineModel integration", () => {
+  it("creates a schema and parses valid input", () => {
+    const Contact = defineModel({
+      name: "Contact2",
+      description: "Contact info",
+      schema: z.object({
+        name: z.string(),
+        email: z.string(),
+      }),
+    });
+
+    const schema = createSchema([Contact]);
+
+    const result = schema.parse('root = Contact2("Alice", "alice@example.com")');
+    expect(result.root).toEqual({ name: "Alice", email: "alice@example.com" });
+    expect(result.meta.rootType).toBe("Contact2");
+    expect(result.meta.validationErrors).toHaveLength(0);
+  });
+
+  it("auto-discovers sub-models from root schema", () => {
+    const Tag = defineModel({
+      name: "AutoTag",
+      description: "A tag",
+      schema: z.object({ label: z.string() }),
+    });
+
+    const Article = defineModel({
+      name: "AutoArticle",
+      description: "An article",
+      schema: z.object({
+        title: z.string(),
+        tags: z.array(Tag.ref),
+      }),
+    });
+
+    // Only pass Article — Tag should be auto-discovered
+    const schema = createSchema([Article]);
+
+    expect(schema.models["AutoArticle"]).toBeDefined();
+    expect(schema.models["AutoTag"]).toBeDefined();
+    expect(schema.root).toBe("AutoArticle");
+
+    const input = `root = AutoArticle("Hello World", [t1, t2])
+t1 = AutoTag("javascript")
+t2 = AutoTag("typescript")`;
+
+    const result = schema.parse(input);
+    expect(result.root).toEqual({
+      title: "Hello World",
+      tags: [{ label: "javascript" }, { label: "typescript" }],
+    });
+    expect(result.meta.rootType).toBe("AutoArticle");
+  });
+
+  it("supports multi-root schemas", () => {
+    const Invoice = defineModel({
+      name: "MultiInvoice",
+      description: "An invoice",
+      schema: z.object({ number: z.string() }),
+    });
+
+    const Receipt = defineModel({
+      name: "MultiReceipt",
+      description: "A receipt",
+      schema: z.object({ store: z.string(), total: z.number() }),
+    });
+
+    const schema = createSchema([Invoice, Receipt]);
+
+    expect(schema.root).toEqual(["MultiInvoice", "MultiReceipt"]);
+
+    const r1 = schema.parse('root = MultiInvoice("INV-001")');
+    expect(r1.root).toEqual({ number: "INV-001" });
+    expect(r1.meta.rootType).toBe("MultiInvoice");
+
+    const r2 = schema.parse('root = MultiReceipt("Shop", 42)');
+    expect(r2.root).toEqual({ store: "Shop", total: 42 });
+    expect(r2.meta.rootType).toBe("MultiReceipt");
+  });
+
+  it("schema.root is undefined for empty createSchema", () => {
+    const schema = createSchema([]);
+    expect(schema.root).toBeUndefined();
+  });
+
+  it("schema.root is a string for single root", () => {
+    const M = defineModel({
+      name: "SingleRoot",
+      description: "Single root model",
+      schema: z.object({ v: z.string() }),
+    });
+    const schema = createSchema([M]);
+    expect(schema.root).toBe("SingleRoot");
+  });
+
+  it("reports validation errors for missing required fields", () => {
+    const Person = defineModel({
+      name: "PersonDM",
+      description: "A person",
+      schema: z.object({
+        firstName: z.string(),
+        lastName: z.string(),
+        age: z.number(),
+      }),
+    });
+
+    const schema = createSchema([Person]);
+
+    const result = schema.parse('root = PersonDM("Alice")');
+    expect(result.root).toBeNull();
+    expect(result.meta.validationErrors.length).toBeGreaterThan(0);
+    expect(result.meta.validationErrors[0].type).toBe("PersonDM");
+  });
+
+  it("handles optional fields correctly", () => {
+    const Note = defineModel({
+      name: "NoteDM",
+      description: "A note",
+      schema: z.object({
+        title: z.string(),
+        body: z.string().optional(),
+      }),
+    });
+
+    const schema = createSchema([Note]);
+
+    const result = schema.parse('root = NoteDM("My Note")');
+    expect(result.root).toEqual({ title: "My Note" });
+    expect(result.meta.validationErrors).toHaveLength(0);
+  });
+
+  it("validates enum fields", () => {
+    const Status = defineModel({
+      name: "StatusDM",
+      description: "A status entry",
+      schema: z.object({
+        state: z.enum(["active", "inactive", "pending"]),
+        label: z.string(),
+      }),
+    });
+
+    const schema = createSchema([Status]);
+
+    const valid = schema.parse('root = StatusDM("active", "Active item")');
+    expect(valid.root).toEqual({ state: "active", label: "Active item" });
+
+    const invalid = schema.parse('root = StatusDM("unknown", "Bad state")');
+    expect(invalid.root).toBeNull();
+    expect(invalid.meta.validationErrors.length).toBeGreaterThan(0);
+  });
+
+  it("handles deeply nested types (3+ levels) via auto-discovery", () => {
+    const Leaf = defineModel({
+      name: "DeepLeafDM",
+      description: "A leaf",
+      schema: z.object({ value: z.string() }),
+    });
+
+    const Branch = defineModel({
+      name: "DeepBranchDM",
+      description: "A branch",
+      schema: z.object({ leaves: z.array(Leaf.ref) }),
+    });
+
+    const Tree = defineModel({
+      name: "DeepTreeDM",
+      description: "A tree",
+      schema: z.object({ branches: z.array(Branch.ref) }),
+    });
+
+    const Forest = defineModel({
+      name: "DeepForestDM",
+      description: "A forest",
+      schema: z.object({ trees: z.array(Tree.ref) }),
+    });
+
+    // Only pass Forest — all sub-models should be auto-discovered
+    const schema = createSchema([Forest]);
+
+    expect(schema.models["DeepLeafDM"]).toBeDefined();
+    expect(schema.models["DeepBranchDM"]).toBeDefined();
+    expect(schema.models["DeepTreeDM"]).toBeDefined();
+    expect(schema.models["DeepForestDM"]).toBeDefined();
+
+    const input = `root = DeepForestDM([t1])
+t1 = DeepTreeDM([b1])
+b1 = DeepBranchDM([l1, l2])
+l1 = DeepLeafDM("leaf-a")
+l2 = DeepLeafDM("leaf-b")`;
+
+    const result = schema.parse(input);
+    expect(result.root).toEqual({
+      trees: [
+        {
+          branches: [
+            { leaves: [{ value: "leaf-a" }, { value: "leaf-b" }] },
+          ],
+        },
+      ],
+    });
+    expect(result.meta.validationErrors).toHaveLength(0);
+    expect(result.meta.rootType).toBe("DeepForestDM");
+  });
+
+  it("validates number constraints (min/max)", () => {
+    const Bounded = defineModel({
+      name: "BoundedNumDM",
+      description: "Bounded number",
+      schema: z.object({
+        score: z.number().min(0).max(100),
+      }),
+    });
+
+    const schema = createSchema([Bounded]);
+
+    const valid = schema.parse("root = BoundedNumDM(50)");
+    expect(valid.root).toEqual({ score: 50 });
+    expect(valid.meta.validationErrors).toHaveLength(0);
+
+    const tooLow = schema.parse("root = BoundedNumDM(-1)");
+    expect(tooLow.root).toBeNull();
+    expect(tooLow.meta.validationErrors[0].type).toBe("BoundedNumDM");
+
+    const tooHigh = schema.parse("root = BoundedNumDM(101)");
+    expect(tooHigh.root).toBeNull();
+    expect(tooHigh.meta.validationErrors[0].type).toBe("BoundedNumDM");
+  });
+
+  it("handles string length constraints", () => {
+    const Constrained = defineModel({
+      name: "ConstrainedStrDM",
+      description: "Constrained string",
+      schema: z.object({
+        code: z.string().min(2).max(5),
+      }),
+    });
+
+    const schema = createSchema([Constrained]);
+
+    const valid = schema.parse('root = ConstrainedStrDM("ABC")');
+    expect(valid.root).toEqual({ code: "ABC" });
+    expect(valid.meta.validationErrors).toHaveLength(0);
+
+    const tooShort = schema.parse('root = ConstrainedStrDM("A")');
+    expect(tooShort.root).toBeNull();
+    expect(tooShort.meta.validationErrors.length).toBeGreaterThan(0);
+  });
+
+  it("handles multiple optional fields with partial arguments", () => {
+    const Flexible = defineModel({
+      name: "FlexTypeDM",
+      description: "Many optionals",
+      schema: z.object({
+        required: z.string(),
+        opt1: z.string().optional(),
+        opt2: z.number().optional(),
+        opt3: z.boolean().optional(),
+      }),
+    });
+
+    const schema = createSchema([Flexible]);
+
+    const minimal = schema.parse('root = FlexTypeDM("only-required")');
+    expect(minimal.root).toEqual({ required: "only-required" });
+    expect(minimal.meta.validationErrors).toHaveLength(0);
+
+    const partial = schema.parse('root = FlexTypeDM("req", "extra")');
+    expect(partial.root).toEqual({ required: "req", opt1: "extra" });
+    expect(partial.meta.validationErrors).toHaveLength(0);
+
+    const full = schema.parse('root = FlexTypeDM("req", "e", 42, true)');
+    expect(full.root).toEqual({
+      required: "req",
+      opt1: "e",
+      opt2: 42,
+      opt3: true,
+    });
+  });
+
+  it("handles empty arrays", () => {
+    const EmptyArr = defineModel({
+      name: "EmptyArrTypeDM",
+      description: "Empty array",
+      schema: z.object({
+        label: z.string(),
+        items: z.array(z.string()),
+      }),
+    });
+
+    const schema = createSchema([EmptyArr]);
+
+    const result = schema.parse('root = EmptyArrTypeDM("list", [])');
+    expect(result.root).toEqual({ label: "list", items: [] });
+    expect(result.meta.validationErrors).toHaveLength(0);
+  });
+
+  it("validates specific error paths for nested validation failures", () => {
+    const Strict = defineModel({
+      name: "StrictPersonDM",
+      description: "Strict person",
+      schema: z.object({
+        name: z.string(),
+        email: z.string().email(),
+      }),
+    });
+
+    const schema = createSchema([Strict]);
+
+    const result = schema.parse('root = StrictPersonDM("Alice", "not-an-email")');
+    expect(result.root).toBeNull();
+    expect(result.meta.validationErrors).toHaveLength(1);
+    expect(result.meta.validationErrors[0]).toEqual({
+      type: "StrictPersonDM",
+      path: "/email",
+      message: expect.stringContaining("email"),
+    });
+  });
+
+  it("handles types with boolean-only schema", () => {
+    const Flags = defineModel({
+      name: "FlagTypeDM",
+      description: "Boolean flags",
+      schema: z.object({
+        active: z.boolean(),
+        visible: z.boolean(),
+      }),
+    });
+
+    const schema = createSchema([Flags]);
+
+    const result = schema.parse("root = FlagTypeDM(true, false)");
+    expect(result.root).toEqual({ active: true, visible: false });
+    expect(result.meta.validationErrors).toHaveLength(0);
+  });
+
+  it("meta.rootType is null for empty result", () => {
+    const M = defineModel({
+      name: "AnyModel",
+      description: "Any model",
+      schema: z.object({ v: z.string() }),
+    });
+    const schema = createSchema([M]);
+    const result = schema.parse("");
+    expect(result.root).toBeNull();
+    expect(result.meta.rootType).toBeNull();
+  });
+});
diff --git a/lang/js/src/__tests__/parser.test.ts b/lang/js/src/__tests__/parser.test.ts
new file mode 100644
index 000000000..cfa9814b1
--- /dev/null
+++ b/lang/js/src/__tests__/parser.test.ts
@@ -0,0 +1,462 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { createSchema, defineModel } from "../index";
+
+describe("parser — plain object output", () => {
+  const Item = defineModel({
+    name: "PItem",
+    description: "A simple item",
+    schema: z.object({
+      name: z.string(),
+      value: z.number(),
+    }),
+  });
+
+  const Container = defineModel({
+    name: "PContainer",
+    description: "Holds items",
+    schema: z.object({
+      title: z.string(),
+      items: z.array(Item.ref),
+    }),
+  });
+
+  // Item is auto-discovered from Container.schema
+  const schema = createSchema([Container]);
+
+  it("parses a flat type to a plain object", () => {
+    const result = schema.parse('root = PItem("test", 42)');
+    expect(result.root).toEqual({ name: "test", value: 42 });
+  });
+
+  it("parses nested types with references", () => {
+    const input = `root = PContainer("Inventory", [a, b])
+a = PItem("Widget", 10)
+b = PItem("Gadget", 20)`;
+
+    const result = schema.parse(input);
+    expect(result.root).toEqual({
+      title: "Inventory",
+      items: [
+        { name: "Widget", value: 10 },
+        { name: "Gadget", value: 20 },
+      ],
+    });
+  });
+
+  it("returns null root for empty input", () => {
+    const result = schema.parse("");
+    expect(result.root).toBeNull();
+    expect(result.meta.incomplete).toBe(true);
+    expect(result.meta.rootType).toBeNull();
+  });
+
+  it("handles hoisting (forward references)", () => {
+    const input = `root = PContainer("List", [item1])
+item1 = PItem("First", 1)`;
+
+    const result = schema.parse(input);
+    expect(result.root).toEqual({
+      title: "List",
+      items: [{ name: "First", value: 1 }],
+    });
+  });
+
+  it("tracks unresolved references", () => {
+    const input = `root = PContainer("List", [missing])`;
+    const result = schema.parse(input);
+    expect(result.meta.unresolved).toContain("missing");
+  });
+
+  it("counts statements", () => {
+    const input = `root = PContainer("X", [a])
+a = PItem("Y", 1)`;
+    const result = schema.parse(input);
+    expect(result.meta.statementCount).toBe(2);
+  });
+
+  it("populates meta.rootType from the root Comp node name", () => {
+    const result = schema.parse('root = PContainer("Test", [])');
+    expect(result.meta.rootType).toBe("PContainer");
+  });
+
+  it("handles boolean and null values", () => {
+    const BoolType = defineModel({
+      name: "BoolType",
+      description: "Bool test",
+      schema: z.object({
+        flag: z.boolean(),
+        label: z.string(),
+      }),
+    });
+
+    const boolSchema = createSchema([BoolType]);
+
+    const result = boolSchema.parse('root = BoolType(true, "test")');
+    expect(result.root).toEqual({ flag: true, label: "test" });
+  });
+
+  it("handles objects as prop values", () => {
+    const MetaType = defineModel({
+      name: "MetaType",
+      description: "Has metadata object",
+      schema: z.object({
+        name: z.string(),
+        meta: z.record(z.string(), z.unknown()).optional(),
+      }),
+    });
+
+    const metaSchema = createSchema([MetaType]);
+
+    const result = metaSchema.parse('root = MetaType("test", {key: "value"})');
+    expect(result.root).toEqual({
+      name: "test",
+      meta: { key: "value" },
+    });
+  });
+
+  it("parses escaped strings (quotes, newlines, backslashes)", () => {
+    const EscType = defineModel({
+      name: "EscType",
+      description: "Escaped string test",
+      schema: z.object({ text: z.string() }),
+    });
+
+    const escSchema = createSchema([EscType]);
+
+    const withQuotes = escSchema.parse('root = EscType("say \\"hello\\"")');
+    expect(withQuotes.root).toEqual({ text: 'say "hello"' });
+
+    const withNewline = escSchema.parse('root = EscType("line1\\nline2")');
+    expect(withNewline.root).toEqual({ text: "line1\nline2" });
+
+    const withBackslash = escSchema.parse('root = EscType("path\\\\to\\\\file")');
+    expect(withBackslash.root).toEqual({ text: "path\\to\\file" });
+  });
+
+  it("parses negative numbers", () => {
+    const NumType = defineModel({
+      name: "NegNumType",
+      description: "Negative number test",
+      schema: z.object({ value: z.number() }),
+    });
+
+    const numSchema = createSchema([NumType]);
+
+    const result = numSchema.parse("root = NegNumType(-42)");
+    expect(result.root).toEqual({ value: -42 });
+
+    const decimal = numSchema.parse("root = NegNumType(-3.14)");
+    expect(decimal.root).toEqual({ value: -3.14 });
+  });
+
+  it("parses scientific notation numbers", () => {
+    const SciType = defineModel({
+      name: "SciType",
+      description: "Sci notation test",
+      schema: z.object({ value: z.number() }),
+    });
+
+    const sciSchema = createSchema([SciType]);
+
+    const result = sciSchema.parse("root = SciType(1e5)");
+    expect(result.root).toEqual({ value: 100000 });
+
+    const negExp = sciSchema.parse("root = SciType(2.5E-3)");
+    expect(negExp.root).toEqual({ value: 0.0025 });
+
+    const posExp = sciSchema.parse("root = SciType(1.2e+4)");
+    expect(posExp.root).toEqual({ value: 12000 });
+  });
+
+  it("parses explicit null arguments", () => {
+    const NullType = defineModel({
+      name: "NullableType",
+      description: "Nullable test",
+      schema: z.object({
+        label: z.string(),
+        extra: z.string().nullable().optional(),
+      }),
+    });
+
+    const nullSchema = createSchema([NullType]);
+
+    const result = nullSchema.parse('root = NullableType("hello", null)');
+    expect(result.root).toEqual({ label: "hello", extra: null });
+  });
+
+  it("handles circular references without infinite loop", () => {
+    const NodeType = defineModel({
+      name: "CircNode",
+      description: "Node with potential cycle",
+      schema: z.object({ label: z.string() }),
+    });
+
+    const circSchema = createSchema([NodeType]);
+
+    const input = `root = CircNode(a)\na = b\nb = a`;
+    const result = circSchema.parse(input);
+    expect(result.meta.unresolved.length).toBeGreaterThan(0);
+  });
+
+  it("handles malformed input gracefully", () => {
+    const MalType = defineModel({
+      name: "MalType",
+      description: "Malformed test",
+      schema: z.object({ x: z.string() }),
+    });
+
+    const malSchema = createSchema([MalType]);
+
+    const garbage = malSchema.parse("!!!???");
+    expect(garbage.root).toBeNull();
+
+    const noEquals = malSchema.parse("just some words");
+    expect(noEquals.root).toBeNull();
+
+    const partial = malSchema.parse("root =");
+    expect(partial.root).toBeNull();
+  });
+
+  it("uses the first statement as root when multiple root= lines exist", () => {
+    const MultiRoot = defineModel({
+      name: "MultiRootType",
+      description: "Multi root test",
+      schema: z.object({ val: z.string() }),
+    });
+
+    const mrSchema = createSchema([MultiRoot]);
+
+    const input = `root = MultiRootType("first")\nroot = MultiRootType("second")`;
+    const result = mrSchema.parse(input);
+    expect(result.root).toEqual({ val: "second" });
+  });
+
+  it("marks complete input as not incomplete", () => {
+    const result = schema.parse('root = PItem("done", 99)');
+    expect(result.meta.incomplete).toBe(false);
+  });
+
+  it("marks input with unclosed parens as incomplete", () => {
+    const result = schema.parse('root = PItem("partial", 1');
+    expect(result.meta.incomplete).toBe(true);
+    expect(result.root).toEqual({ name: "partial", value: 1 });
+  });
+
+  it("handles whitespace-only input", () => {
+    const result = schema.parse("   \n\t\n  ");
+    expect(result.root).toBeNull();
+    expect(result.meta.incomplete).toBe(true);
+  });
+
+  it("handles deeply nested arrays", () => {
+    const LeafType = defineModel({
+      name: "DeepLeaf",
+      description: "Leaf",
+      schema: z.object({ v: z.string() }),
+    });
+    const MidType = defineModel({
+      name: "DeepMid",
+      description: "Mid",
+      schema: z.object({ children: z.array(LeafType.ref) }),
+    });
+    const TopType = defineModel({
+      name: "DeepTop",
+      description: "Top",
+      schema: z.object({ mids: z.array(MidType.ref) }),
+    });
+
+    // TopType → MidType → LeafType, all auto-discovered
+    const deepSchema = createSchema([TopType]);
+
+    const input = `root = DeepTop([m1, m2])
+m1 = DeepMid([l1])
+m2 = DeepMid([l2, l3])
+l1 = DeepLeaf("a")
+l2 = DeepLeaf("b")
+l3 = DeepLeaf("c")`;
+
+    const result = deepSchema.parse(input);
+    expect(result.root).toEqual({
+      mids: [
+        { children: [{ v: "a" }] },
+        { children: [{ v: "b" }, { v: "c" }] },
+      ],
+    });
+    expect(result.meta.validationErrors).toHaveLength(0);
+  });
+
+  it("returns specific validation error paths and messages", () => {
+    const StrictType = defineModel({
+      name: "StrictValType",
+      description: "Strict validation",
+      schema: z.object({
+        email: z.string().email(),
+        age: z.number().min(0),
+      }),
+    });
+
+    const strictSchema = createSchema([StrictType]);
+
+    const result = strictSchema.parse('root = StrictValType("not-email", -5)');
+    expect(result.root).toBeNull();
+    expect(result.meta.validationErrors.length).toBeGreaterThan(0);
+    expect(result.meta.validationErrors[0].type).toBe("StrictValType");
+    expect(result.meta.validationErrors[0].path).toBeDefined();
+    expect(result.meta.validationErrors[0].message).toBeDefined();
+  });
+});
+
+describe("streamingParser — plain object output", () => {
+  it("progressively builds the result", () => {
+    const Simple = defineModel({
+      name: "SItem",
+      description: "Simple",
+      schema: z.object({ name: z.string() }),
+    });
+
+    const schema = createSchema([Simple]);
+
+    const parser = schema.streamingParser();
+
+    let result = parser.push('root = SItem("He');
+    expect(result.meta.incomplete).toBe(true);
+    expect(result.root).toEqual({ name: "He" });
+
+    result = parser.push('llo")');
+    expect(result.root).toEqual({ name: "Hello" });
+  });
+
+  it("resolves references as they stream in", () => {
+    const Child = defineModel({
+      name: "SChild",
+      description: "Child",
+      schema: z.object({ val: z.string() }),
+    });
+
+    const Parent = defineModel({
+      name: "SParent",
+      description: "Parent",
+      schema: z.object({
+        name: z.string(),
+        children: z.array(Child.ref),
+      }),
+    });
+
+    const schema = createSchema([Parent]);
+
+    const parser = schema.streamingParser();
+
+    let result = parser.push('root = SParent("Parent", [c1])\n');
+    expect(result.meta.unresolved).toContain("c1");
+    expect(result.root).toBeNull();
+
+    result = parser.push('c1 = SChild("child1")');
+    expect(result.root).toEqual({
+      name: "Parent",
+      children: [{ val: "child1" }],
+    });
+    expect(result.meta.unresolved).toHaveLength(0);
+  });
+
+  it("getResult returns the latest without consuming new data", () => {
+    const Simple2 = defineModel({
+      name: "S2",
+      description: "S2",
+      schema: z.object({ x: z.string() }),
+    });
+
+    const schema = createSchema([Simple2]);
+    const parser = schema.streamingParser();
+
+    parser.push('root = S2("test")');
+    const r1 = parser.getResult();
+    const r2 = parser.getResult();
+    expect(r1).toEqual(r2);
+  });
+
+  it("handles character-by-character streaming", () => {
+    const CharType = defineModel({
+      name: "CharStream",
+      description: "Char-by-char",
+      schema: z.object({ v: z.string() }),
+    });
+
+    const schema = createSchema([CharType]);
+    const parser = schema.streamingParser();
+
+    const full = 'root = CharStream("hi")';
+    let result;
+    for (const char of full) {
+      result = parser.push(char);
+    }
+    expect(result!.root).toEqual({ v: "hi" });
+  });
+
+  it("handles multi-statement streaming across chunks", () => {
+    const StreamChild = defineModel({
+      name: "StreamChild",
+      description: "Child",
+      schema: z.object({ v: z.string() }),
+    });
+    const StreamParent = defineModel({
+      name: "StreamParent",
+      description: "Parent",
+      schema: z.object({
+        title: z.string(),
+        items: z.array(StreamChild.ref),
+      }),
+    });
+
+    const schema = createSchema([StreamParent]);
+    const parser = schema.streamingParser();
+
+    let result = parser.push('root = StreamParent("List", [a, b])\n');
+    expect(result.root).toBeNull();
+    expect(result.meta.unresolved).toContain("a");
+
+    result = parser.push('a = StreamChild("first")\n');
+    expect(result.meta.unresolved).toContain("b");
+    expect(result.root).toBeNull();
+
+    result = parser.push('b = StreamChild("second")');
+    expect(result.meta.unresolved).toHaveLength(0);
+    expect(result.root).toEqual({
+      title: "List",
+      items: [{ v: "first" }, { v: "second" }],
+    });
+  });
+
+  it("returns incomplete=false for fully closed streaming input", () => {
+    const DoneType = defineModel({
+      name: "StreamDone",
+      description: "Done",
+      schema: z.object({ x: z.string() }),
+    });
+
+    const schema = createSchema([DoneType]);
+    const parser = schema.streamingParser();
+
+    parser.push('root = StreamDone("done")\n');
+    const result = parser.getResult();
+    expect(result.meta.incomplete).toBe(false);
+    expect(result.root).toEqual({ x: "done" });
+  });
+
+  it("handles empty push calls", () => {
+    const EmptyPush = defineModel({
+      name: "EmptyPush",
+      description: "EP",
+      schema: z.object({ x: z.string() }),
+    });
+
+    const schema = createSchema([EmptyPush]);
+    const parser = schema.streamingParser();
+
+    let result = parser.push("");
+    expect(result.root).toBeNull();
+
+    result = parser.push('root = EmptyPush("val")');
+    expect(result.root).toEqual({ x: "val" });
+  });
+});
diff --git a/lang/js/src/__tests__/prompt.test.ts b/lang/js/src/__tests__/prompt.test.ts
new file mode 100644
index 000000000..8c5b02b20
--- /dev/null
+++ b/lang/js/src/__tests__/prompt.test.ts
@@ -0,0 +1,334 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import { createSchema, defineModel } from "../index";
+
+describe("prompt generation", () => {
+  it("uses 'Type Signatures' section header instead of 'Component Signatures'", () => {
+    const T1 = defineModel({
+      name: "PromptT1",
+      description: "Type one",
+      schema: z.object({ a: z.string() }),
+    });
+
+    const schema = createSchema([T1]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("## Type Signatures");
+    expect(prompt).not.toContain("## Component Signatures");
+  });
+
+  it("includes type signatures with descriptions", () => {
+    const Contact = defineModel({
+      name: "PromptContact",
+      description: "Contact information",
+      schema: z.object({
+        name: z.string(),
+        email: z.string(),
+        phone: z.string().optional(),
+      }),
+    });
+
+    const schema = createSchema([Contact]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("PromptContact(");
+    expect(prompt).toContain("name: string");
+    expect(prompt).toContain("email: string");
+    expect(prompt).toContain("phone?: string");
+    expect(prompt).toContain("— Contact information");
+  });
+
+  it("does not include action prop or UI rendering notes", () => {
+    const T = defineModel({
+      name: "PromptNoAction",
+      description: "No action",
+      schema: z.object({ v: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt();
+
+    expect(prompt).not.toContain("action` prop");
+    expect(prompt).not.toContain("ContinueConversation");
+    expect(prompt).not.toContain("OpenUrl");
+    expect(prompt).not.toContain("UI shell appears");
+  });
+
+  it("supports custom preamble", () => {
+    const T = defineModel({
+      name: "PromptCustom",
+      description: "Custom",
+      schema: z.object({ x: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt({ preamble: "You are a custom assistant." });
+
+    expect(prompt).toContain("You are a custom assistant.");
+    expect(prompt).not.toContain("data extraction assistant");
+  });
+
+  it("includes examples when provided", () => {
+    const T = defineModel({
+      name: "PromptEx",
+      description: "Ex",
+      schema: z.object({ x: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt({
+      examples: ['root = PromptEx("hello")'],
+    });
+
+    expect(prompt).toContain("## Examples");
+    expect(prompt).toContain('root = PromptEx("hello")');
+  });
+
+  it("includes additional rules when provided", () => {
+    const T = defineModel({
+      name: "PromptRules",
+      description: "Rules",
+      schema: z.object({ x: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt({
+      additionalRules: ["Always use ISO dates", "Prefer metric units"],
+    });
+
+    expect(prompt).toContain("- Always use ISO dates");
+    expect(prompt).toContain("- Prefer metric units");
+  });
+
+  it("generates correct root reference in syntax rules for single root", () => {
+    const Root = defineModel({
+      name: "MyRoot",
+      description: "Root",
+      schema: z.object({ title: z.string() }),
+    });
+
+    const schema = createSchema([Root]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("root = MyRoot(...)");
+  });
+
+  it("generates multi-root syntax rules containing 'one of'", () => {
+    const Invoice = defineModel({
+      name: "PromptInvoice",
+      description: "An invoice",
+      schema: z.object({ number: z.string() }),
+    });
+
+    const Receipt = defineModel({
+      name: "PromptReceipt",
+      description: "A receipt",
+      schema: z.object({ store: z.string() }),
+    });
+
+    const schema = createSchema([Invoice, Receipt]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("one of");
+    expect(prompt).toContain("PromptInvoice(...)");
+    expect(prompt).toContain("PromptReceipt(...)");
+  });
+
+  it("generates multi-root streaming and important rules with joined names", () => {
+    const A = defineModel({
+      name: "MultiA",
+      description: "Multi A",
+      schema: z.object({ x: z.string() }),
+    });
+    const B = defineModel({
+      name: "MultiB",
+      description: "Multi B",
+      schema: z.object({ y: z.string() }),
+    });
+
+    const schema = createSchema([A, B]);
+    const prompt = schema.prompt();
+
+    // Both roots should appear in the prompt
+    expect(prompt).toContain("MultiA | MultiB");
+  });
+
+  it("generates JSON schema", () => {
+    const T = defineModel({
+      name: "PromptJsonSchema",
+      description: "JSON Schema test",
+      schema: z.object({ x: z.string(), y: z.number().optional() }),
+    });
+
+    const schema = createSchema([T]);
+    const jsonSchema = schema.toJSONSchema();
+
+    expect(jsonSchema).toHaveProperty("$defs");
+  });
+
+  it("falls back to 'Root' when no root model is specified", () => {
+    const schema = createSchema([]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("root = Root(...)");
+  });
+
+  it("includes enum annotations in type signatures", () => {
+    const EnumType = defineModel({
+      name: "PromptEnum",
+      description: "Enum type",
+      schema: z.object({
+        status: z.enum(["active", "inactive", "pending"]),
+        label: z.string(),
+      }),
+    });
+
+    const schema = createSchema([EnumType]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain('"active" | "inactive" | "pending"');
+    expect(prompt).toContain("label: string");
+  });
+
+  it("includes array annotations in type signatures", () => {
+    const ChildType = defineModel({
+      name: "PromptArrChild",
+      description: "Array child",
+      schema: z.object({ v: z.string() }),
+    });
+
+    const ParentType = defineModel({
+      name: "PromptArrParent",
+      description: "Array parent",
+      schema: z.object({
+        name: z.string(),
+        children: z.array(ChildType.ref),
+      }),
+    });
+
+    // Only pass ParentType — ChildType auto-discovered
+    const schema = createSchema([ParentType]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("PromptArrChild[]");
+  });
+
+  it("includes optional array annotations", () => {
+    const ItemType = defineModel({
+      name: "PromptOptItem",
+      description: "Item",
+      schema: z.object({ v: z.string() }),
+    });
+
+    const OptArr = defineModel({
+      name: "PromptOptArr",
+      description: "Optional array",
+      schema: z.object({
+        items: z.array(ItemType.ref).optional(),
+      }),
+    });
+
+    const schema = createSchema([OptArr]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("items?:");
+    expect(prompt).toContain("PromptOptItem[]");
+  });
+
+  it("includes hoisting and streaming rules section", () => {
+    const T = defineModel({
+      name: "PromptHoist",
+      description: "Hoist test",
+      schema: z.object({ v: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("## Hoisting & Forward References");
+    expect(prompt).toContain("root = PromptHoist(...)");
+  });
+
+  it("includes important rules section", () => {
+    const T = defineModel({
+      name: "PromptImportant",
+      description: "Important",
+      schema: z.object({ v: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("## Important Rules");
+    expect(prompt).toContain("ALWAYS start with root = PromptImportant(...)");
+  });
+
+  it("does not include Examples section when no examples provided", () => {
+    const T = defineModel({
+      name: "PromptNoEx",
+      description: "No examples",
+      schema: z.object({ v: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt();
+
+    expect(prompt).not.toContain("## Examples");
+  });
+
+  it("generates JSON schema with correct structure", () => {
+    const T = defineModel({
+      name: "PromptJsonDetail",
+      description: "Detailed JSON schema",
+      schema: z.object({
+        name: z.string(),
+        count: z.number().optional(),
+        active: z.boolean(),
+      }),
+    });
+
+    const schema = createSchema([T]);
+    const jsonSchema = schema.toJSONSchema() as any;
+
+    expect(jsonSchema.$defs).toBeDefined();
+    const typeDef = jsonSchema.$defs.PromptJsonDetail;
+    expect(typeDef).toBeDefined();
+    expect(typeDef.properties).toBeDefined();
+    expect(typeDef.properties.name).toBeDefined();
+    expect(typeDef.properties.active).toBeDefined();
+    expect(typeDef.required).toContain("name");
+    expect(typeDef.required).toContain("active");
+  });
+
+  it("includes syntax rules section", () => {
+    const T = defineModel({
+      name: "PromptSyntax",
+      description: "Syntax",
+      schema: z.object({ v: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt();
+
+    expect(prompt).toContain("## Syntax Rules");
+    expect(prompt).toContain("POSITIONAL");
+    expect(prompt).toContain("double quotes");
+  });
+
+  it("supports multiple examples", () => {
+    const T = defineModel({
+      name: "PromptMultiEx",
+      description: "Multi example",
+      schema: z.object({ x: z.string() }),
+    });
+
+    const schema = createSchema([T]);
+    const prompt = schema.prompt({
+      examples: ['root = PromptMultiEx("first")', 'root = PromptMultiEx("second")'],
+    });
+
+    expect(prompt).toContain("## Examples");
+    expect(prompt).toContain('root = PromptMultiEx("first")');
+    expect(prompt).toContain('root = PromptMultiEx("second")');
+  });
+});
diff --git a/lang/js/src/__tests__/zod.test.ts b/lang/js/src/__tests__/zod.test.ts
new file mode 100644
index 000000000..7acc4747f
--- /dev/null
+++ b/lang/js/src/__tests__/zod.test.ts
@@ -0,0 +1,256 @@
+import { describe, expect, it } from "vitest";
+import { z } from "zod";
+import {
+  getZodDef,
+  getZodType,
+  isOptionalType,
+  unwrapOptional,
+  unwrap,
+  isArrayType,
+  getArrayInnerType,
+  getEnumValues,
+  getSchemaId,
+  getUnionOptions,
+  getObjectShape,
+  resolveTypeAnnotation,
+} from "../utils/zod";
+
+describe("getZodDef", () => {
+  it("returns the internal _zod.def for a Zod schema", () => {
+    const schema = z.string();
+    const def = getZodDef(schema);
+    expect(def).toBeDefined();
+    expect(def.type).toBe("string");
+  });
+
+  it("returns undefined for non-Zod values", () => {
+    expect(getZodDef(null)).toBeUndefined();
+    expect(getZodDef(undefined)).toBeUndefined();
+    expect(getZodDef("hello")).toBeUndefined();
+    expect(getZodDef(42)).toBeUndefined();
+    expect(getZodDef({})).toBeUndefined();
+  });
+});
+
+describe("getZodType", () => {
+  it("returns the type string for primitive schemas", () => {
+    expect(getZodType(z.string())).toBe("string");
+    expect(getZodType(z.number())).toBe("number");
+    expect(getZodType(z.boolean())).toBe("boolean");
+  });
+
+  it("returns 'optional' for optional schemas", () => {
+    expect(getZodType(z.string().optional())).toBe("optional");
+  });
+
+  it("returns 'array' for array schemas", () => {
+    expect(getZodType(z.array(z.string()))).toBe("array");
+  });
+
+  it("returns 'object' for object schemas", () => {
+    expect(getZodType(z.object({ x: z.string() }))).toBe("object");
+  });
+
+  it("returns 'enum' for enum schemas", () => {
+    expect(getZodType(z.enum(["a", "b"]))).toBe("enum");
+  });
+
+  it("returns undefined for non-Zod values", () => {
+    expect(getZodType(null)).toBeUndefined();
+    expect(getZodType(42)).toBeUndefined();
+  });
+});
+
+describe("isOptionalType", () => {
+  it("returns true for optional schemas", () => {
+    expect(isOptionalType(z.string().optional())).toBe(true);
+    expect(isOptionalType(z.number().optional())).toBe(true);
+  });
+
+  it("returns false for required schemas", () => {
+    expect(isOptionalType(z.string())).toBe(false);
+    expect(isOptionalType(z.number())).toBe(false);
+    expect(isOptionalType(z.array(z.string()))).toBe(false);
+  });
+});
+
+describe("unwrapOptional / unwrap", () => {
+  it("strips the optional wrapper", () => {
+    const inner = z.string();
+    const optional = inner.optional();
+    const unwrapped = unwrapOptional(optional);
+    expect(getZodType(unwrapped)).toBe("string");
+  });
+
+  it("returns the schema unchanged when not optional", () => {
+    const schema = z.number();
+    expect(unwrapOptional(schema)).toBe(schema);
+  });
+
+  it("unwrap delegates to unwrapOptional", () => {
+    const optional = z.boolean().optional();
+    expect(getZodType(unwrap(optional))).toBe("boolean");
+
+    const required = z.string();
+    expect(unwrap(required)).toBe(required);
+  });
+});
+
+describe("isArrayType", () => {
+  it("returns true for z.array()", () => {
+    expect(isArrayType(z.array(z.string()))).toBe(true);
+  });
+
+  it("returns true for optional arrays", () => {
+    expect(isArrayType(z.array(z.string()).optional())).toBe(true);
+  });
+
+  it("returns false for non-array types", () => {
+    expect(isArrayType(z.string())).toBe(false);
+    expect(isArrayType(z.object({}))).toBe(false);
+    expect(isArrayType(z.number())).toBe(false);
+  });
+});
+
+describe("getArrayInnerType", () => {
+  it("returns the inner element type of an array", () => {
+    const inner = z.string();
+    const arr = z.array(inner);
+    const result = getArrayInnerType(arr);
+    expect(getZodType(result)).toBe("string");
+  });
+
+  it("returns the inner type through optional wrappers", () => {
+    const arr = z.array(z.number()).optional();
+    const result = getArrayInnerType(arr);
+    expect(getZodType(result)).toBe("number");
+  });
+
+  it("returns undefined for non-array types", () => {
+    expect(getArrayInnerType(z.string())).toBeUndefined();
+    expect(getArrayInnerType(z.object({}))).toBeUndefined();
+  });
+});
+
+describe("getEnumValues", () => {
+  it("returns values for z.enum()", () => {
+    const vals = getEnumValues(z.enum(["a", "b", "c"]));
+    expect(vals).toEqual(["a", "b", "c"]);
+  });
+
+  it("returns values for optional enums", () => {
+    const vals = getEnumValues(z.enum(["x", "y"]).optional());
+    expect(vals).toEqual(["x", "y"]);
+  });
+
+  it("returns undefined for non-enum types", () => {
+    expect(getEnumValues(z.string())).toBeUndefined();
+    expect(getEnumValues(z.number())).toBeUndefined();
+    expect(getEnumValues(z.array(z.string()))).toBeUndefined();
+  });
+});
+
+describe("getSchemaId", () => {
+  it("returns the id when registered in globalRegistry", () => {
+    const schema = z.object({ x: z.string() });
+    (schema as any).register(z.globalRegistry, { id: "ZodTestSchema" });
+    expect(getSchemaId(schema)).toBe("ZodTestSchema");
+  });
+
+  it("returns undefined for unregistered schemas", () => {
+    const schema = z.object({ y: z.number() });
+    expect(getSchemaId(schema)).toBeUndefined();
+  });
+
+  it("returns undefined for non-Zod values", () => {
+    expect(getSchemaId(null)).toBeUndefined();
+    expect(getSchemaId("string")).toBeUndefined();
+  });
+});
+
+describe("getUnionOptions", () => {
+  it("returns options for z.union()", () => {
+    const opts = getUnionOptions(z.union([z.string(), z.number()]));
+    expect(opts).toBeDefined();
+    expect(opts).toHaveLength(2);
+  });
+
+  it("returns undefined for non-union types", () => {
+    expect(getUnionOptions(z.string())).toBeUndefined();
+    expect(getUnionOptions(z.array(z.string()))).toBeUndefined();
+  });
+});
+
+describe("getObjectShape", () => {
+  it("returns shape for z.object()", () => {
+    const shape = getObjectShape(z.object({ a: z.string(), b: z.number() }));
+    expect(shape).toBeDefined();
+    expect(Object.keys(shape!)).toEqual(["a", "b"]);
+  });
+
+  it("returns undefined for non-object types", () => {
+    expect(getObjectShape(z.string())).toBeUndefined();
+    expect(getObjectShape(z.array(z.string()))).toBeUndefined();
+  });
+});
+
+describe("resolveTypeAnnotation", () => {
+  it("resolves primitive types", () => {
+    expect(resolveTypeAnnotation(z.string())).toBe("string");
+    expect(resolveTypeAnnotation(z.number())).toBe("number");
+    expect(resolveTypeAnnotation(z.boolean())).toBe("boolean");
+  });
+
+  it("resolves optional primitives", () => {
+    expect(resolveTypeAnnotation(z.string().optional())).toBe("string");
+    expect(resolveTypeAnnotation(z.number().optional())).toBe("number");
+  });
+
+  it("resolves enum types", () => {
+    const result = resolveTypeAnnotation(z.enum(["a", "b", "c"]));
+    expect(result).toBe('"a" | "b" | "c"');
+  });
+
+  it("resolves registered schema by id", () => {
+    const schema = z.object({ v: z.string() });
+    (schema as any).register(z.globalRegistry, { id: "ResolveTestType" });
+    expect(resolveTypeAnnotation(schema)).toBe("ResolveTestType");
+  });
+
+  it("resolves array of primitives", () => {
+    expect(resolveTypeAnnotation(z.array(z.string()))).toBe("string[]");
+    expect(resolveTypeAnnotation(z.array(z.number()))).toBe("number[]");
+  });
+
+  it("resolves array of registered types", () => {
+    const inner = z.object({ name: z.string() });
+    (inner as any).register(z.globalRegistry, { id: "ArrElemType" });
+    expect(resolveTypeAnnotation(z.array(inner))).toBe("ArrElemType[]");
+  });
+
+  it("resolves union types", () => {
+    const a = z.object({ x: z.string() });
+    (a as any).register(z.globalRegistry, { id: "UnionA" });
+    const b = z.object({ y: z.number() });
+    (b as any).register(z.globalRegistry, { id: "UnionB" });
+    expect(resolveTypeAnnotation(z.union([a, b]))).toBe("UnionA | UnionB");
+  });
+
+  it("resolves array of unions with parentheses", () => {
+    const a = z.object({ x: z.string() });
+    (a as any).register(z.globalRegistry, { id: "ArrUnionA" });
+    const b = z.object({ y: z.number() });
+    (b as any).register(z.globalRegistry, { id: "ArrUnionB" });
+    expect(resolveTypeAnnotation(z.array(z.union([a, b])))).toBe("(ArrUnionA | ArrUnionB)[]");
+  });
+
+  it("resolves inline object shapes", () => {
+    const obj = z.object({ src: z.string(), alt: z.string().optional() });
+    const result = resolveTypeAnnotation(obj);
+    expect(result).toBe("{src: string, alt?: string}");
+  });
+
+  it("returns undefined for unresolvable types", () => {
+    expect(resolveTypeAnnotation(null)).toBeUndefined();
+  });
+});
diff --git a/lang/js/src/defineModel.ts b/lang/js/src/defineModel.ts
new file mode 100644
index 000000000..91d2a3c75
--- /dev/null
+++ b/lang/js/src/defineModel.ts
@@ -0,0 +1,55 @@
+import { z } from "zod";
+
+/**
+ * A fully defined model with name, schema, description, and a `.ref`
+ * for type-safe cross-referencing in parent schemas.
+ */
+export interface Model<T extends z.ZodObject<any> = z.ZodObject<any>> {
+  name: string;
+  description: string;
+  schema: T;
+  /** Use in parent schemas: `z.array(ChildModel.ref)` */
+  ref: T;
+}
+
+/**
+ * Define a model with name, schema, and description.
+ * Registers the Zod schema in `z.globalRegistry` with `{ id: name, description }`
+ * so the prompt generator and sub-model auto-discovery can resolve model info.
+ *
+ * @example
+ * ```ts
+ * const LineItem = defineModel({
+ *   name: "LineItem",
+ *   description: "A single line item in an invoice",
+ *   schema: z.object({
+ *     description: z.string(),
+ *     quantity: z.number(),
+ *     unitPrice: z.number(),
+ *   }),
+ * });
+ *
+ * const Invoice = defineModel({
+ *   name: "Invoice",
+ *   description: "An invoice with line items",
+ *   schema: z.object({
+ *     invoiceNumber: z.string(),
+ *     items: z.array(LineItem.ref),
+ *   }),
+ * });
+ * ```
+ */
+export function defineModel<T extends z.ZodObject<any>>(config: {
+  name: string;
+  description: string;
+  schema: T;
+}): Model<T> {
+  (config.schema as any).register(z.globalRegistry, {
+    id: config.name,
+    description: config.description,
+  });
+  return {
+    ...config,
+    ref: config.schema,
+  };
+}
diff --git a/lang/js/src/index.ts b/lang/js/src/index.ts
new file mode 100644
index 000000000..bafe51ae8
--- /dev/null
+++ b/lang/js/src/index.ts
@@ -0,0 +1,7 @@
+export { defineModel } from "./defineModel";
+export type { Model } from "./defineModel";
+
+export { createSchema } from "./schema";
+export type { PromptOptions, Schema } from "./schema";
+
+export type { ParseResult, StreamingParser, ValidationError } from "./types";
diff --git a/lang/js/src/parser/core.ts b/lang/js/src/parser/core.ts
new file mode 100644
index 000000000..745523ee6
--- /dev/null
+++ b/lang/js/src/parser/core.ts
@@ -0,0 +1,696 @@
+import type { z } from "zod";
+import type { ParseResult, StreamingParser, ValidationError } from "../types";
+import { getZodType, isOptionalType, unwrapOptional } from "../utils/zod";
+
+export interface ParamDef {
+  name: string;
+  required: boolean;
+  defaultValue?: unknown;
+}
+
+export type ParamMap = Map<string, { params: ParamDef[] }>;
+
+/**
+ * Zod schemas keyed by type name — used for Zod-level validation
+ * of each mapped node instead of the manual required-prop check
+ * used in react-lang.
+ */
+export type ZodSchemaMap = Record<string, z.ZodObject<any>>;
+
+// ── AST node types ──────────────────────────────────────────────────────────
+
+type ASTNode =
+  | { k: "Comp"; name: string; args: ASTNode[] }
+  | { k: "Str"; v: string }
+  | { k: "Num"; v: number }
+  | { k: "Bool"; v: boolean }
+  | { k: "Null" }
+  | { k: "Arr"; els: ASTNode[] }
+  | { k: "Obj"; entries: [string, ASTNode][] }
+  | { k: "Ref"; n: string }
+  | { k: "Ph"; n: string };
+
+const enum T {
+  Newline = 0,
+  LParen = 1,
+  RParen = 2,
+  LBrack = 3,
+  RBrack = 4,
+  LBrace = 5,
+  RBrace = 6,
+  Comma = 7,
+  Colon = 8,
+  Equals = 9,
+  True = 10,
+  False = 11,
+  Null = 12,
+  EOF = 13,
+  Str = 14,
+  Num = 15,
+  Ident = 16,
+  Type = 17,
+}
+
+type Token = { t: T; v?: string | number };
+
+function autoClose(input: string): { text: string; wasIncomplete: boolean } {
+  const stack: string[] = [];
+  let inStr = false,
+    esc = false;
+
+  for (let i = 0; i < input.length; i++) {
+    const c = input[i];
+
+    if (esc) {
+      esc = false;
+      continue;
+    }
+    if (c === "\\" && inStr) {
+      esc = true;
+      continue;
+    }
+    if (c === '"') {
+      inStr = !inStr;
+      continue;
+    }
+    if (inStr) continue;
+
+    if (c === "(" || c === "[" || c === "{") stack.push(c);
+    else if (c === ")" && stack[stack.length - 1] === "(") stack.pop();
+    else if (c === "]" && stack[stack.length - 1] === "[") stack.pop();
+    else if (c === "}" && stack[stack.length - 1] === "{") stack.pop();
+  }
+
+  const wasIncomplete = inStr || stack.length > 0;
+  if (!wasIncomplete) return { text: input, wasIncomplete: false };
+
+  let out = input;
+  if (inStr) {
+    if (esc) out += "\\";
+    out += '"';
+  }
+  for (let j = stack.length - 1; j >= 0; j--)
+    out += stack[j] === "(" ? ")" : stack[j] === "[" ? "]" : "}";
+
+  return { text: out, wasIncomplete: true };
+}
+
+function tokenize(src: string): Token[] {
+  const tokens: Token[] = [];
+  let i = 0;
+  const n = src.length;
+
+  while (i < n) {
+    while (i < n && (src[i] === " " || src[i] === "\t" || src[i] === "\r")) i++;
+    if (i >= n) break;
+
+    const c = src[i];
+
+    if (c === "\n") {
+      tokens.push({ t: T.Newline });
+      i++;
+      continue;
+    }
+    if (c === "(") {
+      tokens.push({ t: T.LParen });
+      i++;
+      continue;
+    }
+    if (c === ")") {
+      tokens.push({ t: T.RParen });
+      i++;
+      continue;
+    }
+    if (c === "[") {
+      tokens.push({ t: T.LBrack });
+      i++;
+      continue;
+    }
+    if (c === "]") {
+      tokens.push({ t: T.RBrack });
+      i++;
+      continue;
+    }
+    if (c === "{") {
+      tokens.push({ t: T.LBrace });
+      i++;
+      continue;
+    }
+    if (c === "}") {
+      tokens.push({ t: T.RBrace });
+      i++;
+      continue;
+    }
+    if (c === ",") {
+      tokens.push({ t: T.Comma });
+      i++;
+      continue;
+    }
+    if (c === ":") {
+      tokens.push({ t: T.Colon });
+      i++;
+      continue;
+    }
+    if (c === "=") {
+      tokens.push({ t: T.Equals });
+      i++;
+      continue;
+    }
+
+    if (c === '"') {
+      const start = i;
+      i++;
+
+      let isClosed = false;
+      while (i < n) {
+        if (src[i] === "\\") {
+          i += 2;
+        } else if (src[i] === '"') {
+          i++;
+          isClosed = true;
+          break;
+        } else {
+          i++;
+        }
+      }
+
+      const rawString = src.slice(start, i);
+
+      try {
+        const validJsonString = isClosed ? rawString : rawString + '"';
+        tokens.push({ t: T.Str, v: JSON.parse(validJsonString) });
+      } catch {
+        const stripped = rawString.replace(/^"|"$/g, "");
+        tokens.push({ t: T.Str, v: stripped });
+      }
+      continue;
+    }
+
+    const isDigit = c >= "0" && c <= "9";
+    const isNegDigit = c === "-" && i + 1 < n && src[i + 1] >= "0" && src[i + 1] <= "9";
+    if (isDigit || isNegDigit) {
+      const start = i;
+      if (src[i] === "-") i++;
+      while (i < n && src[i] >= "0" && src[i] <= "9") i++;
+      if (i < n && src[i] === ".") {
+        i++;
+        while (i < n && src[i] >= "0" && src[i] <= "9") i++;
+      }
+      if (i < n && (src[i] === "e" || src[i] === "E")) {
+        i++;
+        if (i < n && (src[i] === "+" || src[i] === "-")) i++;
+        while (i < n && src[i] >= "0" && src[i] <= "9") i++;
+      }
+      tokens.push({ t: T.Num, v: +src.slice(start, i) });
+      continue;
+    }
+
+    const isAlpha = (c >= "a" && c <= "z") || (c >= "A" && c <= "Z") || c === "_";
+    if (isAlpha) {
+      const start = i;
+      while (
+        i < n &&
+        ((src[i] >= "a" && src[i] <= "z") ||
+          (src[i] >= "A" && src[i] <= "Z") ||
+          (src[i] >= "0" && src[i] <= "9") ||
+          src[i] === "_")
+      )
+        i++;
+
+      const word = src.slice(start, i);
+
+      if (word === "true") {
+        tokens.push({ t: T.True });
+        continue;
+      }
+      if (word === "false") {
+        tokens.push({ t: T.False });
+        continue;
+      }
+      if (word === "null" || word === "undefined") {
+        tokens.push({ t: T.Null });
+        continue;
+      }
+
+      const kind = c >= "A" && c <= "Z" ? T.Type : T.Ident;
+      tokens.push({ t: kind, v: word });
+      continue;
+    }
+
+    i++;
+  }
+
+  tokens.push({ t: T.EOF });
+  return tokens;
+}
+
+interface RawStmt {
+  id: string;
+  tokens: Token[];
+}
+
+function split(tokens: Token[]): RawStmt[] {
+  const stmts: RawStmt[] = [];
+  let pos = 0;
+
+  while (pos < tokens.length) {
+    while (pos < tokens.length && tokens[pos].t === T.Newline) pos++;
+    if (pos >= tokens.length || tokens[pos].t === T.EOF) break;
+
+    const tok = tokens[pos];
+    if (tok.t !== T.Ident && tok.t !== T.Type) {
+      while (pos < tokens.length && tokens[pos].t !== T.Newline && tokens[pos].t !== T.EOF) pos++;
+      continue;
+    }
+    const id = tok.v as string;
+    pos++;
+
+    if (pos >= tokens.length || tokens[pos].t !== T.Equals) {
+      while (pos < tokens.length && tokens[pos].t !== T.Newline && tokens[pos].t !== T.EOF) pos++;
+      continue;
+    }
+    pos++;
+
+    const expr: Token[] = [];
+    let depth = 0;
+    while (pos < tokens.length && tokens[pos].t !== T.EOF) {
+      const tt = tokens[pos].t;
+      if (tt === T.Newline && depth <= 0) break;
+      if (tt === T.Newline) {
+        pos++;
+        continue;
+      }
+      if (tt === T.LParen || tt === T.LBrack || tt === T.LBrace) depth++;
+      else if (tt === T.RParen || tt === T.RBrack || tt === T.RBrace) depth--;
+      expr.push(tokens[pos++]);
+    }
+
+    if (expr.length) stmts.push({ id, tokens: expr });
+  }
+
+  return stmts;
+}
+
+function parseTokens(tokens: Token[]): ASTNode {
+  let pos = 0;
+  const cur = (): Token => tokens[pos] ?? { t: T.EOF };
+  const adv = () => pos++;
+  const eat = (kind: T) => {
+    if (cur().t === kind) adv();
+  };
+
+  function parseExpr(): ASTNode {
+    const tok = cur();
+
+    if (tok.t === T.Type) {
+      return tokens[pos + 1]?.t === T.LParen
+        ? parseComp()
+        : (adv(), { k: "Ref", n: tok.v as string });
+    }
+    if (tok.t === T.Str) {
+      adv();
+      return { k: "Str", v: tok.v as string };
+    }
+    if (tok.t === T.Num) {
+      adv();
+      return { k: "Num", v: tok.v as number };
+    }
+    if (tok.t === T.True) {
+      adv();
+      return { k: "Bool", v: true };
+    }
+    if (tok.t === T.False) {
+      adv();
+      return { k: "Bool", v: false };
+    }
+    if (tok.t === T.Null) {
+      adv();
+      return { k: "Null" };
+    }
+    if (tok.t === T.LBrack) return parseArr();
+    if (tok.t === T.LBrace) return parseObj();
+    if (tok.t === T.Ident) {
+      adv();
+      return { k: "Ref", n: tok.v as string };
+    }
+
+    adv();
+    return { k: "Null" };
+  }
+
+  function parseComp(): ASTNode {
+    const name = cur().v as string;
+    adv();
+    eat(T.LParen);
+    const args: ASTNode[] = [];
+    while (cur().t !== T.RParen && cur().t !== T.EOF) {
+      args.push(parseExpr());
+      if (cur().t === T.Comma) adv();
+    }
+    eat(T.RParen);
+    return { k: "Comp", name, args };
+  }
+
+  function parseArr(): ASTNode {
+    adv();
+    const els: ASTNode[] = [];
+    while (cur().t !== T.RBrack && cur().t !== T.EOF) {
+      els.push(parseExpr());
+      if (cur().t === T.Comma) adv();
+    }
+    eat(T.RBrack);
+    return { k: "Arr", els };
+  }
+
+  function parseObj(): ASTNode {
+    adv();
+    const entries: [string, ASTNode][] = [];
+    while (cur().t !== T.RBrace && cur().t !== T.EOF) {
+      const kt = cur();
+      const key =
+        kt.t === T.Ident || kt.t === T.Str || kt.t === T.Type || kt.t === T.Num
+          ? (adv(), String(kt.v))
+          : (adv(), "?");
+      eat(T.Colon);
+      entries.push([key, parseExpr()]);
+      if (cur().t === T.Comma) adv();
+    }
+    eat(T.RBrace);
+    return { k: "Obj", entries };
+  }
+
+  return parseExpr();
+}
+
+function resolveNode(
+  node: ASTNode,
+  syms: Map<string, ASTNode>,
+  unres: string[],
+  visited: Set<string>,
+): ASTNode {
+  if (node.k === "Ref") {
+    const { n } = node;
+    if (visited.has(n)) {
+      unres.push(n);
+      return { k: "Ph", n };
+    }
+    if (!syms.has(n)) {
+      unres.push(n);
+      return { k: "Ph", n };
+    }
+
+    visited.add(n);
+    const resolved = resolveNode(syms.get(n)!, syms, unres, visited);
+    visited.delete(n);
+    return resolved;
+  }
+
+  if (node.k === "Comp")
+    return {
+      ...node,
+      args: node.args.map((a) => resolveNode(a, syms, unres, visited)),
+    };
+  if (node.k === "Arr")
+    return {
+      ...node,
+      els: node.els.map((e) => resolveNode(e, syms, unres, visited)),
+    };
+  if (node.k === "Obj")
+    return {
+      ...node,
+      entries: node.entries.map(([k, v]) => [k, resolveNode(v, syms, unres, visited)]),
+    };
+
+  return node;
+}
+
+type JsonVal = string | number | boolean | null | JsonVal[] | { [k: string]: JsonVal };
+
+function toJson(
+  node: ASTNode,
+  partial: boolean,
+  errors: ValidationError[],
+  cat: ParamMap | undefined,
+  zodSchemas: ZodSchemaMap | undefined,
+): JsonVal {
+  if (node.k === "Str") return node.v;
+  if (node.k === "Num") return node.v;
+  if (node.k === "Bool") return node.v;
+  if (node.k === "Null") return null;
+  if (node.k === "Arr") {
+    const items: JsonVal[] = [];
+    for (const e of node.els) {
+      if (e.k === "Ph") continue;
+      const value = toJson(e, partial, errors, cat, zodSchemas);
+      if (e.k === "Comp" && value === null) continue;
+      items.push(value);
+    }
+    return items;
+  }
+  if (node.k === "Obj") {
+    const o: { [k: string]: JsonVal } = {};
+    for (const [k, v] of node.entries) o[k] = toJson(v, partial, errors, cat, zodSchemas);
+    return o;
+  }
+  if (node.k === "Comp")
+    return mapNode(node, partial, errors, cat, zodSchemas) as unknown as JsonVal;
+  if (node.k === "Ph") return null;
+  return null;
+}
+
+/**
+ * Map a Comp AST node to a plain JS object.
+ *
+ * Key difference from react-lang: returns the Zod-validated props object
+ * directly instead of wrapping in `{ type: "element", typeName, props, partial }`.
+ * Validation uses `zodSchema.safeParse()` for full Zod validation.
+ */
+function mapNode(
+  node: ASTNode,
+  partial: boolean,
+  errors: ValidationError[],
+  cat: ParamMap | undefined,
+  zodSchemas: ZodSchemaMap | undefined,
+): JsonVal {
+  if (node.k === "Ph") return null;
+  if (node.k !== "Comp") return null;
+
+  const { name, args } = node;
+  const def = cat?.get(name);
+  const props: { [k: string]: JsonVal } = {};
+
+  if (def) {
+    for (let i = 0; i < def.params.length && i < args.length; i++)
+      props[def.params[i].name] = toJson(args[i], partial, errors, cat, zodSchemas);
+  } else {
+    props._args = args.map((a) => toJson(a, partial, errors, cat, zodSchemas));
+  }
+
+  const zodSchema = zodSchemas?.[name];
+  if (zodSchema) {
+    const shape = zodSchema.shape as Record<string, unknown> | undefined;
+    if (shape) {
+      for (const key of Object.keys(props)) {
+        if (props[key] === null && isOptionalType(shape[key])) {
+          const inner = unwrapOptional(shape[key]);
+          if (getZodType(inner) !== "nullable") {
+            delete props[key];
+          }
+        }
+      }
+    }
+
+    const result = zodSchema.safeParse(props);
+    if (!result.success) {
+      for (const issue of result.error.issues) {
+        errors.push({
+          type: name,
+          path: "/" + issue.path.join("/"),
+          message: issue.message,
+        });
+      }
+      return null;
+    }
+    return result.data as JsonVal;
+  }
+
+  return props;
+}
+
+function emptyResult(incomplete = true): ParseResult {
+  return {
+    root: null,
+    meta: {
+      rootType: null,
+      incomplete,
+      unresolved: [],
+      statementCount: 0,
+      validationErrors: [],
+    },
+  };
+}
+
+function buildResult(
+  syms: Map<string, ASTNode>,
+  firstId: string,
+  wasIncomplete: boolean,
+  stmtCount: number,
+  cat: ParamMap | undefined,
+  zodSchemas: ZodSchemaMap | undefined,
+): ParseResult {
+  if (!syms.has(firstId)) return emptyResult(wasIncomplete);
+
+  const unres: string[] = [];
+  const resolved = resolveNode(syms.get(firstId)!, syms, unres, new Set());
+  const errors: ValidationError[] = [];
+  const root = mapNode(resolved, wasIncomplete, errors, cat, zodSchemas);
+  const rootType = resolved.k === "Comp" ? resolved.name : null;
+
+  return {
+    root,
+    meta: {
+      rootType,
+      incomplete: wasIncomplete,
+      unresolved: unres,
+      statementCount: stmtCount,
+      validationErrors: errors,
+    },
+  };
+}
+
+export function parse(input: string, cat?: ParamMap, zodSchemas?: ZodSchemaMap): ParseResult {
+  const trimmed = input.trim();
+  if (!trimmed) return emptyResult();
+
+  const { text, wasIncomplete } = autoClose(trimmed);
+  const stmts = split(tokenize(text));
+  if (!stmts.length) return emptyResult(wasIncomplete);
+
+  const syms = new Map<string, ASTNode>();
+  let firstId = "";
+  for (const s of stmts) {
+    syms.set(s.id, parseTokens(s.tokens));
+    if (!firstId) firstId = s.id;
+  }
+
+  return buildResult(syms, firstId, wasIncomplete, stmts.length, cat, zodSchemas);
+}
+
+export function createStreamParser(cat?: ParamMap, zodSchemas?: ZodSchemaMap): StreamingParser {
+  let buf = "";
+  let completedEnd = 0;
+  const completedSyms = new Map<string, ASTNode>();
+
+  let completedCount = 0;
+  let firstId = "";
+
+  function addStmt(text: string) {
+    for (const s of split(tokenize(text))) {
+      completedSyms.set(s.id, parseTokens(s.tokens));
+      completedCount++;
+      if (!firstId) firstId = s.id;
+    }
+  }
+
+  function scanNewCompleted(): number {
+    let depth = 0,
+      inStr = false,
+      esc = false;
+    let stmtStart = completedEnd;
+
+    for (let i = completedEnd; i < buf.length; i++) {
+      const c = buf[i];
+      if (esc) {
+        esc = false;
+        continue;
+      }
+      if (c === "\\" && inStr) {
+        esc = true;
+        continue;
+      }
+      if (c === '"') {
+        inStr = !inStr;
+        continue;
+      }
+      if (inStr) continue;
+
+      if (c === "(" || c === "[" || c === "{") depth++;
+      else if (c === ")" || c === "]" || c === "}") depth--;
+      else if (c === "\n" && depth <= 0) {
+        const t = buf.slice(stmtStart, i).trim();
+        if (t) addStmt(t);
+        stmtStart = i + 1;
+        completedEnd = i + 1;
+      }
+    }
+
+    return stmtStart;
+  }
+
+  function currentResult(): ParseResult {
+    const pendingStart = scanNewCompleted();
+    const pendingText = buf.slice(pendingStart).trim();
+
+    if (!pendingText) {
+      if (completedCount === 0) return emptyResult();
+      return buildResult(completedSyms, firstId, false, completedCount, cat, zodSchemas);
+    }
+
+    const { text: closed, wasIncomplete } = autoClose(pendingText);
+    const stmts = split(tokenize(closed));
+
+    if (!stmts.length) {
+      if (completedCount === 0) return emptyResult(wasIncomplete);
+      return buildResult(completedSyms, firstId, wasIncomplete, completedCount, cat, zodSchemas);
+    }
+
+    const allSyms = new Map(completedSyms);
+    for (const s of stmts) allSyms.set(s.id, parseTokens(s.tokens));
+
+    const fid = firstId || stmts[0].id;
+    return buildResult(allSyms, fid, wasIncomplete, completedCount + stmts.length, cat, zodSchemas);
+  }
+
+  function nullRootIfUnresolved(result: ParseResult): ParseResult {
+    if (result.meta.unresolved.length > 0) {
+      return { ...result, root: null };
+    }
+    return result;
+  }
+
+  return {
+    push(chunk) {
+      buf += chunk;
+      return nullRootIfUnresolved(currentResult());
+    },
+    getResult() {
+      return nullRootIfUnresolved(currentResult());
+    },
+  };
+}
+
+export function compileSchema(schema: {
+  $defs?: Record<
+    string,
+    {
+      properties?: Record<string, unknown>;
+      required?: string[];
+    }
+  >;
+}): ParamMap {
+  const map: ParamMap = new Map();
+  const defs = schema.$defs ?? {};
+
+  for (const [name, def] of Object.entries(defs)) {
+    const properties = def.properties ?? {};
+    const required = def.required ?? [];
+    const params = Object.keys(properties).map((k) => ({
+      name: k,
+      required: required.includes(k),
+      defaultValue: (properties[k] as any)?.default,
+    }));
+    map.set(name, { params });
+  }
+
+  return map;
+}
diff --git a/lang/js/src/parser/prompt.ts b/lang/js/src/parser/prompt.ts
new file mode 100644
index 000000000..8732bcc9c
--- /dev/null
+++ b/lang/js/src/parser/prompt.ts
@@ -0,0 +1,155 @@
+import type { Model } from "../defineModel";
+import { isArrayType, isOptionalType, resolveTypeAnnotation } from "../utils/zod";
+
+export interface PromptOptions {
+  preamble?: string;
+  additionalRules?: string[];
+  examples?: string[];
+}
+
+export interface PromptInput {
+  models: Record<string, Model>;
+  root: string | string[] | undefined;
+}
+
+function rootDisplay(root: string | string[] | undefined): string {
+  return Array.isArray(root) ? root.join(" | ") : (root ?? "Root");
+}
+
+function syntaxRules(root: string | string[] | undefined): string {
+  const rootRule = Array.isArray(root)
+    ? `\`root\` is the entry point — every program must define \`root\` as one of: ${root.map((r) => `\`${r}(...)\``).join(", ")}`
+    : `\`root\` is the entry point — every program must define \`root = ${root ?? "Root"}(...)\``;
+
+  return `
+Respond using OpenUI Lang, a structured output format. Your ENTIRE response must be valid OpenUI Lang — no markdown, no explanations.
+
+## Syntax Rules
+
+1. Each statement is on its own line: \`identifier = Expression\`
+2. ${rootRule}
+3. Expressions are: strings ("..."), numbers, booleans (true/false), arrays ([...]), objects ({...}), or type calls TypeName(arg1, arg2, ...)
+4. Use references for readability: define \`name = ...\` on one line, then use \`name\` later
+5. EVERY variable (except root) MUST be referenced by at least one other variable. Unreferenced variables are silently dropped. Always include defined variables in their parent's children/items array.
+6. Arguments are POSITIONAL (order matters, not names)
+7. Arguments are POSITIONAL — you CANNOT skip optional arguments in the middle. Pass null explicitly for any optional argument you want to omit, e.g. TypeName(arg1, null, arg3).
+8. No operators, no logic, no variables — only declarations
+9. Strings use double quotes with backslash escaping`;
+}
+
+function streamingRules(root: string | string[] | undefined): string {
+  const display = rootDisplay(root);
+  return `## Hoisting & Forward References
+
+OpenUI Lang supports hoisting: a reference can be used BEFORE it is defined. The parser resolves all references after the full input is parsed.
+
+**Recommended statement order:**
+1. \`root = ${display}(...)\` — top-level structure first
+2. Type definitions — fill in as they are defined
+3. Data values — leaf content last
+
+Always write the root = ${display}(...) statement first.`;
+}
+
+function importantRules(root: string | string[] | undefined): string {
+  const display = rootDisplay(root);
+  return `## Important Rules
+- ALWAYS start with root = ${display}(...)
+- Write statements in TOP-DOWN order: root → types → data (leverages hoisting)
+- Each statement on its own line
+- No trailing text or explanations — output ONLY OpenUI Lang code
+- Generate realistic/plausible data when extracting information
+- NEVER define a variable without referencing it from the tree. Every variable must be reachable from root.`;
+}
+
+// ─── Field analysis ───
+
+interface FieldInfo {
+  name: string;
+  isOptional: boolean;
+  isArray: boolean;
+  typeAnnotation?: string;
+}
+
+function analyzeFields(shape: Record<string, unknown>): FieldInfo[] {
+  return Object.entries(shape).map(([name, schema]) => ({
+    name,
+    isOptional: isOptionalType(schema),
+    isArray: isArrayType(schema),
+    typeAnnotation: resolveTypeAnnotation(schema),
+  }));
+}
+
+// ─── Signature generation ───
+
+function buildSignature(typeName: string, fields: FieldInfo[]): string {
+  const params = fields.map((f) => {
+    if (f.typeAnnotation) {
+      return f.isOptional ? `${f.name}?: ${f.typeAnnotation}` : `${f.name}: ${f.typeAnnotation}`;
+    }
+    if (f.isArray) {
+      return f.isOptional ? `[${f.name}]?` : `[${f.name}]`;
+    }
+    return f.isOptional ? `${f.name}?` : f.name;
+  });
+  return `${typeName}(${params.join(", ")})`;
+}
+
+function buildTypeLine(typeName: string, def: Model): string {
+  const fields = analyzeFields(def.schema.shape);
+  const sig = buildSignature(typeName, fields);
+  if (def.description) {
+    return `${sig} — ${def.description}`;
+  }
+  return sig;
+}
+
+// ─── Prompt assembly ───
+
+function generateTypeSignatures(input: PromptInput): string {
+  const lines: string[] = [
+    "## Type Signatures",
+    "",
+    "Arguments marked with ? are optional. Sub-types can be inline or referenced; prefer references for better readability.",
+    "",
+  ];
+
+  for (const [name, def] of Object.entries(input.models)) {
+    lines.push(buildTypeLine(name, def));
+  }
+
+  return lines.join("\n");
+}
+
+export function generatePrompt(input: PromptInput, options?: PromptOptions): string {
+  const parts: string[] = [];
+
+  parts.push(options?.preamble ?? "");
+  parts.push(syntaxRules(input.root));
+  parts.push("");
+  parts.push(generateTypeSignatures(input));
+  parts.push("");
+  parts.push(streamingRules(input.root));
+
+  const examples = options?.examples;
+  if (examples?.length) {
+    parts.push("");
+    parts.push("## Examples");
+    parts.push("");
+    for (const ex of examples) {
+      parts.push(ex);
+      parts.push("");
+    }
+  }
+
+  parts.push(importantRules(input.root));
+
+  if (options?.additionalRules?.length) {
+    parts.push("");
+    for (const rule of options.additionalRules) {
+      parts.push(`- ${rule}`);
+    }
+  }
+
+  return parts.join("\n");
+}
diff --git a/lang/js/src/schema.ts b/lang/js/src/schema.ts
new file mode 100644
index 000000000..fc2726acf
--- /dev/null
+++ b/lang/js/src/schema.ts
@@ -0,0 +1,76 @@
+import { z } from "zod";
+import type { Model } from "./defineModel";
+import { collectModels } from "./utils/collectModels";
+import { compileSchema, createStreamParser, parse, type ZodSchemaMap } from "./parser/core";
+import { generatePrompt, type PromptOptions } from "./parser/prompt";
+import type { ParseResult, StreamingParser } from "./types";
+
+export type { PromptOptions } from "./parser/prompt";
+
+export interface Schema {
+  readonly models: Record<string, Model>;
+  readonly root: string | string[] | undefined;
+  prompt(options?: PromptOptions): string;
+  toJSONSchema(): object;
+  parse(input: string): ParseResult<unknown>;
+  streamingParser(): StreamingParser<unknown>;
+}
+
+export function createSchema(rootModels: Model[]): Schema {
+  const allModels = collectModels(rootModels);
+
+  const modelsRecord: Record<string, Model> = {};
+  for (const m of allModels) {
+    if (!z.globalRegistry.has(m.schema)) {
+      (m.schema as any).register(z.globalRegistry, { id: m.name, description: m.description });
+    }
+    modelsRecord[m.name] = m;
+  }
+
+  const root: string | string[] | undefined =
+    rootModels.length === 0
+      ? undefined
+      : rootModels.length === 1
+        ? rootModels[0].name
+        : rootModels.map((m) => m.name);
+
+  const combinedSchema = z.object(
+    Object.fromEntries(Object.entries(modelsRecord).map(([k, v]) => [k, v.schema])) as any,
+  );
+  const jsonSchema = z.toJSONSchema(combinedSchema);
+  const paramMap = compileSchema(jsonSchema as any);
+
+  const zodSchemas: ZodSchemaMap = {};
+  for (const [name, def] of Object.entries(modelsRecord)) {
+    zodSchemas[name] = def.schema;
+  }
+
+  const schema: Schema = {
+    models: modelsRecord,
+    root,
+
+    prompt(options?: PromptOptions): string {
+      return generatePrompt(
+        {
+          models: modelsRecord,
+          root,
+        },
+        options,
+      );
+    },
+
+    toJSONSchema(): object {
+      return jsonSchema;
+    },
+
+    parse(inputText: string): ParseResult<unknown> {
+      return parse(inputText, paramMap, zodSchemas);
+    },
+
+    streamingParser(): StreamingParser<unknown> {
+      return createStreamParser(paramMap, zodSchemas);
+    },
+  };
+
+  return schema;
+}
diff --git a/lang/js/src/types.ts b/lang/js/src/types.ts
new file mode 100644
index 000000000..afecce8e2
--- /dev/null
+++ b/lang/js/src/types.ts
@@ -0,0 +1,51 @@
+/**
+ * A validation error from the parser.
+ * When a type has missing required props or fails Zod validation,
+ * the node is redacted (dropped as null) and errors are recorded here.
+ */
+export interface ValidationError {
+  /** Type name, e.g. "Contact", "Invoice". */
+  type: string;
+  /** JSON Pointer path within the props object, e.g. "/title", "". */
+  path: string;
+  /** Human-readable error message. */
+  message: string;
+}
+
+/**
+ * The output of a single `parse()` call.
+ *
+ * During streaming, each chunk produces a new ParseResult as the
+ * accumulated text is re-parsed. The `root` progressively resolves
+ * from null → partial object → complete object.
+ */
+export interface ParseResult<T = unknown> {
+  /** The root data object, or null if parsing hasn't produced one yet. */
+  root: T | null;
+  meta: {
+    /** The type name of the root model that was matched, or null if none. */
+    rootType: string | null;
+    /** True if the parser detected truncated/incomplete input. */
+    incomplete: boolean;
+    /** Names of references used but not yet defined (dropped as null in output). */
+    unresolved: string[];
+    /** Total number of `identifier = Expression` statements parsed. */
+    statementCount: number;
+    /**
+     * Validation errors. Types with missing required props or failing Zod
+     * validation are redacted (dropped as null) and listed here.
+     */
+    validationErrors: ValidationError[];
+  };
+}
+
+/**
+ * A streaming parser that accumulates chunks of OpenUI Lang text
+ * and produces updated ParseResults on each push.
+ */
+export interface StreamingParser<T = unknown> {
+  /** Feed the next SSE/stream chunk and get the latest ParseResult. */
+  push(chunk: string): ParseResult<T>;
+  /** Get the latest ParseResult without consuming new data. */
+  getResult(): ParseResult<T>;
+}
diff --git a/lang/js/src/utils/collectModels.ts b/lang/js/src/utils/collectModels.ts
new file mode 100644
index 000000000..d4bc08bba
--- /dev/null
+++ b/lang/js/src/utils/collectModels.ts
@@ -0,0 +1,77 @@
+import { z } from "zod";
+import type { Model } from "../defineModel";
+import { getZodDef, getZodType } from "./zod";
+
+/**
+ * Walk root models' `schema` fields recursively and collect all named sub-models.
+ * Sub-models are discovered via `z.globalRegistry` — any schema registered with
+ * `{ id, description }` is treated as a named model.
+ *
+ * Returns roots first, followed by all discovered sub-models (deduplicated by name).
+ */
+export function collectModels(roots: Model[]): Model[] {
+  const seen = new Set<string>(roots.map((r) => r.name));
+  const results: Model[] = [...roots];
+
+  for (const root of roots) {
+    collectFromSchema(root.schema, seen, results);
+  }
+
+  return results;
+}
+
+function collectFromSchema(
+  schema: unknown,
+  seen: Set<string>,
+  results: Model[],
+): void {
+  if (!schema || typeof schema !== "object") return;
+
+  const def = getZodDef(schema);
+  if (!def) return;
+
+  const type = getZodType(schema);
+
+  let children: unknown[] = [];
+  if (type === "object") {
+    const shape = def.shape;
+    if (shape && typeof shape === "object") {
+      children = Object.values(shape as Record<string, unknown>);
+    }
+  } else if (type === "array") {
+    const element = def.element ?? def.innerType;
+    if (element != null) children = [element];
+  } else if (type === "optional") {
+    const inner = def.innerType;
+    if (inner != null) children = [inner];
+  } else if (type === "union") {
+    if (Array.isArray(def.options)) children = def.options;
+  }
+
+  for (const child of children) {
+    if (!child || typeof child !== "object") continue;
+
+    try {
+      const meta = z.globalRegistry.get(child as z.ZodType);
+      if (meta?.id && meta?.description) {
+        const name = meta.id as string;
+        if (!seen.has(name)) {
+          seen.add(name);
+          results.push({
+            name,
+            description: meta.description as string,
+            schema: child as z.ZodObject<any>,
+            ref: child as z.ZodObject<any>,
+          });
+          // Recurse into this model's schema to find its sub-models
+          collectFromSchema(child, seen, results);
+        }
+      } else {
+        // Not a registered model, but might contain registered models
+        collectFromSchema(child, seen, results);
+      }
+    } catch {
+      collectFromSchema(child, seen, results);
+    }
+  }
+}
diff --git a/lang/js/src/utils/zod.ts b/lang/js/src/utils/zod.ts
new file mode 100644
index 000000000..106fac749
--- /dev/null
+++ b/lang/js/src/utils/zod.ts
@@ -0,0 +1,155 @@
+import { z } from "zod";
+
+export function getZodDef(schema: unknown): any {
+  return (schema as any)?._zod?.def;
+}
+
+export function getZodType(schema: unknown): string | undefined {
+  return getZodDef(schema)?.type;
+}
+
+export function isOptionalType(schema: unknown): boolean {
+  return getZodType(schema) === "optional";
+}
+
+export function unwrapOptional(schema: unknown): unknown {
+  const def = getZodDef(schema);
+  if (def?.type === "optional") return def.innerType;
+  return schema;
+}
+
+/** Strip optional wrapper to reach the core schema. */
+export function unwrap(schema: unknown): unknown {
+  return unwrapOptional(schema);
+}
+
+export function isArrayType(schema: unknown): boolean {
+  const s = unwrap(schema);
+  return getZodType(s) === "array";
+}
+
+export function getArrayInnerType(schema: unknown): unknown | undefined {
+  const s = unwrap(schema);
+  const def = getZodDef(s);
+  if (def?.type === "array") return def.element ?? def.innerType;
+  return undefined;
+}
+
+export function getEnumValues(schema: unknown): string[] | undefined {
+  const s = unwrap(schema);
+  const def = getZodDef(s);
+  if (def?.type !== "enum") return undefined;
+  if (Array.isArray(def.values)) return def.values;
+  if (def.entries && typeof def.entries === "object") return Object.keys(def.entries);
+  return undefined;
+}
+
+export function getSchemaId(schema: unknown): string | undefined {
+  try {
+    const meta = z.globalRegistry.get(schema as z.ZodType);
+    return meta?.id;
+  } catch {
+    return undefined;
+  }
+}
+
+export function getUnionOptions(schema: unknown): unknown[] | undefined {
+  const def = getZodDef(schema);
+  if (def?.type === "union" && Array.isArray(def.options)) return def.options;
+  return undefined;
+}
+
+export function getObjectShape(schema: unknown): Record<string, unknown> | undefined {
+  const def = getZodDef(schema);
+  if (def?.type === "object" && def.shape && typeof def.shape === "object")
+    return def.shape as Record<string, unknown>;
+  return undefined;
+}
+
+/**
+ * Resolve the type annotation for a schema field.
+ * Returns a human-readable type string for the schema.
+ *
+ * Examples:
+ *  - z.string()                   → "string"
+ *  - z.number()                   → "number"
+ *  - z.boolean()                  → "boolean"
+ *  - z.enum(["a","b"])            → '"a" | "b"'
+ *  - z.array(TabItemSchema)       → "TabItem[]"
+ *  - z.union([Input, TextArea])   → "Input | TextArea"
+ *  - z.array(z.union([A, B]))     → "(A | B)[]"
+ *  - ButtonGroupSchema            → "ButtonGroup"
+ *  - z.object({src: z.string()})  → "{src: string}" (inline when unregistered)
+ */
+export function resolveTypeAnnotation(schema: unknown): string | undefined {
+  const inner = unwrap(schema);
+
+  const directId = getSchemaId(inner);
+  if (directId) return directId;
+
+  const unionOpts = getUnionOptions(inner);
+  if (unionOpts) {
+    const resolved = unionOpts.map((o) => resolveTypeAnnotation(o));
+    const names = resolved.filter(Boolean) as string[];
+    if (names.length > 0) {
+      if (names.length < unionOpts.length) {
+        console.warn(
+          `[prompt] Partially resolved union: ${names.length}/${unionOpts.length} options resolved`,
+        );
+      }
+      return names.join(" | ");
+    }
+  }
+
+  if (isArrayType(schema)) {
+    const arrayInner = getArrayInnerType(schema);
+    if (!arrayInner) return undefined;
+
+    const innerType = resolveTypeAnnotation(arrayInner);
+    if (innerType) {
+      const isUnion = getUnionOptions(unwrap(arrayInner)) !== undefined;
+      return isUnion ? `(${innerType})[]` : `${innerType}[]`;
+    }
+
+    console.warn(
+      `[prompt] Could not resolve array element type (inner zod type: "${getZodType(arrayInner) ?? "unknown"}")`,
+    );
+    return undefined;
+  }
+
+  const zodType = getZodType(inner);
+  if (zodType === "string") return "string";
+  if (zodType === "number") return "number";
+  if (zodType === "boolean") return "boolean";
+
+  const enumVals = getEnumValues(inner);
+  if (enumVals) return enumVals.map((v) => `"${v}"`).join(" | ");
+
+  if (zodType === "literal") {
+    const vals = getZodDef(inner)?.values;
+    if (Array.isArray(vals) && vals.length === 1) {
+      const v = vals[0];
+      return typeof v === "string" ? `"${v}"` : String(v);
+    }
+  }
+
+  const shape = getObjectShape(inner);
+  if (shape) {
+    const fields = Object.entries(shape).map(([name, fieldSchema]) => {
+      const opt = isOptionalType(fieldSchema) ? "?" : "";
+      const fieldType = resolveTypeAnnotation(fieldSchema as z.ZodType);
+      return fieldType ? `${name}${opt}: ${fieldType}` : `${name}${opt}`;
+    });
+    return `{${fields.join(", ")}}`;
+  }
+
+  if (zodType === "lazy") {
+    console.warn(
+      `[prompt] z.lazy() schemas are not resolved — remove z.lazy() wrapper from the schema`,
+    );
+  } else if (zodType) {
+    console.warn(`[prompt] Unresolved schema type: "${zodType}"`);
+  }
+
+  return undefined;
+}
diff --git a/lang/js/tsconfig.eslint.json b/lang/js/tsconfig.eslint.json
new file mode 100644
index 000000000..054a8ccc7
--- /dev/null
+++ b/lang/js/tsconfig.eslint.json
@@ -0,0 +1,6 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "./tsconfig.json",
+  "include": ["src/**/*"],
+  "exclude": []
+}
diff --git a/lang/js/tsconfig.json b/lang/js/tsconfig.json
new file mode 100644
index 000000000..5419616d1
--- /dev/null
+++ b/lang/js/tsconfig.json
@@ -0,0 +1,17 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "extends": "../../tsconfig.json",
+  "include": ["src/**/*"],
+  "exclude": [],
+  "compilerOptions": {
+    "moduleResolution": "bundler",
+    "module": "ESNext",
+    "outDir": "./dist/structured-outputs",
+    "rootDir": "./src",
+    "declaration": true,
+    "noPropertyAccessFromIndexSignature": false,
+    "noUncheckedIndexedAccess": false,
+    "noImplicitReturns": false,
+    "noImplicitOverride": false
+  }
+}
diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml
index 772135c22..19009b1b7 100644
--- a/pnpm-lock.yaml
+++ b/pnpm-lock.yaml
@@ -130,6 +130,52 @@ importers:
         specifier: ^4.1.18
         version: 4.2.1
 
+  examples/invoices-structured-output:
+    dependencies:
+      '@openuidev/structured-output':
+        specifier: workspace:^
+        version: link:../../packages/structured-outputs
+      next:
+        specifier: 16.1.6
+        version: 16.1.6(@babel/core@7.29.0)(@opentelemetry/api@1.9.0)(babel-plugin-react-compiler@1.0.0)(react-dom@19.2.3(react@19.2.3))(react@19.2.3)(sass@1.89.2)
+      openai:
+        specifier: ^6.27.0
+        version: 6.27.0(ws@8.18.2)(zod@4.3.6)
+      react:
+        specifier: 19.2.3
+        version: 19.2.3
+      react-dom:
+        specifier: 19.2.3
+        version: 19.2.3(react@19.2.3)
+      zod:
+        specifier: ^4.3.6
+        version: 4.3.6
+    devDependencies:
+      '@tailwindcss/postcss':
+        specifier: ^4
+        version: 4.2.1
+      '@types/node':
+        specifier: ^20
+        version: 20.19.35
+      '@types/react':
+        specifier: ^19
+        version: 19.2.14
+      '@types/react-dom':
+        specifier: ^19
+        version: 19.2.3(@types/react@19.2.14)
+      eslint:
+        specifier: ^9
+        version: 9.29.0(jiti@2.6.1)
+      eslint-config-next:
+        specifier: 16.1.6
+        version: 16.1.6(@typescript-eslint/parser@8.56.1(eslint@9.29.0(jiti@2.6.1))(typescript@5.9.3))(eslint@9.29.0(jiti@2.6.1))(typescript@5.9.3)
+      tailwindcss:
+        specifier: ^4
+        version: 4.2.1
+      typescript:
+        specifier: ^5
+        version: 5.9.3
+
   examples/openui-chat:
     dependencies:
       '@openuidev/cli':
@@ -421,6 +467,19 @@ importers:
         specifier: ^5
         version: 5.9.3
 
+  lang/js:
+    dependencies:
+      zod:
+        specifier: ^4.0.0
+        version: 4.3.6
+    devDependencies:
+      typescript:
+        specifier: ^5.9.3
+        version: 5.9.3
+      vitest:
+        specifier: ^3.0.0
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@25.3.2)(jsdom@28.1.0)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)
+
   packages/openui-cli:
     dependencies:
       '@inquirer/core':
@@ -698,6 +757,19 @@ importers:
         specifier: ^5.0.0
         version: 5.4.19(@types/node@22.15.32)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)
 
+  packages/structured-outputs:
+    dependencies:
+      zod:
+        specifier: ^4.0.0
+        version: 4.3.6
+    devDependencies:
+      typescript:
+        specifier: ^5.9.3
+        version: 5.9.3
+      vitest:
+        specifier: ^3.0.0
+        version: 3.2.4(@types/debug@4.1.12)(@types/node@25.3.2)(jsdom@28.1.0)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)
+
 packages:
 
   '@0no-co/graphql.web@1.2.0':
@@ -4646,9 +4718,23 @@ packages:
   '@vitest/expect@2.0.5':
     resolution: {integrity: sha512-yHZtwuP7JZivj65Gxoi8upUN2OzHTi3zVfjwdpu2WrvCZPLwsJ2Ey5ILIPccoW23dd/zQBlJ4/dhi7DWNyXCpA==}
 
+  '@vitest/expect@3.2.4':
+    resolution: {integrity: sha512-Io0yyORnB6sikFlt8QW5K7slY4OjqNX9jmJQ02QDda8lyM6B5oNgVWoSoKPac8/kgnCUzuHQKrSLtu/uOqqrig==}
+
   '@vitest/expect@4.0.18':
     resolution: {integrity: sha512-8sCWUyckXXYvx4opfzVY03EOiYVxyNrHS5QxX3DAIi5dpJAAkyJezHCP77VMX4HKA2LDT/Jpfo8i2r5BE3GnQQ==}
 
+  '@vitest/mocker@3.2.4':
+    resolution: {integrity: sha512-46ryTE9RZO/rfDd7pEqFl7etuyzekzEhUbTW3BvmeO/BcCMEgq59BKhek3dXDWgAj4oMK6OZi+vRr1wPW6qjEQ==}
+    peerDependencies:
+      msw: ^2.4.9
+      vite: ^5.0.0 || ^6.0.0 || ^7.0.0-0
+    peerDependenciesMeta:
+      msw:
+        optional: true
+      vite:
+        optional: true
+
   '@vitest/mocker@4.0.18':
     resolution: {integrity: sha512-HhVd0MDnzzsgevnOWCBj5Otnzobjy5wLBe4EdeeFGv8luMsGcYqDuFRMcttKWZA5vVO8RFjexVovXvAM4JoJDQ==}
     peerDependencies:
@@ -4666,18 +4752,30 @@ packages:
   '@vitest/pretty-format@2.1.9':
     resolution: {integrity: sha512-KhRIdGV2U9HOUzxfiHmY8IFHTdqtOhIzCpd8WRdJiE7D/HUcZVD0EgQCVjm+Q9gkUXWgBvMmTtZgIG48wq7sOQ==}
 
+  '@vitest/pretty-format@3.2.4':
+    resolution: {integrity: sha512-IVNZik8IVRJRTr9fxlitMKeJeXFFFN0JaB9PHPGQ8NKQbGpfjlTx9zO4RefN8gp7eqjNy8nyK3NZmBzOPeIxtA==}
+
   '@vitest/pretty-format@4.0.18':
     resolution: {integrity: sha512-P24GK3GulZWC5tz87ux0m8OADrQIUVDPIjjj65vBXYG17ZeU3qD7r+MNZ1RNv4l8CGU2vtTRqixrOi9fYk/yKw==}
 
+  '@vitest/runner@3.2.4':
+    resolution: {integrity: sha512-oukfKT9Mk41LreEW09vt45f8wx7DordoWUZMYdY/cyAk7w5TWkTRCNZYF7sX7n2wB7jyGAl74OxgwhPgKaqDMQ==}
+
   '@vitest/runner@4.0.18':
     resolution: {integrity: sha512-rpk9y12PGa22Jg6g5M3UVVnTS7+zycIGk9ZNGN+m6tZHKQb7jrP7/77WfZy13Y/EUDd52NDsLRQhYKtv7XfPQw==}
 
+  '@vitest/snapshot@3.2.4':
+    resolution: {integrity: sha512-dEYtS7qQP2CjU27QBC5oUOxLE/v5eLkGqPE0ZKEIDGMs4vKWe7IjgLOeauHsR0D5YuuycGRO5oSRXnwnmA78fQ==}
+
   '@vitest/snapshot@4.0.18':
     resolution: {integrity: sha512-PCiV0rcl7jKQjbgYqjtakly6T1uwv/5BQ9SwBLekVg/EaYeQFPiXcgrC2Y7vDMA8dM1SUEAEV82kgSQIlXNMvA==}
 
   '@vitest/spy@2.0.5':
     resolution: {integrity: sha512-c/jdthAhvJdpfVuaexSrnawxZz6pywlTPe84LUB2m/4t3rl2fTo9NFGBG4oWgaD+FTgDDV8hJ/nibT7IfH3JfA==}
 
+  '@vitest/spy@3.2.4':
+    resolution: {integrity: sha512-vAfasCOe6AIK70iP5UD11Ac4siNUNJ9i/9PZ3NKx07sG6sUxeag1LWdNrMWeKKYBLlzuK+Gn65Yd5nyL6ds+nw==}
+
   '@vitest/spy@4.0.18':
     resolution: {integrity: sha512-cbQt3PTSD7P2OARdVW3qWER5EGq7PHlvE+QfzSC0lbwO+xnt7+XH06ZzFjFRgzUX//JmpxrCu92VdwvEPlWSNw==}
 
@@ -4687,6 +4785,9 @@ packages:
   '@vitest/utils@2.1.9':
     resolution: {integrity: sha512-v0psaMSkNJ3A2NMrUEHFRzJtDPFn+/VWZ5WxImB21T9fjucJRmS7xCS3ppEnARb9y11OAzaD+P2Ps+b+BGX5iQ==}
 
+  '@vitest/utils@3.2.4':
+    resolution: {integrity: sha512-fB2V0JFrQSMsCo9HiSq3Ezpdv4iYaXRG1Sx8edX3MwxfyNn83mKiGzOcH+Fkxt4MHxr3y42fQi1oeAInqgX2QA==}
+
   '@vitest/utils@4.0.18':
     resolution: {integrity: sha512-msMRKLMVLWygpK3u2Hybgi4MNjcYJvwTb0Ru09+fOyCXIgT5raYP041DRRdiJiI3k/2U6SEbAETB3YtBrUkCFA==}
 
@@ -5090,6 +5191,10 @@ packages:
     resolution: {integrity: sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==}
     engines: {node: '>= 0.8'}
 
+  cac@6.7.14:
+    resolution: {integrity: sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ==}
+    engines: {node: '>=8'}
+
   call-bind-apply-helpers@1.0.2:
     resolution: {integrity: sha512-Sp1ablJ0ivDkSzjcaJdxEunN5/XvksFJ2sMBFfq6x0ryhQV/2b/KwFe21cMpmHtPOSij8K99/wSfoEuTObmuMQ==}
     engines: {node: '>= 0.4'}
@@ -6875,6 +6980,9 @@ packages:
   js-tokens@4.0.0:
     resolution: {integrity: sha512-RdJUflcE3cUzKiMqQgsCu06FPu9UdIJO0beYbPhHN4k6apgJtifcoCtT9bcxOpYBtpD2kCM6Sbzg4CausW/PKQ==}
 
+  js-tokens@9.0.1:
+    resolution: {integrity: sha512-mxa9E9ITFOt0ban3j6L5MpjwegGz6lBQmM1IJkWeBZGcMxto50+eWdjC/52xDbS2vy0k7vIMK0Fe2wfL9OQSpQ==}
+
   js-yaml@3.14.2:
     resolution: {integrity: sha512-PMSmkqxr106Xa156c2M265Z+FTrPl+oxd/rgOQy2tijQeK5TxQ43psO1ZCwhVOSdnn+RzkzlRz/eY4BgJBYVpg==}
     hasBin: true
@@ -7791,6 +7899,18 @@ packages:
       zod:
         optional: true
 
+  openai@6.27.0:
+    resolution: {integrity: sha512-osTKySlrdYrLYTt0zjhY8yp0JUBmWDCN+Q+QxsV4xMQnnoVFpylgKGgxwN8sSdTNw0G4y+WUXs4eCMWpyDNWZQ==}
+    hasBin: true
+    peerDependencies:
+      ws: ^8.18.0
+      zod: ^3.25 || ^4.0
+    peerDependenciesMeta:
+      ws:
+        optional: true
+      zod:
+        optional: true
+
   optionator@0.9.4:
     resolution: {integrity: sha512-6IpQ7mKUxRcZNLIObR0hz7lxsapSSIYNZJwXPGeF0mTVqGKFIXj1DQcMoT22S3ROcLyY/rz0PWaWZ9ayWmad9g==}
     engines: {node: '>= 0.8.0'}
@@ -8782,6 +8902,9 @@ packages:
     resolution: {integrity: sha512-6fPc+R4ihwqP6N/aIv2f1gMH8lOVtWQHoqC4yK6oSDVVocumAsfCqjkXnqiYMhmMwS/mEHLp7Vehlt3ql6lEig==}
     engines: {node: '>=8'}
 
+  strip-literal@3.1.0:
+    resolution: {integrity: sha512-8r3mkIM/2+PpjHoOtiAW8Rg3jJLHaV7xPwG+YRGrv6FP0wwk/toTpATxWYOW0BKdWwl82VT2tFYi5DlROa0Mxg==}
+
   structured-headers@0.4.1:
     resolution: {integrity: sha512-0MP/Cxx5SzeeZ10p/bZI0S6MpgD+yxAhi1BOQ34jgnMXsCq3j1t6tQnZu+KdlL7dvJTLT3g9xN8tl10TqgFMcg==}
 
@@ -8908,6 +9031,9 @@ packages:
   tinybench@2.9.0:
     resolution: {integrity: sha512-0+DUvqWMValLmha6lr4kD8iAMK1HzV0/aKnCtWb9v9641TnP/MFb7Pc2bxoxQjTXAErryXVgUOfv2YqNllqGeg==}
 
+  tinyexec@0.3.2:
+    resolution: {integrity: sha512-KQQR9yN7R5+OSwaK0XQoj22pwHoTlgYqmUscPYoknOoWCWfj/5/ABTMRi69FrKU5ffPVh5QcFikpWJI/P1ocHA==}
+
   tinyexec@1.0.2:
     resolution: {integrity: sha512-W/KYk+NFhkmsYpuHq5JykngiOCnxeVL8v8dFnqxSD8qEEdRfXk1SDM6JzNqcERbcGYj9tMrDQBYV9cjgnunFIg==}
     engines: {node: '>=18'}
@@ -8916,10 +9042,18 @@ packages:
     resolution: {integrity: sha512-j2Zq4NyQYG5XMST4cbs02Ak8iJUdxRM0XI5QyxXuZOzKOINmWurp3smXu3y5wDcJrptwpSjgXHzIQxR0omXljQ==}
     engines: {node: '>=12.0.0'}
 
+  tinypool@1.1.1:
+    resolution: {integrity: sha512-Zba82s87IFq9A9XmjiX5uZA/ARWDrB03OHlq+Vw1fSdt0I+4/Kutwy8BP4Y/y/aORMo61FQ0vIb5j44vSo5Pkg==}
+    engines: {node: ^18.0.0 || >=20.0.0}
+
   tinyrainbow@1.2.0:
     resolution: {integrity: sha512-weEDEq7Z5eTHPDh4xjX789+fHfF+P8boiFB+0vbWzpbnbsEr/GRaohi/uMKxg8RZMXnl1ItAi/IUHWMsjDV7kQ==}
     engines: {node: '>=14.0.0'}
 
+  tinyrainbow@2.0.0:
+    resolution: {integrity: sha512-op4nsTR47R6p0vMUUoYl/a+ljLFVtlfaXkLQmqfLR1qHma1h/ysYk4hEXZ880bf2CYgTskvTa/e196Vd5dDQXw==}
+    engines: {node: '>=14.0.0'}
+
   tinyrainbow@3.0.3:
     resolution: {integrity: sha512-PSkbLUoxOFRzJYjjxHJt9xro7D+iilgMX/C9lawzVuYiIdcihh9DXmVibBe8lmcFrRi/VzlPjBxbN7rH24q8/Q==}
     engines: {node: '>=14.0.0'}
@@ -8928,6 +9062,10 @@ packages:
     resolution: {integrity: sha512-n1cw8k1k0x4pgA2+9XrOkFydTerNcJ1zWCO5Nn9scWHTD+5tp8dghT2x1uduQePZTZgd3Tupf+x9BxJjeJi77Q==}
     engines: {node: '>=14.0.0'}
 
+  tinyspy@4.0.4:
+    resolution: {integrity: sha512-azl+t0z7pw/z958Gy9svOTuzqIk6xq+NSheJzn5MMWtWTFywIacg2wUlzKFGtt3cthx0r2SxMK0yzJOR0IES7Q==}
+    engines: {node: '>=14.0.0'}
+
   tldts-core@7.0.25:
     resolution: {integrity: sha512-ZjCZK0rppSBu7rjHYDYsEaMOIbbT+nWF57hKkv4IUmZWBNrBWBOjIElc0mKRgLM8bm7x/BBlof6t2gi/Oq/Asw==}
 
@@ -9216,6 +9354,11 @@ packages:
   victory-vendor@36.9.2:
     resolution: {integrity: sha512-PnpQQMuxlwYdocC8fIJqVXvkeViHYzotI+NJrCuav0ZYFoq912ZHBk3mCeuj+5/VpodOjPe1z0Fk2ihgzlXqjQ==}
 
+  vite-node@3.2.4:
+    resolution: {integrity: sha512-EbKSKh+bh1E1IFxeO0pg1n4dvoOTt0UDiXMd/qn++r98+jPO1xtJilvXldeuQ8giIB5IkpjCgMleHMNEsGH6pg==}
+    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+    hasBin: true
+
   vite@5.4.19:
     resolution: {integrity: sha512-qO3aKv3HoQC8QKiNSTuUM1l9o/XX3+c+VTgLHbJWHZGeTPVAg2XwazI9UWzoxjIJCGCV2zU60uqMzjeLZuULqA==}
     engines: {node: ^18.0.0 || >=20.0.0}
@@ -9287,6 +9430,34 @@ packages:
       yaml:
         optional: true
 
+  vitest@3.2.4:
+    resolution: {integrity: sha512-LUCP5ev3GURDysTWiP47wRRUpLKMOfPh+yKTx3kVIEiu5KOMeqzpnYNsKyOoVrULivR8tLcks4+lga33Whn90A==}
+    engines: {node: ^18.0.0 || ^20.0.0 || >=22.0.0}
+    hasBin: true
+    peerDependencies:
+      '@edge-runtime/vm': '*'
+      '@types/debug': ^4.1.12
+      '@types/node': ^18.0.0 || ^20.0.0 || >=22.0.0
+      '@vitest/browser': 3.2.4
+      '@vitest/ui': 3.2.4
+      happy-dom: '*'
+      jsdom: '*'
+    peerDependenciesMeta:
+      '@edge-runtime/vm':
+        optional: true
+      '@types/debug':
+        optional: true
+      '@types/node':
+        optional: true
+      '@vitest/browser':
+        optional: true
+      '@vitest/ui':
+        optional: true
+      happy-dom:
+        optional: true
+      jsdom:
+        optional: true
+
   vitest@4.0.18:
     resolution: {integrity: sha512-hOQuK7h0FGKgBAas7v0mSAsnvrIgAvWmRFjmzpJ7SwFHH3g1k2u37JtYwOwmEKhK6ZO3v9ggDBBm0La1LCK4uQ==}
     engines: {node: ^20.0.0 || ^22.0.0 || >=24.0.0}
@@ -11327,7 +11498,7 @@ snapshots:
   '@jridgewell/gen-mapping@0.3.8':
     dependencies:
       '@jridgewell/set-array': 1.2.1
-      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/sourcemap-codec': 1.5.5
       '@jridgewell/trace-mapping': 0.3.25
 
   '@jridgewell/remapping@2.3.5':
@@ -11351,7 +11522,7 @@ snapshots:
   '@jridgewell/trace-mapping@0.3.25':
     dependencies:
       '@jridgewell/resolve-uri': 3.1.2
-      '@jridgewell/sourcemap-codec': 1.5.0
+      '@jridgewell/sourcemap-codec': 1.5.5
 
   '@jridgewell/trace-mapping@0.3.31':
     dependencies:
@@ -14388,6 +14559,14 @@ snapshots:
       chai: 5.2.0
       tinyrainbow: 1.2.0
 
+  '@vitest/expect@3.2.4':
+    dependencies:
+      '@types/chai': 5.2.3
+      '@vitest/spy': 3.2.4
+      '@vitest/utils': 3.2.4
+      chai: 5.2.0
+      tinyrainbow: 2.0.0
+
   '@vitest/expect@4.0.18':
     dependencies:
       '@standard-schema/spec': 1.1.0
@@ -14397,6 +14576,14 @@ snapshots:
       chai: 6.2.2
       tinyrainbow: 3.0.3
 
+  '@vitest/mocker@3.2.4(vite@5.4.19(@types/node@25.3.2)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0))':
+    dependencies:
+      '@vitest/spy': 3.2.4
+      estree-walker: 3.0.3
+      magic-string: 0.30.21
+    optionalDependencies:
+      vite: 5.4.19(@types/node@25.3.2)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)
+
   '@vitest/mocker@4.0.18(vite@7.3.1(@types/node@25.3.2)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)(tsx@4.20.3)(yaml@2.8.0))':
     dependencies:
       '@vitest/spy': 4.0.18
@@ -14413,15 +14600,31 @@ snapshots:
     dependencies:
       tinyrainbow: 1.2.0
 
+  '@vitest/pretty-format@3.2.4':
+    dependencies:
+      tinyrainbow: 2.0.0
+
   '@vitest/pretty-format@4.0.18':
     dependencies:
       tinyrainbow: 3.0.3
 
+  '@vitest/runner@3.2.4':
+    dependencies:
+      '@vitest/utils': 3.2.4
+      pathe: 2.0.3
+      strip-literal: 3.1.0
+
   '@vitest/runner@4.0.18':
     dependencies:
       '@vitest/utils': 4.0.18
       pathe: 2.0.3
 
+  '@vitest/snapshot@3.2.4':
+    dependencies:
+      '@vitest/pretty-format': 3.2.4
+      magic-string: 0.30.21
+      pathe: 2.0.3
+
   '@vitest/snapshot@4.0.18':
     dependencies:
       '@vitest/pretty-format': 4.0.18
@@ -14432,6 +14635,10 @@ snapshots:
     dependencies:
       tinyspy: 3.0.2
 
+  '@vitest/spy@3.2.4':
+    dependencies:
+      tinyspy: 4.0.4
+
   '@vitest/spy@4.0.18': {}
 
   '@vitest/utils@2.0.5':
@@ -14447,6 +14654,12 @@ snapshots:
       loupe: 3.1.4
       tinyrainbow: 1.2.0
 
+  '@vitest/utils@3.2.4':
+    dependencies:
+      '@vitest/pretty-format': 3.2.4
+      loupe: 3.1.4
+      tinyrainbow: 2.0.0
+
   '@vitest/utils@4.0.18':
     dependencies:
       '@vitest/pretty-format': 4.0.18
@@ -14953,6 +15166,8 @@ snapshots:
 
   bytes@3.1.2: {}
 
+  cac@6.7.14: {}
+
   call-bind-apply-helpers@1.0.2:
     dependencies:
       es-errors: 1.3.0
@@ -17222,6 +17437,8 @@ snapshots:
 
   js-tokens@4.0.0: {}
 
+  js-tokens@9.0.1: {}
+
   js-yaml@3.14.2:
     dependencies:
       argparse: 1.0.10
@@ -18623,6 +18840,11 @@ snapshots:
       ws: 8.18.2
       zod: 4.3.6
 
+  openai@6.27.0(ws@8.18.2)(zod@4.3.6):
+    optionalDependencies:
+      ws: 8.18.2
+      zod: 4.3.6
+
   optionator@0.9.4:
     dependencies:
       deep-is: 0.1.4
@@ -20027,6 +20249,10 @@ snapshots:
 
   strip-json-comments@3.1.1: {}
 
+  strip-literal@3.1.0:
+    dependencies:
+      js-tokens: 9.0.1
+
   structured-headers@0.4.1: {}
 
   style-to-js@1.1.17:
@@ -20183,6 +20409,8 @@ snapshots:
 
   tinybench@2.9.0: {}
 
+  tinyexec@0.3.2: {}
+
   tinyexec@1.0.2: {}
 
   tinyglobby@0.2.15:
@@ -20190,12 +20418,18 @@ snapshots:
       fdir: 6.5.0(picomatch@4.0.3)
       picomatch: 4.0.3
 
+  tinypool@1.1.1: {}
+
   tinyrainbow@1.2.0: {}
 
+  tinyrainbow@2.0.0: {}
+
   tinyrainbow@3.0.3: {}
 
   tinyspy@3.0.2: {}
 
+  tinyspy@4.0.4: {}
+
   tldts-core@7.0.25:
     optional: true
 
@@ -20563,6 +20797,24 @@ snapshots:
       d3-time: 3.1.0
       d3-timer: 3.0.1
 
+  vite-node@3.2.4(@types/node@25.3.2)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0):
+    dependencies:
+      cac: 6.7.14
+      debug: 4.4.3
+      es-module-lexer: 1.7.0
+      pathe: 2.0.3
+      vite: 5.4.19(@types/node@25.3.2)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)
+    transitivePeerDependencies:
+      - '@types/node'
+      - less
+      - lightningcss
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
   vite@5.4.19(@types/node@22.15.32)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0):
     dependencies:
       esbuild: 0.21.5
@@ -20575,6 +20827,18 @@ snapshots:
       sass: 1.89.2
       terser: 5.43.0
 
+  vite@5.4.19(@types/node@25.3.2)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0):
+    dependencies:
+      esbuild: 0.21.5
+      postcss: 8.5.6
+      rollup: 4.43.0
+    optionalDependencies:
+      '@types/node': 25.3.2
+      fsevents: 2.3.3
+      lightningcss: 1.31.1
+      sass: 1.89.2
+      terser: 5.43.0
+
   vite@7.3.1(@types/node@25.3.2)(jiti@2.6.1)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)(tsx@4.20.3)(yaml@2.8.0):
     dependencies:
       esbuild: 0.27.3
@@ -20593,6 +20857,46 @@ snapshots:
       tsx: 4.20.3
       yaml: 2.8.0
 
+  vitest@3.2.4(@types/debug@4.1.12)(@types/node@25.3.2)(jsdom@28.1.0)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0):
+    dependencies:
+      '@types/chai': 5.2.3
+      '@vitest/expect': 3.2.4
+      '@vitest/mocker': 3.2.4(vite@5.4.19(@types/node@25.3.2)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0))
+      '@vitest/pretty-format': 3.2.4
+      '@vitest/runner': 3.2.4
+      '@vitest/snapshot': 3.2.4
+      '@vitest/spy': 3.2.4
+      '@vitest/utils': 3.2.4
+      chai: 5.2.0
+      debug: 4.4.3
+      expect-type: 1.3.0
+      magic-string: 0.30.21
+      pathe: 2.0.3
+      picomatch: 4.0.3
+      std-env: 3.10.0
+      tinybench: 2.9.0
+      tinyexec: 0.3.2
+      tinyglobby: 0.2.15
+      tinypool: 1.1.1
+      tinyrainbow: 2.0.0
+      vite: 5.4.19(@types/node@25.3.2)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)
+      vite-node: 3.2.4(@types/node@25.3.2)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)
+      why-is-node-running: 2.3.0
+    optionalDependencies:
+      '@types/debug': 4.1.12
+      '@types/node': 25.3.2
+      jsdom: 28.1.0
+    transitivePeerDependencies:
+      - less
+      - lightningcss
+      - msw
+      - sass
+      - sass-embedded
+      - stylus
+      - sugarss
+      - supports-color
+      - terser
+
   vitest@4.0.18(@opentelemetry/api@1.9.0)(@types/node@25.3.2)(jiti@2.6.1)(jsdom@28.1.0)(lightningcss@1.31.1)(sass@1.89.2)(terser@5.43.0)(tsx@4.20.3)(yaml@2.8.0):
     dependencies:
       '@vitest/expect': 4.0.18
diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml
index d1a3a8ddb..0403c654d 100644
--- a/pnpm-workspace.yaml
+++ b/pnpm-workspace.yaml
@@ -1,5 +1,6 @@
 packages:
   - "packages/*"
+  - "lang/*"
   - "examples/**/*"
   - "docs/"
   - "!**/src/templates/**"