acrylblends 0.3.0 → 0.4.1

package/templates/agent/src/routes.ts

@@ -1,6 +1,6 @@
 import type { Context } from '@deepseek-ai/cordis'
-import { readJson } from './plugins/acryl-router/src/helpers/index.ts'
-import type {} from './plugins/acryl-router/src/index.ts'
+import { App } from './plugins/acryl-router/src/index.ts'
+import { bodyLimit } from './plugins/acryl-router/src/middleware/index.ts'
 import type {} from './plugins/agent/index.ts'
 import type {} from './plugins/extensions/index.ts'
 import type {} from './plugins/tasks/index.ts'
@@ -10,44 +10,54 @@ export const APP_NAME = '__APP_NAME__'
 /**
  * The app's own routes on the router: `POST /ask` for the agent; `GET /extensions` and `GET /tasks` to observe what it did (every run is a
  * durable task owning one task per tool call); `POST /tasks/cancel`. What changes is also streamed: `GET /api/state/tasks/events` and
- * `GET /api/state/extensions/events`. A route registered from this plugin's context is removed when the plugin is disposed.
+ * `GET /api/state/extensions/events`. The mount is removed when the plugin is disposed.
  */
 export const routes = {
   name: 'routes',
   inject: ['router', 'agent', 'extensions', 'tasks'],
   apply(ctx: Context) {
-    const { router } = ctx
-    router.get('/', (c) => c.json({ app: APP_NAME, ok: true }))
-    router.get('/health', (c) => c.json({ ok: true }))
-    router.get('/extensions', (c) =>
-      c.json({
-        installed: ctx.extensions.list(),
-        notInstalled: ctx.extensions.pending(),
-        waitingForApproval: ctx.extensions.approvals(),
-      }),
-    )
+    // A body here is a name, an id or a question; anything bigger is refused before it is read.
+    const json = async (c: {
+      req: { json(): Promise<unknown> }
+    }): Promise<Record<string, unknown>> => {
+      const body = await c.req.json().catch(() => undefined)
+      return typeof body === 'object' && body !== null ? (body as Record<string, unknown>) : {}
+    }
+    const app = new App()
+      .use(bodyLimit({ maxSize: 64 * 1024 }))
+      .get('/', (c) => c.json({ app: APP_NAME, ok: true }))
+      .get('/health', (c) => c.json({ ok: true }))
+      .get('/extensions', (c) =>
+        c.json({
+          installed: ctx.extensions.list(),
+          notInstalled: ctx.extensions.pending(),
+          waitingForApproval: ctx.extensions.approvals(),
+        }),
+      )
     // The owner's decision on an install that is waiting (the `approval` parameter in blend.yaml).
     for (const [path, decide] of [
       ['/extensions/approve', (name: string) => ctx.extensions.approve(name)],
       ['/extensions/deny', (name: string) => ctx.extensions.deny(name)],
     ] as const) {
-      router.post(path, async (c) => {
-        const name = ((await readJson(c)) as { name?: unknown } | undefined)?.name
+      app.post(path, async (c) => {
+        const { name } = await json(c)
         if (typeof name !== 'string') return c.json({ error: 'name must be a string' }, 400)
         return c.json(await decide(name))
       })
     }
-    router.get('/tasks', (c) => c.json(ctx.tasks.list().slice(0, 100)))
-    router.post('/tasks/cancel', async (c) => {
-      const id = ((await readJson(c)) as { id?: unknown } | undefined)?.id
-      if (typeof id !== 'string' || !ctx.tasks.get(id))
-        return c.json({ error: 'no such task' }, 404)
-      return c.json({ cancelled: ctx.tasks.cancel(id) })
-    })
-    router.post('/ask', async (c) => {
-      const question = ((await readJson(c)) as { question?: unknown } | undefined)?.question
-      if (typeof question !== 'string') return c.json({ error: 'question must be a string' }, 400)
-      return c.json(await ctx.agent.run(question))
-    })
+    app
+      .get('/tasks', (c) => c.json(ctx.tasks.list().slice(0, 100)))
+      .post('/tasks/cancel', async (c) => {
+        const { id } = await json(c)
+        if (typeof id !== 'string' || !ctx.tasks.get(id))
+          return c.json({ error: 'no such task' }, 404)
+        return c.json({ cancelled: ctx.tasks.cancel(id) })
+      })
+      .post('/ask', async (c) => {
+        const { question } = await json(c)
+        if (typeof question !== 'string') return c.json({ error: 'question must be a string' }, 400)
+        return c.json(await ctx.agent.run(question))
+      })
+    ctx.router.route('/', app)
   },
 }

package/templates/agent/test/model.test.ts

@@ -10,11 +10,12 @@ import { pinnedInstance, withPort } from '../src/plugins/instance/index.ts'
 
 /** A plugin no scripted command knows: the model writes it from scratch. */
 const COUNTER = `import type { Context } from '@deepseek-ai/cordis'
+import { App } from 'acryl-router'
 export const name = 'counter'
 export const inject = ['router']
 export function apply(ctx: Context) {
   let count = 0
-  ctx.router.get('/count', (c) => c.json({ count: ++count }))
+  ctx.router.route('/', new App().get('/count', (c) => c.json({ count: ++count })))
 }
 `
 

package/templates/agent/tsconfig.json

@@ -1,19 +1,22 @@
 {
   "compilerOptions": {
-    "target": "ES2023",
-    "lib": ["ES2023"],
+    "target": "ES2024",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
     "noImplicitOverride": true,
     "verbatimModuleSyntax": true,
     "erasableSyntaxOnly": true,
     "allowImportingTsExtensions": true,
     "noEmit": true,
     "skipLibCheck": true,
-    "types": ["node"]
+    "types": ["node"],
+    "paths": {
+      "acryl-router": ["./src/plugins/acryl-router/src/index.ts"],
+      "acryl-router/middleware": ["./src/plugins/acryl-router/src/middleware/index.ts"],
+      "acryl-router/helpers": ["./src/plugins/acryl-router/src/helpers/index.ts"]
+    }
   },
   "include": ["src", "test", "extensions"]
 }

package/templates/blank/AGENTS.md

@@ -0,0 +1,5 @@
+
+## This app (blank)
+
+`src/routes.ts` is the app's own plugin: add routes to its `App`. `blend.yaml` lists the plugins that are mounted. `acrylblends add <plugin>` copies
+another library plugin (for example `acryl-state`) into `src/plugins/`.

package/templates/blank/README.md

@@ -15,7 +15,7 @@ npm run check      # type-check
   one off with `disabled: true`. `npm run lock` writes `blend.lock.json`: the manifest's digest and a digest of
   every plugin folder, so a diff of the lock shows what changed.
 - `src/app.ts` holds the registry of plugins the code provides, and mounts the manifest's rows.
-- `src/routes.ts` is your own plugin: routes added inside `ctx.effect`.
+- `src/routes.ts` is your own plugin: it builds an `App` (`import { App } from './plugins/acryl-router/src/index.ts'`) and mounts it with `ctx.router.route(prefix, app)`. Routes added to the app after it is mounted are not served. A page mounted at `/x` answers `/x`, not `/x/` (trailing slashes are strict). The router API is documented at https://acrylblends.github.io/docs/framework/the-acryl-framework and in `docs/framework` of the acrylblends repository.
 - `src/plugins/` holds the plugins copied from the ACRYLBLENDS library. They are yours now; edit them freely.
   Add more with `acrylblends add <plugin>`.
 

package/templates/blank/src/routes.ts

@@ -1,14 +1,16 @@
 import type { Context } from '@deepseek-ai/cordis'
-import type {} from './plugins/acryl-router/src/index.ts'
+import { App } from './plugins/acryl-router/src/index.ts'
 
 export const APP_NAME = '__APP_NAME__'
 
-/** The app's own routes on the router. A route registered from this plugin's context is removed when the plugin is disposed. */
+/** The app's own routes: an `App` mounted on the router. The mount is removed when this plugin is disposed. */
 export const routes = {
   name: 'routes',
   inject: ['router'],
   apply(ctx: Context) {
-    ctx.router.get('/', (c) => c.json({ app: APP_NAME, ok: true }))
-    ctx.router.get('/health', (c) => c.json({ ok: true }))
+    const app = new App()
+      .get('/', (c) => c.json({ app: APP_NAME, ok: true }))
+      .get('/health', (c) => c.json({ ok: true }))
+    ctx.router.route('/', app)
   },
 }

package/templates/blank/tsconfig.json

@@ -1,12 +1,10 @@
 {
   "compilerOptions": {
-    "target": "ES2023",
-    "lib": ["ES2023"],
+    "target": "ES2024",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
     "noImplicitOverride": true,
     "verbatimModuleSyntax": true,
     "erasableSyntaxOnly": true,

package/templates/todo/AGENTS.md

@@ -0,0 +1,5 @@
+
+## This app (todo)
+
+`src/todo.ts` is the whole feature: a plugin that mounts an `App` (CRUD, a page, a server-sent stream) and keeps the list in a state cell that it
+also writes to a file in the app's home. Use it as the reference for a new plugin, and keep its tests passing when you change it.

package/templates/todo/src/page.ts

@@ -1,7 +1,7 @@
 /** The page: plain HTML and a few lines of script; it follows the list through the server-sent event stream. */
 export const PAGE = `<!doctype html>
 <meta charset="utf-8"><title>Todo</title>
-<style>body{font:16px system-ui;max-width:32rem;margin:2rem auto}li{display:flex;gap:.5rem;padding:.25rem 0}.done span{text-decoration:line-through;opacity:.6}</style>
+<style>body{font:16px system-ui;max-width:32rem;margin:2rem auto}ul{list-style:none;padding:0}li{display:flex;gap:.5rem;padding:.25rem 0}.done span{text-decoration:line-through;opacity:.6}</style>
 <h1>Todo</h1>
 <form id="add"><input id="title" placeholder="What needs doing?" autofocus> <button>Add</button></form>
 <ul id="list"></ul>

package/templates/todo/src/todo.ts

@@ -6,9 +6,9 @@
 import { mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
 import { dirname } from 'node:path'
 import type { Context } from '@deepseek-ai/cordis'
-import { HttpError } from './plugins/acryl-router/src/index.ts'
-import { loopbackOnly } from './plugins/acryl-router/src/middleware/index.ts'
-import { readJson, streamSSE, valid, validate, type StandardSchema } from './plugins/acryl-router/src/helpers/index.ts'
+import { App, HTTPException } from './plugins/acryl-router/src/index.ts'
+import { bodyLimit, loopbackOnly, trimTrailingSlash } from './plugins/acryl-router/src/middleware/index.ts'
+import { schemaValidator, streamSSE, type StandardSchema } from './plugins/acryl-router/src/helpers/index.ts'
 import type {} from './plugins/acryl-state/src/index.ts'
 import { PAGE } from './page.ts'
 
@@ -31,6 +31,19 @@ const NewTodo: StandardSchema<{ title: string }> = {
   },
 }
 
+/** Standard Schema for a change to a todo. */
+const TodoChange: StandardSchema<{ done: boolean }> = {
+  '~standard': {
+    validate: value => {
+      const done = (value as { done?: unknown } | null)?.done
+      return typeof done === 'boolean' ? { value: { done } } : { issues: [{ message: 'done must be true or false', path: ['done'] }] }
+    },
+  },
+}
+
+/** A todo body is small; anything bigger is refused before it is read. */
+const MAX_BODY_BYTES = 16 * 1024
+
 /** A missing file is a new list. Any other failure (unreadable, corrupt, half-written) refuses to start: starting empty would overwrite the user's real list on the first save. */
 function load(file: string | undefined): Todo[] {
   if (file === undefined) return []
@@ -65,32 +78,48 @@ export function apply(ctx: Context, config: Config = {}): void {
   }
   const nextId = (): number => todos.get().reduce((max, todo) => Math.max(max, todo.id), 0) + 1
 
-  const api = ctx.router.group('/todo', loopbackOnly({ inProcess: 'allow' }))
-  api.get('/', c => c.html(PAGE))
-  api.get('/api', c => c.json(todos.get()))
-  api.post('/api', validate('json', NewTodo), c => {
-    const todo: Todo = { id: nextId(), title: valid<{ title: string }>(c, 'json').title, done: false }
-    todos.update(list => [...list, todo])
-    return c.json(todo, 201)
-  })
-  api.patch('/api/:id', async c => {
-    const id = Number(c.param('id'))
-    const change = await readJson(c) as { done?: unknown }
-    if (!todos.get().some(todo => todo.id === id)) throw new HttpError(404, { message: 'no such todo' })
-    if (typeof change.done !== 'boolean') throw new HttpError(400, { message: 'done must be true or false' })
-    todos.update(list => list.map(todo => todo.id === id ? { ...todo, done: change.done as boolean } : todo))
-    return c.json(todos.get().find(todo => todo.id === id))
-  })
-  api.delete('/api/:id', c => {
-    const id = Number(c.param('id'))
-    if (!todos.get().some(todo => todo.id === id)) throw new HttpError(404, { message: 'no such todo' })
-    todos.update(list => list.filter(todo => todo.id !== id))
-    return c.body(null, 204)
-  })
-  api.get('/events', c => streamSSE(c, stream => {
-    stream.send(todos.get())
-    return todos.subscribe(list => { stream.send(list) })
-  }))
+  const find = (id: number): Todo => {
+    const todo = todos.get().find(item => item.id === id)
+    if (todo === undefined) throw new HTTPException(404, { message: 'no such todo' })
+    return todo
+  }
+
+  // `/todo/` is what people type: trimTrailingSlash answers a GET for an unknown path ending in `/` with a 301 to the path without it,
+  // so the page is found either way while each route keeps one canonical path (the router itself treats `/a` and `/a/` as different).
+  const api = new App()
+    .use(loopbackOnly({ inProcess: 'allow' }), bodyLimit({ maxSize: MAX_BODY_BYTES }), trimTrailingSlash())
+    .get('/', c => c.html(PAGE))
+    .get('/api', c => c.json(todos.get()))
+    .post('/api', schemaValidator('json', NewTodo), c => {
+      const todo: Todo = { id: nextId(), title: c.req.valid('json').title, done: false }
+      todos.update(list => [...list, todo])
+      return c.json(todo, 201)
+    })
+    .patch('/api/:id', schemaValidator('json', TodoChange), c => {
+      const { id } = find(Number(c.req.param('id')))
+      const { done } = c.req.valid('json')
+      todos.update(list => list.map(todo => todo.id === id ? { ...todo, done } : todo))
+      return c.json(find(id))
+    })
+    .delete('/api/:id', c => {
+      const { id } = find(Number(c.req.param('id')))
+      todos.update(list => list.filter(todo => todo.id !== id))
+      return c.body(null, 204)
+    })
+    .get('/events', c => streamSSE(c, async stream => {
+      const ended = new Promise<void>(resolve => { stream.onAbort(resolve) })
+      // Writes are asynchronous; chaining them keeps events in the order the list changed.
+      let queue: Promise<unknown> = Promise.resolve()
+      const send = (list: readonly Todo[]): void => { queue = queue.then(() => stream.writeSSE({ data: JSON.stringify(list) })).catch(() => {}) }
+      send(todos.get())
+      const unsubscribe = todos.subscribe(send)
+      try {
+        await ended
+      } finally {
+        unsubscribe()
+      }
+    }))
+  ctx.router.route('/todo', api)
 
   ctx.inject(['routerHttp'], inner => { inner.routerHttp.mount('/todo') })
 }

package/templates/todo/tsconfig.json

@@ -1,12 +1,10 @@
 {
   "compilerOptions": {
-    "target": "ES2023",
-    "lib": ["ES2023"],
+    "target": "ES2024",
+    "lib": ["ES2024", "DOM", "DOM.Iterable"],
     "module": "NodeNext",
     "moduleResolution": "NodeNext",
     "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "exactOptionalPropertyTypes": true,
     "noImplicitOverride": true,
     "verbatimModuleSyntax": true,
     "erasableSyntaxOnly": true,

package/templates/todo/upstream.json

@@ -5,8 +5,8 @@
       "examples/acryl-todo/src/index.ts": "src/todo.ts",
       "examples/acryl-todo/src/page.ts": "src/page.ts"
     },
-    "commit": "11fed295161c0282d144b5ac62616988b58d8189"
+    "commit": "64e7c9d2e787f74b2da82492644fbbb46a601074"
   },
   "rewrittenSpecifiers": 4,
-  "digest": "sha256:5ca4e0883b7ff0fdec8cf18baac5271209ee27fcc8ce8decf298c9720256f92c"
+  "digest": "sha256:b62b5167344084f7ac03c8286923f92419a4ab41c5d8235adb3247d983807aca"
 }

package/plugins/acryl-router/src/compose.ts

@@ -1,21 +0,0 @@
-import type { Handler, Middleware, RouteContext } from './types.ts'
-
-/**
- * Run `middleware` in order around `final`. Each middleware receives `next`, which runs the rest of the chain and
- * resolves to its response. Calling `next` twice in one middleware is a programming error and rejects.
- */
-export function compose(middleware: readonly Middleware[], final: Handler): Handler {
-  return (c: RouteContext): Promise<Response> => {
-    const dispatch = async (index: number): Promise<Response> => {
-      const current = middleware[index]
-      if (current === undefined) return final(c)
-      let called = false
-      return current(c, () => {
-        if (called) return Promise.reject(new Error('router: next() called more than once'))
-        called = true
-        return dispatch(index + 1)
-      })
-    }
-    return dispatch(0)
-  }
-}

package/plugins/acryl-router/src/context.ts

@@ -1,59 +0,0 @@
-import type { ConnectionInfo, ResponseBody, RouteContext } from './types.ts'
-
-const JSON_TYPE = 'application/json; charset=utf-8'
-const TEXT_TYPE = 'text/plain; charset=utf-8'
-const HTML_TYPE = 'text/html; charset=utf-8'
-
-/** Statuses that must not carry a body; a `Response` constructed with one throws. */
-const NULL_BODY_STATUSES = new Set([101, 204, 205, 304])
-const bodyFor = <T>(status: number, body: T): T | null => NULL_BODY_STATUSES.has(status) ? null : body
-
-/** Build the per-request context. `notFound` is what `c.notFound()` runs: the router's own answer. */
-export function createContext(
-  req: Request,
-  params: Record<string, string>,
-  signal: AbortSignal,
-  connection: ConnectionInfo,
-  track: (task: Promise<unknown>) => void,
-  notFound: (c: RouteContext) => Response | Promise<Response>,
-): RouteContext {
-  const values = new Map<string, unknown>()
-  const url = new URL(req.url)
-  const defaults = new Headers()
-  let defaultStatus = 200
-
-  const respond = (body: ResponseBody, status: number | undefined, type: string | undefined, extra?: Record<string, string>): Response => {
-    const code = status ?? defaultStatus
-    const headers = new Headers(defaults)
-    if (type !== undefined && !headers.has('content-type')) headers.set('content-type', type)
-    for (const [name, value] of Object.entries(extra ?? {})) headers.set(name, value)
-    return new Response(bodyFor(code, body), { status: code, headers })
-  }
-
-  const context: RouteContext = {
-    req,
-    url,
-    params,
-    connection,
-    signal,
-    waitUntil: track,
-    get: <T>(key: string) => values.get(key) as T | undefined,
-    set: (key, value) => { values.set(key, value) },
-    header: (name, value) => { defaults.set(name, value) },
-    status: code => { defaultStatus = code },
-    query: ((name?: string) => {
-      if (name !== undefined) return url.searchParams.get(name) ?? undefined
-      const all: Record<string, string> = {}
-      for (const [key, value] of url.searchParams) if (!(key in all)) all[key] = value
-      return all
-    }) as RouteContext['query'],
-    param: ((name?: string) => name === undefined ? params : params[name]) as RouteContext['param'],
-    json: (data, status) => respond(JSON.stringify(data), status, JSON_TYPE),
-    text: (body, status) => respond(body, status, TEXT_TYPE),
-    html: (body, status) => respond(body, status, HTML_TYPE),
-    body: (data, status, headers) => respond(data, status, undefined, headers),
-    redirect: (location, status = 302) => respond(null, status, undefined, { location }),
-    notFound: () => notFound(context),
-  }
-  return context
-}

package/plugins/acryl-router/src/helpers/read-body.ts

@@ -1,59 +0,0 @@
-import { HttpError } from '../http-error.ts'
-import { BODY_LIMIT_KEY } from '../middleware/body-limit.ts'
-import type { RouteContext } from '../types.ts'
-
-export interface ReadBodyOptions {
-  /** The most bytes to accept. Defaults to the `bodyLimit` middleware's limit when it ran, otherwise 1 MiB. */
-  readonly maxBytes?: number
-}
-
-const DEFAULT_MAX_BYTES = 1024 * 1024
-
-/**
- * Read the request body as bytes, counting as it streams, and stop at the limit (a 413 `HttpError`). Stops at once when the request is aborted.
- * A request with no body gives an empty array.
- */
-export async function readBytes(c: RouteContext, options: ReadBodyOptions = {}): Promise<Uint8Array> {
-  const limit = options.maxBytes ?? c.get<number>(BODY_LIMIT_KEY) ?? DEFAULT_MAX_BYTES
-  c.signal.throwIfAborted()
-  const reader = c.req.body?.getReader()
-  if (reader === undefined) return new Uint8Array()
-  const onAbort = (): void => { void reader.cancel(c.signal.reason).catch(() => undefined) }
-  c.signal.addEventListener('abort', onAbort, { once: true })
-  const chunks: Uint8Array[] = []
-  let size = 0
-  try {
-    for (;;) {
-      const { done, value } = await reader.read()
-      if (done) break
-      size += value.byteLength
-      if (size > limit) {
-        await reader.cancel().catch(() => undefined)
-        throw new HttpError(413, { message: 'payload too large' })
-      }
-      chunks.push(value)
-    }
-  } finally {
-    c.signal.removeEventListener('abort', onAbort)
-  }
-  c.signal.throwIfAborted()
-  const bytes = new Uint8Array(size)
-  let offset = 0
-  for (const chunk of chunks) { bytes.set(chunk, offset); offset += chunk.byteLength }
-  return bytes
-}
-
-/** The body as UTF-8 text, within the limit. */
-export async function readText(c: RouteContext, options?: ReadBodyOptions): Promise<string> {
-  return new TextDecoder().decode(await readBytes(c, options))
-}
-
-/** The body parsed as JSON, within the limit. Bad JSON is a 400 `HttpError`. */
-export async function readJson(c: RouteContext, options?: ReadBodyOptions): Promise<unknown> {
-  const text = await readText(c, options)
-  try {
-    return JSON.parse(text) as unknown
-  } catch {
-    throw new HttpError(400, { message: 'invalid json' })
-  }
-}

package/plugins/acryl-router/src/helpers/sse.ts

@@ -1,83 +0,0 @@
-import type { RouteContext } from '../types.ts'
-
-export interface SseStream {
-  /** Send one event. Objects and arrays are sent as JSON; strings as they are. */
-  send(data: unknown, options?: { readonly event?: string, readonly id?: string }): void
-  /** Send a comment line (a keep-alive that clients ignore). */
-  comment(text: string): void
-  /** End the stream from the server side. */
-  close(): void
-  /** Aborted when the client goes away or the router is disposed. */
-  readonly signal: AbortSignal
-}
-
-const HEADERS = {
-  'content-type': 'text/event-stream; charset=utf-8',
-  'cache-control': 'no-store',
-  'x-content-type-options': 'nosniff',
-} as const
-
-const encode = (text: string): Uint8Array => new TextEncoder().encode(text)
-
-export interface SseOptions {
-  /** A comment line is sent this often so proxies and browsers keep an idle stream open. Default 15 seconds. */
-  readonly keepAliveMs?: number
-}
-
-const DEFAULT_KEEP_ALIVE_MS = 15_000
-
-/**
- * A server-sent-event response. `run` starts the stream; whatever cleanup function it returns runs exactly once when the stream
- * ends for any reason (the client disconnects, `close()`, a plugin unload, the router being disposed). The request is held in flight with `waitUntil`
- * until then, so disposal waits for the stream instead of leaking it.
- */
-export function streamSSE(c: RouteContext, run: (stream: SseStream) => void | (() => void), options: SseOptions = {}): Response {
-  let finish!: () => void
-  c.waitUntil(new Promise<void>(resolve => { finish = resolve }))
-  let controller!: ReadableStreamDefaultController<Uint8Array>
-  let cleanup: (() => void) | undefined
-  let ended = false
-  let keepAlive: ReturnType<typeof setInterval> | undefined
-
-  const end = (): void => {
-    if (ended) return
-    ended = true
-    clearInterval(keepAlive)
-    c.signal.removeEventListener('abort', end)
-    try { cleanup?.() } finally {
-      try { controller.close() } catch { /* already closed */ }
-      finish()
-    }
-  }
-
-  const body = new ReadableStream<Uint8Array>({
-    start: ctrl => {
-      controller = ctrl
-      const stream: SseStream = {
-        signal: c.signal,
-        send: (data, options) => {
-          if (ended) return
-          const lines: string[] = []
-          if (options?.id !== undefined) lines.push(`id: ${options.id}`)
-          if (options?.event !== undefined) lines.push(`event: ${options.event}`)
-          const payload = typeof data === 'string' ? data : JSON.stringify(data)
-          for (const line of payload.split('\n')) lines.push(`data: ${line}`)
-          try { controller.enqueue(encode(`${lines.join('\n')}\n\n`)) } catch { end() }
-        },
-        comment: text => {
-          if (ended) return
-          try { controller.enqueue(encode(`: ${text.replaceAll('\n', ' ')}\n\n`)) } catch { end() }
-        },
-        close: end,
-      }
-      if (c.signal.aborted) { end(); return }
-      c.signal.addEventListener('abort', end, { once: true })
-      keepAlive = setInterval(() => { stream.comment('keepalive') }, options.keepAliveMs ?? DEFAULT_KEEP_ALIVE_MS)
-      keepAlive.unref()
-      cleanup = run(stream) ?? undefined
-      if (ended) { try { cleanup?.() } catch { /* the stream already ended */ } }
-    },
-    cancel: end,
-  })
-  return new Response(body, { headers: HEADERS })
-}

package/plugins/acryl-router/src/helpers/validate.ts

@@ -1,44 +0,0 @@
-import { HttpError } from '../http-error.ts'
-import type { Middleware, RouteContext } from '../types.ts'
-import { readJson } from './read-body.ts'
-
-/** The slice of the Standard Schema interface this needs; Schemastery (what Cordis uses), Zod and Valibot all implement it. */
-export interface StandardSchema<T = unknown> {
-  readonly '~standard': {
-    validate(value: unknown): StandardResult<T> | Promise<StandardResult<T>>
-  }
-}
-
-type StandardResult<T> =
-  | { readonly value: T, readonly issues?: undefined }
-  | { readonly issues: readonly { readonly message: string, readonly path?: readonly unknown[] | undefined }[] }
-
-export type ValidationTarget = 'json' | 'query' | 'param'
-
-const key = (target: ValidationTarget): string => `valid:${target}`
-
-/**
- * Validate part of the request against a schema before the handler runs. A failure is a 400 with the issues; success stores the
- * parsed value, which the handler reads with `valid(c, target)`. `json` reads the body within the limit; `query` is the first value of each query
- * parameter; `param` is the matched path parameters.
- */
-export function validate<T>(target: ValidationTarget, schema: StandardSchema<T>): Middleware {
-  return async (c, next) => {
-    const input = target === 'json' ? await readJson(c) : target === 'query' ? c.query() : { ...c.param() }
-    const result = await schema['~standard'].validate(input)
-    if (result.issues !== undefined) {
-      throw new HttpError(400, {
-        response: c.json({ error: `invalid ${target}`, issues: result.issues.map(issue => ({ message: issue.message, path: (issue.path ?? []).map(part => String(typeof part === 'object' && part !== null && 'key' in part ? (part as { key: unknown }).key : part)).join('.') })) }, 400),
-      })
-    }
-    c.set(key(target), result.value)
-    return next()
-  }
-}
-
-/** The value `validate(target, schema)` stored. Throws if that middleware did not run on this route. */
-export function valid<T>(c: RouteContext, target: ValidationTarget): T {
-  const value = c.get<T>(key(target))
-  if (value === undefined) throw new Error(`valid("${target}"): no validate("${target}", schema) ran before this handler`)
-  return value
-}

package/plugins/acryl-router/src/http-error.ts

@@ -1,21 +0,0 @@
-/**
- * An error that carries the response it should become. A handler or middleware throws it to stop a request
- * with a status: `throw new HttpError(401, { message: 'Sign in first' })`. The router answers with `getResponse()`; a registered
- * `onError` handler still sees every other error.
- */
-export class HttpError extends Error {
-  readonly status: number
-  private readonly response: Response | undefined
-
-  constructor(status: number, options: { readonly message?: string, readonly response?: Response, readonly cause?: unknown } = {}) {
-    super(options.message ?? `HTTP ${String(status)}`, options.cause === undefined ? undefined : { cause: options.cause })
-    this.name = 'HttpError'
-    this.status = status
-    this.response = options.response
-  }
-
-  /** The response this error stands for: the one it was given, or its message as plain text with its status. */
-  getResponse(): Response {
-    return this.response ?? new Response(this.message, { status: this.status, headers: { 'content-type': 'text/plain; charset=utf-8' } })
-  }
-}