Datastar + dotnet

https://github.com/starfederation/datastar-dotnet
Admin
Datastar + dotnet is a real-time hypermedia-first library and framework for dotnet, enabling...
Tokens:48,728
Snippets:296
Trust Score:8.5
License:MIT
Update:23 hours ago
Show doc for...
Tokens:
Raw
### F# HelloWorld Program with Datastar SSE Endpoints

Source: https://github.com/starfederation/datastar-dotnet/blob/main/README.md

Complete F# backend using ASP.NET Core and StarFederation.Datastar.FSharp. Defines a MySignals record for input/output, maps GET /displayDate to patch a date element, GET /removeDate to remove it, and POST /changeOutput to read signals and patch the output. Requires StarFederation.Datastar.FSharp package and ASP.NET Core services.

```fsharp
namespace HelloWorld
open System
open System.Text.Json
open System.Threading.Tasks
open Microsoft.AspNetCore.Builder
open Microsoft.AspNetCore.Http
open Microsoft.Extensions.DependencyInjection
open Microsoft.Extensions.Hosting
open StarFederation.Datastar.FSharp

module Program =
    let message = "Hello, world!"

    [<CLIMutable>]
    type MySignals = { input:string; output:string }

    [<EntryPoint>]
    let main args =

        let builder = WebApplication.CreateBuilder(args)
        builder.Services.AddHttpContextAccessor();
        let app = builder.Build()
        app.UseStaticFiles()

        app.MapGet("/displayDate", Func<IHttpContextAccessor, Task>(fun ctx -> task {
            do! ServerSentEventGenerator.StartServerEventStreamAsync(ctx.HttpContext.Response)
            let today = DateTime.Now.ToString("%y-%M-%d %h:%m:%s")
            do! ServerSentEventGenerator.PatchElementsAsync(ctx.HttpContext.Response, $"""<div id='target'><span id='date'><b>{today}</b><button data-on:click="@get('/removeDate')">Remove</button></span></div>""")
        }))

        app.MapGet("/removeDate", Func<IHttpContextAccessor, Task>(fun ctx -> task {
            do! ServerSentEventGenerator.StartServerEventStreamAsync(ctx.HttpContext.Response)
            do! ServerSentEventGenerator.RemoveElementAsync (ctx.HttpContext.Response, "#date")
        }))

        app.MapPost("/changeOutput", Func<IHttpContextAccessor, Task>(fun ctx -> task {
            do! ServerSentEventGenerator.StartServerEventStreamAsync(ctx.HttpContext.Response)
            let! signals = ServerSentEventGenerator.ReadSignalsAsync<MySignals>(ctx.HttpContext.Request)
            let signals' = signals |> ValueOption.defaultValue { input = ""; output = "" }
            do! ServerSentEventGenerator.PatchSignalsAsync(ctx.HttpContext.Response, JsonSerializer.Serialize( { signals' with output = $"Your input: {signals'.input}" } ))
        }))

        app.Run()

        0
```

--------------------------------

### F# minimal setup with AddHttpContextAccessor

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/configuration.md

For F# without DI extension: register IHttpContextAccessor and construct ServerSentEventGenerator per request.

```fsharp
let builder = WebApplication.CreateBuilder(args)
builder.Services.AddHttpContextAccessor()
```

--------------------------------

### AddDatastar usage example

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/dependency-injection.md

Shows how to register Datastar services and use IDatastarService in a minimal API endpoint. Requires the StarFederation.Datastar.DependencyInjection namespace.

```csharp
using StarFederation.Datastar.DependencyInjection;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
builder.Services.AddDatastar();
WebApplication app = builder.Build();

app.MapGet("/displayDate", async (IDatastarService datastarService) =>
{
    await datastarService.PatchElementsAsync("<div id='date'>Today</div>");
});
```

--------------------------------

### AddJsonOptions usage example

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/dependency-injection.md

Configures JsonSerializerOptions for signal serialization. Throws ArgumentNullException if builder or configureOptions is null.

```csharp
builder.Services
    .AddDatastar()
    .AddJsonOptions(options =>
    {
        options.Converters.Add(new JsonStringEnumConverter());
        options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
    });
```

--------------------------------

### Usage examples for SignalPath, Selector, and Signals

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Shows how to use SignalPath.tryCreate, Selector.create/tryCreate, Signals.tryCreate, and PatchElementsOptions with defaults. Includes handling of invalid inputs returning ValueNone.

```fsharp
open StarFederation.Datastar.FSharp
open System.Text.Json

// Building a typed signal path
match SignalPath.tryCreate "settings.theme" with
| ValueSome path ->
    let segments = SignalPath.keys path           // [| "settings"; "theme" |]
    let kebab = SignalPath.kebabValue path        // "settings-theme"
| ValueNone -> printfn "invalid path"

// Safe selector/non-JSON handling
let selector = Selector.create "#main"            // ok
let badSelector = Selector.tryCreate "http://x"   // ValueNone -> no exception

let signals = Signals.tryCreate """{"a":1}"""     // ValueSome (Signals "{...}")
let invalid = Signals.tryCreate "not json"        // ValueNone

// Options with defaults
let options = { PatchElementsOptions.Defaults with
                    Selector = ValueSome "#target"
                    UseViewTransition = true }
```

--------------------------------

### SendEventAsync private method

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Enqueues an event task and starts the SSE stream on first call if not already started. Dequeues FIFO and awaits the event task; response start is idempotent.

```fsharp
member private this.SendEventAsync(sendEventTask:unit -> Task, cancellationToken:CancellationToken) =
    backgroundTask {
        _eventQueue.Enqueue(sendEventTask)
        do!
            if _startResponseTask <> null
            then _startResponseTask
            else this.StartServerEventStreamAsync(Seq.empty, cancellationToken)
        let (_, sendEventTask') = _eventQueue.TryDequeue()
        return! sendEventTask' ()
    }
```

--------------------------------

### Example: readAndPatch using ReadSignalsAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Shows how to read signals and patch them back. Uses ServerSentEventGenerator.ReadSignalsAsync and PatchSignalsAsync. Requires open StarFederation.Datastar.FSharp and Microsoft.AspNetCore.Http.

```fsharp
open StarFederation.Datastar.FSharp
open Microsoft.AspNetCore.Http

let readAndPatch (ctx: HttpContext) = task {
    let! signals : MySignals voption =
        ServerSentEventGenerator.ReadSignalsAsync<MySignals>(ctx.Request, JsonSerializerOptions.SignalsDefault, ctx.RequestAborted)
    match signals with
    | ValueSome s -> return! ServerSentEventGenerator.PatchSignalsAsync(ctx.Response, JsonSerializer.Serialize({ s with Output = "ok" }))
    | ValueNone   -> return! ServerSentEventGenerator.PatchSignalsAsync(ctx.Response, """{"Output":"missing"}""")
}
```

--------------------------------

### Minimal DI registration with AddDatastar

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/configuration.md

Required setup for ASP.NET Core: registers IOptions<DatastarJsonOptions>, IHttpContextAccessor, and scoped IDatastarService. Must be called before building the app.

```csharp
WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
builder.Services.AddDatastar();
WebApplication app = builder.Build();
```

--------------------------------

### Read DatastarJsonOptions via IOptions

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/configuration.md

Example controller injecting IOptions<DatastarJsonOptions> to access SignalsJsonSerializerOptions. Useful when you need the effective serializer options.

```csharp
public class MyController : ControllerBase
{
    private readonly IOptions<DatastarJsonOptions> _options;
    public MyController(IOptions<DatastarJsonOptions> options) => _options = options;

    public JsonSerializerOptions EffectiveOptions => _options.Value.SignalsJsonSerializerOptions;
}
```

--------------------------------

### StartServerEventStreamAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Starts the server-sent event stream. The instance method starts the stream directly under a lock and caches the task; static and instance short-hand overloads are provided with default cancellation tokens and options.

```APIDOC
## StartServerEventStreamAsync

### Description
Starts the server-sent event stream. The instance method starts the stream directly under a lock and caches the task.

### Method
F# member function

### Signatures

#### Instance (full)
```fsharp
member this.StartServerEventStreamAsync(additionalHeaders, cancellationToken) : Task
```

#### Instance short-hands
```fsharp
member this.StartServerEventStreamAsync(additionalHeaders)
member this.StartServerEventStreamAsync(cancellationToken: CancellationToken)
member this.StartServerEventStreamAsync()
```

#### Static short-hands
```fsharp
static member StartServerEventStreamAsync(httpResponse, additionalHeaders)
static member StartServerEventStreamAsync(httpResponse)
static member StartServerEventStreamAsync(httpResponse, cancellationToken)
```

### Parameters
- **additionalHeaders** - Additional headers for the response.
- **cancellationToken** - Cancellation token; defaults to `httpResponse.HttpContext.RequestAborted` (static) or `defaultCancellationToken` (instance).
- **httpResponse** - The HTTP response object (static overloads).

### Remarks
- Instance methods delegate to static members using the captured `httpResponse` / `httpRequest`.
- Write members route through `SendEventAsync` (queue + automatic start).
- `StartServerEventStreamAsync(additionalHeaders, cancellationToken)` is the one instance method that starts the stream directly under `_startResponseLock` and caches the task.
```

--------------------------------

### PatchSignalsAsync usage with PatchSignalsOptions

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/options-types.md

Shows how to call PatchSignalsAsync with a PatchSignalsOptions instance. The example sets OnlyIfMissing to true and passes a new { Count = 42 } signal.

```csharp
await datastarService.PatchSignalsAsync(
    new { Count = 42 },
    new PatchSignalsOptions { OnlyIfMissing = true });
```

--------------------------------

### Using PatchElementsOptions in MapGet

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/options-types.md

Example of passing PatchElementsOptions to PatchElementsAsync in an endpoint. Sets Selector, PatchMode, UseViewTransition, ViewTransitionSelector, EventId, and Retry.

```csharp
app.MapGet("/patch", async (IDatastarService s) =>
{
    await s.PatchElementsAsync(
        "<div id='target'>New content</div>",
        new PatchElementsOptions
        {
            Selector = "#target",
            PatchMode = ElementPatchMode.Replace,
            UseViewTransition = true,
            ViewTransitionSelector = "#container",
            EventId = "patch-1",
            Retry = TimeSpan.FromSeconds(2)
        });
});
```

--------------------------------

### Minimal API example with AddDatastar and PatchElementsAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Registers the Datastar service via AddDatastar and uses IDatastarService to patch elements in a minimal API endpoint. Requires the StarFederation.Datastar.DependencyInjection namespace.

```csharp
using StarFederation.Datastar.DependencyInjection;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
builder.Services.AddDatastar();
WebApplication app = builder.Build();

app.MapGet("/stream", async (IDatastarService datastarService) =>
{
    await datastarService.PatchElementsAsync("<div id='target'>Hello</div>");
});
```

--------------------------------

### C# Backend with Datastar service

Source: https://github.com/starfederation/datastar-dotnet/blob/main/README.md

C# backend using StarFederation.Datastar to register the service, handle GET and POST endpoints, and read/patch signals. Includes a MySignals record for typed signal handling.

```csharp
using StarFederation.Datastar;
using StarFederation.Datastar.DependencyInjection;
using System.Text.Json;
using System.Text.Json.Serialization;

// add as an ASP Service
//  allows injection of IDatastarService, to respond to a request with a Datastar friendly ServerSentEvent
//  and to read the signals sent by the client
builder.Services
    .AddDatastar()
    .AddJsonOptions(options =>
    {
        options.Converters.Add(new JsonStringEnumConverter());
    });

// displayDate - patching an element
app.MapGet("/displayDate", async (IDatastarService datastarService) =>
{
    string today = DateTime.Now.ToString("%y-%M-%d %h:%m:%s");
    await datastarService.PatchElementsAsync($"""<div id='target'><span id='date'><b>{today}</b><button data-on:click="@get('/removeDate')">Remove</button></span></div>""");
});

// removeDate - removing an element
app.MapGet("/removeDate", async (IDatastarService datastarService) => { await datastarService.RemoveElementAsync("#date"); });

public record MySignals {
    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    public string? Input { get; init; } = null;

    [JsonIgnore(Condition = JsonIgnoreCondition.WhenWritingNull)]
    public string? Output { get; init; } = null;

    public string Serialize() => ...
}

// changeOutput - reads the signals, update the Output, and merge back
app.MapPost("/changeOutput", async (IDatastarService datastarService) => ...
{
    MySignals signals = await datastarService.ReadSignalsAsync<MySignals>();
    MySignals newSignals = new() { Output = $"Your Input: {signals.Input}" };
    await datastarService.PatchSignalsAsync(newSignals.Serialize());
});
```

--------------------------------

### HTML Frontend with Datastar attributes

Source: https://github.com/starfederation/datastar-dotnet/blob/main/README.md

HTML page using Datastar attributes to bind signals and handle click events. The buttons trigger GET and POST requests to the backend endpoints.

```html
<main class="container" id="main" data-signals="{'input':'','output':'empty'}">
    <button data-on:click="@get('/displayDate')">Display Date</button>
    <div id="target"></div>
    <input type="text" placeholder="input:" data-bind:input/><br/>
    <span data-text="$output"></span>
    <button data-on:click="@post('/changeOutput')">Change Output</button>
</main>
```

--------------------------------

### Selector.create valid and invalid examples

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/errors.md

Selector.create throws System.Exception with message "{input} is not a valid selector" when the input does not match the compiled CSS-selector regex (Selector.regex). Use Selector.tryCreate (returns ValueNone) or wrap in try...with to handle invalid selectors.

```fsharp
let s = Selector.create "#main"      // ok
let s' = Selector.create "not a selector??"  // throws
```

--------------------------------

### StartServerEventStreamAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Starts a server-sent event stream on the HTTP response, setting appropriate headers and flushing the body writer. Additional headers are added only if not already present.

```APIDOC
## StartServerEventStreamAsync

### Description
Starts a server-sent event stream on the HTTP response, setting `ContentType` to `text/event-stream`, `CacheControl` to `no-cache`, and for HTTP/1.1 also `Connection` to `keep-alive`. Additional headers are added only if not already present, then the response is started and flushed.

### Method
Static member (F#)

### Signature
```fsharp
static member StartServerEventStreamAsync(httpResponse:HttpResponse, additionalHeaders:KeyValuePair<string, StringValues> seq, cancellationToken:CancellationToken) : Task
```

### Parameters
- **httpResponse** (`HttpResponse`) - Target response
- **additionalHeaders** (`KeyValuePair<string, StringValues> seq`) - Extra headers (added only if absent)
- **cancellationToken** (`CancellationToken`) - Aborts response start

### Response
Returns a `Task` representing the asynchronous operation.
```

--------------------------------

### RemoveElementAsync usage with RemoveElementOptions

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/options-types.md

Shows how to call RemoveElementAsync with a RemoveElementOptions instance. The example sets UseViewTransition to true and EventId to "remove-1".

```csharp
await datastarService.RemoveElementAsync("#modal", new RemoveElementOptions
{
    UseViewTransition = true,
    EventId = "remove-1"
});
```

--------------------------------

### StartServerEventStreamAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Starts the server-sent event stream for the current HTTP response. Multiple overloads allow specifying additional headers and a cancellation token.

```APIDOC
## StartServerEventStreamAsync

### Description
Starts the server-sent event stream for the current HTTP response. Multiple overloads allow specifying additional headers and a cancellation token.

### Method
C# method

### Signature
```csharp
Task StartServerEventStreamAsync();
Task StartServerEventStreamAsync(CancellationToken cancellationToken);
Task StartServerEventStreamAsync(IEnumerable<KeyValuePair<string, StringValues>> additionalHeaders);
Task StartServerEventStreamAsync(IEnumerable<KeyValuePair<string, string>> additionalHeaders);
Task StartServerEventStreamAsync(IEnumerable<KeyValuePair<string, StringValues>> additionalHeaders, CancellationToken cancellationToken);
Task StartServerEventStreamAsync(IEnumerable<KeyValuePair<string, string>> additionalHeaders, CancellationToken cancellationToken);
```

### Parameters
- **additionalHeaders** (IEnumerable<KeyValuePair<string, StringValues>> or IEnumerable<KeyValuePair<string, string>>) - Optional - Additional headers to include in the response.
- **cancellationToken** (CancellationToken) - Optional - Token to cancel the operation.

### Returns
- **Task** - A task representing the asynchronous operation.
```

--------------------------------

### StartServerEventStreamAsync with custom headers

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Starts the server-sent event stream with additional headers. The headers are added only if not already present on the response. The stream is started exactly once per request.

```csharp
await datastarService.StartServerEventStreamAsync(new Dictionary<string, string>
{
    ["X-Custom-Header"] = "value"
});
```

--------------------------------

### StartServerEventStreamAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Sets the 200 text/event-stream response with headers Content-Type: text/event-stream and Cache-Control: no-cache. The stream is started exactly once per request.

```APIDOC
## StartServerEventStreamAsync

### Description
Sets the 200 `text/event-stream` response. Headers set: `Content-Type: text/event-stream`, `Cache-Control: no-cache`; for HTTP/1.1 also `Connection: keep-alive`. The stream is started exactly once per request (guarded by a lock in the F# generator).

### Method
Not specified (method call)

### Endpoint
Not applicable (SDK method)

### Parameters
- **additionalHeaders** (`IEnumerable<KeyValuePair<string, StringValues>>`) - Optional - Headers added only if not already present on the response
- **additionalHeaders** (`IEnumerable<KeyValuePair<string, string>>`) - Optional - Same, converted to `StringValues` per key
- **cancellationToken** (`CancellationToken`) - Optional - Cancels the response start (default: `HttpContext.RequestAborted`)

### Request Example
```csharp
await datastarService.StartServerEventStreamAsync(new Dictionary<string, string>
{
    ["X-Custom-Header"] = "value"
});
```

### Response
Not specified in source.
```

--------------------------------

### EnumToString usage example

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/consts-enums.md

Shows how to call Consts.EnumToString for each enum type. Returns lower-case wire values: "prepend", "svg", and "datastar-patch-signals".

```csharp
using StarFederation.Datastar;

string mode = Consts.EnumToString(ElementPatchMode.Prepend);   // "prepend"
string ns = Consts.EnumToString(PatchElementNamespace.Svg);    // "svg"
string evt = Consts.EnumToString(EventType.PatchSignals);      // "datastar-patch-signals"
```

--------------------------------

### HomeController with [FromSignals] usage

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/model-binding.md

Example controller action that uses [FromSignals] to bind signals to a model. On binder failure, ModelState is invalid, logs a warning, and returns BadRequest with the model state.

```csharp
public class HomeController : ControllerBase
{
    private readonly ILogger<HomeController> _logger;

    [HttpPost("signals")]
    public IActionResult Handle([FromSignals] MySignals signals)
    {
        if (!ModelState.IsValid)           // binder failure sets failed binding
        {
            _logger.LogWarning("Signals binding failed");
            return BadRequest(ModelState);
        }
        return Ok(signals);
    }
}
```

--------------------------------

### Instance-based minimal API (F#)

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Configures a minimal API with Datastar SSE. Maps /displayDate to patch a div with the current date and /changeOutput to read signals and patch the output signal. Requires AddHttpContextAccessor and the StarFederation.Datastar.FSharp namespace.

```fsharp
namespace HelloWorld
open System
open System.Threading.Tasks
open Microsoft.AspNetCore.Builder
open Microsoft.AspNetCore.Http
open Microsoft.Extensions.DependencyInjection
open Microsoft.Extensions.Hosting
open StarFederation.Datastar.FSharp

module Program =
    [<CLIMutable>]
    type MySignals = { input:string; output:string }

    [<EntryPoint>]
    let main args =
        let builder = WebApplication.CreateBuilder(args)
        builder.Services.AddHttpContextAccessor()
        let app = builder.Build()

        app.MapGet("/displayDate", Func<IHttpContextAccessor, Task>(fun ctx -> task {
            let sse = ServerSentEventGenerator(ctx)
            let today = DateTime.Now.ToString("%y-%M-%d %h:%m:%s")
            do! sse.PatchElementsAsync($"""<div id='target'><span id='date'><b>{today}</b></span></div>""")
        }))

        app.MapGet("/changeOutput", Func<IHttpContextAccessor, Task>(fun ctx -> task {
            let sse = ServerSentEventGenerator(ctx)
            let! signals = sse.ReadSignalsAsync<MySignals>()
            let s = signals |> ValueOption.defaultValue { input = ""; output = "" }
            do! sse.PatchSignalsAsync(JsonSerializer.Serialize({ s with output = $"Your input: {s.input}" }))
        }))

        app.Run()
        0
```

--------------------------------

### PatchElementsAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Sends a patch of elements to the client via the server-sent event stream. Used in minimal API example to update the DOM.

```APIDOC
## PatchElementsAsync

### Description
Sends a patch of elements to the client via the server-sent event stream. Used in minimal API example to update the DOM.

### Method
Not specified (method call)

### Endpoint
Not applicable (SDK method)

### Parameters
- **content** (string) - Required - The HTML content to patch (e.g., `<div id='target'>Hello</div>`)

### Request Example
```csharp
await datastarService.PatchElementsAsync("<div id='target'>Hello</div>");
```

### Response
Not specified in source.
```

--------------------------------

### Catch SignalPath.create exception

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/errors.md

Shows how to catch System.Exception from SignalPath.create and print the error message. Use when you must handle invalid input without using tryCreate.

```fsharp
try
    let p = SignalPath.create userInput
    // ...
with :? System.Exception as ex ->
    eprintfn "Invalid signal path: %s" ex.Message
```

--------------------------------

### F# core default serializer

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/configuration.md

Shows how F# consumers can explicitly mirror the C# default serializer options. The ServerSentEventGenerator.ReadSignalsAsync method defaults to these options when no options argument is given.

```APIDOC
## F# core default serializer

### Description
F# consumers can mirror the C# default explicitly.

### Code Example
```fsharp
open StarFederation.Datastar.FSharp
let options = JsonSerializerOptions.SignalsDefault   // JsonSerializerDefaults.Web
```

### Notes
`ServerSentEventGenerator.ReadSignalsAsync<'T>()` defaults to `JsonSerializerOptions.SignalsDefault` when no options argument is given.
```

--------------------------------

### Controller actions using [FromSignals]

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/model-binding.md

Shows how to bind controller action parameters from Datastar signals. Includes binding by parameter name, by path, and splitting a path across multiple parameters. Note: only one [FromSignals] is allowed in the parameter list for requests with signals in the body.

```csharp
public sealed class MyController : ControllerBase
{
    // Binds "myString" key from signals
    public IActionResult Test_GetValues([FromSignals] string myString, [FromSignals] int myInt) => Ok();

    // Binds the inner object at signals path "myInner"
    public IActionResult Test_GetInnerPathed([FromSignals(Path = "myInner")] InnerSignals inner) => Ok();

    // Splits one path across parameters
    public IActionResult Test_GetInnerValues(
        [FromSignals(Path = "myInner.myInnerString")] string innerString,
        [FromSignals(Path = "myInner.myInnerInt")] int innerInt) => Ok();
}
```

--------------------------------

### SignalPath.tryCreate

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Attempts to create a SignalPath from a string, returning a SignalPath option. Returns None if the input is invalid.

```APIDOC
## [FUNCTION] SignalPath.tryCreate

### Description
Attempts to create a SignalPath from a string, returning a SignalPath option. Returns None if the input is invalid.

### Method
F# function

### Signature
`SignalPath.tryCreate : string -> SignalPath option`

### Parameters
- **path** (string) - Required - The string to attempt to create the SignalPath from.

### Returns
- **SignalPath option** - Some SignalPath if successful, None otherwise.

### Example
```fsharp
match SignalPath.tryCreate "foo.bar" with
| Some path -> printfn "%s" path
| None -> printfn "Invalid path"
```
```

--------------------------------

### Define signal model class and use [FromSignals] in actions

Source: https://github.com/starfederation/datastar-dotnet/blob/main/README.md

Defines a MySignals class with nested InnerSignals and shows how to bind signals to action parameters using [FromSignals]. The Path property allows binding to nested or specific signal paths.

```csharp
public class MySignals {
    public string MyString { get; set; } = "";
    public int MyInt { get; set; } = 0;
    public InnerSignals MyInner { get; set; } = new();

    public class InnerSignals {
        public string MyInnerString { get; set; } = "";
        public int MyInnerInt { get; set; } = 0;
    }
}
```

```csharp
public IActionResult Test_GetSignals([FromSignals] MySignals signals) => ...
```

```csharp
public IActionResult Test_GetValues([FromSignals] string myString, [FromSignals] int myInt) => ...
```

```csharp
public IActionResult Test_GetInnerPathed([FromSignals(Path = "myInner")] MySignals.InnerSignals myInnerOther) => ...
```

```csharp
public IActionResult Test_GetInnerValues([FromSignals(Path = "myInner.myInnerString")] string myInnerStringOther, [FromSignals(Path = "myInner.myInnerInt")] int myInnerIntOther) => ...
```

--------------------------------

### Error handling with SignalPath.create

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Shows a safe wrapper around SignalPath.create that falls back to a default path, but raises an exception if the fallback is also invalid.

```fsharp
let safeSignalPath (input: string) : SignalPath =
    match SignalPath.tryCreate input with
    | ValueSome p -> p
    | ValueNone ->
        eprintfn $"'{input}' is not a valid signal path"
        SignalPath.create "fallback"   // raises if fallback is invalid too
```

--------------------------------

### ExecuteScriptAsync with ExecuteScriptOptions

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/options-types.md

Calls ExecuteScriptAsync with options setting AutoRemove true and an extra attribute data-owner. The generated script tag gets data-effect="el.remove()" when AutoRemove is true.

```csharp
await datastarService.ExecuteScriptAsync("initMap()", new ExecuteScriptOptions
{
    AutoRemove = true,
    Attributes = [new KeyValuePair<string, string>("data-owner", "dashboard")]
});
```

--------------------------------

### Per-call option objects

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/configuration.md

Lists the option classes and their associated functions for per-call configuration. These objects are passed per invocation and override the defaults for a single event.

```APIDOC
## Per-call option objects

### Description
These objects are passed per invocation and override the defaults above for a single event.

### Option Classes

| Option class | Function | Keys |
|---|---|---|
| `PatchElementsOptions` | `PatchElementsAsync` | `Selector`, `PatchMode`, `UseViewTransition`, `ViewTransitionSelector`, `Namespace`, `EventId`, `Retry` |
| `RemoveElementOptions` | `RemoveElementAsync` | `UseViewTransition`, `EventId`, `Retry` |
| `PatchSignalsOptions` | `PatchSignalsAsync` | `OnlyIfMissing`, `EventId`, `Retry` |
| `ExecuteScriptOptions` | `ExecuteScriptAsync` | `EventId`, `Retry`, `AutoRemove`, `Attributes` |

### Defaults (from `Consts`, `src/csharp/Consts.cs`)

| Constant | Value |
|---|---|
| `DefaultElementPatchMode` | `Outer` |
| `DefaultPatchElementNamespace` | `Html` |
| `DefaultElementsUseViewTransitions` | `false` |
| `DefaultPatchSignalsOnlyIfMissing` | `false` |
| `DefaultSseRetryDuration` | `TimeSpan.FromMilliseconds(1000)` |
| `DatastarKey` | `"datastar"` |
```

--------------------------------

### Explicit-response static style (F#)

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Uses the static ServerSentEventGenerator methods to start an SSE stream and remove an element by ID. This style works directly with the HttpResponse without needing an instance.

```fsharp
app.MapGet("/remove", Func<IHttpContextAccessor, Task>(fun ctx -> task {
    do! ServerSentEventGenerator.StartServerEventStreamAsync(ctx.HttpContext.Response)
    do! ServerSentEventGenerator.RemoveElementAsync(ctx.HttpContext.Response, "#date")
}))
```

--------------------------------

### Signals.tryCreate returns ValueNone for invalid JSON

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/errors.md

Signals.tryCreate parses a JSON string; if parsing fails, it returns ValueNone instead of throwing. The example shows passing 'not json' and expecting ValueNone.

```fsharp
let v = Signals.tryCreate "not json"    // ValueNone; no exception
```

--------------------------------

### ExecuteScriptAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Writes a datastar-patch-elements event that appends a script to the body. The opening tag depends on the AutoRemove and Attributes options.

```APIDOC
## ExecuteScriptAsync

### Description
Writes a `datastar-patch-elements` event that appends a `<script>` to `body`: `data: selector body`, `data: mode append`, then `data: elements <script ...>` opening tag, one line per script segment, and the `</script>` line.

### Parameters
- **httpResponse** (`HttpResponse`) - Required - Target response
- **script** (`string`) - Required - JS snippet without `<script>` tags
- **options** (`ExecuteScriptOptions`) - Required - `ExecuteScriptOptions.Defaults` (note `AutoRemove = true` in F#) when using short-hands
- **cancellationToken** (`CancellationToken`) - Required - Aborts the flush

### Notes
The opening tag depends on `options.AutoRemove` and `options.Attributes`:

| AutoRemove | Attributes | Opening tag |
|---|---|---|
| `true` | `[]` | `<script data-effect="el.remove()">` |
| `false` | `[]` | `<script>` |
| `true` | non-empty | `<script data-effect="el.remove()" {key}="{html-encoded value}" ...>` |
| `false` | non-empty | `<script {key}="{html-encoded value}" ...>` |

Attribute values are encoded with `HttpUtility.HtmlEncode`.
```

--------------------------------

### PatchElementsAsync with options

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Sends a `datastar-patch-elements` SSE event with options: `Selector`, `PatchMode`, and `UseViewTransition`. The `PatchMode` is set to `ElementPatchMode.Prepend`.

```csharp
await datastarService.PatchElementsAsync(
    "<div id='date'>Today</div>",
    new PatchElementsOptions
    {
        Selector = "#target",
        PatchMode = ElementPatchMode.Prepend,
        UseViewTransition = true,
    });
```

--------------------------------

### ServerSentEventGenerator type declaration

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Defines the sealed F# class with constructor taking IHttpContextAccessor. Captures request, response, and RequestAborted token; fields manage one-shot stream start and event serialization.

```fsharp
[<Sealed>]
type ServerSentEventGenerator(httpContextAccessor:IHttpContextAccessor) =
    let defaultCancellationToken = httpContextAccessor.HttpContext.RequestAborted
    let httpRequest = httpContextAccessor.HttpContext.Request
    let httpResponse = httpContextAccessor.HttpContext.Response
    let mutable _startResponseTask : Task = null
    let _startResponseLock = obj()
    let _eventQueue = ConcurrentQueue<unit -> Task>()
```

--------------------------------

### AddDatastarMvc without AddDatastar throws Exception

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/errors.md

Calling AddDatastarMvc when IDatastarService is not registered throws System.Exception with message 'AddDatastarMvc requires that AddDatastar is added first'. The example shows catching the exception and checking the message.

```csharp
try
{
    builder.Services.AddDatastarMvc();   // AddDatastar() never called
}
catch (Exception ex)
{
    // ex.Message == "AddDatastarMvc requires that AddDatastar is added first"
}
```

--------------------------------

### SignalPath.create

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Creates a SignalPath from a string. Throws a System.Exception if the string is not a valid signal path.

```APIDOC
## SignalPath.create

### Description
Creates a SignalPath from a string. Throws a System.Exception if the string is not a valid signal path.

### Signature
`string -> SignalPath`

### Parameters
- `signalPathString` (string) - Required - The signal path string.

### Exceptions
- `System.Exception` - Thrown when the string is not a valid signal path.
```

--------------------------------

### Selector.tryCreate

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Attempts to create a Selector from a string, returning a Selector option. Returns None if the input is invalid.

```APIDOC
## [FUNCTION] Selector.tryCreate

### Description
Attempts to create a Selector from a string, returning a Selector option. Returns None if the input is invalid.

### Method
F# function

### Signature
`Selector.tryCreate : string -> Selector option`

### Parameters
- **selector** (string) - Required - The string to attempt to create the Selector from.

### Returns
- **Selector option** - Some Selector if successful, None otherwise.

### Example
```fsharp
match Selector.tryCreate "#my-element" with
| Some selector -> printfn "%s" selector
| None -> printfn "Invalid selector"
```
```

--------------------------------

### GetSignalsStream: Get signals stream

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Returns a stream over the request's signals in JSON form. For GET/DELETE requests, a MemoryStream is created from the 'datastar' query-string value (or Stream.Null if absent); for other methods, the raw request body stream is returned.

```csharp
Stream GetSignalsStream();
```

```csharp
using Stream signalsStream = datastarService.GetSignalsStream();
```

--------------------------------

### F#: Mirror C# default serializer with JsonSerializerOptions.SignalsDefault

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/configuration.md

Use this F# snippet to explicitly mirror the C# default serializer options. It sets JsonSerializerOptions.SignalsDefault, which corresponds to JsonSerializerDefaults.Web. When no options argument is provided, ServerSentEventGenerator.ReadSignalsAsync<'T>() defaults to this same option.

```fsharp
open StarFederation.Datastar.FSharp
let options = JsonSerializerOptions.SignalsDefault   // JsonSerializerDefaults.Web
```

--------------------------------

### ExecuteScriptAsync basic usage

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/options-types.md

Executes a script without any options, using all defaults.

```csharp
await datastarService.ExecuteScriptAsync("console.log('done')");
```

--------------------------------

### SignalPath.tryCreate

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Attempts to create a SignalPath from a string. Returns ValueNone if the string is not a valid signal path.

```APIDOC
## SignalPath.tryCreate

### Description
Attempts to create a SignalPath from a string. Returns ValueNone if the string is not a valid signal path.

### Signature
`string -> SignalPath voption`

### Parameters
- `signalPathString` (string) - Required - The signal path string.

### Returns
`ValueSome(SignalPath)` if valid; otherwise `ValueNone`.
```

--------------------------------

### ServiceCollectionExtensionMethods class declaration

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/dependency-injection.md

Declares the extension methods for registering Datastar services. AddDatastar registers required services and returns a builder; AddJsonOptions configures JSON serialization options.

```csharp
public static class ServiceCollectionExtensionMethods
{
    public static IDatastarBuilder AddDatastar(this IServiceCollection serviceCollection);
    public static IDatastarBuilder AddJsonOptions(this IDatastarBuilder datastarBuilder, Action<JsonSerializerOptions> configureOptions);
}
```

--------------------------------

### Signals module: create, tryCreate, empty

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Provides constructors for Signals. tryCreate returns ValueNone when the string does not parse as a JSON object (JsonObject.Parse throws). empty is "{ }".

```fsharp
module Signals =
    let create (signalsString:string) = Signals signalsString
    let tryCreate (signalsString:string) =
        try
            let _ = JsonObject.Parse(signalsString)
            ValueSome(Signals signalsString)
        with _ ->
            ValueNone
    let empty = Signals "{ }"
```

--------------------------------

### Usage of AddDatastarMvc with AddDatastar

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/dependency-injection.md

Shows the required call order: AddDatastar must be called before AddDatastarMvc. AddDatastarMvc registers controllers and the SignalsModelBinderProvider.

```csharp
builder.Services
    .AddDatastar()          // required first
    .AddDatastarMvc();      // registers controllers + SignalsModelBinderProvider
```

--------------------------------

### AddJsonOptions

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/dependency-injection.md

Configures the JsonSerializerOptions used for signal serialization/deserialization. Throws ArgumentNullException if the builder or configuration action is null.

```APIDOC
## AddJsonOptions

### Description
Configures the `JsonSerializerOptions` used for signal serialization/deserialization. Throws `ArgumentNullException` if `datastarBuilder` or `configureOptions` is null.

### Method
ServiceCollectionExtensionMethods.AddJsonOptions

### Endpoint
`IDatastarBuilder.AddJsonOptions(Action<JsonSerializerOptions> configureOptions)`

### Parameters
- **datastarBuilder** (`IDatastarBuilder`) - Required - The builder returned by `AddDatastar`
- **configureOptions** (`Action<JsonSerializerOptions>`) - Required - Action to configure the JSON serializer options

### Request Example
```csharp
builder.Services
    .AddDatastar()
    .AddJsonOptions(options =>
    {
        options.Converters.Add(new JsonStringEnumConverter());
        options.PropertyNamingPolicy = JsonNamingPolicy.CamelCase;
    });
```

### Response
No response body; returns the same `IDatastarBuilder` instance for chaining.
```

--------------------------------

### PatchElementsAsync basic usage

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Sends a `datastar-patch-elements` SSE event with complete, well-formed HTML. Multi-line strings are emitted as one `data: elements` line per segment.

```csharp
await datastarService.PatchElementsAsync("""
    <div id="message"><b>Hello</b>
    <button data-on:click="@get('/remove')">Remove</button></div>
    """);
```

--------------------------------

### ExecuteScriptAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Executes a script via server-sent events. Provides static and instance overloads with default options and cancellation tokens.

```APIDOC
## ExecuteScriptAsync

### Description
Executes a script via server-sent events.

### Method
F# member function

### Signatures

#### Instance (full)
```fsharp
member this.ExecuteScriptAsync(script, options, cancellationToken) : Task
```

#### Instance short-hands
```fsharp
member this.ExecuteScriptAsync(script, options)
member this.ExecuteScriptAsync(script, cancellationToken)
member this.ExecuteScriptAsync(script)
```

#### Static short-hands
```fsharp
static member ExecuteScriptAsync(httpResponse, script, options)
static member ExecuteScriptAsync(httpResponse, script)
```

### Parameters
- **script** - The script to execute.
- **options** - Options for the execution; defaults to the `*.Defaults` option record.
- **cancellationToken** - Cancellation token; defaults to `httpResponse.HttpContext.RequestAborted` (static) or `defaultCancellationToken` (instance).
- **httpResponse** - The HTTP response object (static overloads).

### Remarks
- Instance methods delegate to static members using the captured `httpResponse` / `httpRequest`.
- Write members route through `SendEventAsync` (queue + automatic start).
```

--------------------------------

### PatchSignalsAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Patches signals via server-sent events. Provides static and instance overloads with default options and cancellation tokens.

```APIDOC
## PatchSignalsAsync

### Description
Patches signals via server-sent events.

### Method
F# member function

### Signatures

#### Instance (full)
```fsharp
member this.PatchSignalsAsync(signals, options, cancellationToken) : Task
```

#### Instance short-hands
```fsharp
member this.PatchSignalsAsync(signals, options)
member this.PatchSignalsAsync(signals, cancellationToken)
member this.PatchSignalsAsync(signals)
```

#### Static short-hands
```fsharp
static member PatchSignalsAsync(httpResponse, signals, options)
static member PatchSignalsAsync(httpResponse, signals)
```

### Parameters
- **signals** - The signals to patch.
- **options** - Options for the patch; defaults to the `*.Defaults` option record.
- **cancellationToken** - Cancellation token; defaults to `httpResponse.HttpContext.RequestAborted` (static) or `defaultCancellationToken` (instance).
- **httpResponse** - The HTTP response object (static overloads).

### Remarks
- Instance methods delegate to static members using the captured `httpResponse` / `httpRequest`.
- Write members route through `SendEventAsync` (queue + automatic start).
```

--------------------------------

### Selector.create

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Creates a Selector from a string. Assumes the input is valid; use tryCreate for validation.

```APIDOC
## [FUNCTION] Selector.create

### Description
Creates a Selector from a string. Assumes the input is valid; use tryCreate for validation.

### Method
F# function

### Signature
`Selector.create : string -> Selector`

### Parameters
- **selector** (string) - Required - The string to create the Selector from.

### Returns
- **Selector** - The created Selector.

### Example
```fsharp
let selector = Selector.create "#my-element"
```
```

--------------------------------

### SignalPath.create

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-types-modules.md

Creates a SignalPath from a string. Assumes the input is valid; use tryCreate for validation.

```APIDOC
## [FUNCTION] SignalPath.create

### Description
Creates a SignalPath from a string. Assumes the input is valid; use tryCreate for validation.

### Method
F# function

### Signature
`SignalPath.create : string -> SignalPath`

### Parameters
- **path** (string) - Required - The string to create the SignalPath from.

### Returns
- **SignalPath** - The created SignalPath.

### Example
```fsharp
let path = SignalPath.create "foo.bar"
```
```

--------------------------------

### ExecuteScriptAsync - Basic Usage

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/idatastar-service.md

Sends a script to the browser. Do not include <script> in the string; the generator wraps it. The event is datastar-patch-elements with selector: body, mode: append, and elements lines forming a <script> tag.

```csharp
await datastarService.ExecuteScriptAsync("alert('Hello! from the server 🚀')");
```

--------------------------------

### GetSignalsStream

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Returns a stream for reading signals from the HTTP request.

```APIDOC
## GetSignalsStream

### Description
Returns a stream for reading signals from the HTTP request.

### Method
Static member (F#)

### Signature
```fsharp
static member GetSignalsStream(httpRequest:HttpRequest) : Stream
```

### Parameters
- **httpRequest** (`HttpRequest`) - The HTTP request

### Response
Returns a `Stream` for reading signals.
```

--------------------------------

### AddDatastar

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/dependency-injection.md

Registers all required services for injecting IDatastarService, including options, HTTP context accessor, and scoped service. Returns a fluent builder for chaining configuration methods.

```APIDOC
## AddDatastar

### Description
Registers everything required to inject `IDatastarService` into the application. This includes options, HTTP context accessor, and a scoped `IDatastarService` instance.

### Method
ServiceCollectionExtensionMethods.AddDatastar

### Endpoint
`IServiceCollection.AddDatastar()`

### Parameters
- **serviceCollection** (`IServiceCollection`) - Required - The application's service container (typically `builder.Services`)

### Returns
- **IDatastarBuilder** - Fluent builder for chaining `AddJsonOptions` / `AddDatastarMvc`

### Request Example
```csharp
using StarFederation.Datastar.DependencyInjection;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
builder.Services.AddDatastar();
WebApplication app = builder.Build();

app.MapGet("/displayDate", async (IDatastarService datastarService) =>
{
    await datastarService.PatchElementsAsync("<div id='date'>Today</div>");
});
```

### Response
No response body; returns an `IDatastarBuilder` instance.
```

--------------------------------

### Full Datastar registration with MVC and JSON options

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/dependency-injection.md

Registers Datastar services with JSON enum converter and MVC model binding, then defines endpoints for removing an element and patching signals. Requires the StarFederation.Datastar, DependencyInjection, and ModelBinding namespaces.

```csharp
using StarFederation.Datastar;
using StarFederation.Datastar.DependencyInjection;
using StarFederation.Datastar.ModelBinding;
using System.Text.Json;
using System.Text.Json.Serialization;

WebApplicationBuilder builder = WebApplication.CreateBuilder(args);
builder.Services
    .AddDatastar()
    .AddJsonOptions(options => options.Converters.Add(new JsonStringEnumConverter()))
    .AddDatastarMvc();

WebApplication app = builder.Build();
app.UseStaticFiles();

app.MapGet("/removeDate", async (IDatastarService datastarService) =>
{
    await datastarService.RemoveElementAsync("#date");
});

app.MapPost("/changeOutput", async (IDatastarService datastarService) =>
{
    MySignals signals = await datastarService.ReadSignalsAsync<MySignals>();
    await datastarService.PatchSignalsAsync(new MySignals { Output = $"Your Input: {signals.Input}" });
});

app.Run();
```

--------------------------------

### PatchSignalsAsync

Source: https://github.com/starfederation/datastar-dotnet/blob/main/_autodocs/api-reference/fsharp-server-sent-event-generator.md

Writes a `datastar-patch-signals` event to the response body writer. Includes optional id, retry, onlyIfMissing, and signals data lines.

```APIDOC
## PatchSignalsAsync

### Description
Writes a `datastar-patch-signals` event to the response body writer. Includes optional id, retry, onlyIfMissing, and signals data lines.

### Method
Static member (F#)

### Signature
```fsharp
static member PatchSignalsAsync(httpResponse:HttpResponse, signals:Signals, options:PatchSignalsOptions, cancellationToken:CancellationToken) : Task
```

### Parameters
- **httpResponse** (`HttpResponse`) - Target response
- **signals** (`Signals`) - JSON string (type alias for `string`)
- **options** (`PatchSignalsOptions`) - `PatchSignalsOptions.Defaults` when using short-hands
- **cancellationToken** (`CancellationToken`) - Aborts the flush

### Response
Returns a `Task` representing the asynchronous operation.
```
Tokens:
Raw