@stephen-netu/design-system 0.1.0 → 0.2.1

package/dist/g0-generative/parser/parseOpenUILang.js

@@ -0,0 +1,319 @@
+/**
+ * OpenUI Lang Parser
+ *
+ * Streaming-compatible, line-by-line parser.
+ * Sovereignty-compliant: uses insertion-ordered Map (deterministic iteration), no SystemTime/rand.
+ *
+ * Syntax:
+ *   identifier = ComponentName([arg1, arg2, ...])
+ *   identifier = [ref1, ref2]  // shorthand for Lists
+ *
+ * Forward references allowed — unresolved identifiers become placeholders.
+ */
+class ParserState {
+    nodes = new Map();
+    references = new Map(); // id -> refs it contains
+    referencedBy = new Map(); // id -> ids that reference it
+    errors = [];
+    lineNumber = 0;
+    root = null;
+    recordReference(from, to) {
+        if (!this.references.has(from)) {
+            this.references.set(from, new Set());
+        }
+        this.references.get(from).add(to);
+        if (!this.referencedBy.has(to)) {
+            this.referencedBy.set(to, new Set());
+        }
+        this.referencedBy.get(to).add(from);
+    }
+    addError(message, severity = 'error') {
+        this.errors.push({ line: this.lineNumber, message, severity });
+    }
+}
+function tokenize(line) {
+    // Remove comments
+    const commentIdx = line.indexOf('//');
+    const clean = commentIdx >= 0 ? line.slice(0, commentIdx) : line;
+    if (!clean.trim())
+        return null;
+    const tokens = [];
+    let current = '';
+    let inString = false;
+    let stringChar = '';
+    let depth = 0;
+    for (let i = 0; i < clean.length; i++) {
+        const char = clean[i];
+        if (inString) {
+            if (char === '\\' && i + 1 < clean.length) {
+                current += clean[++i];
+            }
+            else if (char === stringChar) {
+                inString = false;
+                tokens.push(current);
+                current = '';
+            }
+            else {
+                current += char;
+            }
+            continue;
+        }
+        if (char === '"' || char === "'") {
+            inString = true;
+            stringChar = char;
+            if (current.trim()) {
+                tokens.push(current.trim());
+                current = '';
+            }
+            continue;
+        }
+        if (char === '(' || char === '[') {
+            depth++;
+            if (current.trim()) {
+                tokens.push(current.trim());
+                current = '';
+            }
+            tokens.push(char);
+            continue;
+        }
+        if (char === ')' || char === ']') {
+            depth--;
+            if (current.trim()) {
+                tokens.push(current.trim());
+                current = '';
+            }
+            tokens.push(char);
+            continue;
+        }
+        if (char === ',' || char === '=') {
+            if (current.trim()) {
+                tokens.push(current.trim());
+                current = '';
+            }
+            if (char === '=') {
+                tokens.push('=');
+            }
+            continue;
+        }
+        if (char === ' ' || char === '\t') {
+            if (current.trim()) {
+                tokens.push(current.trim());
+                current = '';
+            }
+            continue;
+        }
+        current += char;
+    }
+    if (current.trim()) {
+        tokens.push(current.trim());
+    }
+    return tokens;
+}
+function parseValue(token, state, elementId) {
+    // Note: Tokenizer strips quotes, so we don't need to handle them here
+    // Unquoted string that looks like an identifier reference
+    if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(token)) {
+        state.recordReference(elementId, token);
+        return token; // Return as identifier reference
+    }
+    // Number
+    if (/^-?\d+(\.\d+)?$/.test(token)) {
+        return parseFloat(token);
+    }
+    // Boolean
+    if (token === 'true')
+        return true;
+    if (token === 'false')
+        return false;
+    // Array marker
+    if (token === '[' || token === ']') {
+        return null; // Handled at higher level
+    }
+    // String without quotes
+    return token;
+}
+function parseLine(line, state) {
+    state.lineNumber++;
+    const tokens = tokenize(line);
+    if (!tokens)
+        return;
+    // Must have: identifier = Component(...)
+    const eqIdx = tokens.indexOf('=');
+    if (eqIdx < 0) {
+        state.addError('Expected assignment operator "="');
+        return;
+    }
+    if (eqIdx !== 1) {
+        state.addError('Expected identifier before "="');
+        return;
+    }
+    const identifier = tokens[0];
+    // Validate identifier
+    if (!/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(identifier)) {
+        state.addError(`Invalid identifier: ${identifier}`);
+        return;
+    }
+    // Set root if first assignment
+    if (state.root === null) {
+        state.root = identifier;
+    }
+    // Check for duplicate definition
+    if (state.nodes.has(identifier)) {
+        state.addError(`Duplicate definition: ${identifier}`, 'warning');
+    }
+    const afterEq = tokens.slice(eqIdx + 1);
+    // Check for shorthand array: [ref1, ref2]
+    if (afterEq[0] === '[' && afterEq[afterEq.length - 1] === ']') {
+        // This is a List shorthand: identifier = [a, b, c]
+        // Treat as: identifier = List([a, b, c])
+        const refs = [];
+        for (let i = 1; i < afterEq.length - 1; i++) {
+            const token = afterEq[i];
+            if (token === ',')
+                continue;
+            if (/^[a-zA-Z_][a-zA-Z0-9_]*$/.test(token)) {
+                refs.push(token);
+                state.recordReference(identifier, token);
+            }
+        }
+        const element = {
+            type: 'element',
+            identifier,
+            component: 'List',
+            args: [refs],
+            line: state.lineNumber,
+        };
+        state.nodes.set(identifier, element);
+        return;
+    }
+    // Component call: ComponentName([args])
+    if (afterEq.length < 3) {
+        state.addError('Expected ComponentName([args]) after "="');
+        return;
+    }
+    const component = afterEq[0];
+    if (afterEq[1] !== '(' || afterEq[afterEq.length - 1] !== ')') {
+        state.addError('Expected parentheses around component arguments');
+        return;
+    }
+    // Parse arguments
+    const args = [];
+    const innerTokens = afterEq.slice(2, -1);
+    let i = 0;
+    while (i < innerTokens.length) {
+        const token = innerTokens[i];
+        // Skip commas
+        if (token === ',') {
+            i++;
+            continue;
+        }
+        // Nested array literal [a, b, c]
+        if (token === '[') {
+            const arr = [];
+            i++;
+            while (i < innerTokens.length && innerTokens[i] !== ']') {
+                if (innerTokens[i] === ',') {
+                    i++;
+                    continue;
+                }
+                const val = parseValue(innerTokens[i], state, identifier);
+                if (typeof val === 'string') {
+                    arr.push(val);
+                }
+                i++;
+            }
+            args.push(arr);
+            i++; // skip ]
+            continue;
+        }
+        const val = parseValue(token, state, identifier);
+        if (val !== null) {
+            args.push(val);
+        }
+        i++;
+    }
+    const element = {
+        type: 'element',
+        identifier,
+        component,
+        args,
+        line: state.lineNumber,
+    };
+    state.nodes.set(identifier, element);
+}
+function resolvePlaceholders(state) {
+    // Any identifier referenced but not defined becomes a placeholder
+    for (const [ref, referrers] of state.referencedBy) {
+        if (!state.nodes.has(ref)) {
+            const placeholder = {
+                type: 'placeholder',
+                identifier: ref,
+                referencedBy: Array.from(referrers),
+                line: 0,
+            };
+            state.nodes.set(ref, placeholder);
+        }
+    }
+}
+export function parseOpenUILang(input) {
+    const state = new ParserState();
+    const lines = input.split('\n');
+    for (const line of lines) {
+        parseLine(line, state);
+    }
+    resolvePlaceholders(state);
+    // Validate root exists
+    if (state.root === null) {
+        state.addError('No root element defined (first assignment becomes root)');
+    }
+    // Check for orphaned nodes (nothing references them, not root)
+    const referenced = new Set();
+    referenced.add(state.root || '');
+    for (const refs of state.references.values()) {
+        for (const ref of refs) {
+            referenced.add(ref);
+        }
+    }
+    for (const [id, node] of state.nodes) {
+        if (node.type === 'element' && !referenced.has(id) && id !== state.root) {
+            state.addError(`Orphaned element: ${id} (nothing references it)`, 'warning');
+        }
+    }
+    const ast = {
+        root: state.root,
+        nodes: state.nodes,
+        errors: state.errors,
+    };
+    return {
+        ast,
+        success: state.errors.filter(e => e.severity === 'error').length === 0,
+    };
+}
+export function parsePartial(input, existingAST) {
+    // For streaming: parse new lines, merge with existing AST
+    const result = parseOpenUILang(input);
+    if (!existingAST) {
+        return result;
+    }
+    // Merge: new definitions override old ones
+    const mergedNodes = new Map(existingAST.nodes);
+    for (const [id, node] of result.ast.nodes) {
+        mergedNodes.set(id, node);
+    }
+    const mergedErrors = [...existingAST.errors];
+    for (const err of result.ast.errors) {
+        // Deduplicate errors by line+message
+        const exists = mergedErrors.some(e => e.line === err.line && e.message === err.message);
+        if (!exists) {
+            mergedErrors.push(err);
+        }
+    }
+    return {
+        ast: {
+            root: result.ast.root || existingAST.root,
+            nodes: mergedNodes,
+            errors: mergedErrors,
+        },
+        success: result.success,
+    };
+}

package/dist/g0-generative/parser/types.d.ts

@@ -0,0 +1,41 @@
+/**
+ * OpenUI Lang AST Types
+ *
+ * Line-oriented DSL: identifier = ComponentName([arg1, arg2, ...])
+ *
+ * Example:
+ *   root = Stack([header, content])
+ *   header = Text("Title", "large")
+ *   content = Card([text])
+ *   text = Text("Hello world")
+ */
+export type OpenUIIdentifier = string;
+export interface OpenUIElement {
+    type: 'element';
+    identifier: OpenUIIdentifier;
+    component: string;
+    args: (string | number | boolean | OpenUIIdentifier | OpenUIIdentifier[])[];
+    line: number;
+}
+export interface OpenUIPlaceholder {
+    type: 'placeholder';
+    identifier: OpenUIIdentifier;
+    referencedBy: OpenUIIdentifier[];
+    line: number;
+}
+export type OpenUINode = OpenUIElement | OpenUIPlaceholder;
+export interface OpenUIAST {
+    root: OpenUIIdentifier | null;
+    nodes: Map<OpenUIIdentifier, OpenUINode>;
+    errors: ParseError[];
+}
+export interface ParseError {
+    line: number;
+    message: string;
+    severity: 'error' | 'warning';
+}
+export interface ParseResult {
+    ast: OpenUIAST;
+    success: boolean;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/g0-generative/parser/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/g0-generative/parser/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,MAAM,MAAM,gBAAgB,GAAG,MAAM,CAAC;AAEtC,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,SAAS,CAAC;IAChB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,SAAS,EAAE,MAAM,CAAC;IAClB,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,GAAG,OAAO,GAAG,gBAAgB,GAAG,gBAAgB,EAAE,CAAC,EAAE,CAAC;IAC5E,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,aAAa,CAAC;IACpB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,YAAY,EAAE,gBAAgB,EAAE,CAAC;IACjC,IAAI,EAAE,MAAM,CAAC;CACd;AAED,MAAM,MAAM,UAAU,GAAG,aAAa,GAAG,iBAAiB,CAAC;AAE3D,MAAM,WAAW,SAAS;IACxB,IAAI,EAAE,gBAAgB,GAAG,IAAI,CAAC;IAC9B,KAAK,EAAE,GAAG,CAAC,gBAAgB,EAAE,UAAU,CAAC,CAAC;IACzC,MAAM,EAAE,UAAU,EAAE,CAAC;CACtB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;IAChB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;CAC/B;AAED,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,SAAS,CAAC;IACf,OAAO,EAAE,OAAO,CAAC;CAClB"}

package/dist/g0-generative/parser/types.js

@@ -0,0 +1,12 @@
+/**
+ * OpenUI Lang AST Types
+ *
+ * Line-oriented DSL: identifier = ComponentName([arg1, arg2, ...])
+ *
+ * Example:
+ *   root = Stack([header, content])
+ *   header = Text("Title", "large")
+ *   content = Card([text])
+ *   text = Text("Hello world")
+ */
+export {};

package/dist/g0-generative/prompt-gen/generateSystemPrompt.d.ts

@@ -0,0 +1,18 @@
+/**
+ * System Prompt Generator
+ *
+ * Generates LLM system prompts from component library definitions.
+ */
+import type { ComponentLibrary } from '../library/ComponentLibrary';
+export interface PromptOptions {
+    includeExamples?: boolean;
+    maxExamples?: number;
+    contextWindow?: number;
+    streamingHints?: boolean;
+}
+export declare function generateSystemPrompt(library: ComponentLibrary, options?: PromptOptions): string;
+/**
+ * Example prompt with common UI patterns
+ */
+export declare function getExamplePrompt(): string;
+//# sourceMappingURL=generateSystemPrompt.d.ts.map

package/dist/g0-generative/prompt-gen/generateSystemPrompt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generateSystemPrompt.d.ts","sourceRoot":"","sources":["../../../src/g0-generative/prompt-gen/generateSystemPrompt.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAEpE,MAAM,WAAW,aAAa;IAC5B,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,gBAAgB,EACzB,OAAO,GAAE,aAAkB,GAC1B,MAAM,CAER;AAED;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,MAAM,CAgBzC"}

package/dist/g0-generative/prompt-gen/generateSystemPrompt.js

@@ -0,0 +1,28 @@
+/**
+ * System Prompt Generator
+ *
+ * Generates LLM system prompts from component library definitions.
+ */
+export function generateSystemPrompt(library, options = {}) {
+    return library.generatePrompt();
+}
+/**
+ * Example prompt with common UI patterns
+ */
+export function getExamplePrompt() {
+    return `
+# OpenUI Example: Dashboard Layout
+
+root = Stack([header, stats, chart])
+header = Text("Q4 Performance", "large")
+stats = Grid([s1, s2, s3])
+s1 = StatCard("Revenue", "$1.2M", "up")
+s2 = StatCard("Users", "450k", "flat")
+s3 = StatCard("Churn", "2.1%", "down")
+chart = LineChart([data])
+data = DataSeries("Monthly", [jan, feb, mar])
+jan = DataPoint("Jan", 100)
+feb = DataPoint("Feb", 120)
+mar = DataPoint("Mar", 115)
+`;
+}

package/dist/g0-generative/renderer/OpenUIRenderer.svelte

@@ -0,0 +1,188 @@
+<script lang="ts">
+  /**
+   * OpenUI Renderer
+   * 
+   * Renders OpenUI Lang AST to Svelte components.
+   * Progressive rendering with placeholder support.
+   * 
+   * @package @kos/design-system/g0-generative
+   */
+  import type { OpenUIAST, OpenUIElement, OpenUIPlaceholder, OpenUINode } from '../parser/types';
+  import type { ComponentLibrary } from '../library/ComponentLibrary';
+  import type { StreamingState } from '../streaming/StreamingAdapter';
+
+  interface Props {
+    ast: OpenUIAST | null;
+    library: ComponentLibrary;
+    isStreaming?: boolean;
+    fallback?: import('svelte').Snippet;
+  }
+
+  let { ast, library, isStreaming, fallback }: Props = $props();
+
+  // Registry mapping component names to Svelte components
+  const componentRegistry = $derived(buildRegistry(library));
+
+  function buildRegistry(library: ComponentLibrary): Map<string, import('svelte').Component<Record<string, unknown>>> {
+    // TODO: Implement component registration from library schemas
+    // This requires mapping ComponentLibrary schemas to actual Svelte imports
+    // Example: if (library.hasComponent('Card')) registry.set('Card', CardComponent);
+    // For now, return empty - consumers must register components manually
+    return new Map();
+  }
+
+  function isResolved(node: OpenUINode): boolean {
+    return node.type === 'element';
+  }
+
+  function getComponent(name: string): import('svelte').Component<Record<string, unknown>> | null {
+    return componentRegistry.get(name) || null;
+  }
+
+  function renderElement(element: OpenUIElement): {
+    component: import('svelte').Component<Record<string, unknown>> | null;
+    props: Record<string, unknown>;
+    children: string[];
+    grandchildren: string[];
+  } {
+    const Component = getComponent(element.component);
+    const schema = library.getComponent(element.component);
+    
+    const componentProps: Record<string, unknown> = {};
+    const children: string[] = [];
+    const grandchildren: string[] = [];
+
+    if (schema) {
+      // Map positional args to named props
+      for (let i = 0; i < element.args.length; i++) {
+        const propName = schema.propOrder[i];
+        if (propName) {
+          const value = element.args[i];
+          // If this is an identifier array, treat as children
+          if (Array.isArray(value) && value.every(v => typeof v === 'string')) {
+            children.push(...value);
+          } else {
+            componentProps[propName] = value;
+          }
+        }
+      }
+    } else {
+      // No schema - treat all array args as children
+      for (const arg of element.args) {
+        if (Array.isArray(arg) && arg.every(v => typeof v === 'string')) {
+          children.push(...arg);
+        }
+      }
+    }
+
+    // Extract grandchildren from children (nested structure)
+    for (const childId of children) {
+      const childNode = ast?.nodes.get(childId);
+      if (childNode?.type === 'element') {
+        for (const arg of childNode.args) {
+          if (Array.isArray(arg) && arg.every(v => typeof v === 'string')) {
+            grandchildren.push(...arg);
+          }
+        }
+      }
+    }
+
+    return { component: Component, props: componentProps, children, grandchildren };
+  }
+</script>
+
+{#if ast?.root}
+  {@const rootNode = ast.nodes.get(ast.root)}
+  {#if rootNode}
+    {#if rootNode.type === 'placeholder'}
+      <!-- Root is still a placeholder - show skeleton -->
+      <div class="openui-skeleton" role="progressbar" aria-busy={isStreaming}>
+        {#if fallback}
+          {@render fallback()}
+        {:else}
+          <div class="openui-loading">Loading...</div>
+        {/if}
+      </div>
+    {:else if rootNode.type === 'element'}
+      {@const { component: RootComponent, props: rootProps, children } = renderElement(rootNode)}
+      {#if RootComponent}
+        <RootComponent {...rootProps}>
+          {#each children as childId}
+            {@const childNode = ast!.nodes.get(childId)}
+            {#if childNode}
+              <!-- Recursive child rendering via snippet -->
+              {@render renderChild(childId, childNode)}
+            {/if}
+          {/each}
+        </RootComponent>
+      {:else}
+        <!-- Unregistered component - render children inline -->
+        {#each children as childId}
+          {@const childNode = ast!.nodes.get(childId)}
+          {#if childNode?.type === 'element'}
+            {@const { component: ChildComponent, props: childProps } = renderElement(childNode)}
+            {#if ChildComponent}
+              <ChildComponent {...childProps} />
+            {/if}
+          {/if}
+        {/each}
+      {/if}
+    {/if}
+  {/if}
+{#snippet renderChild(childId: string, childNode: OpenUINode)}
+  {#if childNode.type === 'placeholder'}
+    <div class="openui-skeleton" role="progressbar" aria-busy={isStreaming}>
+      <div class="openui-loading">Loading...</div>
+    </div>
+  {:else if childNode.type === 'element'}
+    {@const { component: ChildComponent, props: childProps, grandchildren } = renderElement(childNode)}
+    {#if ChildComponent}
+      <ChildComponent {...childProps}>
+        {#each grandchildren as grandchildId}
+          {@const grandchildNode = ast!.nodes.get(grandchildId)}
+          {#if grandchildNode}
+            {@render renderChild(grandchildId, grandchildNode)}
+          {/if}
+        {/each}
+      </ChildComponent>
+    {:else}
+      <!-- Unregistered component - render children inline -->
+      {#each grandchildren as grandchildId}
+        {@const grandchildNode = ast!.nodes.get(grandchildId)}
+        {#if grandchildNode?.type === 'element'}
+          {@const { component: GC, props: gp } = renderElement(grandchildNode)}
+          {#if GC}
+            <GC {...gp} />
+          {/if}
+        {/if}
+      {/each}
+    {/if}
+  {/if}
+{/snippet}
+
+{:else}
+  <!-- No AST yet -->
+  <div class="openui-empty">
+    {#if fallback}
+      {@render fallback()}
+    {/if}
+  </div>
+{/if}
+
+<style>
+  .openui-skeleton {
+    min-height: 100px;
+    background: var(--color-bg-secondary, #1a1a1a);
+    border-radius: var(--radius-lg, 0.5rem);
+    padding: var(--space-4, 1rem);
+  }
+
+  .openui-loading {
+    color: var(--color-text-muted, #888);
+    text-align: center;
+  }
+
+  .openui-empty {
+    min-height: 50px;
+  }
+</style>

package/dist/g0-generative/renderer/OpenUIRenderer.svelte.d.ts

@@ -0,0 +1,20 @@
+/**
+   * OpenUI Renderer
+   *
+   * Renders OpenUI Lang AST to Svelte components.
+   * Progressive rendering with placeholder support.
+   *
+   * @package @kos/design-system/g0-generative
+   */
+import type { OpenUIAST } from '../parser/types';
+import type { ComponentLibrary } from '../library/ComponentLibrary';
+interface Props {
+    ast: OpenUIAST | null;
+    library: ComponentLibrary;
+    isStreaming?: boolean;
+    fallback?: import('svelte').Snippet;
+}
+declare const OpenUIRenderer: import("svelte").Component<Props, {}, "">;
+type OpenUIRenderer = ReturnType<typeof OpenUIRenderer>;
+export default OpenUIRenderer;
+//# sourceMappingURL=OpenUIRenderer.svelte.d.ts.map

package/dist/g0-generative/renderer/OpenUIRenderer.svelte.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OpenUIRenderer.svelte.d.ts","sourceRoot":"","sources":["../../../src/g0-generative/renderer/OpenUIRenderer.svelte.ts"],"names":[],"mappings":"AAGA;;;;;;;KAOK;AACL,OAAO,KAAK,EAAE,SAAS,EAAgD,MAAM,iBAAiB,CAAC;AAC/F,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AAIlE,UAAU,KAAK;IACb,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB,OAAO,EAAE,gBAAgB,CAAC;IAC1B,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,QAAQ,EAAE,OAAO,CAAC;CACrC;AAmKH,QAAA,MAAM,cAAc,2CAAwC,CAAC;AAC7D,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,cAAc,CAAC,CAAC;AACxD,eAAe,cAAc,CAAC"}

package/dist/g0-generative/streaming/StreamingAdapter.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Streaming Adapter
+ *
+ * Progressive rendering for Svelte 5 runes.
+ * Handles incremental parsing and state updates as LLM tokens arrive.
+ *
+ * ADR: 2026-05-04-openui-generative-ui-integration
+ */
+import type { OpenUIAST } from '../parser/types';
+export interface StreamChunk {
+    content: string;
+    isComplete: boolean;
+}
+export interface StreamingState {
+    ast: OpenUIAST | null;
+    partialContent: string;
+    isStreaming: boolean;
+    hasError: boolean;
+    errorMessage: string | null;
+    /** True if content was truncated due to size limit */
+    wasTruncated: boolean;
+}
+export declare class StreamingAdapter {
+    private state;
+    private onUpdate;
+    private maxSize;
+    constructor(onUpdate?: (state: StreamingState) => void, maxSize?: number);
+    getState(): StreamingState;
+    startStream(): void;
+    appendChunk(chunk: string): void;
+    endStream(): void;
+    reset(): void;
+    private notify;
+}
+/** StreamingAdapter is the unified API. Factory removed to prevent API divergence. */
+//# sourceMappingURL=StreamingAdapter.d.ts.map

package/dist/g0-generative/streaming/StreamingAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StreamingAdapter.d.ts","sourceRoot":"","sources":["../../../src/g0-generative/streaming/StreamingAdapter.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAMjD,MAAM,WAAW,WAAW;IAC1B,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,OAAO,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,GAAG,EAAE,SAAS,GAAG,IAAI,CAAC;IACtB,cAAc,EAAE,MAAM,CAAC;IACvB,WAAW,EAAE,OAAO,CAAC;IACrB,QAAQ,EAAE,OAAO,CAAC;IAClB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,sDAAsD;IACtD,YAAY,EAAE,OAAO,CAAC;CACvB;AAED,qBAAa,gBAAgB;IAC3B,OAAO,CAAC,KAAK,CAOX;IAEF,OAAO,CAAC,QAAQ,CAAkD;IAClE,OAAO,CAAC,OAAO,CAAS;gBAEZ,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,cAAc,KAAK,IAAI,EAAE,OAAO,SAAmB;IAKlF,QAAQ,IAAI,cAAc;IAI1B,WAAW,IAAI,IAAI;IAYnB,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI;IA0ChC,SAAS,IAAI,IAAI;IAmBjB,KAAK,IAAI,IAAI;IAYb,OAAO,CAAC,MAAM;CAGf;AAED,sFAAsF"}