acrylblends 0.6.2 → 0.6.4

package/plugins/acryl-router-http/tests/stream.spec.ts

@@ -1,133 +0,0 @@
-/**
- * Server-sent events end to end (spec 046, M5): the actual DSH `webServer`, the router, the HTTP adapter and the state
- * service. A browser-shaped `fetch` reads the stream; a change in the Host reaches it; a disconnect and a plugin unload both
- * end it and leave nothing subscribed.
- */
-
-import { request as httpRequest } from 'node:http'
-import { Context } from '@deepseek-ai/cordis'
-import WebServer from '@deepseek-ai/dsh-host-webserver'
-import { apply as routerApply, name as routerName } from '../../acryl-router/src/index.ts'
-import { apply as stateApply, name as stateName } from '../../acryl-state/src/index.ts'
-import { afterEach, describe, expect, it } from 'vitest'
-import { apply as httpApply, inject as httpInject, name as httpName } from '../src/index.ts'
-
-const contexts: Context[] = []
-const settle = (ms = 0): Promise<void> => new Promise(resolve => setTimeout(resolve, ms))
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-async function until(check: () => boolean, label: string): Promise<void> {
-  for (let i = 0; i < 300; i += 1) { if (check()) return; await settle(10) }
-  throw new Error(`timed out waiting for: ${label}`)
-}
-
-async function stack(): Promise<{ ctx: Context, base: string }> {
-  const ctx = new Context()
-  contexts.push(ctx)
-  ctx.plugin(WebServer, { host: '127.0.0.1', port: 0 } as never)
-  ctx.plugin({ name: routerName, apply: routerApply }, { trailingSlash: 'strict' })
-  ctx.plugin({ name: httpName, inject: httpInject, apply: httpApply })
-  ctx.plugin({ name: stateName, apply: stateApply })
-  const web = ctx as unknown as { webServer?: { port: number } }
-  await until(() => web.webServer?.port !== undefined && (ctx as unknown as { routerHttp?: unknown }).routerHttp !== undefined && (ctx as unknown as { state?: unknown }).state !== undefined, 'the stack')
-  await settle(30)
-  return { ctx, base: `http://127.0.0.1:${String(web.webServer!.port)}` }
-}
-
-/** Collect SSE records from a fetch response until `count` arrived. */
-async function read(reader: ReadableStreamDefaultReader<Uint8Array>, count: number): Promise<string[]> {
-  const decoder = new TextDecoder()
-  let buffer = ''
-  const out: string[] = []
-  while (out.length < count) {
-    const { done, value } = await reader.read()
-    if (done) break
-    buffer += decoder.decode(value, { stream: true })
-    for (let at = buffer.indexOf('\n\n'); at !== -1; at = buffer.indexOf('\n\n')) {
-      out.push(buffer.slice(0, at))
-      buffer = buffer.slice(at + 2)
-    }
-  }
-  return out
-}
-
-describe('server-sent events through the real stack', () => {
-  it('streams the value now and each change to a real HTTP client, with the stream headers', async () => {
-    const { ctx, base } = await stack()
-    const cell = ctx.state.cell<{ n: number }>('app.counter', { n: 0 })
-    const response = await fetch(`${base}/api/state/app.counter/events`)
-    expect(response.status).toBe(200)
-    expect(response.headers.get('content-type')).toContain('text/event-stream')
-    const reader = response.body!.getReader()
-    const first = read(reader, 3)
-    await settle(20)
-    cell.set({ n: 1 })
-    cell.set({ n: 2 })
-    expect(await first).toEqual(['event: value\ndata: {"n":0}', 'event: value\ndata: {"n":1}', 'event: value\ndata: {"n":2}'])
-    await reader.cancel()
-  })
-
-  it('stops pushing to a client that disconnected: the cell keeps no subscriber for it', async () => {
-    const { ctx, base } = await stack()
-    const cell = ctx.state.cell<number>('app.n', 0)
-    const controller = new AbortController()
-    const response = await fetch(`${base}/api/state/app.n/events`, { signal: controller.signal })
-    const reader = response.body!.getReader()
-    await read(reader, 1)
-    let seenByProbe = 0
-    // While connected, a change reaches the stream; count the cell's own subscribers through a counting wrapper.
-    controller.abort()
-    await reader.cancel().catch(() => undefined)
-    await settle(50)
-    const stop = cell.subscribe(() => { seenByProbe += 1 })
-    cell.set(1)
-    stop()
-    expect(seenByProbe).toBe(1)
-    // The disconnect released the stream: the router has no request left in flight to abort at disposal.
-    const started = Date.now()
-    await ctx.fiber.dispose()
-    contexts.length = 0
-    expect(Date.now() - started).toBeLessThan(1500)
-  })
-
-  it('ends an open stream when the state plugin unloads', async () => {
-    const { ctx, base } = await stack()
-    ctx.state.cell<number>('app.n', 0)
-    const response = await fetch(`${base}/api/state/app.n/events`)
-    const reader = response.body!.getReader()
-    await read(reader, 1)
-    const ended = reader.read()
-    const routerFiber = [...[...ctx.registry.values()].find(runtime => runtime.name === routerName)!.fibers][0]!
-    await routerFiber.dispose()
-    await expect(ended).resolves.toMatchObject({ done: true })
-  })
-})
-
-describe('the loopback guard over real HTTP', () => {
-  /** A raw request, so the test chooses the Host header (fetch would set its own). */
-  function raw(port: number, path: string, headers: Record<string, string>): Promise<{ status: number, body: string }> {
-    return new Promise((resolve, reject) => {
-      const req = httpRequest({ host: '127.0.0.1', port, path, headers }, res => {
-        let body = ''
-        res.on('data', chunk => { body += String(chunk) })
-        res.on('end', () => { resolve({ status: res.statusCode ?? 0, body }) })
-      })
-      req.on('error', reject)
-      req.end()
-    })
-  }
-
-  it('serves the state routes to this machine and refuses a request that names another host or is marked cross-site', async () => {
-    const { ctx, base } = await stack()
-    ctx.state.cell<number>('app.n', 3)
-    const port = Number(new URL(base).port)
-    const ok = await raw(port, '/api/state/app.n', { host: `127.0.0.1:${String(port)}` })
-    expect(ok.status).toBe(200)
-    expect(JSON.parse(ok.body)).toEqual({ key: 'app.n', value: 3 })
-    expect((await raw(port, '/api/state/app.n', { host: 'evil.example' })).status).toBe(403)
-    expect((await raw(port, '/api/state/app.n', { host: `127.0.0.1:${String(port + 1)}` })).status).toBe(403)
-    expect((await raw(port, '/api/state/app.n', { host: `127.0.0.1:${String(port)}`, 'sec-fetch-site': 'cross-site' })).status).toBe(403)
-  })
-})

package/plugins/acryl-router-http/tests/surfaces.spec.ts

@@ -1,101 +0,0 @@
-/**
- * One plugin, two compositions (spec 046, M3): the same `apply` runs in a Web or Desktop composition (the DSH webServer,
- * the router and the HTTP adapter) and in a terminal composition (the router alone, no server at all). The routes are
- * registered once, in `apply`; serving them over HTTP is the optional part, requested through an inner `inject`. The
- * assertions compare what a browser receives with what the terminal's in-process call receives.
- */
-
-import { Context } from '@deepseek-ai/cordis'
-import WebServer from '@deepseek-ai/dsh-host-webserver'
-import { Acryl, apply as routerApply, name as routerName } from '../../acryl-router/src/index.ts'
-import { afterEach, describe, expect, it } from 'vitest'
-import { apply as httpApply, inject as httpInject, name as httpName } from '../src/index.ts'
-
-const contexts: Context[] = []
-const settle = (ms = 0): Promise<void> => new Promise(resolve => setTimeout(resolve, ms))
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-async function until(check: () => boolean, label: string): Promise<void> {
-  for (let i = 0; i < 300; i += 1) { if (check()) return; await settle(10) }
-  throw new Error(`timed out waiting for: ${label}`)
-}
-
-/** A capability as a plugin author writes it: routes in `apply`, HTTP only if an adapter happens to be present. */
-const notes = {
-  name: 'notes-demo',
-  inject: ['router'],
-  apply(ctx: Context): void {
-    const store = new Map<string, string>()
-    const app = new Acryl()
-      .post('/:id', async c => {
-        const text = await c.req.text()
-        store.set(c.req.param('id'), text)
-        return c.json({ id: c.req.param('id'), saved: text.length }, 201)
-      })
-      .get('/:id', c => {
-        const text = store.get(c.req.param('id'))
-        return text === undefined ? c.json({ error: 'not found' }, 404) : c.json({ id: c.req.param('id'), text })
-      })
-    ctx.router.route('/api/notes', app)
-    ctx.inject(['routerHttp'], inner => { inner.routerHttp.mount('/api/notes') })
-  },
-}
-
-/** Web or Desktop: a loopback webServer, the router and the adapter. */
-async function webComposition(): Promise<{ ctx: Context, base: string }> {
-  const ctx = new Context()
-  contexts.push(ctx)
-  ctx.plugin(WebServer, { host: '127.0.0.1', port: 0 } as never)
-  ctx.plugin({ name: routerName, apply: routerApply }, { trailingSlash: 'strict' })
-  ctx.plugin({ name: httpName, inject: httpInject, apply: httpApply })
-  const web = ctx as unknown as { webServer?: { port: number } }
-  await until(() => web.webServer?.port !== undefined && (ctx as unknown as { routerHttp?: unknown }).routerHttp !== undefined, 'the web composition')
-  ctx.plugin(notes)
-  await settle(30)
-  return { ctx, base: `http://127.0.0.1:${String(web.webServer!.port)}` }
-}
-
-/** Terminal: the router only. No server, no adapter, nothing listening. */
-async function terminalComposition(): Promise<Context> {
-  const ctx = new Context()
-  contexts.push(ctx)
-  ctx.plugin({ name: routerName, apply: routerApply }, { trailingSlash: 'strict' })
-  await settle(20)
-  ctx.plugin(notes)
-  await settle(20)
-  return ctx
-}
-
-async function snapshot(response: Response): Promise<{ status: number, type: string | null, body: unknown }> {
-  return { status: response.status, type: response.headers.get('content-type'), body: await response.json() }
-}
-
-describe('the same capability on every surface', () => {
-  it('answers a browser over HTTP and the terminal in process with the same status, headers and body', async () => {
-    const web = await webComposition()
-    const terminal = await terminalComposition()
-
-    const viaHttp = [
-      await snapshot(await fetch(`${web.base}/api/notes/a`)),
-      await snapshot(await fetch(`${web.base}/api/notes/a`, { method: 'POST', body: 'hello' })),
-      await snapshot(await fetch(`${web.base}/api/notes/a`)),
-    ]
-    const router = (terminal as unknown as { router: { fetch(request: Request): Promise<Response> } }).router
-    const inProcess = [
-      await snapshot(await router.fetch(new Request('http://acryl.test/api/notes/a'))),
-      await snapshot(await router.fetch(new Request('http://acryl.test/api/notes/a', { method: 'POST', body: 'hello' }))),
-      await snapshot(await router.fetch(new Request('http://acryl.test/api/notes/a'))),
-    ]
-
-    expect(inProcess).toEqual(viaHttp)
-    expect(viaHttp.map(step => step.status)).toEqual([404, 201, 200])
-  })
-
-  it('opens no socket in the terminal composition: nothing in that context is a server', async () => {
-    const terminal = await terminalComposition()
-    expect((terminal as unknown as { webServer?: unknown }).webServer).toBeUndefined()
-    expect((terminal as unknown as { routerHttp?: unknown }).routerHttp).toBeUndefined()
-  })
-})

package/plugins/acryl-state/src/react.ts

@@ -1,11 +0,0 @@
-/**
- * The React binding: one hook that reads a cell and re-renders when it changes. `useSyncExternalStore` is React's own
- * contract for exactly this, so it is tear-free under concurrent rendering. Import from `acryl-state/react`.
- */
-
-import { useSyncExternalStore } from 'react'
-import type { ReadonlyCell } from './cell.ts'
-
-export function useCell<T>(cell: ReadonlyCell<T>): T {
-  return useSyncExternalStore(listener => cell.subscribe(listener), cell.get, cell.get)
-}

package/plugins/acryl-state/tests/cell.spec.ts

@@ -1,71 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import { createCell, createDerived } from '../src/cell.ts'
-
-describe('cells', () => {
-  it('holds a value, notifies on change with the previous value, and ignores a set to an equal value', () => {
-    const cell = createCell('a.b', 1)
-    const seen: Array<[number, number]> = []
-    cell.subscribe((value, previous) => seen.push([value, previous]))
-    cell.set(2)
-    cell.set(2)
-    cell.update(n => n + 1)
-    expect(cell.get()).toBe(3)
-    expect(seen).toEqual([[2, 1], [3, 2]])
-  })
-
-  it('stops notifying after unsubscribe, and unsubscribing twice is harmless', () => {
-    const cell = createCell('a', 0)
-    const listener = vi.fn()
-    const stop = cell.subscribe(listener)
-    cell.set(1)
-    stop()
-    stop()
-    cell.set(2)
-    expect(listener).toHaveBeenCalledTimes(1)
-  })
-
-  it('isolates a failing subscriber: the others still run and the error is reported', () => {
-    const report = vi.fn()
-    const cell = createCell('a', 0, report)
-    const after = vi.fn()
-    cell.subscribe(() => { throw new Error('boom') })
-    cell.subscribe(after)
-    cell.set(1)
-    expect(after).toHaveBeenCalledWith(1, 0)
-    expect(report).toHaveBeenCalledTimes(1)
-  })
-
-  it('lets a subscriber unsubscribe itself while being notified', () => {
-    const cell = createCell('a', 0)
-    const calls: number[] = []
-    const stop = cell.subscribe(value => { calls.push(value); stop() })
-    cell.subscribe(value => calls.push(value * 10))
-    cell.set(1)
-    cell.set(2)
-    expect(calls).toEqual([1, 10, 20])
-  })
-})
-
-describe('derived cells', () => {
-  it('recomputes from its inputs, notifies only when its own value changes, and detaches on dispose', () => {
-    const a = createCell('a', 2)
-    const b = createCell('b', 3)
-    const { cell: sum, dispose } = createDerived('sum', [a, b] as const, (x, y) => x + y)
-    const seen: number[] = []
-    sum.subscribe(value => seen.push(value))
-    expect(sum.get()).toBe(5)
-    a.set(10)
-    b.set(1)
-    expect(seen).toEqual([13, 11])
-    const parity = createDerived('parity', [a] as const, x => x % 2 === 0).cell
-    const flips: boolean[] = []
-    parity.subscribe(value => flips.push(value))
-    a.set(12)
-    a.set(14)
-    expect(flips).toEqual([])
-    dispose()
-    a.set(100)
-    // Detached: it keeps the last value it computed (14 + 1), not 100 + 1.
-    expect(sum.get()).toBe(15)
-  })
-})

package/plugins/acryl-state/tests/react.spec.ts

@@ -1,39 +0,0 @@
-// @vitest-environment jsdom
-import { act, cleanup, render } from '@testing-library/react'
-import { createElement } from 'react'
-import { afterEach, describe, expect, it } from 'vitest'
-import { createCell } from '../src/cell.ts'
-import { useCell } from '../src/react.ts'
-
-;(globalThis as { IS_REACT_ACT_ENVIRONMENT?: boolean }).IS_REACT_ACT_ENVIRONMENT = true
-afterEach(cleanup)
-
-function Counter({ cell }: { cell: ReturnType<typeof createCell<number>> }) {
-  return createElement('span', { 'data-testid': 'v' }, String(useCell(cell)))
-}
-
-describe('useCell', () => {
-  it('renders the current value and re-renders when the cell changes', () => {
-    const cell = createCell('r.count', 1)
-    const view = render(createElement(Counter, { cell }))
-    expect(view.getByTestId('v').textContent).toBe('1')
-    act(() => { cell.set(2) })
-    expect(view.getByTestId('v').textContent).toBe('2')
-  })
-
-  it('unsubscribes on unmount, and a second component on the same cell stays in step', () => {
-    const cell = createCell('r.count', 0)
-    let live = 0
-    const watched = { ...cell, subscribe: (listener: Parameters<typeof cell.subscribe>[0]) => { live += 1; const stop = cell.subscribe(listener); return () => { live -= 1; stop() } } }
-    const a = render(createElement(Counter, { cell: watched }))
-    const b = render(createElement(Counter, { cell: watched }))
-    expect(live).toBe(2)
-    act(() => { cell.set(7) })
-    expect(a.container.querySelector('[data-testid=v]')?.textContent).toBe('7')
-    expect(b.container.querySelector('[data-testid=v]')?.textContent).toBe('7')
-    a.unmount()
-    expect(live).toBe(1)
-    b.unmount()
-    expect(live).toBe(0)
-  })
-})

package/plugins/acryl-state/tests/service.spec.ts

@@ -1,132 +0,0 @@
-/**
- * The state service through a real Cordis `Context`: cells are owned by the plugin that made them, readable and
- * subscribable in process, and streamed through the router as server-sent events, with cancellation and disposal.
- */
-
-import { Context } from '@deepseek-ai/cordis'
-import { apply as routerApply, name as routerName } from '../../acryl-router/src/index.ts'
-import { afterEach, describe, expect, it } from 'vitest'
-import { apply, name } from '../src/index.ts'
-
-const contexts: Context[] = []
-const settle = (ms = 0): Promise<void> => new Promise(resolve => setTimeout(resolve, ms))
-afterEach(async () => {
-  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
-})
-
-async function system(withRouter = true): Promise<Context> {
-  const ctx = new Context()
-  contexts.push(ctx)
-  if (withRouter) ctx.plugin({ name: routerName, apply: routerApply }, { trailingSlash: 'strict' })
-  ctx.plugin({ name, apply })
-  await settle()
-  return ctx
-}
-
-/** A tiny SSE reader over a Response body. */
-async function events(response: Response, count: number): Promise<string[]> {
-  const reader = response.body!.getReader()
-  const decoder = new TextDecoder()
-  let buffer = ''
-  const out: string[] = []
-  while (out.length < count) {
-    const { done, value } = await reader.read()
-    if (done) break
-    buffer += decoder.decode(value, { stream: true })
-    for (let at = buffer.indexOf('\n\n'); at !== -1; at = buffer.indexOf('\n\n')) {
-      out.push(buffer.slice(0, at))
-      buffer = buffer.slice(at + 2)
-    }
-  }
-  reader.releaseLock()
-  return out
-}
-
-describe('acryl-state', () => {
-  it('creates cells owned by the calling plugin and removes them when it unloads', async () => {
-    const ctx = await system()
-    const fiber = ctx.plugin({ name: 'owner', inject: ['state'], apply(c: Context) { c.state.cell('owner.count', 1) } })
-    await settle()
-    expect(ctx.state.keys()).toEqual(['owner.count'])
-    expect(ctx.state.find<number>('owner.count')?.get()).toBe(1)
-    await fiber.dispose()
-    await settle()
-    expect(ctx.state.keys()).toEqual([])
-    expect(ctx.state.find('owner.count')).toBeUndefined()
-  })
-
-  it('rejects a bad or duplicate key', async () => {
-    const ctx = await system()
-    ctx.state.cell('ok.key', 0)
-    expect(() => ctx.state.cell('ok.key', 1)).toThrow(/already in use/)
-    expect(() => ctx.state.cell('Bad Key', 1)).toThrow(/dotted lowercase/)
-    expect(() => ctx.state.derive('ok.key', [], () => 1)).toThrow(/already in use/)
-  })
-
-  it('derives a cell from others and detaches it when its owner unloads', async () => {
-    const ctx = await system()
-    const a = ctx.state.cell<number>('n.a', 1)
-    const fiber = ctx.plugin({ name: 'deriver', inject: ['state'], apply(c: Context) { c.state.derive('n.double', [a] as const, x => x * 2) } })
-    await settle()
-    expect(ctx.state.find<number>('n.double')?.get()).toBe(2)
-    a.set(5)
-    expect(ctx.state.find<number>('n.double')?.get()).toBe(10)
-    await fiber.dispose()
-    await settle()
-    expect(ctx.state.find('n.double')).toBeUndefined()
-  })
-
-  it('serves keys and values as JSON on the router, read-only', async () => {
-    const ctx = await system()
-    ctx.state.cell('app.title', 'hello')
-    const keys = await ctx.router.fetch(new Request('http://acryl.test/api/state'))
-    expect(await keys.json()).toEqual({ keys: ['app.title'] })
-    const one = await ctx.router.fetch(new Request('http://acryl.test/api/state/app.title'))
-    expect(await one.json()).toEqual({ key: 'app.title', value: 'hello' })
-    expect((await ctx.router.fetch(new Request('http://acryl.test/api/state/none'))).status).toBe(404)
-    expect((await ctx.router.fetch(new Request('http://acryl.test/api/state/app.title', { method: 'PUT', body: '"x"' }))).status).toBe(405)
-    expect(ctx.state.find('app.title')?.get()).toBe('hello')
-  })
-
-  it('streams the value now and every change as server-sent events, and ends when the caller aborts', async () => {
-    const ctx = await system()
-    const cell = ctx.state.cell<number>('app.count', 0)
-    const controller = new AbortController()
-    const response = await ctx.router.fetch(new Request('http://acryl.test/api/state/app.count/events', { signal: controller.signal }))
-    expect(response.headers.get('content-type')).toContain('text/event-stream')
-    const reading = events(response, 3)
-    await settle(5)
-    cell.set(1)
-    cell.set(2)
-    expect(await reading).toEqual(['event: value\ndata: 0', 'event: value\ndata: 1', 'event: value\ndata: 2'])
-    controller.abort()
-    await settle(5)
-    // After the abort the stream no longer holds a subscription on the cell.
-    let notified = 0
-    const probe = ctx.state.find<number>('app.count')!.subscribe(() => { notified += 1 })
-    cell.set(3)
-    probe()
-    expect(notified).toBe(1)
-  })
-
-  it('closes every open stream when the router is disposed', async () => {
-    const ctx = await system()
-    ctx.state.cell<number>('app.count', 0)
-    const routerFiber = [...[...ctx.registry.values()].find(runtime => runtime.name === routerName)!.fibers][0]!
-    const response = await ctx.router.fetch(new Request('http://acryl.test/api/state/app.count/events'))
-    const reader = response.body!.getReader()
-    await reader.read()
-    const ended = reader.read()
-    await routerFiber.dispose()
-    await expect(ended).resolves.toMatchObject({ done: true })
-  })
-
-  it('works with no router: cells and subscriptions only, no routes', async () => {
-    const ctx = await system(false)
-    const cell = ctx.state.cell<string>('plain.value', 'a')
-    const seen: string[] = []
-    cell.subscribe(value => seen.push(value))
-    cell.set('b')
-    expect(seen).toEqual(['b'])
-  })
-})