@nifrajs/core 4.0.2 → 5.1.0

package/src/single-copy.ts

@@ -55,7 +55,7 @@
  */
 
 import { existsSync, lstatSync, readdirSync, readFileSync, realpathSync, statSync } from "node:fs"
-import { dirname, join, relative, resolve, sep } from "node:path"
+import { dirname, isAbsolute, join, parse, relative, resolve, sep } from "node:path"
 import type { BunPlugin } from "bun"
 import { codeUnitOrder } from "./internal/code-unit-order.ts"
 
@@ -77,6 +77,14 @@ export const IDENTITY_SENSITIVE_PACKAGES: readonly string[] = [
 
 /** Files a redirect may rewrite. Everything else in a package (json, css, wasm) loads unchanged. */
 const REDIRECTABLE = /\.(?:m|c)?[jt]sx?$/
+
+/** The loader a {@link REDIRECTABLE} file is parsed with. `.ts` is never `tsx`: under JSX rules a
+ * generic arrow (`<T>(x: T) => x`) reads as an unclosed element and swallows the file. */
+function sourceLoader(path: string): "js" | "jsx" | "ts" | "tsx" {
+  if (path.endsWith(".tsx")) return "tsx"
+  if (path.endsWith(".jsx")) return "jsx"
+  return /\.[mc]?ts$/.test(path) ? "ts" : "js"
+}
 /** Runaway guards. A real `node_modules` top level is hundreds of entries, a repo walk is a few. */
 const MAX_SCANNED_ENTRIES = 4_096
 const MAX_ANCESTOR_DIRS = 16
@@ -331,6 +339,26 @@ const installedCopy = (
   }
 }
 
+/** The package a bare specifier names, without its subpath: `@scope/name` or `name`. */
+const packageNameOf = (specifier: string): string =>
+  specifier
+    .split("/")
+    .slice(0, specifier.startsWith("@") ? 2 : 1)
+    .join("/")
+
+/**
+ * Whether Bun's own node_modules walk from `importer` already reaches the app's copy. Bun then keeps
+ * the package's `sideEffects: false` pruning; a path handed back from `onResolve` loses it, so the
+ * bundle reads every module the entry re-exports, `node:` imports included.
+ */
+const reachesAppCopy = (specifier: string, importer: string, root: string): boolean => {
+  if (!isAbsolute(importer)) return false
+  const name = packageNameOf(specifier)
+  const ours = installedCopy(root, name, parse(root).root)
+  if (ours === undefined) return false
+  return installedCopy(dirname(importer), name, parse(importer).root)?.root === ours.root
+}
+
 /** Every `node_modules` from the app root up to (and including) its repository root. */
 const nodeModulesDirs = (root: string): readonly string[] => {
   const boundary = repoBoundary(root)
@@ -347,6 +375,17 @@ const nodeModulesDirs = (root: string): readonly string[] => {
   return dirs
 }
 
+/** Where a real package folder lives when only its files are links: Bun installs a `file:` folder
+ * dependency as a directory of per-file symlinks, so its imports resolve beside the linked files. */
+const fileLinkedDir = (dir: string): string | undefined => {
+  const manifest = join(dir, "package.json")
+  try {
+    return lstatSync(manifest).isSymbolicLink() ? dirname(realpathOrSelf(manifest)) : undefined
+  } catch {
+    return undefined
+  }
+}
+
 /**
  * Package directories that are symlinked OUT of this repository - the `link:` / `file:` / `npm link`
  * consumers whose own imports resolve somewhere this install does not own. Those are the only
@@ -380,9 +419,8 @@ const linkedPackageDirs = (root: string): readonly string[] => {
         } catch {
           continue
         }
-        if (!link.isSymbolicLink()) continue
-        const target = realpathOrSelf(candidate)
-        if (inside(repo, target)) continue
+        const target = link.isSymbolicLink() ? realpathOrSelf(candidate) : fileLinkedDir(candidate)
+        if (target === undefined || inside(repo, target)) continue
         found.add(target)
       }
     }
@@ -411,6 +449,17 @@ const declaredNames = (root: string, declared: readonly string[]): readonly stri
   return [...names].sort()
 }
 
+/**
+ * The installed package names the app's declaration covers: each exact name, and each package
+ * installed under a declared `@scope/*`. Empty without a declaration. A bundler that pins packages by
+ * name, such as Vite's `resolve.dedupe`, takes this list.
+ */
+export function singleCopyPackageNames(cwd: string): readonly string[] {
+  const root = realpathOrSelf(resolve(cwd))
+  const declared = readSingleCopyDeclaration(root)
+  return declared === undefined ? [] : declaredNames(root, declared)
+}
+
 /**
  * Work out which foreign copies exist and which of them may be redirected.
  *
@@ -531,6 +580,7 @@ export function singleCopyPlugin(options: SingleCopyOptions = {}): SingleCopyPlu
         if (alternatives.length > 0) {
           const filter = new RegExp(`^(?:${alternatives.join("|")})$`)
           build.onResolve({ filter }, (args) => {
+            if (reachesAppCopy(args.path, args.importer, plan.root)) return undefined
             try {
               return { path: Bun.resolveSync(args.path, plan.root) }
             } catch {
@@ -569,7 +619,7 @@ export function singleCopyPlugin(options: SingleCopyOptions = {}): SingleCopyPlu
         // A runtime `onLoad` must always return an object - returning nothing fails the load rather
         // than falling through to the default. Hand back the file as it was, at its own path, so its
         // relative imports keep resolving exactly as they would have.
-        return { contents: readFileSync(args.path, "utf8"), loader: "js" }
+        return { contents: readFileSync(args.path, "utf8"), loader: sourceLoader(args.path) }
       })
     },
   }

package/src/tool-contract.ts

@@ -461,6 +461,25 @@ export async function executeTool<Input, Output>(
       ...(tool.cost === undefined ? {} : { cost: tool.cost }),
     })
   }
+  // A failed abandon leaves the key reserved until its lease lapses, as a failed renewal does; the
+  // call's own outcome still stands.
+  const abandon = async (): Promise<void> => {
+    if (reservation === undefined) return
+    try {
+      await options.idempotency?.abandon(reservationInput(reservation))
+    } catch {}
+  }
+  // Once the executor has run, the reservation is never released: a retry would repeat a side effect
+  // that may have committed. A store that throws on completion counts as one that refused it.
+  let executed = false
+  const complete = async (): Promise<boolean> => {
+    if (reservation === undefined) return true
+    try {
+      return (await options.idempotency?.complete(reservationInput(reservation))) === true
+    } catch {
+      return false
+    }
+  }
   type ToolCallOutcome =
     | { readonly ok: true; readonly dryRun: boolean; readonly output?: Output }
     | { readonly ok: false; readonly dryRun: boolean; readonly error: ToolError }
@@ -625,22 +644,19 @@ export async function executeTool<Input, Output>(
     record("idempotency", tool.idempotency === undefined ? "skipped" : "passed")
 
     if (options.budget !== undefined && !options.budget.consume(tool.cost)) {
-      if (reservation !== undefined)
-        await options.idempotency?.abandon(reservationInput(reservation))
+      await abandon()
       record("budget", "denied", "budget_exceeded")
       return finish({ ok: false, dryRun, error: { code: "budget_exceeded", stage: "budget" } })
     }
     record("budget", tool.cost === undefined ? "skipped" : "passed")
 
     if (signal.aborted) {
-      if (reservation !== undefined)
-        await options.idempotency?.abandon(reservationInput(reservation))
+      await abandon()
       record("execution", "denied", "cancelled")
       return finish({ ok: false, dryRun, error: { code: "cancelled", stage: "execution" } })
     }
     if (dryRun) {
-      if (reservation !== undefined)
-        await options.idempotency?.abandon(reservationInput(reservation))
+      await abandon()
       record("execution", "dry-run")
       return finish({ ok: true, dryRun })
     }
@@ -651,21 +667,19 @@ export async function executeTool<Input, Output>(
       dryRun,
       ...(tool.policy === undefined ? {} : { policy: tool.policy }),
     })
+    executed = true
     record("execution", "committed")
     const validatedOutput = await validateStandard(tool.output, output)
     if (!validatedOutput.ok) {
       // The executor has already run. Keep the reservation completed even when its return shape is
       // invalid, so a caller cannot retry and duplicate a side effect that may have committed.
-      if (reservation !== undefined) {
-        const completed = await options.idempotency?.complete(reservationInput(reservation))
-        if (completed !== true) {
-          record("idempotency", "failed", "idempotency_capacity")
-          return finish({
-            ok: false,
-            dryRun,
-            error: { code: "idempotency_capacity", stage: "idempotency" },
-          })
-        }
+      if (!(await complete())) {
+        record("idempotency", "failed", "idempotency_capacity")
+        return finish({
+          ok: false,
+          dryRun,
+          error: { code: "idempotency_capacity", stage: "idempotency" },
+        })
       }
       record("output", "failed", "output_invalid")
       return finish({
@@ -675,20 +689,17 @@ export async function executeTool<Input, Output>(
       })
     }
     record("output", "passed")
-    if (reservation !== undefined) {
-      const completed = await options.idempotency?.complete(reservationInput(reservation))
-      if (completed !== true) {
-        record("idempotency", "failed", "idempotency_capacity")
-        return finish({
-          ok: false,
-          dryRun,
-          error: { code: "idempotency_capacity", stage: "idempotency" },
-        })
-      }
+    if (!(await complete())) {
+      record("idempotency", "failed", "idempotency_capacity")
+      return finish({
+        ok: false,
+        dryRun,
+        error: { code: "idempotency_capacity", stage: "idempotency" },
+      })
     }
     return finish({ ok: true, dryRun, output: validatedOutput.value })
   } catch (error) {
-    if (reservation !== undefined) await options.idempotency?.abandon(reservationInput(reservation))
+    if (!executed) await abandon()
     const code = signal.aborted || isAbortError(error) ? "cancelled" : "execution_failed"
     record("execution", "failed", code)
     return finish({ ok: false, dryRun, error: { code, stage: "execution" } })
@@ -788,18 +799,35 @@ export function toolHttpResult<Output>(result: ToolCallResult<Output>): Response
       ? { ok: true, output: result.output, dryRun: result.dryRun, evidence: result.evidence }
       : { ok: false, error: result.error, dryRun: result.dryRun, evidence: result.evidence },
   )
-  const status = result.ok
-    ? 200
-    : result.error.code === "input_invalid"
-      ? 422
-      : result.error.code === "approval_required" ||
-          result.error.code === "approval_denied" ||
-          result.error.code === "capability_denied"
-        ? 403
-        : result.error.code === "budget_exceeded"
-          ? 429
-          : 500
-  return new Response(body, { status, headers: { "content-type": "application/json" } })
+  const headers: Record<string, string> = { "content-type": "application/json" }
+  const status = result.ok ? 200 : toolErrorStatus(result.error.code)
+  // The idempotency refusals answer as the HTTP idempotency lane does, a retry included.
+  if (!result.ok && retryableIdempotency(result.error.code)) headers["retry-after"] = "1"
+  return new Response(body, { status, headers })
+}
+
+function retryableIdempotency(code: ToolError["code"]): boolean {
+  return code === "idempotency_in_flight" || code === "idempotency_capacity"
+}
+
+function toolErrorStatus(code: ToolError["code"]): number {
+  switch (code) {
+    case "input_invalid":
+      return 422
+    case "approval_required":
+    case "approval_denied":
+    case "capability_denied":
+      return 403
+    case "idempotency_duplicate":
+    case "idempotency_in_flight":
+      return 409
+    case "budget_exceeded":
+      return 429
+    case "idempotency_capacity":
+      return 503
+    default:
+      return 500
+  }
 }
 
 export function toolInputJsonSchema<Input, Output>(

package/src/wire.ts

@@ -43,6 +43,11 @@ export interface WireDecodeLimits {
   readonly maxCollectionEntries?: number
   /** Maximum UTF-8 string plus decoded binary bytes materialized. Default 16 MiB. */
   readonly maxDecodedBytes?: number
+  /**
+   * Maximum decimal digits in one `bigint`. Default 4,096 (past 8192-bit integers). Parsing grows
+   * faster than the digit count, so one long token would cost seconds of CPU under the byte limit.
+   */
+  readonly maxBigIntDigits?: number
 }
 
 export const DEFAULT_WIRE_DECODE_LIMITS: Readonly<Required<WireDecodeLimits>> = Object.freeze({
@@ -50,6 +55,7 @@ export const DEFAULT_WIRE_DECODE_LIMITS: Readonly<Required<WireDecodeLimits>> =
   maxDepth: 256,
   maxCollectionEntries: 100_000,
   maxDecodedBytes: 16 * 1024 * 1024,
+  maxBigIntDigits: 4096,
 })
 
 /** Thrown by {@link encode} for a value it will not encode (a function or a symbol). */
@@ -223,6 +229,11 @@ export function decode(wire: Wire, limits: WireDecodeLimits = {}): unknown {
     DEFAULT_WIRE_DECODE_LIMITS.maxDecodedBytes,
     "maxDecodedBytes",
   )
+  const maxBigIntDigits = decodeLimit(
+    limits.maxBigIntDigits,
+    DEFAULT_WIRE_DECODE_LIMITS.maxBigIntDigits,
+    "maxBigIntDigits",
+  )
   if (nodes.length > maxNodes) throw new WireDecodeError("wire node limit exceeded")
   const built = new Map<number, unknown>()
   let collectionEntries = 0
@@ -279,6 +290,9 @@ export function decode(wire: Wire, limits: WireDecodeLimits = {}): unknown {
         if (typeof record.v !== "string" || !/^-?(?:0|[1-9][0-9]*)$/u.test(record.v)) {
           throw new WireDecodeError("malformed bigint token")
         }
+        if (record.v.length - (record.v.charCodeAt(0) === 45 ? 1 : 0) > maxBigIntDigits) {
+          throw new WireDecodeError("wire bigint digit limit exceeded")
+        }
         chargeString(record.v)
         return BigInt(record.v)
       }

package/src/ws.ts

@@ -21,8 +21,11 @@ import { INSTALL_WS } from "./server/install.ts"
 import type { IdentityPlugin } from "./server/plugin.ts"
 import type { AnyServer } from "./server/server.ts"
 import {
+  acceptedHandshake,
   attachWebSocket,
+  handshakeUpgradeStep,
   TopicRegistry,
+  webSocketSender,
   wrapWebSocketMessageValidation,
 } from "./server/websocket.ts"
 import { createBunWsHandlers } from "./server/ws-bun.ts"
@@ -30,9 +33,12 @@ import type { WsRuntime } from "./server/ws-hook.ts"
 
 const WS_RUNTIME: WsRuntime = {
   wrapHandler: wrapWebSocketMessageValidation,
+  upgradeStep: handshakeUpgradeStep,
+  accepted: acceptedHandshake,
   createTopics: () => new TopicRegistry(),
   bunHandlers: createBunWsHandlers,
   attach: attachWebSocket,
+  sender: webSocketSender,
 }
 
 /** The install seam a server exposes so the `websocket()` plugin can hand it the runtime. */