acrylblends 0.3.0 → 0.4.1

package/plugins/acryl-inspect/upstream.json

@@ -2,7 +2,7 @@
   "source": {
     "repo": "acryldev/acryl",
     "path": "plugins/acryl-inspect",
-    "commit": "11fed295161c0282d144b5ac62616988b58d8189"
+    "commit": "64e7c9d2e787f74b2da82492644fbbb46a601074"
   },
   "vendored": [
     "src",
@@ -10,7 +10,7 @@
     "LICENSE"
   ],
   "rewrittenSpecifiers": 3,
-  "digest": "sha256:0fa799474c66b7a2a159c17ea143030b9fc6a38fcb4219f5139e78fd4508bdb7",
+  "digest": "sha256:434ed3cf6b9028da90ad6b395209affbc917a62aa994f2b3c8f1d98a26398ea7",
   "testsNotRun": {},
   "notice": [
     "LICENSE"

package/plugins/acryl-node-server/LICENSE

@@ -19,3 +19,29 @@ 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

@@ -8,5 +8,6 @@
     "@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"
+  "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'