Changelog
What each release changed, and what it asks of your code.
CHANGELOG.md in the repository is authoritative and complete. This page carries only what changes how you write code, with a sentence about what to do.
0.23.0
A value is written where it stands. interpolate { """<a href="${+url}">${+title}</a>""" }
marks each value with +, and interpolate escapes or refuses it by where it landed, as it does
the value of a %s. Nothing you have written changes: the placeholder form stays. The editors’ fix
for a value in an HTML string now writes the block. Strings has
the rules.
A build can ask for every mark. failures( also fails on the warnings of a
value written without its mark. failures() is as it was.
The analysis shows the test.
0.22.0
interpolate takes a collection as one value. A List, Set or array handed to it is written
in brackets and escaped, where a lone List was taken for the values. Spread it to pass its
elements, interpolate(, and put an aliased bundle’s prefixes first,
interpolate(. A value in data-match-media now throws: write the
query into the format, or use dataMatchMedia.
Elements in the wrong namespace throw. PatchElements and ElementsResponse refuse an HTML
element under svg or mathml, and an SVG or MathML element under html outside its root. Put HTML
in a <foreignObject>, or send shapes with namespace = ElementNamespace., as
SVG and MathML shows.
The starter CSP requires Trusted Types. CspNonce., the default of
CspNoncePlugin and CspNonceFilter, allows only Datastar’s policy, so other code that writes
into the DOM as markup or a script, or a library that creates a policy of its own, is refused, and
so is a patch with an inline on* attribute or a <script src>. The policy is yours shows how to set one without.
viewTransitionSelector comes after useViewTransition in ElementsResponse,
respondElements, datastarElements, elementsResponse, PatchElements. and
removeElements. Name the arguments that follow it, eventId and retry of a removal and the
streamlord bean of datastarElements, and rebuild.
A few signatures moved. FetchOptions. is gone, since the client never read
it: set the selector, mode and view transition on respondElements or datastarElements, and
onlyIfMissing on respondSignals or datastarSignals. Spring’s
datastarSignals( takes the bean last. fit in
streamlord-html-pro names its flags shouldClamp and shouldRound. awaitPatchElements in
streamlord-test takes new matchers before timeout, so name it, timeout = 5..
JsonObject., JsonNumber. and toBigDecimalOrNull are extension functions:
import them, or from Java call JsonDecimals.. SignalFilter has three more
values, so code compiled against its constructor needs a rebuild.
With guardElements on, two more mistakes throw: a patch without a selector in outer or
replace mode whose top element has no id, and a data-* name with two letters swapped,
data-no:click.
streamlord-analysis takes a Source everywhere. AnalyzeOptions is gone: write
analyzer., with
Source. for what was core, htmlDsl and coreHtml. Only what the editors call stays
public; CHANGELOG.md lists
what replaces each name that went internal.
The IntelliJ plugin needs the Kotlin plugin in K2 mode, the default. IntelliJ 2026.1 with K1 turned on no longer loads it.
0.21.0
Code that calls the requests file functions of streamlord-analysis needs a few changes.
Requests. and Requests. are gone: call Requests. and
Requests. with the text of the file, and write the RequestsEdit they return.
RequestsFile has a third value, skipped, and HoleLanding in streamlord-core a fifth,
tagStart; Kotlin source that names the values compiles as before, and code compiled against
the old constructors needs a rebuild. Requests. reports a root that is no
object, a requests that is no list and a version other than 1 in error, so check it before
you save over such a file.
0.20.0
interpolate escapes some Html values it wrote as markup. An Html value that reshapes the
markup around it where it lands, such as an <a> without its </a>, a <p> in
<svg>%s</svg> or a <td> in a <td>, let a value written after it land where it was not
judged. It is printed as text now. Close in the value what it opens, an <a> with its </a>, and
write it where the browser keeps it in place: a whole table, a whole form and <path/> in an svg
are still markup. An Html of an element that holds HTML, such as <button><span>a</span></button>
in a <div>, which 0.19.0 escaped, is markup again.
A few names and messages changed. The editors’ error for a %s count that does not match the
values is interpolate-placeholders, where it was interpolate-holes, so anything that names the
old code, such as a test over the findings of analyzeProject, needs the new one. The message
interpolate throws for that count speaks of placeholders, and the refusal of mergePatchAsClient
of empty slots, so a test that matches either text needs the new one. In streamlord-core, the
holeLimit argument of mergePatchAsClient is emptySlotLimit.
Code that calls streamlord-analysis needs a few changes. HoleFact is ValueFact and
AnalyzeOptions. is valueFact, and a when over every ValueFact needs a branch for
its new OTHER. tokenize, MarkupOptions and valueAtCaret take a new templates: Kotlin
source compiles as before, Java source passes true for a template or an HTML file and false
for an HTML string in Kotlin, and code compiled against the old signatures needs a rebuild.
0.19.0
Code that uses the SDK needs no change. The release is editors that know what the project
has: in a module or a file without streamlord-html a call named as the DSL’s is somebody else’s,
and gets no Datastar checks, help or colours. Code that calls streamlord-analysis needs
recompiling: the constructor and copy of AnalyzeOptions take three new properties, htmlDsl,
core and foreignCalls, and attributeDoc a third parameter, withKotlin. Kotlin source
compiles as before.
0.18.0
Code that uses the SDK needs no change. The release is signal navigation in the editors: go
to declaration, find usages and rename. The analysis gains signalDeclarations,
signalRenameText and signalReadRenameText for editors, and nothing it reported before has
changed.
0.17.0
Code that uses the SDK needs no change. The release is help in the editors, inside a Datastar expression.
A test over your sources can now fail on data-nonce. The analysis reports an empty
data-nonce on <html> as missing-nonce, an error, since Datastar then throws NonceRequired
and does not start, and one that is no base64 value as invalid-nonce, a warning. dataNonce of
such a literal is an error either way, since it throws as the page renders. Put the nonce your
server sends in the Content-Security-Policy header there; Security shows how. Code
that calls streamlord-analysis needs recompiling: FetchOption has a fourth property, doc, and
no constructor or copy of three arguments.
0.16.0
interpolate returns Html. Hand it to patchElements, respondElements or
datastarElements as it is, or to another interpolate, which writes it as markup in element
text. Where you need the string, write .text: val s: String = interpolate( no longer
compiles, and +interpolate( in a kotlinx.html unsafe block becomes
+interpolate(. An Html is never equal to a String, so a test’s
assertEquals( or AssertJ isEqualTo still compiles and fails
although both print the same: compare .text. On Spring, ResponseEntity.
compiles but no converter writes an Html: return datastarElements(, or pass .text. From
Java, interpolate still returns a String, so one nested in another from Java is escaped; nest
in Kotlin, or wrap the inner one in Trusted.
Put the host in the literal of a URL that loads code. <script src="%s">, <iframe src>,
<embed src>, <object data>, <base href> and <link href> now throw where 0.15.0 let a
relative or https: value through. Write "/js/%s" or "https://cdn., or wrap a
URL you chose yourself in Trusted. An end tag, </%s>, throws too: write it from literals. A
Trusted value in a URL no longer waives the other values in it, since the URL is judged whole:
wrap the whole URL you chose, or put the host in the literal. Nor does a Trusted tag or
attribute name: the values beside it are judged where its text puts them, so a value after
<%s> with Trusted(, or in %s="%s" with Trusted(, throws. Write such
names in the literal, or wrap the whole of what you chose.
Strings says why.
The editors judge every Kotlin value in an HTML string. ${...}, values joined with +
and $$ literals are judged as $name was, by where they land, under two new codes,
unescaped-interpolation and unsafe-interpolation; Strings
has the table. A check from a test that filtered on kotlin-interpolation to catch values in HTML
should filter on the new codes. Code that calls streamlord-analysis needs recompiling:
AnalyzeOptions, KotlinString and Fix have new JVM constructors, Fix is no longer a data class,
so it no longer destructures, and InterpolationKind has a new entry, OPERAND, for an exhaustive
when.
0.15.0
Write each signal name in camelCase, without a hyphen. A name with a hyphen now throws where
you write it, with the name to write instead: InvalidSignalNameException from
dataSignals(, dataBind( and every other DSL helper that names
a signal, and DatastarEventValidationException from patchSignals( and
removeSignals(. Rename it, fooBar, in Kotlin and in the expressions of the page
alike. In 0.14.0 the keyed form declared $fooBar while patchSignals patched foo-bar, so in
most pages the camelCase name is the one the browser already read. In signal, set and the other
expression helpers a hyphen in a key you quote is fine, signal(. One the
client reads as a minus or as part of a signal, signal(, throws, and the exception
says to write the subtraction in the expression: "\$items[\$i - 1]". The editors flag each such
call before it runs, and Casing has the rule.
A key with a hyphen inside a value is written as it stands. "user" to mapOf( declares $user['first-name'], where 0.14.0 declared $user.. Read it with
brackets, or rename the key. dataBind, dataRef and dataIndicator always write the name in the
value now, so a test that compares rendered HTML may need its expected markup updated.
Drop case from dataSignals, dataComputed, dataRef, dataIndicator, dataMatchMedia and
BindModifiers. The DSL writes the key that gives back the name you wrote, so a case could
only change it. Source that passes one no longer compiles; delete the argument. dataOn and
dataClass keep theirs.
LiveDatastarStream. sends {} as the signals of the page. A handler under test that
reads signals gets an empty object, as it would from a browser, where it got none. Pass signals = """{"count":3}""" to send others. Its JVM signature changed, and so did that of the key form of
dataAnimate and the constructors of SignalFacts and SignalDriftReport, so recompile code
built against 0.14. A drift test of pages that
declare their signals with toJsonValue of a class the analysis cannot read passes with every name
declared; SignalDriftReport. says when that happened.
Write produces = ["text/ on a Spring MVC page with a CSP nonce. The
recipe on Security used MediaType., which lets Spring MVC pick
Latin-1.
Raise what your build pins, if a scanner reports it. On Spring Boot, Jackson to 3.1.8 and 2.21.8 for CVE-2026-110879, since Boot’s dependency management wins over the codec’s version. On Ktor 3.0’s Tomcat or Jetty engine, Tomcat to 10.1.61 and Jetty to 11.0.26. Install has the lines for Maven and Gradle.
0.14.0
Nothing to change. A MockMvc test of a stream may drop MockMvcPrint.. If you turned
Spring Boot’s printing off because a stream test failed now and then with
ConcurrentModificationException, the header that caused it is now set before the controller
returns. Two causes remain, and keep the setting needed where they apply: a test that sends
Accept-Encoding: gzip to a stream with compress = true, and Spring Security writing its
headers when the response commits. Testing says
what to do about each.
0.13.0
Drop status from the response helpers. respondDatastar, respondElements,
respondSignals and respondScript on Ktor, and datastarElements, datastarSignals,
datastarScript and toResponseEntity on Spring, no longer take one: Datastar’s client reads
neither a stream nor a body with any status but 200, so any other made the response do nothing.
Source that passes one, also as the first positional argument of respondDatastar, no longer
compiles; delete the argument. Code compiled against 0.12 still links.
Every stream has a heartbeat now. A stream silent for 30 seconds carries a : keep-alive
comment, and one silent from the start gets its first after five seconds, or after the interval
if that is shorter, on Ktor and on Spring WebMVC, unless you set heartbeat = null on the
instance, in the plugin or on one stream. That first comment commits the response, so a block that
waits longer than that and then fails cuts the stream off instead of answering with a status. On
Spring WebMVC the heartbeat asks your StreamAuthorisation from an IO thread, without the
request’s thread-locals, Spring Security’s context among them: read what allows() needs before
the stream opens, or it refuses a stream that used to stay open. A test
that calls Streamlord. under runTest, with a block that waits on a real thread, gets
comment after comment while virtual time skips ahead: give it Streamlord(. A
test that counts events. counts the comments too. See
Operations and Testing.
Pass the block after the parentheses. respondDatastar and datastarStream take a
heartbeat for one stream, and datastarStream a timeout and an executor as well, so a
lambda or a function reference written inside the parentheses as the last positional argument,
datastarStream(, lands on timeout or heartbeat
and no longer compiles. Write datastarStream(, or name it
block = …. Java source written against 0.12 no longer compiles either: the new parameters take
a kotlin., which Java can only pass as null, and a null heartbeat means none
at all. Binaries compiled against 0.12 still link.
Spring WebMVC shows timeout and executor.
Signals in a body must be sent as application/. Datastar’s client always does, so pages
change nothing. A client of your own that posts signals without that Content-Type now gets
SignalsMediaTypeException: set the header, or pass requireJsonContentType = false. On Ktor,
map the exception to 415 in StatusPages; Security has
the block and the reason.
Name signals the way Datastar’s client reads them. Names that reached the client as another name, or as none, now throw where you write them:
- The pairs form of
dataSignalscamel-cases its keys, as the keyed form does:dataSignals(declares"foo-bar" to 7) $fooBar, where it declaredfoo-bar. Read$fooBarin the page. - A dotted name in
patchSignals,removeSignalsand the pairs ofdataSignalsnests:patchSignals(patches"form. email" to "x") $form., where it sent one key thatemail $form.did not reach.email patchSignalsthrows on a name given twice. - A name that declares a signal is ASCII letters, digits and
_, in parts joined by.or-.über,a:b, a/, an empty part and a part such asconstructor,toStringor__proto__throwInvalidSignalNameException. - A name that ends in
_before a modifier, a name indataOnordataClassthat mixes capitals with a hyphen before a lower-case letter (fooBar-baz), aBindModifiers.with a capital or aevents ., aBindModifiers.Datastar cannot give back (prop x2y,_value,my_prop) and a custom property with capitals indataStyleare refused. A class from a library, such asMuiButton-root, goes in the object form:dataClass(."{'MuiButton-root': ...}")
Casing has the rule the names now follow.
Durations, retries and ids the browser cannot honour throw. A modifier duration that is
negative or over Int. milliseconds, a flag such as debounceLeading without its
duration, more than one of half, full and threshold on dataOnIntersect, an interval of
zero, and a negative
retryMaxCount or retryScaler throw where you write them. An event with a retry that is not a
whole number of milliseconds from 1 to Int., or an eventId that is not printable
ASCII or has a space at either end, throws DatastarEventValidationException. SignalFilter
refuses a Kotlin Regex that JavaScript reads otherwise or refuses, such as a possessive
quantifier, \A or \p{...}: write the pattern as JavaScript would read it.
A test may go red that used to be green. streamlord-test reads a stream as Datastar’s client
does: a retry or an id the client would not keep, a data line with no space after its key and
signals that are not one JSON object fail the decode, and assertSignal no longer looks for a key
holding a dot. The literals the HTML helpers write escape quotes, & and \, so 'it\'s' is now
'it\x27s', and dataSignals writes \ as \u005c. If a test compared that text, compare the
new; if one fails on a stream, the browser was not doing what the test said.
The Jackson codecs refuse a missing or null primitive. {} into
data class Delete( used to reach the handler as Delete(; it is a 400 now.
A Kotlin class needs jackson-module-kotlin on the mapper you hand the codec, and without it a
decode throws SignalsCodecException: register the module. Text after the JSON value is a 400
too.
The Jackson codecs ignore keys your type does not name, even when your mapper refuses them.
A mapper with FAIL_ON_UNKNOWN_PROPERTIES on, as jacksonObjectMapper() has it, no longer fails
every request that carries a signal the type does not name; nothing to change unless a test of
yours counted on that failure. Jackson2SignalsCodec reads through a copy of the mapper you hand
it, made once, so that mapper keeps its own rules; a mapper of a subclass that does not override
copy() cannot be used.
Jackson2SignalsCodec refuses a null inside a Kotlin parameter’s List<Int>. A page that
sends one gets a 400; declare the element List<Int?> if it may. A mapper set to skip such a
null with setDefaultSetterInfo no longer does for these parameters: put
@JsonSetter( on the parameter instead. Signals
lists where each codec refuses a null.
requireNamedSerializers = true wants a container named whole. A List<Signals> that went
through because Signals was named now fails with SignalsCodecException until you add
typeOf<List<Signals>>() to ListSerializer( to serializers; naming
Signals alone does not reach the list. Native image
shows it.
On Ktor, a failed stream is cut, so Datastar’s client reconnects. The frames the block sent
before it threw go out first. Tomcat and Jetty ended such a stream as if it had finished, and now
cut it as CIO and Netty do. On Ktor’s servlet engine, Streamlord throws a stream’s failure only
once the engine’s response writer has finished. Catch inside the block what the page should show;
Ktor says which engines are cut and shows how to end a
respondBytesWriter of your own.
StreamlordExceptionHandler takes the exception in its handlers. Only if you call
signalsTooLarge or signalsUnreadable yourself: pass the exception. The 0.12 signatures remain,
hidden, for code compiled against them, and the new signalsNotJson answers
SignalsMediaTypeException with 415.
streamlord-analysis changed signatures. Only if you call it yourself:
ExpressionValidator., MarkupValidator., Requests.,
MarkupOptions, RequestsFile and AttributeSpec take new parameters with defaults, so Kotlin
source compiles, but code compiled against 0.12 does not link until you rebuild it. keyName is
gone; it named a signal otherwise than the client does.
0.12.0
Spring Boot 3 is no longer supported. The Spring adapter is built for Boot 4 (Framework 7.0, Servlet 6.1), and Streamlord needs kotlinx-coroutines 1.10.2 or newer, which Boot 4 already pins. On Boot 3, stay on 0.11.1. Ktor applications change nothing.
Map SignalsDecodeException to 400, not SignalsCodecException. The new subclass is what a
codec throws when the request’s signals cannot be read. A mapping of the old type still catches
it, but also turns a value the server could not encode, its own bug, into a 400. See
Security.
Requests. and fillPath are gone from streamlord-analysis, with the dialog they
served. Only if you call them yourself: Requests. writes a route’s URL with a {{name}}
for each path parameter, filled from the env file’s params.
0.11.1
Nothing to change in your code. The modules are the same as in 0.11.0; this release carries the documentation: the introduction opens with the same endpoint written by hand and with Streamlord, and the testing page says where Ktor 3.6.0’s test host misleads a test.
0.11.0
The inspector’s variables are three, in .streamlord/. Only if you call
Requests in streamlord-analysis yourself: parseEnvFile is gone, read the file with
parseEnv, which reports anything but baseUrl, signals and headers, and pass
mergeVariables( to resolveRequest, which now returns errors and the keys that
are not set instead of a list of missing names. The editors are updated to match.
0.10.1
Spring Boot works again. On 0.10.0 every readSignals and datastarStream under Spring Boot
throws NoSuchMethodError, because Boot pins an older kotlinx-coroutines than the one that
release was compiled against. Upgrade to this release. If you cannot yet, put
ext["kotlin-coroutines. in your build.
Take the Streamlord bean through the constructor on Spring. The samples used to take it as
a parameter of the handler method, where Spring builds a new default instance instead of
injecting yours. If you copied them, your codec and guardElements are being ignored. See
Spring WebMVC.
A refused stream stays refused. A handler that caught the refusal of a StreamAuthorisation
and carried on used to keep writing. Every write after a refusal is now refused again. Nothing
to change in your code.
Return asDatastarResponse() from a WebFlux controller. The bare flow from
asServerSentEvents() went out without Cache-Control: no-cache and X-Accel-Buffering: no,
because a Flow cannot carry headers. The new function returns it in a ResponseEntity that
does. See Spring WebFlux.
interpolate refuses more. A value in onclick or another event handler, in srcdoc, a
string in style, and a javascript: URL at the start of href or src now throw
UnsafeInterpolationException. If one of yours throws, the value was reaching something the
browser runs; wrap it in Trusted only if you wrote it yourself. See Strings.
Map a body that will not parse to 400. JsonParseException and SignalsCodecException
are a 500 until you do. See Security.
dataNonce( throws, as the plugin always did for an empty nonce.
A test may go red that used to be green. streamlord-test now reads a response the way the
browser does. A frame with no blank line after it is not an event, mode APPEND in capitals is
malformed, and assertSignal follows the client’s merge for onlyIfMissing. If a test of yours
fails after upgrading, the browser was not doing what the test said. assertSignal(
now matches a 13 on the wire.
Import ExpressionGuard and InterpolatedExpressionException from core.. The
aliases in streamlord-html, deprecated since 0.2.0, are gone.
0.10.0
Assert on events, not on strings. The new streamlord-test module reads a response back into
the events it carried: datastarEvents( and
assertSignal(. Assertions ignore what they did not ask about, so a test survives a
handler gaining an event, and assertExactly is there for when the whole stream is the point. It
binds no test framework. See Testing.
mergePatch moved from streamlord-analysis to streamlord-core, into core.. Change
the import if you used it; nothing else about it changed.
0.9.0
asSse() is gone. One line of sugar over Streamlord., which stays. It was the
only public name in the whole SDK with no caller anywhere and no page describing it, so nothing
you have written can be using it. If something is, call encode directly.
0.8.0
A stream can be asked again whether it may still run. StreamAuthorisation goes where you
open the stream: Streamlord asks at the open and then on an interval, a refusal lets you say
something to the reader through onRefused and then ends the response rather than going quiet,
and the check is ordinary Kotlin that never reaches the browser. See Operations.
0.7.0
signalDrift now reports what it saw. It returns a SignalDriftReport; assert that
report. is not empty as well as that report. is, because a check that matched
nothing looks exactly like a project in order. See The analysis.
KotlinxSignalsCodec( is now requireNamedSerializers. Same behaviour, a name
that says what it does. Refusing unknown signals was never this flag; that is ignoreUnknownKeys
on the Json you pass.
Do not put a CSP nonce on a script event. Datastar re-creates every script it patches in and sets the nonce from the page’s, so one you pass is overwritten under CSP mode and ignored without it. The KDoc used to suggest otherwise. See Security.
0.6.0
A signal your handler reads that no page declares is now findable. signalDrift in
streamlord-analysis takes your whole project, compares the signals handlers read against the
signals markup declares, and reports the ones that will always be a default. It is a test you
write once; see The analysis. Signal classes written public data class also contribute
to completion again, which an over-strict pattern had excluded.
0.5.0
Values from outside, put into markup safely. interpolate( fills the
placeholders you leave and decides what to do with each value by where it landed. Text and ordinary
attributes are escaped; a data-* attribute Datastar reads, a tag or attribute name, an unquoted
value and a script body are refused, because escaping cannot save those. Trusted( waives it
for markup you rendered yourself. See Strings.
0.4.0
The CSP nonce is Streamlord’s job now. install( on Ktor, or a
CspNonceFilter bean on Spring WebMVC, generates one nonce per response, writes the
Content-Security-Policy header from it, and hands the same value to call. or
request. for dataNonce on your <html>. Nothing used to enforce that the header and
the markup agreed, and when they drift Datastar fails silently. The Ktor plugin is route-scoped,
so an application that serves documents from some routes and streams from others installs it
where the documents are. WebFlux gets exchange. for a WebFilter you register
yourself. See Security, which links to a page running under a real policy.
0.3.1
Name your serializers for a native image. KotlinxSignalsCodec now takes them by the type
they handle and consults them before the reflective lookup, and strict = true, which 0.7.0 renamed to requireNamedSerializers, refuses that
fallback so a type you forgot fails on the JVM rather than inside the image. Nothing changes if
you pass none. See Native image.
The javadoc jar is no longer empty. Every module up to 0.3.0 published an empty one, so javadoc.io had nothing to show for a library whose source is mostly documentation. From this release it carries the API reference generated from the KDoc.
A hyphen after a signal is part of the name. Datastar 1.0.4 reads $foo-bar as the signal
foo-bar, and $count-1 as the signal count-1, not as subtraction. Only $a-$b subtracts.
The editors now say so, and offer both fixes: a camelCase signal name, or the subtraction written
with spaces. See Casing.
0.3.0
streamlord-analysis. The analysis behind the editor tooling, extracted into a Kotlin module
that depends on nothing beyond streamlord-core. Analyzer(). and
analyzeHtml( return the issues they find, each with its range, severity, message and
quick fixes. You can call it yourself, which is worth doing in the tests of your markup
functions. See The editors.
The IntelliJ plugin, for IDEA 2026.1 and newer, Community and Ultimate. Inspections, completion, hover, highlighting, HTML injection into marker-less strings, and the Stream Inspector as a tool window, sharing saved requests with VS Code.
Fixed: an expression opening with { is now read as the object literal Datastar makes of it,
so data-signals="{count: 0}" is no longer flagged as a syntax error.
0.2.0
ElementsGuard, and guardElements. The $ trap hunted in HTML written as a string. Turn it
on with Streamlord(, or install(
on Ktor, and every element patch leaving that instance is walked: an expression an eaten Kotlin
template left behind throws with the attribute named, and a data-* name one letter from a real
one throws MistypedAttributeException. Off by default. See Strings.
0.1.1
ExpressionGuard. Every expression helper in the DSL refuses, at render time, text with the
shape a Kotlin string template leaves behind when it eats a signal. The message names the helpers
and the $$"..." literal. See The $ trap.
0.1.0
The first forging: the protocol and the encoder verified against the official golden files, both
adapters, the kotlinx.html DSL, the codec modules, the VS Code extension, and
catalog/ as the shared source of truth.
On versioning
Streamlord is 0.x, and the API is still allowed to move. A breaking change is listed here with its migration in the same entry. At 1.0 the ordinary rule takes over.
The Datastar protocol version is tracked separately and stated on every release. This one speaks 1.0.4.