acrylblends 0.2.0 → 0.4.0

package/plugins/acryl-inspect/src/service.ts

@@ -0,0 +1,68 @@
+/**
+ * The ACRYL inspector (`ctx.inspect`): what every running plugin requires, provides and registers, read from the live
+ * registry. It owns no state and registers nothing of its own beyond an optional read-only pair of router routes, which are
+ * reachable in process unless some plugin mounts their prefix over HTTP.
+ */
+
+import { Context, Service } from '@deepseek-ai/cordis'
+import { loopbackOnly } from '../../acryl-router/src/middleware/index.ts'
+import { App } from '../../acryl-router/src/index.ts'
+import { explain, ownerOf, renderReports, reportFiber, type FiberView, type PluginReport } from './report.ts'
+
+declare module '@deepseek-ai/cordis' {
+  interface Context {
+    inspect: Inspect
+  }
+}
+
+/** Stable Cordis plugin name, equal to the package name and the Loader row id. */
+export const name = 'acryl-inspect'
+
+export class Inspect extends Service {
+  constructor(ctx: Context) {
+    super(ctx, 'inspect')
+  }
+
+  /** A report for every live plugin instance, in registry order. */
+  plugins(): PluginReport[] {
+    const fibers = [...this.ctx.registry.values()].flatMap(runtime => [...runtime.fibers] as unknown as FiberView[])
+    // An unnamed inline callback is part of the plugin that wrote it: its routes and mounts are that plugin's.
+    const adopted = new Map<FiberView, FiberView[]>()
+    const owners: FiberView[] = []
+    for (const fiber of fibers) {
+      const owner = ownerOf(fiber)
+      if (owner === fiber) owners.push(fiber)
+      else adopted.set(owner, [...(adopted.get(owner) ?? []), fiber])
+    }
+    return owners.map(fiber => reportFiber(fiber, adopted.get(fiber) ?? []))
+  }
+
+  /** The text explanation of the plugin called `pluginName`, or `undefined` when none is registered. */
+  explain(pluginName: string): string | undefined {
+    const found = this.plugins().filter(report => report.name === pluginName)
+    return found.length === 0 ? undefined : found.map(explain).join('\n\n')
+  }
+
+  /** The whole system as text. */
+  render(): string {
+    return renderReports(this.plugins())
+  }
+}
+
+export function apply(ctx: Context): void {
+  const inspect = new Inspect(ctx)
+  // The same facts on the router, for any surface; present only where a router is. A request over a socket must come from this machine to this app;
+  // the terminal calls the router in process and is the host's own code.
+  ctx.inject(['router'], inner => {
+    const api = new App()
+      .use(loopbackOnly({ inProcess: 'allow' }))
+      .get('/plugins', c => c.json(inspect.plugins()))
+      .get('/plugins/:name', c => {
+        const text = inspect.explain(c.req.param('name'))
+        return text === undefined ? c.json({ error: 'no such plugin' }, 404) : c.text(text)
+      })
+    inner.router.route('/api/inspect', api)
+    // Over HTTP only where an adapter exists (Web and Desktop); the terminal needs none.
+    inner.inject(['routerHttp'], http => { http.routerHttp.mount('/api/inspect') })
+  })
+}

package/plugins/acryl-inspect/tests/report.spec.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from 'vitest'
+import { explain, renderReports, reportFiber, stateName, type FiberView } from '../src/report.ts'
+
+function fiber(over: Partial<FiberView> & { effects?: FiberView['getEffects'] extends () => infer R ? R : never } = {}): FiberView {
+  const { effects = [], ...rest } = over
+  return { state: 2, inject: {}, runtime: { name: 'demo' }, getEffects: () => effects, ...rest }
+}
+
+describe('reportFiber', () => {
+  it('sorts effects into provides, mounts with their routes, and everything else, including nested ones', () => {
+    const report = reportFiber(fiber({
+      inject: { router: null, acrylSettings: null },
+      effects: [
+        { label: 'ctx.provide("things")', children: [] },
+        { label: 'acryl-router: route /api (ALL /api/*, GET /api/things/:id)', children: [] },
+        { label: 'acryl-router: route /api/things (POST /api/things)', children: [{ label: 'inner timer', children: [] }] },
+        { label: 'ctx.on("internal/status")', children: [] },
+      ],
+    }))
+    expect(report).toEqual({
+      name: 'demo',
+      state: 'ACTIVE',
+      requires: ['acrylSettings', 'router'],
+      provides: ['things'],
+      mounts: ['/api', '/api/things'],
+      routes: [{ method: 'ALL', path: '/api/*' }, { method: 'GET', path: '/api/things/:id' }, { method: 'POST', path: '/api/things' }],
+      other: ['inner timer', 'ctx.on("internal/status")'],
+      removedOnUnload: 5,
+    })
+  })
+
+  it('names the state and an anonymous plugin', () => {
+    expect(stateName(0)).toBe('PENDING')
+    expect(stateName(2)).toBe('ACTIVE')
+    expect(stateName(5)).toBe('UNLOADING')
+    expect(reportFiber(fiber({ runtime: null })).name).toBe('anonymous')
+  })
+})
+
+describe('explain', () => {
+  it('says what a plugin needs, adds and removes on unload', () => {
+    const text = explain(reportFiber(fiber({
+      inject: { router: null },
+      effects: [{ label: 'acryl-router: route / (GET /a)', children: [] }],
+    })))
+    expect(text).toContain('demo (ACTIVE)')
+    expect(text).toContain('needs:     router')
+    expect(text).toContain('routes:    GET /a')
+    expect(text).toContain('unloading: removes 1 registration and nothing else')
+  })
+
+  it('says a pending plugin is waiting for its services', () => {
+    const text = explain(reportFiber(fiber({ state: 0, inject: { router: null, webServer: null } })))
+    expect(text).toContain('demo (PENDING)')
+    expect(text).toContain('it starts when router, webServer are available')
+  })
+
+  it('renders several plugins as blocks', () => {
+    const a = reportFiber(fiber({ runtime: { name: 'a' } }))
+    const b = reportFiber(fiber({ runtime: { name: 'b' } }))
+    expect(renderReports([a, b]).split('\n\n')).toHaveLength(2)
+  })
+})

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

@@ -0,0 +1,121 @@
+/**
+ * The inspector against real Cordis plugins: what it reports is what Cordis holds, so the tests build a small system and
+ * compare the report with what the plugins actually did.
+ */
+
+import { Context } from '@deepseek-ai/cordis'
+import { App, apply as routerApply, name as routerName } from '../../acryl-router/src/index.ts'
+import { afterEach, describe, expect, it } from 'vitest'
+import { apply, name, type PluginReport } from '../src/index.ts'
+
+const contexts: Context[] = []
+const settle = (): Promise<void> => new Promise(resolve => setTimeout(resolve, 0))
+afterEach(async () => {
+  while (contexts.length > 0) await contexts.pop()?.fiber.dispose()
+})
+
+const market = {
+  name: 'demo-market',
+  inject: ['router'],
+  apply(ctx: Context): void {
+    ctx.router.route('/api/demo', new App()
+      .use(async (_c, next) => { await next() })
+      .get('/state', c => c.json({ ok: true }))
+      .post('/sources', c => c.json({ ok: true }, 201)))
+  },
+}
+
+async function system(): Promise<Context> {
+  const ctx = new Context()
+  contexts.push(ctx)
+  ctx.plugin({ name: routerName, apply: routerApply }, { trailingSlash: 'strict' })
+  ctx.plugin({ name, apply })
+  await settle()
+  return ctx
+}
+
+const byName = (reports: readonly PluginReport[], pluginName: string): PluginReport => {
+  const found = reports.find(report => report.name === pluginName)
+  if (found === undefined) throw new Error(`no report for ${pluginName}`)
+  return found
+}
+
+describe('acryl-inspect', () => {
+  it('counts what an inline ctx.inject callback registers as the owning plugin\'s', async () => {
+    const ctx = await system()
+    ctx.plugin({
+      name: 'demo-inline',
+      apply(inner: Context): void {
+        inner.inject(['router'], deeper => { deeper.router.route('/', new App().get('/api/inline', c => c.json({ ok: true }))) })
+      },
+    })
+    await settle()
+    const reports = ctx.inspect.plugins()
+    expect(byName(reports, 'demo-inline').routes).toEqual([{ method: 'GET', path: '/api/inline' }])
+    expect(reports.every(report => report.name !== 'anonymous')).toBe(true)
+  })
+
+  it('reports what a plugin requires, provides and registers, from the running system', async () => {
+    const ctx = await system()
+    ctx.plugin(market)
+    await settle()
+    const reports = ctx.inspect.plugins()
+
+    expect(byName(reports, 'acryl-router')).toMatchObject({ state: 'ACTIVE', requires: [], provides: ['router'] })
+    expect(byName(reports, 'acryl-inspect')).toMatchObject({ state: 'ACTIVE', provides: ['inspect'] })
+    const demo = byName(reports, 'demo-market')
+    expect(demo).toMatchObject({
+      state: 'ACTIVE',
+      requires: ['router'],
+      provides: [],
+      mounts: ['/api/demo'],
+      routes: [{ method: 'ALL', path: '/api/demo/*' }, { method: 'GET', path: '/api/demo/state' }, { method: 'POST', path: '/api/demo/sources' }],
+      removedOnUnload: 1,
+    })
+  })
+
+  it('shows a plugin whose service is missing as PENDING and says what it waits for', async () => {
+    const ctx = await system()
+    ctx.plugin({ name: 'needs-a-thing', inject: ['neverProvided'], apply() { /* never runs */ } })
+    await settle()
+    expect(byName(ctx.inspect.plugins(), 'needs-a-thing')).toMatchObject({ state: 'PENDING', requires: ['neverProvided'] })
+    expect(ctx.inspect.explain('needs-a-thing')).toContain('it starts when neverProvided is available')
+  })
+
+  it('stops listing a plugin that unloaded, and the router really lost what the report said would go', async () => {
+    const ctx = await system()
+    const baseline = ctx.router.size
+    const fiber = ctx.plugin(market)
+    await settle()
+    const promised = byName(ctx.inspect.plugins(), 'demo-market').removedOnUnload
+    expect(ctx.router.size - baseline).toBe(promised)
+
+    await fiber.dispose()
+    await settle()
+    expect(ctx.inspect.plugins().some(report => report.name === 'demo-market' && report.state === 'ACTIVE')).toBe(false)
+    expect(ctx.router.size).toBe(baseline)
+  })
+
+  it('serves the same facts on the router, in process', async () => {
+    const ctx = await system()
+    ctx.plugin(market)
+    await settle()
+    const list = await ctx.router.fetch(new Request('http://acryl.test/api/inspect/plugins'))
+    expect(list.status).toBe(200)
+    const reports = await list.json() as PluginReport[]
+    expect(byName(reports, 'demo-market').routes).toHaveLength(3)
+
+    const one = await ctx.router.fetch(new Request('http://acryl.test/api/inspect/plugins/demo-market'))
+    expect(await one.text()).toContain('removes 1 registration and nothing else')
+    expect((await ctx.router.fetch(new Request('http://acryl.test/api/inspect/plugins/nope'))).status).toBe(404)
+  })
+
+  it('needs no router: without one it still answers in code and registers no routes', async () => {
+    const ctx = new Context()
+    contexts.push(ctx)
+    ctx.plugin({ name, apply })
+    await settle()
+    expect(byName(ctx.inspect.plugins(), 'acryl-inspect').routes).toEqual([])
+    expect(ctx.inspect.render()).toContain('acryl-inspect (ACTIVE)')
+  })
+})

package/plugins/acryl-inspect/upstream.json

@@ -0,0 +1,18 @@
+{
+  "source": {
+    "repo": "acryldev/acryl",
+    "path": "plugins/acryl-inspect",
+    "commit": "df79b188398b6d4f8cceda35a72b88300a10a9ce"
+  },
+  "vendored": [
+    "src",
+    "tests",
+    "LICENSE"
+  ],
+  "rewrittenSpecifiers": 3,
+  "digest": "sha256:e9887df0d2b5274d4fc5de4c730975528a84fd1d270994ee85a2789bec101db7",
+  "testsNotRun": {},
+  "notice": [
+    "LICENSE"
+  ]
+}

package/plugins/acryl-node-server/LICENSE

@@ -0,0 +1,47 @@
+MIT License
+
+Copyright (c) 2026 WebBoxes s.r.o.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---
+
+The files under src/adapter and tests/adapter are derived from @hono/node-server v2.1.5 (https://github.com/honojs/node-server), used under this license:
+
+MIT License
+
+Copyright (c) 2022 - present, Yusuke Wada and Hono contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

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

@@ -0,0 +1,13 @@
+{
+  "name": "acryl-node-server",
+  "description": "The standalone HTTP server as a Cordis plugin: one node:http listener that sends every request to the router. Port, loopback host and next-free-port scan; ends open streams and frees the port when unloaded. Vendored from ACRYL.",
+  "requires": ["acryl-router", "acryl-router-http"],
+  "inject": ["router"],
+  "provides": ["nodeServer"],
+  "dependencies": {
+    "@deepseek-ai/cordis": "4.0.4",
+    "@deepseek-ai/schemastery": "3.18.4"
+  },
+  "mount": "root.plugin(router); root.plugin(nodeServer, { port: 3000, hostname: '127.0.0.1', scan: 20 }); ctx.nodeServer.url",
+  "omit": ["**/*.test.*", "**/*.case.ts"]
+}

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

@@ -0,0 +1,23 @@
+import type { GetConnInfo } from '../../../acryl-router/src/helpers/index.ts'
+import type { HttpBindings } from './types.ts'
+
+/**
+ * ConnInfo Helper for Node.js
+ * @param c Context
+ * @returns ConnInfo
+ */
+export const getConnInfo: GetConnInfo = (c) => {
+  const bindings = (c.env.server ? c.env.server : c.env) as HttpBindings
+
+  const address = bindings.incoming.socket.remoteAddress
+  const port = bindings.incoming.socket.remotePort
+  const family = bindings.incoming.socket.remoteFamily
+
+  return {
+    remote: {
+      address,
+      port,
+      addressType: family === 'IPv4' ? 'IPv4' : family === 'IPv6' ? 'IPv6' : void 0,
+    },
+  }
+}

package/plugins/acryl-node-server/src/adapter/early-hints.ts

@@ -0,0 +1,55 @@
+import type { Context, Env, MiddlewareHandler } from '../../../acryl-router/src/index.ts'
+import type { HttpBindings } from './types.ts'
+
+export type EarlyHintsOptions<E extends Env = Env> = {
+  link: string | string[] | ((c: Context<E>) => string | string[] | undefined)
+}
+
+/**
+ * Early Hints middleware for Node.js
+ * Automatically sends a 103 Early Hints informational response with the specified Link header(s).
+ *
+ * @param options EarlyHintsOptions
+ * @returns MiddlewareHandler
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const earlyHints = <E extends Env = any>(
+  options: EarlyHintsOptions<E>
+): MiddlewareHandler<E> => {
+  let warned = false
+
+  return async (c, next) => {
+    const mode = c.req.header('Sec-Fetch-Mode')
+    const dest = c.req.header('Sec-Fetch-Dest')
+
+    if ((mode && mode !== 'navigate') || (dest && dest !== 'document')) {
+      return next()
+    }
+
+    const env = c.env || {}
+    const bindings = ('server' in env ? env.server : env) as HttpBindings
+    const outgoing = bindings?.outgoing
+
+    // Capability check: outgoing.writeEarlyHints exists and is a function.
+    // This guard exists for non-Node runtimes and non-HTTP bindings.
+    if (typeof outgoing?.writeEarlyHints !== 'function') {
+      if (!warned) {
+        console.warn(
+          'Early Hints Middleware is not supported because writeEarlyHints is not defined.'
+        )
+        warned = true
+      }
+      return await next()
+    }
+
+    if (!outgoing.headersSent) {
+      const link = typeof options.link === 'function' ? options.link(c) : options.link
+
+      if (link !== undefined && (Array.isArray(link) ? link.length > 0 : Boolean(link))) {
+        outgoing.writeEarlyHints({ link })
+      }
+    }
+
+    await next()
+  }
+}

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

@@ -0,0 +1,11 @@
+export class RequestError extends Error {
+  constructor(
+    message: string,
+    options?: {
+      cause?: unknown
+    }
+  ) {
+    super(message, options)
+    this.name = 'RequestError'
+  }
+}

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

@@ -0,0 +1,249 @@
+import type { IncomingMessage } from 'node:http'
+import { Http2ServerRequest } from 'node:http2'
+
+type IncomingHeadersSource = Pick<IncomingMessage | Http2ServerRequest, 'rawHeaders'> & {
+  headers?: IncomingMessage['headers']
+}
+
+// Node's HTTP/1 parser already joins ordinary repeated headers with the same
+// separators as WHATWG Headers, so its parsed object is a safe fast path for
+// those names. It discards repeats of this fixed set by default, however, and
+// HTTP/2 has different collapsing rules; resolve those cases from rawHeaders.
+// https://nodejs.org/api/http.html#messageheaders
+// https://github.com/nodejs/node/blob/v26.7.0/lib/_http_incoming.js
+// https://www.rfc-editor.org/rfc/rfc9110.html#section-5.2
+const nonJoinedHeaders = new Set([
+  'age',
+  'authorization',
+  'content-length',
+  'content-type',
+  'etag',
+  'expires',
+  'from',
+  'host',
+  'if-modified-since',
+  'if-unmodified-since',
+  'last-modified',
+  'location',
+  'max-forwards',
+  'proxy-authorization',
+  'referer',
+  'retry-after',
+  'server',
+  'user-agent',
+])
+
+// Converted from RFC 9110's `field-name = token` and `token`/`tchar` ABNF.
+// https://www.rfc-editor.org/rfc/rfc9110.html#section-5.1
+// https://www.rfc-editor.org/rfc/rfc9110.html#section-5.6.2
+const validHeaderName = /^[!#$%&'*+\-.^_`|~\dA-Za-z]+$/
+
+const isHttpWhitespace = (code: number): boolean =>
+  code === 0x09 || code === 0x0a || code === 0x0d || code === 0x20
+
+const normalizeHeaderValue = (value: string): string => {
+  if (
+    !isHttpWhitespace(value.charCodeAt(0)) &&
+    !isHttpWhitespace(value.charCodeAt(value.length - 1))
+  ) {
+    return value
+  }
+  let start = 0
+  let end = value.length
+  while (start < end && isHttpWhitespace(value.charCodeAt(start))) {
+    start++
+  }
+  while (end > start && isHttpWhitespace(value.charCodeAt(end - 1))) {
+    end--
+  }
+  return value.slice(start, end)
+}
+
+const forbiddenHeaderValue = /[\0\r\n]/
+
+export const GlobalHeaders = globalThis.Headers
+export type GlobalHeaders = InstanceType<typeof GlobalHeaders>
+
+const materializeHeaders = (
+  rawHeaders: string[],
+  HeadersCtor: typeof GlobalHeaders = GlobalHeaders
+): GlobalHeaders => {
+  const headers = new HeadersCtor()
+  for (let i = 0; i < rawHeaders.length; i += 2) {
+    const name = rawHeaders[i]
+    if (!name.startsWith(':')) {
+      headers.append(name, rawHeaders[i + 1])
+    }
+  }
+  return headers
+}
+
+export class RequestHeaders {
+  #incoming: IncomingHeadersSource
+  #rawHeaders?: string[]
+  #headers?: GlobalHeaders
+  #invalidValue?: boolean
+
+  constructor(incoming: IncomingHeadersSource) {
+    this.#incoming = incoming
+    if (incoming instanceof Http2ServerRequest) {
+      this.#rawHeaders = incoming.rawHeaders.slice()
+    }
+  }
+
+  get #lazyRawHeaders(): string[] {
+    return (this.#rawHeaders ??= this.#incoming.rawHeaders.slice())
+  }
+
+  get #native(): GlobalHeaders {
+    if (!this.#headers) {
+      this.#headers = materializeHeaders(this.#lazyRawHeaders)
+      this.#rawHeaders = undefined
+    }
+    return this.#headers
+  }
+
+  #normalizedName(name: string): string | undefined {
+    if (typeof name !== 'string') {
+      return
+    }
+    if (!validHeaderName.test(name)) {
+      throw new TypeError(`Invalid header name: ${name}`)
+    }
+    return name.toLowerCase()
+  }
+
+  // The HTTP/1 fast path trusts Node's parser-produced headers object. Mutating
+  // it through the incoming binding is outside this optimization's contract;
+  // detecting such changes would require scanning or copying every header.
+  #lookupHttp1(lowerName: string): string | null | undefined {
+    const headers =
+      this.#incoming instanceof Http2ServerRequest ? undefined : this.#incoming.headers
+    if (
+      !headers ||
+      nonJoinedHeaders.has(lowerName) ||
+      lowerName === 'set-cookie' ||
+      lowerName === '__proto__'
+    ) {
+      return
+    }
+
+    if (!Object.hasOwn(headers, lowerName)) {
+      return null
+    }
+    const rawValue = headers[lowerName]
+    if (typeof rawValue === 'string') {
+      const value = normalizeHeaderValue(rawValue)
+      return forbiddenHeaderValue.test(value) ? undefined : value
+    }
+    return
+  }
+
+  #lookup(rawHeaders: string[], lowerName: string): string | null | undefined {
+    const separator = lowerName === 'cookie' ? '; ' : ', '
+    let value: string | null = null
+    for (let i = 0; i < rawHeaders.length; i += 2) {
+      const rawName = rawHeaders[i]
+      if (rawName.length === lowerName.length && rawName.toLowerCase() === lowerName) {
+        const rawValue = normalizeHeaderValue(rawHeaders[i + 1])
+        if (forbiddenHeaderValue.test(rawValue)) {
+          this.#invalidValue = true
+          return
+        }
+        value = value === null ? rawValue : value + separator + rawValue
+      }
+    }
+
+    return value
+  }
+
+  append(name: string, value: string): void {
+    this.#native.append(name, value)
+  }
+
+  delete(name: string): void {
+    this.#native.delete(name)
+  }
+
+  get(name: string): string | null {
+    const lowerName = this.#normalizedName(name)
+    if (lowerName && !this.#headers && !this.#invalidValue) {
+      const http1Value = this.#lookupHttp1(lowerName)
+      if (http1Value !== undefined) {
+        return http1Value
+      }
+      const value = this.#lookup(this.#lazyRawHeaders, lowerName)
+      if (value !== undefined) {
+        return value
+      }
+    }
+    return this.#native.get(name)
+  }
+
+  has(name: string): boolean {
+    const lowerName = this.#normalizedName(name)
+    if (lowerName && !this.#headers && !this.#invalidValue) {
+      const http1Value = this.#lookupHttp1(lowerName)
+      if (http1Value !== undefined) {
+        return http1Value !== null
+      }
+      const value = this.#lookup(this.#lazyRawHeaders, lowerName)
+      if (value !== undefined) {
+        return value !== null
+      }
+    }
+    return this.#native.has(name)
+  }
+
+  set(name: string, value: string): void {
+    this.#native.set(name, value)
+  }
+
+  getSetCookie(): string[] {
+    return this.#native.getSetCookie()
+  }
+
+  keys(): HeadersIterator<string> {
+    return this.#native.keys()
+  }
+
+  values(): HeadersIterator<string> {
+    return this.#native.values()
+  }
+
+  entries(): HeadersIterator<[string, string]> {
+    return this.#native.entries()
+  }
+
+  forEach(
+    callback: (value: string, key: string, parent: GlobalHeaders) => void,
+    thisArg?: unknown
+  ): void {
+    this.#native.forEach((value, key) => {
+      callback.call(thisArg, value, key, this as unknown as GlobalHeaders)
+    })
+  }
+
+  [Symbol.iterator](): HeadersIterator<[string, string]> {
+    return this.entries()
+  }
+}
+
+Object.defineProperty(RequestHeaders.prototype, Symbol.for('nodejs.util.inspect.custom'), {
+  value: function (this: RequestHeaders, depth: number, options: object, inspectFn: Function) {
+    const props = Object.fromEntries(this)
+    return `Headers (lightweight) ${inspectFn(props, { ...options, depth: depth == null ? null : depth - 1 })}`
+  },
+})
+
+// Keep request headers compatible with the captured Headers constructor so
+// `request.headers instanceof Headers` remains true without Symbol.hasInstance
+// or replacing the global constructor.
+Object.setPrototypeOf(RequestHeaders.prototype, GlobalHeaders.prototype)
+
+// Preserve the previous live-global behavior when a consumer installs a
+// Headers polyfill after this module has initialized.
+export const newHeadersFromIncoming = (incoming: IncomingHeadersSource): GlobalHeaders =>
+  globalThis.Headers === GlobalHeaders
+    ? (new RequestHeaders(incoming) as unknown as GlobalHeaders)
+    : materializeHeaders(incoming.rawHeaders, globalThis.Headers)

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

@@ -0,0 +1,6 @@
+export { serve, createAdaptorServer } from './server.ts'
+export { upgradeWebSocket } from './websocket.ts'
+export { getRequestListener } from './listener.ts'
+export { RequestError } from './request.ts'
+export type { HttpBindings, Http2Bindings, ServerType } from './types.ts'
+export type { WebSocketData, WebSocketLike, WebSocketServerLike } from './websocket-types.ts'