Fuaran.UI.ServerDriven 0.78.1

Prefix Reserved

There is a newer version of this package available.
See the version list below for details.

dotnet add package Fuaran.UI.ServerDriven --version 0.78.1

NuGet\Install-Package Fuaran.UI.ServerDriven -Version 0.78.1

This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.

<PackageReference Include="Fuaran.UI.ServerDriven" Version="0.78.1" />

For projects that support PackageReference, copy this XML node into the project file to reference the package.

<PackageVersion Include="Fuaran.UI.ServerDriven" Version="0.78.1" />
                    

                            Directory.Packages.props

<PackageReference Include="Fuaran.UI.ServerDriven" />
                    

                            Project file

For projects that support Central Package Management (CPM), copy this XML node into the solution Directory.Packages.props file to version the package.

paket add Fuaran.UI.ServerDriven --version 0.78.1

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

#r "nuget: Fuaran.UI.ServerDriven, 0.78.1"

#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.

#:package Fuaran.UI.ServerDriven@0.78.1

#:package directive can be used in C# file-based apps starting in .NET 10 preview 4. Copy this into a .cs file before any lines of code to reference the package.

#addin nuget:?package=Fuaran.UI.ServerDriven&version=0.78.1
                    

                            Install as a Cake Addin

#tool nuget:?package=Fuaran.UI.ServerDriven&version=0.78.1
                    

                            Install as a Cake Tool

The NuGet Team does not provide support for this client. Please contact its maintainers for support.

Fuaran.UI.ServerDriven

The transport-agnostic core for server-driven interactivity over a Fuaran tree — the third client tier (alongside the Fable client renderer and the Phase 143 hydrateRoot hydration), HTMX / Phoenix-LiveView / Blazor-Server-shaped: keep the Elmish update loop on the server, ship one tiny generic JS shim to the browser, and patch the DOM in place.

The loop: browser event on a [data-fuaran-node-id] element → server runs update → re-renders the tree → diffs old→new into a TreeOp list (Fuaran.UI.OpStream.Replay.TreeOpDiff) → lowers each op to a DomPatch (rendering HTML fragments via Fuaran.UI.Renderer.Server for structure-adding ops) → sends the patch → the shim applies it (targeted, no full re-render, no flash).

What's here

DomPatch — the lowered, closure-free, browser-applyable patch vocabulary (8 primitives: SetAttr / RemoveAttr / SetText / ReplaceFragment / InsertFragment / RemoveNode / ReorderChildren / MoveNode). The shim's entire instruction set. Tagged-object camelCase JSON.
ClientEffect — the parallel channel for client-only effects the server decides but the shim performs (WriteToClipboard / Navigate / Focus / Download / ReadFileBody), because they are inherently browser-side and have no DOM-mutation form.
Lowering — TreeOp → DomPatch (Lowering.lower : renderFragment -> newTree -> TreeOp list -> DomPatch list). Structural ops lower directly (RemoveNode / ReorderChildren / MoveNode / InsertChild→InsertFragment); content ops re-render the changed node (looked up in the post-apply tree) into a targeted ReplaceFragment; Batch flattens. The HTML renderer is injected (renderFragment : Node<'Msg> -> string) rather than a hard Renderer.Server dependency — keeps the core Fable-clean + dependency-light and dodges the Node<obj> cast; the host wires Render.render.
content/fuaran-live-patch.js — the generic browser shim (shipped as package content under content/). App-agnostic, framework-free vanilla JS (~a few KB): event delegation on [data-fuaran-node-id], a transport adapter (connect/send — the client mirror of IFuaranLiveChannel, default SSE-push + POST-receive), the DomPatch applier (addresses by node id; MoveNode / ReorderChildren relocate the live element, identity-preserving), and the ClientEffect performer. Auto-starts from <script src="fuaran-live-patch.js" data-fuaran-live-stream="/live/stream" data-fuaran-live-send="/live/event">, or call FuaranLive.start(config, adapterFactory?) explicitly (a WebSocket adapter is a drop-in — only the adapter object changes; the patch/effect/delegation core is transport-identical). start() is restartable — hosts that swap the live tree per page state call it repeatedly: each call closes the previous stream and re-points the once-wired document-level delegation at the new transport (no leaked EventSource, no duplicate sends). Click payloads bridge layout interactivity server-side: a tab-header click carries payload.index (from the server renderer's data-tab-index), a disclosure summary click carries payload.open (from the <details> state). Browser-verified via samples/server-driven (tabs + disclosure + repeated start()); no headless unit tests.

Roadmap (Phase 152)

✅ Track A — the TreeOp-emitting diff (Fuaran.UI.OpStream.Replay.TreeOpDiff).
Track B (in progress) — ✅ the DomPatch / ClientEffect wire vocabularies (this package), ✅ the TreeOp → DomPatch lowering (renderer injected), ✅ the generic JS shim. Remaining: the granular SetText / SetAttr lowering follow-on (currently content ops re-render the node via ReplaceFragment — correct + targeted, just not field-level).
Track C (in progress) — ✅ the G1 inbound trust boundary (Validation.fs — the non-negotiable default-deny gate: node-exists / event-legitimate-for-kind / payload-in-bounds / dispatch-policy-gated, mirroring the client runAction gate server-side), ✅ the per-connection driver (Driver.fs — LiveSession + step: validate → interpret → update → re-view → diff → lower → DomPatch/ClientEffect, with the server-closure win + the server-executable/client-only split). Remaining: the explicit per-field Binding.Local / CommitLocal form-buffer protocol (the floor — client-buffered, server-sees-the-flush — already holds).
Track D ✅ — the IFuaranLiveChannel transport seam + Frame + InMemoryChannel + LiveConnection (Channel.fs), transport-agnostic reconnect replay (LiveConnection.Resync), the SSE frame wire encoding (FrameWire.fs), and both backends: Fuaran.UI.ServerDriven.AspNetCore (SSE+POST, the v1 default — verified end-to-end via the sample) and Fuaran.UI.ServerDriven.WebSocket (the lower-latency drop-in; its structural identity to the SSE backend proves the seam is transport-neutral).
Track E ✅ — fuaran-dotnet/docs/SERVER_DRIVEN.md (architecture + transport analysis + the per-arm tables) and samples/server-driven (an SSR counter made live via the shim + the SSE backend, no client bundle).

No platform-SDK dependency appears anywhere here — the SSE framing is implemented here, not depended on.

Apache-2.0 licensed — see the repo LICENSE.

Product	Compatible and additional computed target framework versions.
.NET	net10.0 is compatible. net10.0-android was computed. net10.0-browser was computed. net10.0-ios was computed. net10.0-maccatalyst was computed. net10.0-macos was computed. net10.0-tvos was computed. net10.0-windows was computed.

Compatible target framework(s)

Included target framework(s) (in package)

Learn more about Target Frameworks and .NET Standard.

net10.0
- Fable.Core (>= 5.0.0)
- FSharp.Core (>= 10.1.300)
- Fuaran.Core.Column (>= 0.21.0)
- Fuaran.Core.DataFrame (>= 0.21.0)
- Fuaran.Core.Function (>= 0.21.0)
- Fuaran.Core.Ops (>= 0.21.0)
- Fuaran.Core.OpStream (>= 0.21.0)
- Fuaran.Core.Tree (>= 0.21.0)
- Fuaran.Core.Validator (>= 0.21.0)
- Fuaran.Core.Wire (>= 0.21.0)
- Fuaran.UI (>= 0.78.1)
- Fuaran.UI.Ops (>= 0.78.1)
- Fuaran.UI.OpStream.Replay (>= 0.78.1)
- Fuaran.UI.Renderer.Core (>= 0.78.1)

NuGet packages (4)

Showing the top 4 NuGet packages that depend on Fuaran.UI.ServerDriven:

Package	Downloads
Fuaran.UI.ServerDriven.WebSocket Fuaran server-driven backend 2 — one bidirectional WebSocket channel over ASP.NET. The lower-latency transport for measured high-frequency interaction (per-keystroke, drag, live cursors). A first-class second backend whose structural identity to the SSE backend (differing only in channel + endpoint glue) is the architectural-integrity check that IFuaranLiveChannel is genuinely transport-neutral. No platform-SDK dependency. Apache-2.0 licensed.	3.3K
Fuaran.UI.ServerDriven.AspNetCore Fuaran server-driven backend 1 (v1 default) — SSE-push + POST-receive over ASP.NET. The thin transport glue around the Fuaran.UI.ServerDriven core: an SSE IFuaranLiveChannel, the POST inbound parser, the connection registry, and the GET-stream / POST-event endpoint wiring (mapFuaranLive). Default because SSE+POST rides natively through proxies/CDNs/WAFs, gets per-event HTTP governance for free, and maps reconnect 1:1 onto the journal via Last-Event-ID. No platform-SDK dependency (the SSE framing is self-contained). Apache-2.0 licensed.	3.3K
Fuaran.Program.Server.UI Fuaran.Program.Server.UI — the UI adapter for the server placement of the domain-generic bounded program core: the pre-0.6.0 server names as aliases over the UI witness, and the UI event step (the validation gate in front of the core's dispatch) for the server session, the durable interpreter and the operator controls. .NET only. Released in the same version as the core it instantiates. Apache-2.0 licensed.	35
Fuaran.Program.UI Fuaran.Program.UI — the UI adapter for the domain-generic bounded program core: the UI witness (the UI tier's action union, node tree, binding store, tree-ops and client effects seen through the core's witness contract), the pre-0.6.0 names as aliases over it, and the UI transport loop (the bounded driver, its channel glue and the client runtime). Fable-clean. Released in the same version as the core it instantiates. Apache-2.0 licensed.	33

GitHub repositories

This package is not used by any popular GitHub repositories.