acrylblends 0.7.7 → 0.8.0

package/plugins/acryl-kv/src/conformance.ts

@@ -0,0 +1,226 @@
+/**
+ * The `kv` conformance suite: what every provider of the port must do, as Vitest tests. A provider passes it to be accepted
+ * (`describeKvConformance('acryl-kv-json', open)` in its own tests), so the same cases run on a file and on SQL.
+ */
+
+import { afterEach, describe, expect, it } from 'vitest'
+import type { Kv } from './kv.ts'
+
+/** A fresh, empty store from the provider under test. */
+export interface KvUnderTest {
+  readonly kv: Kv
+  close(): Promise<void>
+  /** Close this store (if it is still open) and open the same storage again, to prove what was written is durable. */
+  reopen(): Promise<KvUnderTest>
+}
+
+export function describeKvConformance(provider: string, open: () => Promise<KvUnderTest>): void {
+  describe(`kv conformance: ${provider}`, () => {
+    const opened: KvUnderTest[] = []
+    const track = (subject: KvUnderTest): KvUnderTest => {
+      opened.push(subject)
+      return subject
+    }
+    const fresh = async (): Promise<Kv> => track(await open()).kv
+    afterEach(async () => {
+      await Promise.all(opened.splice(0).map(subject => subject.close()))
+    })
+
+    it('round-trips null, booleans, numbers, text with unicode, arrays and nested objects', async () => {
+      const kv = await fresh()
+      const values: unknown[] = [null, true, false, 0, -1.5, 9_007_199_254_740_991, '', 'café ✓ 😀', [], [1, [2, [3]]], {}, { a: { b: [1, { c: null }] }, 'ключ': 'значение' }]
+      for (const [index, value] of values.entries()) {
+        await kv.set(`value/${index}`, value)
+        expect(await kv.get(`value/${index}`), JSON.stringify(value)).toEqual(value)
+      }
+    })
+
+    it('answers get with undefined for a missing key, and overwrites on set', async () => {
+      const kv = await fresh()
+      expect(await kv.get('missing')).toBeUndefined()
+      await kv.set('k', { n: 1 })
+      await kv.set('k', { n: 2 })
+      expect(await kv.get('k')).toEqual({ n: 2 })
+    })
+
+    it('deletes a key, and a missing key is not an error', async () => {
+      const kv = await fresh()
+      await kv.set('k', 1)
+      await kv.delete('k')
+      expect(await kv.get('k')).toBeUndefined()
+      await expect(kv.delete('k')).resolves.toBeUndefined()
+      await expect(kv.delete('never-existed')).resolves.toBeUndefined()
+    })
+
+    it('stores a null value as null, apart from a missing key', async () => {
+      const kv = await fresh()
+      await kv.set('k', null)
+      expect(await kv.get('k')).toBeNull()
+      expect(await kv.list()).toEqual(['k'])
+    })
+
+    it('lists keys sorted by code point, with an optional prefix', async () => {
+      const kv = await fresh()
+      for (const key of ['b', 'a/2', 'a/10', 'a/1', 'ab', 'B', 'a']) await kv.set(key, key)
+      expect(await kv.list()).toEqual(['B', 'a', 'a/1', 'a/10', 'a/2', 'ab', 'b'])
+      expect(await kv.list('a/')).toEqual(['a/1', 'a/10', 'a/2'])
+      expect(await kv.list('a')).toEqual(['a', 'a/1', 'a/10', 'a/2', 'ab'])
+      expect(await kv.list('')).toEqual(['B', 'a', 'a/1', 'a/10', 'a/2', 'ab', 'b'])
+      expect(await kv.list('nothing')).toEqual([])
+      expect(await kv.list(undefined)).toEqual(await kv.list())
+    })
+
+    it('orders astral characters after the rest of the basic plane, as code points', async () => {
+      const kv = await fresh()
+      for (const key of ['\u{1F600}', '～', 'z', '']) await kv.set(key, 1)
+      expect(await kv.list()).toEqual(['z', '', '～', '\u{1F600}'])
+    })
+
+    it('treats % _ \\ and letter case in a prefix as plain characters', async () => {
+      const kv = await fresh()
+      for (const key of ['100%', '100x', 'a_b', 'axb', 'Abc', 'abc', 'back\\slash', 'backXslash']) await kv.set(key, 1)
+      expect(await kv.list('100%')).toEqual(['100%'])
+      expect(await kv.list('a_')).toEqual(['a_b'])
+      expect(await kv.list('ab')).toEqual(['abc'])
+      expect(await kv.list('Ab')).toEqual(['Abc'])
+      expect(await kv.list('back\\')).toEqual(['back\\slash'])
+      expect(await kv.list('\u{1F600}')).toEqual([])
+    })
+
+    it('updates a missing key from undefined, and a present one from its value, resolving the new value', async () => {
+      const kv = await fresh()
+      expect(await kv.update<number>('n', current => (current ?? 0) + 1)).toBe(1)
+      expect(await kv.update<number>('n', current => (current ?? 0) + 10)).toBe(11)
+      expect(await kv.get('n')).toBe(11)
+      expect(await kv.update<string[]>('list', current => [...(current ?? []), 'a'])).toEqual(['a'])
+    })
+
+    it('counts fifty concurrent updates to exactly fifty', async () => {
+      const kv = await fresh()
+      await Promise.all(Array.from({ length: 50 }, () => kv.update<number>('counter', current => (current ?? 0) + 1)))
+      expect(await kv.get('counter')).toBe(50)
+    })
+
+    it('keeps updates of different keys independent, and a set between two updates in order', async () => {
+      const kv = await fresh()
+      const results = await Promise.all([
+        kv.update<number>('a', current => (current ?? 0) + 1),
+        kv.set('a', 100),
+        kv.update<number>('a', current => (current ?? 0) + 1),
+        kv.update<number>('b', current => (current ?? 0) + 5),
+      ])
+      expect(results[0]).toBe(1)
+      expect(results[2]).toBe(101)
+      expect(await kv.get('a')).toBe(101)
+      expect(await kv.get('b')).toBe(5)
+    })
+
+    it('leaves the value as it was when the update callback throws, and rejects with its error', async () => {
+      const kv = await fresh()
+      await kv.set('k', 'before')
+      const failure = new Error('stop')
+      await expect(kv.update('k', () => { throw failure })).rejects.toBe(failure)
+      expect(await kv.get('k')).toBe('before')
+      await expect(kv.update('absent', () => { throw failure })).rejects.toBe(failure)
+      expect(await kv.get('absent')).toBeUndefined()
+    })
+
+    it('leaves the value as it was when the update returns something that is not JSON', async () => {
+      const kv = await fresh()
+      await kv.set('k', 'before')
+      await expect(kv.update('k', () => undefined as never)).rejects.toThrow(TypeError)
+      await expect(kv.update('k', () => Number.NaN as never)).rejects.toThrow(TypeError)
+      expect(await kv.get('k')).toBe('before')
+    })
+
+    it('rejects an update callback that returns a promise, with a message that says what to do, and keeps the value', async () => {
+      const kv = await fresh()
+      await kv.set('k', 1)
+      const asynchronous = (async () => 2) as unknown as (current: number | undefined) => number
+      await expect(kv.update<number>('k', asynchronous)).rejects.toThrow(/synchronous/u)
+      expect(await kv.get('k')).toBe(1)
+      await kv.update<number>('k', current => (current ?? 0) + 1)
+      expect(await kv.get('k')).toBe(2)
+    })
+
+    it('refuses an empty or non-string key on every call, and writes nothing', async () => {
+      const kv = await fresh()
+      for (const key of ['', 1, null, undefined, {}] as unknown as string[]) {
+        await expect(kv.get(key)).rejects.toThrow(TypeError)
+        await expect(kv.set(key, 1)).rejects.toThrow(TypeError)
+        await expect(kv.update(key, () => 1)).rejects.toThrow(TypeError)
+        await expect(kv.delete(key)).rejects.toThrow(TypeError)
+      }
+      expect(await kv.list()).toEqual([])
+    })
+
+    it('refuses a value that is not JSON with a TypeError, and writes nothing', async () => {
+      const kv = await fresh()
+      const circular: Record<string, unknown> = {}
+      circular.self = circular
+      for (const value of [undefined, () => 1, Symbol('s'), 1n, Number.NaN, Number.POSITIVE_INFINITY, circular, { deep: [Number.NEGATIVE_INFINITY] }]) {
+        await expect(kv.set('k', value), String(value)).rejects.toThrow(TypeError)
+      }
+      expect(await kv.list()).toEqual([])
+      await kv.set('k', 'kept')
+      await expect(kv.set('k', undefined)).rejects.toThrow(TypeError)
+      expect(await kv.get('k')).toBe('kept')
+    })
+
+    it('hands out copies: changing what get returned, or the value after set, changes nothing stored', async () => {
+      const kv = await fresh()
+      const original = { list: [1, 2], nested: { n: 1 } }
+      await kv.set('k', original)
+      original.list.push(3)
+      const first = await kv.get<typeof original>('k')
+      expect(first).toEqual({ list: [1, 2], nested: { n: 1 } })
+      first!.nested.n = 99
+      expect(await kv.get('k')).toEqual({ list: [1, 2], nested: { n: 1 } })
+      const updated = await kv.update<typeof original>('k', current => {
+        current!.list.push(4)
+        return current!
+      })
+      updated.list.push(5)
+      expect(await kv.get('k')).toEqual({ list: [1, 2, 4], nested: { n: 1 } })
+    })
+
+    it('stores a value of a megabyte', async () => {
+      const kv = await fresh()
+      const big = 'x'.repeat(1024 * 1024)
+      await kv.set('big', { big })
+      expect((await kv.get<{ big: string }>('big'))?.big.length).toBe(big.length)
+    })
+
+    it('keeps what was written across close and reopen, and keeps a deleted key deleted', async () => {
+      const first = track(await open())
+      await first.kv.set('a', { n: 1 })
+      await first.kv.set('b', 'two')
+      await first.kv.update<number>('count', current => (current ?? 0) + 1)
+      await first.kv.set('gone', 1)
+      await first.kv.delete('gone')
+      const second = track(await first.reopen())
+      expect(await second.kv.list()).toEqual(['a', 'b', 'count'])
+      expect(await second.kv.get('a')).toEqual({ n: 1 })
+      expect(await second.kv.get('count')).toBe(1)
+      expect(await second.kv.get('gone')).toBeUndefined()
+    })
+
+    it('rejects calls after close, and closing twice does nothing', async () => {
+      const subject = track(await open())
+      await subject.kv.set('k', 1)
+      await subject.close()
+      await subject.close()
+      await expect(subject.kv.get('k')).rejects.toThrow()
+      await expect(subject.kv.set('k', 2)).rejects.toThrow()
+    })
+
+    it('waits for writes still in flight when it closes', async () => {
+      const subject = track(await open())
+      const writes = Array.from({ length: 20 }, (_, index) => subject.kv.set(`k${String(index).padStart(2, '0')}`, index))
+      await subject.close()
+      await Promise.all(writes)
+      const again = track(await subject.reopen())
+      expect(await again.kv.list()).toHaveLength(20)
+    })
+  })
+}

package/plugins/acryl-kv/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-kv",
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "vendored": [
     "src",

package/plugins/acryl-kv-db/plugin.json

@@ -9,5 +9,8 @@
     "@deepseek-ai/schemastery": "3.18.4"
   },
   "mount": "mount it after acryl-db-sqlite: root.plugin(kvDb, {}); it waits for db and provides the same kv as acryl-kv-json",
-  "omit": ["**/*.test.*", "**/*.spec.*", "**/*.case.ts"]
+  "omit": ["**/*.test.*", "**/*.spec.*", "**/*.case.ts"],
+  "imports": {
+    "#acryl-kv-db": "acryl-kv-db/src/index.ts"
+  }
 }

package/plugins/acryl-kv-db/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-kv-db",
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "vendored": [
     "src",

package/plugins/acryl-kv-json/plugin.json

@@ -9,5 +9,8 @@
     "@deepseek-ai/schemastery": "3.18.4"
   },
   "mount": "mount it after instance: root.plugin(kvJson, {}) (the file is kv.json in the app home, or set path); then a plugin that declares inject: ['kv'] calls await ctx.kv.set('theme', 'dark') and ctx.kv.update('visits', (n) => (n ?? 0) + 1)",
-  "omit": ["**/*.test.*", "**/*.spec.*", "**/*.case.ts"]
+  "omit": ["**/*.test.*", "**/*.spec.*", "**/*.case.ts"],
+  "imports": {
+    "#acryl-kv-json": "acryl-kv-json/src/index.ts"
+  }
 }

package/plugins/acryl-kv-json/src/open.ts

@@ -3,9 +3,12 @@
  * memory and resolves the `kv` port with the function that closes it. The Cordis plugin is a thin wrapper over this, so both run one code
  * path. This entry imports nothing from Cordis.
  *
- * Every write queues behind the writes before it and persists the whole map: serialize to a temporary file in the same folder, flush it,
- * rename it over the file, and flush the folder where the platform allows. The call resolves after the rename, so a crash leaves the old file
- * or the new one, never half of one. One process owns the file: two writers would overwrite each other.
+ * Every write persists the whole map: serialize to a temporary file in the same folder, flush it, rename it over the file, and flush the
+ * folder where the platform allows. The call resolves after the rename, so a crash leaves the old file or the new one, never half of one.
+ * Writes are grouped: the calls made in one turn of the event loop, and those that queue while a file write is in flight, are applied in
+ * call order and persisted together by one write, so a burst of calls costs one flush and one rename, not one each (on Windows each costs
+ * tens of milliseconds). One process owns the
+ * file: two writers would overwrite each other.
  */
 
 import { mkdir, open, readdir, readFile, rename, rm } from 'node:fs/promises'
@@ -95,6 +98,20 @@ async function flushFolder(folder: string): Promise<void> {
   }
 }
 
+/** What one call does to the map: the key's new JSON text (`undefined` deletes it), and what the call resolves with. */
+interface Change<T = unknown> {
+  readonly key: string
+  readonly text: string | undefined
+  readonly result: T
+}
+
+/** A call waiting for the file write that will contain it. Its change reads the state as the calls before it in the round left it. */
+interface Pending {
+  readonly change: (read: (key: string) => string | undefined) => Change
+  readonly resolve: (result: unknown) => void
+  readonly reject: (error: unknown) => void
+}
+
 /** Open (and create, when missing) a JSON-file store. @throws when the file exists and is not a readable kv file. */
 export async function openKv(options: OpenKvOptions): Promise<KvOpened> {
   const file = resolve(options.path)
@@ -103,7 +120,12 @@ export async function openKv(options: OpenKvOptions): Promise<KvOpened> {
   let state = await load(file)
   let closed = false
   let sequence = 0
-  let tail: Promise<unknown> = Promise.resolve()
+  /** Calls waiting for the next file write, in call order. */
+  let queue: Pending[] = []
+  /** Whether the loop that writes the queue runs; cleared by the loop itself, so a call queued after it ends starts a new one. */
+  let draining = false
+  /** The latest loop, for `close` to wait on. */
+  let drained: Promise<void> = Promise.resolve()
 
   const guard = (): void => {
     if (closed) throw new Error(`acryl-kv-json: ${file} is closed`)
@@ -129,18 +151,62 @@ export async function openKv(options: OpenKvOptions): Promise<KvOpened> {
     await flushFolder(dirname(file))
   }
 
-  /** Run a change after every earlier one; the map it works on becomes the state only once it is on disk. */
-  const write = <T>(change: (draft: Map<string, string>) => T): Promise<T> => {
-    guard()
-    const task = tail.then(async () => {
+  /**
+   * Write the queue until it is empty. Each round takes every call queued so far and applies them in order to one copy of the state. A call
+   * whose change throws rejects with its error and changes nothing, and the others in the round still apply. The copy becomes the state
+   * only once it is on disk. A failed file write rejects every call in its round and leaves the state as it was.
+   */
+  const drain = async (): Promise<void> => {
+    try {
+      // Let the calls made in this turn join the first round.
+      await Promise.resolve()
+      await rounds()
+    } finally {
+      draining = false
+    }
+  }
+
+  const rounds = async (): Promise<void> => {
+    while (queue.length > 0) {
+      const round = queue
+      queue = []
       const draft = new Map(state)
-      const result = change(draft)
-      await persist(draft)
+      const applied: { readonly call: Pending; readonly result: unknown }[] = []
+      for (const call of round) {
+        let change: Change
+        try {
+          change = call.change(key => draft.get(key))
+        } catch (error) {
+          call.reject(error)
+          continue
+        }
+        if (change.text === undefined) draft.delete(change.key)
+        else draft.set(change.key, change.text)
+        applied.push({ call, result: change.result })
+      }
+      if (applied.length === 0) continue
+      try {
+        await persist(draft)
+      } catch (error) {
+        for (const { call } of applied) call.reject(error)
+        continue
+      }
       state = draft
-      return result
+      for (const { call, result } of applied) call.resolve(result)
+    }
+  }
+
+  /** Queue one change behind every earlier call; it resolves once a file write that contains it is on disk. */
+  const write = <T>(change: (read: (key: string) => string | undefined) => Change<T>): Promise<T> => {
+    guard()
+    const done = new Promise<T>((resolveCall, rejectCall) => {
+      queue.push({ change, resolve: resolveCall as (result: unknown) => void, reject: rejectCall })
     })
-    tail = task.catch(() => undefined)
-    return task
+    if (!draining) {
+      draining = true
+      drained = drain()
+    }
+    return done
   }
 
   const kv: Kv = {
@@ -153,21 +219,19 @@ export async function openKv(options: OpenKvOptions): Promise<KvOpened> {
     async set(key, value) {
       checkKey(key)
       const text = encodeValue(value)
-      await write(draft => { draft.set(key, text) })
+      await write(() => ({ key, text, result: undefined }))
     },
     async update<T>(key: string, change: (current: T | undefined) => T) {
       checkKey(key)
-      return write(draft => {
-        const text = draft.get(key)
-        const next = runChange(change, text === undefined ? undefined : decodeValue<T>(text))
-        const encoded = encodeValue(next)
-        draft.set(key, encoded)
-        return decodeValue<T>(encoded)
+      return write(read => {
+        const text = read(key)
+        const encoded = encodeValue(runChange(change, text === undefined ? undefined : decodeValue<T>(text)))
+        return { key, text: encoded, result: decodeValue<T>(encoded) }
       })
     },
     async delete(key) {
       checkKey(key)
-      await write(draft => { draft.delete(key) })
+      await write(() => ({ key, text: undefined, result: undefined }))
     },
     async list(prefix = '') {
       guard()
@@ -179,7 +243,7 @@ export async function openKv(options: OpenKvOptions): Promise<KvOpened> {
     kv,
     close: async () => {
       closed = true
-      await tail
+      await drained
     },
   }
 }

package/plugins/acryl-kv-json/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-kv-json",
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "vendored": [
     "src",
@@ -10,7 +10,7 @@
     "LICENSE"
   ],
   "rewrittenSpecifiers": 6,
-  "digest": "sha256:d8e3e7f9c98399d0f21f29f91323b4ce57646e59e312d4175978259d618a88cf",
+  "digest": "sha256:10613b53bdcf15cce86d6dce5e606d0cd93367cc2569b7603cbf157ebc557548",
   "testsNotRun": {
     "tests/loader.spec.ts": "loads the plugin through the real Loader (@deepseek-ai/cordis-plugin-loader), which generated apps do not install; the plain opener it wraps is tested here by open.spec.ts and conformance.spec.ts",
     "tests/crash.spec.ts": "kills a child process that imports the package build (lib/), which a copy vendored into an app does not have; it runs in ACRYL",

package/plugins/acryl-node-server/src/adapter/listener.ts

@@ -89,6 +89,11 @@ const drainIncoming = (incoming: IncomingMessage | Http2ServerRequest): void =>
     }
   }
 
+  // A body reader the app stopped using (Readable.toWeb behind bodyLimit, for one) still listens for
+  // data and pauses the request again as soon as its queue is full, so the drain would stall after
+  // one chunk and the timer would close a socket with unread data, which the kernel answers with RST.
+  // Nobody reads the body any more, so the drain is the only data listener.
+  incoming.removeAllListeners('data')
   incoming.on('data', onData)
   incoming.on('end', cleanup)
   incoming.on('error', cleanup)

package/plugins/acryl-node-server/src/client-modules.ts

@@ -1,12 +1,12 @@
 /**
  * Client components without a bundler. `clientModules({ root: 'src/client' })` is an app that serves the TypeScript and JSX modules of a
  * folder to the browser as ES modules: a `.tsx`/`.ts`/`.jsx` file compiled with the app's own `typescript` (JSX for `acrylblends/jsx/dom`),
- * a `.js`/`.mjs` file as it is. The framework's own browser imports (`acrylblends/jsx/dom` with its runtimes and `client`, and
- * `acrylblends/client`) are rewritten to two self-contained files the same app serves, at a URL relative to each module, so a page needs
+ * a `.js`/`.mjs` file as it is. The framework's own browser imports (`acrylblends/jsx/dom` with its runtimes and `client`,
+ * `acrylblends/client` and `acrylblends/read-sse`) are rewritten to three self-contained files the same app serves, at a URL relative to each module, so a page needs
  * one `<script type="module" src="/client/counter.tsx">` and no import map, under whatever path the app is routed at.
  *
  * Production runs without `typescript` (a deploy that leaves out devDependencies): `buildClientModules` writes the same compiled modules
- * and the two browser files into a folder, and with `NODE_ENV=production` and `compiled` set, only that folder is served.
+ * and the three browser files into a folder, and with `NODE_ENV=production` and `compiled` set, only that folder is served.
  */
 
 import { copyFileSync, mkdirSync, readFileSync, readdirSync, realpathSync, statSync, writeFileSync } from 'node:fs'
@@ -16,7 +16,7 @@ import { Acryl } from '../../acryl-router/src/index.ts'
 import { basePath } from '../../acryl-router/src/helpers/index.ts'
 import { MissingTypeScriptError, compileModule } from './transpile.ts'
 
-/** The folder the two browser files are served from, below the app's mount. A source folder of this name is not served. */
+/** The folder the three browser files are served from, below the app's mount. A source folder of this name is not served. */
 const RUNTIME_DIR = '@acrylblends'
 /** The framework's browser imports and the browser file that provides each. */
 const BROWSER_IMPORTS: Readonly<Record<string, string>> = {
@@ -25,8 +25,9 @@ const BROWSER_IMPORTS: Readonly<Record<string, string>> = {
   'acrylblends/jsx/dom/jsx-dev-runtime': 'jsx-dom.js',
   'acrylblends/jsx/dom/client': 'jsx-dom.js',
   'acrylblends/client': 'client.js',
+  'acrylblends/read-sse': 'read-sse.js',
 }
-const RUNTIME_FILES = ['jsx-dom.js', 'client.js'] as const
+const RUNTIME_FILES = ['jsx-dom.js', 'client.js', 'read-sse.js'] as const
 const COMPILED = new Set(['.ts', '.tsx', '.jsx', '.mts'])
 const SERVED = new Set([...COMPILED, '.js', '.mjs'])
 const JS_TYPE = 'text/javascript; charset=utf-8'
@@ -41,7 +42,7 @@ export interface ClientModulesOptions {
   readonly compiled?: string | undefined
   /** At most this many bytes of compiled modules are kept in memory (least recently served first out); 16 MiB when not given. */
   readonly cacheBytes?: number | undefined
-  /** The folder holding `jsx-dom.js` and `client.js`; the framework's own when not given. */
+  /** The folder holding `jsx-dom.js`, `client.js` and `read-sse.js`; the framework's own when not given. */
   readonly runtimeDir?: string | undefined
 }
 
@@ -51,11 +52,11 @@ export interface BuildClientModulesOptions {
   readonly root: string
   /** Where the compiled modules go, at the same relative paths and file names; it must not lie inside `root`. */
   readonly outDir: string
-  /** The folder holding `jsx-dom.js` and `client.js`; the framework's own when not given. */
+  /** The folder holding `jsx-dom.js`, `client.js` and `read-sse.js`; the framework's own when not given. */
   readonly runtimeDir?: string | undefined
 }
 
-/** The framework's two browser files, next to the built module that contains this code. */
+/** The framework's three browser files, next to the built module that contains this code. */
 const defaultRuntimeDir = (): string => fileURLToPath(new URL('./browser/', import.meta.url))
 
 /** A module path below the root (`widgets/counter.tsx`) with the URL prefix that reaches the browser files from it. */
@@ -264,7 +265,7 @@ function sourceFiles(root: string, dir = root): string[] {
 
 /**
  * Compile a folder of client modules once, for a production that has no `typescript`: each module is written to `outDir` at the same
- * relative path and file name (so the page's URLs stay the same), compiled exactly as {@link clientModules} compiles it, and the two
+ * relative path and file name (so the page's URLs stay the same), compiled exactly as {@link clientModules} compiles it, and the three
  * browser files are copied to `outDir/@acrylblends/`. Files already in `outDir` that no source produces are left there.
  * @param options - the source folder and the output folder.
  * @returns the paths written, relative to `outDir`.

package/plugins/acryl-node-server/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-node-server",
-    "commit": "f8e385e4389fe2fdc6fd2a4366a7f2a7389faacb"
+    "commit": "20bdc263d6f0f8febbd967007bda4cf4a802efd2"
   },
   "vendored": [
     "src",
@@ -10,7 +10,7 @@
     "LICENSE"
   ],
   "rewrittenSpecifiers": 31,
-  "digest": "sha256:e4f98422082758912834a6e454505230a18ac543b4851f6eb697b628a1acec4e",
+  "digest": "sha256:4142980d289b36c661e572ecbb5f19f06f0c95fc277ce4dca9b543d366c291e8",
   "testsNotRun": {
     "tests/client-modules.spec.ts": "links typescript from the plugin's own node_modules (ACRYL's workspace layout); clientModules and build-client are exercised here by the templates' tests and verify:scaffolder",
     "tests/register.spec.ts": "links typescript from the plugin's own node_modules (ACRYL's workspace layout); the hook is exercised here by the templates' own .tsx tests and verify:scaffolder"

package/plugins/acryl-router/src/browser/read-sse.ts

@@ -0,0 +1,3 @@
+/** `readSSE` (`acrylblends/read-sse`) as one browser module with no imports, served by `clientModules`. */
+
+export * from '../helpers/read-sse.ts'