Add nebula-genui: streaming generative UI from an LLM

[AndroidPoet]

What

A new nebula-genui module that renders a Nebula component tree an LLM streams back token by token — the screen assembles itself as JSON arrives instead of waiting for the full response. This is the generative-UI counterpart to the existing JSON SDUI path, reusing the whole NebulaComponent model and renderer.

Why

The JSON path today needs the complete document before it can render (decodeFromString). A model dribbles JSON out over seconds. This module closes that gap so you can point Nebula at any LLM and watch native Compose UI build progressively.

How it works

• repairToValidJson — a single-pass, string/scalar-aware repair that turns any prefix of a JSON document into the largest valid JSON so far (balancing open containers, dropping a dangling ,, a half-typed key, or an in-progress number). This is the core trick that makes partial output renderable.
• Flow<String>.asNebulaTree() — buffers tokens, repairs, decodes to NebulaComponent, and emits a new tree only when it changes.
• NebulaStream — a @Composable that observes the flow and renders the partial tree via the existing Nebula(component = …), refilling on each update.
• NebulaPrompt.system() — auto-generates the system prompt from the component + action catalog, so the model only emits components the renderer understands (prompt and renderer can't drift).
• NebulaUiSource — pluggable, bring-your-own-model interface (core only consumes a Flow<String>). MockNebulaUiSource drives previews/tests with no network.

No changes to nebula-core — this builds entirely on top.

Tests

:nebula-genui:desktopTest — 12 tests, all green. Highlights:

• Every prefix of a nested document repairs to structurally valid JSON (never throws).
• Dangling keys/colons/commas and in-progress numbers are dropped; complete values are kept.
• The stream emits progressively and ends on the complete tree; consecutive emissions are distinct.
• The generated prompt lists every component and action type.

Notes / follow-ups

• Root also builds Android; CI compiles nebula-core only, so this module is verified locally via the desktop target.
• A value string currently reappears when its closing quote arrives (dropped-to-last-complete-field). A future refinement can close in-progress value strings to stream partial text as it types.

[AndroidPoet]

What

A new nebula-genui module that renders a Nebula component tree an LLM streams back token by token — the screen assembles itself as JSON arrives instead of waiting for the full response. This is the generative-UI counterpart to the existing JSON SDUI path, reusing the whole NebulaComponent model and renderer.

Why

The JSON path today needs the complete document before it can render (decodeFromString). A model dribbles JSON out over seconds. This module closes that gap so you can point Nebula at any LLM and watch native Compose UI build progressively.

How it works

• repairToValidJson — a single-pass, string/scalar-aware repair that turns any prefix of a JSON document into the largest valid JSON so far (balancing open containers, dropping a dangling ,, a half-typed key, or an in-progress number). This is the core trick that makes partial output renderable.
• Flow<String>.asNebulaTree() — buffers tokens, repairs, decodes to NebulaComponent, and emits a new tree only when it changes.
• NebulaStream — a @Composable that observes the flow and renders the partial tree via the existing Nebula(component = …), refilling on each update.
• NebulaPrompt.system() — auto-generates the system prompt from the component + action catalog, so the model only emits components the renderer understands (prompt and renderer can't drift).
• NebulaUiSource — pluggable, bring-your-own-model interface (core only consumes a Flow<String>). MockNebulaUiSource drives previews/tests with no network.

No changes to nebula-core — this builds entirely on top.

Tests

:nebula-genui:desktopTest — 12 tests, all green. Highlights:

• Every prefix of a nested document repairs to structurally valid JSON (never throws).
• Dangling keys/colons/commas and in-progress numbers are dropped; complete values are kept.
• The stream emits progressively and ends on the complete tree; consecutive emissions are distinct.
• The generated prompt lists every component and action type.

Notes / follow-ups

• Root also builds Android; CI compiles nebula-core only, so this module is verified locally via the desktop target.
• A value string currently reappears when its closing quote arrives (dropped-to-last-complete-field). A future refinement can close in-progress value strings to stream partial text as it types.

[AndroidPoet]

What

A new nebula-genui module that renders a Nebula component tree an LLM streams back token by token — the screen assembles itself as JSON arrives instead of waiting for the full response. This is the generative-UI counterpart to the existing JSON SDUI path, reusing the whole NebulaComponent model and renderer.

Why

The JSON path today needs the complete document before it can render (decodeFromString). A model dribbles JSON out over seconds. This module closes that gap so you can point Nebula at any LLM and watch native Compose UI build progressively.

How it works

• repairToValidJson — a single-pass, string/scalar-aware repair that turns any prefix of a JSON document into the largest valid JSON so far (balancing open containers, dropping a dangling ,, a half-typed key, or an in-progress number). This is the core trick that makes partial output renderable.
• Flow<String>.asNebulaTree() — buffers tokens, repairs, decodes to NebulaComponent, and emits a new tree only when it changes.
• NebulaStream — a @Composable that observes the flow and renders the partial tree via the existing Nebula(component = …), refilling on each update.
• NebulaPrompt.system() — auto-generates the system prompt from the component + action catalog, so the model only emits components the renderer understands (prompt and renderer can't drift).
• NebulaUiSource — pluggable, bring-your-own-model interface (core only consumes a Flow<String>). MockNebulaUiSource drives previews/tests with no network.

No changes to nebula-core — this builds entirely on top.

Tests

:nebula-genui:desktopTest — 12 tests, all green. Highlights:

• Every prefix of a nested document repairs to structurally valid JSON (never throws).
• Dangling keys/colons/commas and in-progress numbers are dropped; complete values are kept.
• The stream emits progressively and ends on the complete tree; consecutive emissions are distinct.
• The generated prompt lists every component and action type.

Notes / follow-ups

• Root also builds Android; CI compiles nebula-core only, so this module is verified locally via the desktop target.
• A value string currently reappears when its closing quote arrives (dropped-to-last-complete-field). A future refinement can close in-progress value strings to stream partial text as it types.

[AndroidPoet]

What

A new nebula-genui module that renders a Nebula component tree an LLM streams back token by token — the screen assembles itself as JSON arrives instead of waiting for the full response. This is the generative-UI counterpart to the existing JSON SDUI path, reusing the whole NebulaComponent model and renderer.

Why

The JSON path today needs the complete document before it can render (decodeFromString). A model dribbles JSON out over seconds. This module closes that gap so you can point Nebula at any LLM and watch native Compose UI build progressively.

How it works

• repairToValidJson — a single-pass, string/scalar-aware repair that turns any prefix of a JSON document into the largest valid JSON so far (balancing open containers, dropping a dangling ,, a half-typed key, or an in-progress number). This is the core trick that makes partial output renderable.
• Flow<String>.asNebulaTree() — buffers tokens, repairs, decodes to NebulaComponent, and emits a new tree only when it changes.
• NebulaStream — a @Composable that observes the flow and renders the partial tree via the existing Nebula(component = …), refilling on each update.
• NebulaPrompt.system() — auto-generates the system prompt from the component + action catalog, so the model only emits components the renderer understands (prompt and renderer can't drift).
• NebulaUiSource — pluggable, bring-your-own-model interface (core only consumes a Flow<String>). MockNebulaUiSource drives previews/tests with no network.

No changes to nebula-core — this builds entirely on top.

Tests

:nebula-genui:desktopTest — 12 tests, all green. Highlights:

• Every prefix of a nested document repairs to structurally valid JSON (never throws).
• Dangling keys/colons/commas and in-progress numbers are dropped; complete values are kept.
• The stream emits progressively and ends on the complete tree; consecutive emissions are distinct.
• The generated prompt lists every component and action type.

Notes / follow-ups

• Root also builds Android; CI compiles nebula-core only, so this module is verified locally via the desktop target.
• A value string currently reappears when its closing quote arrives (dropped-to-last-complete-field). A future refinement can close in-progress value strings to stream partial text as it types.

[AndroidPoet]

What

A new nebula-genui module that renders a Nebula component tree an LLM streams back token by token — the screen assembles itself as JSON arrives instead of waiting for the full response. This is the generative-UI counterpart to the existing JSON SDUI path, reusing the whole NebulaComponent model and renderer.

Why

The JSON path today needs the complete document before it can render (decodeFromString). A model dribbles JSON out over seconds. This module closes that gap so you can point Nebula at any LLM and watch native Compose UI build progressively.

How it works

• repairToValidJson — a single-pass, string/scalar-aware repair that turns any prefix of a JSON document into the largest valid JSON so far (balancing open containers, dropping a dangling ,, a half-typed key, or an in-progress number). This is the core trick that makes partial output renderable.
• Flow<String>.asNebulaTree() — buffers tokens, repairs, decodes to NebulaComponent, and emits a new tree only when it changes.
• NebulaStream — a @Composable that observes the flow and renders the partial tree via the existing Nebula(component = …), refilling on each update.
• NebulaPrompt.system() — auto-generates the system prompt from the component + action catalog, so the model only emits components the renderer understands (prompt and renderer can't drift).
• NebulaUiSource — pluggable, bring-your-own-model interface (core only consumes a Flow<String>). MockNebulaUiSource drives previews/tests with no network.

No changes to nebula-core — this builds entirely on top.

Tests

:nebula-genui:desktopTest — 12 tests, all green. Highlights:

• Every prefix of a nested document repairs to structurally valid JSON (never throws).
• Dangling keys/colons/commas and in-progress numbers are dropped; complete values are kept.
• The stream emits progressively and ends on the complete tree; consecutive emissions are distinct.
• The generated prompt lists every component and action type.

Notes / follow-ups

• Root also builds Android; CI compiles nebula-core only, so this module is verified locally via the desktop target.
• A value string currently reappears when its closing quote arrives (dropped-to-last-complete-field). A future refinement can close in-progress value strings to stream partial text as it types.

[AndroidPoet]

What

A new nebula-genui module that renders a Nebula component tree an LLM streams back token by token — the screen assembles itself as JSON arrives instead of waiting for the full response. This is the generative-UI counterpart to the existing JSON SDUI path, reusing the whole NebulaComponent model and renderer.

Why

The JSON path today needs the complete document before it can render (decodeFromString). A model dribbles JSON out over seconds. This module closes that gap so you can point Nebula at any LLM and watch native Compose UI build progressively.

How it works

• repairToValidJson — a single-pass, string/scalar-aware repair that turns any prefix of a JSON document into the largest valid JSON so far (balancing open containers, dropping a dangling ,, a half-typed key, or an in-progress number). This is the core trick that makes partial output renderable.
• Flow<String>.asNebulaTree() — buffers tokens, repairs, decodes to NebulaComponent, and emits a new tree only when it changes.
• NebulaStream — a @Composable that observes the flow and renders the partial tree via the existing Nebula(component = …), refilling on each update.
• NebulaPrompt.system() — auto-generates the system prompt from the component + action catalog, so the model only emits components the renderer understands (prompt and renderer can't drift).
• NebulaUiSource — pluggable, bring-your-own-model interface (core only consumes a Flow<String>). MockNebulaUiSource drives previews/tests with no network.

No changes to nebula-core — this builds entirely on top.

Tests

:nebula-genui:desktopTest — 12 tests, all green. Highlights:

• Every prefix of a nested document repairs to structurally valid JSON (never throws).
• Dangling keys/colons/commas and in-progress numbers are dropped; complete values are kept.
• The stream emits progressively and ends on the complete tree; consecutive emissions are distinct.
• The generated prompt lists every component and action type.

Notes / follow-ups

• Root also builds Android; CI compiles nebula-core only, so this module is verified locally via the desktop target.
• A value string currently reappears when its closing quote arrives (dropped-to-last-complete-field). A future refinement can close in-progress value strings to stream partial text as it types.

[AndroidPoet]

What

A new nebula-genui module that renders a Nebula component tree an LLM streams back token by token — the screen assembles itself as JSON arrives instead of waiting for the full response. This is the generative-UI counterpart to the existing JSON SDUI path, reusing the whole NebulaComponent model and renderer.

Why

The JSON path today needs the complete document before it can render (decodeFromString). A model dribbles JSON out over seconds. This module closes that gap so you can point Nebula at any LLM and watch native Compose UI build progressively.

How it works

• repairToValidJson — a single-pass, string/scalar-aware repair that turns any prefix of a JSON document into the largest valid JSON so far (balancing open containers, dropping a dangling ,, a half-typed key, or an in-progress number). This is the core trick that makes partial output renderable.
• Flow<String>.asNebulaTree() — buffers tokens, repairs, decodes to NebulaComponent, and emits a new tree only when it changes.
• NebulaStream — a @Composable that observes the flow and renders the partial tree via the existing Nebula(component = …), refilling on each update.
• NebulaPrompt.system() — auto-generates the system prompt from the component + action catalog, so the model only emits components the renderer understands (prompt and renderer can't drift).
• NebulaUiSource — pluggable, bring-your-own-model interface (core only consumes a Flow<String>). MockNebulaUiSource drives previews/tests with no network.

No changes to nebula-core — this builds entirely on top.

Tests

:nebula-genui:desktopTest — 12 tests, all green. Highlights:

• Every prefix of a nested document repairs to structurally valid JSON (never throws).
• Dangling keys/colons/commas and in-progress numbers are dropped; complete values are kept.
• The stream emits progressively and ends on the complete tree; consecutive emissions are distinct.
• The generated prompt lists every component and action type.

Notes / follow-ups

• Root also builds Android; CI compiles nebula-core only, so this module is verified locally via the desktop target.
• A value string currently reappears when its closing quote arrives (dropped-to-last-complete-field). A future refinement can close in-progress value strings to stream partial text as it types.

[AndroidPoet]

What

A new nebula-genui module that renders a Nebula component tree an LLM streams back token by token — the screen assembles itself as JSON arrives instead of waiting for the full response. This is the generative-UI counterpart to the existing JSON SDUI path, reusing the whole NebulaComponent model and renderer.

Why

The JSON path today needs the complete document before it can render (decodeFromString). A model dribbles JSON out over seconds. This module closes that gap so you can point Nebula at any LLM and watch native Compose UI build progressively.

How it works

• repairToValidJson — a single-pass, string/scalar-aware repair that turns any prefix of a JSON document into the largest valid JSON so far (balancing open containers, dropping a dangling ,, a half-typed key, or an in-progress number). This is the core trick that makes partial output renderable.
• Flow<String>.asNebulaTree() — buffers tokens, repairs, decodes to NebulaComponent, and emits a new tree only when it changes.
• NebulaStream — a @Composable that observes the flow and renders the partial tree via the existing Nebula(component = …), refilling on each update.
• NebulaPrompt.system() — auto-generates the system prompt from the component + action catalog, so the model only emits components the renderer understands (prompt and renderer can't drift).
• NebulaUiSource — pluggable, bring-your-own-model interface (core only consumes a Flow<String>). MockNebulaUiSource drives previews/tests with no network.

No changes to nebula-core — this builds entirely on top.

Tests

:nebula-genui:desktopTest — 12 tests, all green. Highlights:

• Every prefix of a nested document repairs to structurally valid JSON (never throws).
• Dangling keys/colons/commas and in-progress numbers are dropped; complete values are kept.
• The stream emits progressively and ends on the complete tree; consecutive emissions are distinct.
• The generated prompt lists every component and action type.

Notes / follow-ups

• Root also builds Android; CI compiles nebula-core only, so this module is verified locally via the desktop target.
• A value string currently reappears when its closing quote arrives (dropped-to-last-complete-field). A future refinement can close in-progress value strings to stream partial text as it types.