@nifrajs/core 5.5.1 → 5.7.0

package/src/internal/route-program.ts

@@ -11,8 +11,10 @@ import type { StandardSchemaV1 } from "../schema/standard.ts"
 import { markAuthenticatedRequest } from "../server/auth.ts"
 import { declaredHeaderNames } from "../server/headers.ts"
 import { pathnameOf } from "../server/http.ts"
+import type { Logger } from "../server/logger.ts"
 import { queryObjectOf } from "../server/query.ts"
 import type { Registry } from "../server/registry.ts"
+import { toResponse } from "../server/respond.ts"
 import {
   CONTEXT_SEARCH,
   CONTEXT_SET,
@@ -262,6 +264,77 @@ function authenticationInputOf(
   })
 }
 
+/**
+ * Run the `authenticate()` stages a mount was registered after, in order, against the request the
+ * mount would receive: `undefined` once each one authenticated, else the response that refuses it. A
+ * stage that throws or decides nothing valid answers 503, and its cause goes to `logger`, as a route
+ * error no hook answers does.
+ */
+export function authenticateMount(
+  stages: readonly RawAuthStage[],
+  request: Request,
+  platform: { readonly env?: unknown; readonly clientIp?: string | undefined } | undefined,
+  logger: Logger,
+): MaybePromise<Response | undefined> {
+  let query: Readonly<Record<string, string | readonly string[]>> | undefined
+  const search = (() => {
+    const at = request.url.indexOf("?")
+    return at === -1 ? "" : request.url.slice(at)
+  })()
+  const input = Object.freeze({
+    method: request.method,
+    pathname: pathnameOf(request.url),
+    headers: authHeadersOf(request),
+    params: Object.freeze({}),
+    search,
+    get query() {
+      query ??= frozenQueryOf(search)
+      return query
+    },
+    request,
+    env: platform?.env,
+    clientIp: platform?.clientIp,
+    signal: request.signal,
+  })
+  const unavailable = (error: unknown): Response => {
+    logger.error("authenticate() stage failed before a mount", {
+      method: request.method,
+      path: input.pathname,
+      error: error instanceof Error ? error.message : String(error),
+    })
+    return toResponse(defaultAuthenticationResponse("unavailable"), EMPTY_RESPONSE_CONTROLS)
+  }
+  const decide = (
+    index: number,
+    result: import("../server/auth.ts").AuthenticationResult<unknown>,
+  ): MaybePromise<Response | undefined> => {
+    if (!isAuthenticationDecision(result)) {
+      const id = stages[index]?.id
+      return unavailable(new TypeError(`authenticate() stage "${id}" returned an invalid decision`))
+    }
+    if (result.kind === "rejected") {
+      const refusal = result.response ?? defaultAuthenticationResponse(result.reason)
+      return refusal instanceof Response ? refusal : toResponse(refusal, EMPTY_RESPONSE_CONTROLS)
+    }
+    markAuthenticatedRequest(request)
+    return run(index + 1)
+  }
+  const run = (index: number): MaybePromise<Response | undefined> => {
+    const stage = stages[index]
+    if (stage === undefined) return undefined
+    let outcome: MaybePromise<import("../server/auth.ts").AuthenticationResult<unknown>>
+    try {
+      outcome = stage.run(input)
+    } catch (error) {
+      return unavailable(error)
+    }
+    return outcome instanceof Promise
+      ? outcome.then((settled) => decide(index, settled), unavailable)
+      : decide(index, outcome)
+  }
+  return run(0)
+}
+
 function defaultAuthenticationResponse(
   reason: import("../server/auth.ts").AuthenticationFailureReason | undefined,
 ): ResponseResult {
@@ -270,6 +343,25 @@ function defaultAuthenticationResponse(
   return status(401, { ok: false, error: "unauthorized" })
 }
 
+/** Whether a stage returned a decision it may: a rejection with a known reason and a response, if
+ * any, that answers; or a principal. */
+function isAuthenticationDecision(
+  result: import("../server/auth.ts").AuthenticationResult<unknown>,
+): boolean {
+  return (
+    result !== null &&
+    typeof result === "object" &&
+    (result.kind === "rejected"
+      ? validAuthenticationFailureReason(result.reason) &&
+        (result.response === undefined ||
+          result.response instanceof Response ||
+          isResponseResult(result.response))
+      : result.kind === "authenticated" &&
+        result.principal !== null &&
+        result.principal !== undefined)
+  )
+}
+
 function validAuthenticationFailureReason(
   value: unknown,
 ): value is import("../server/auth.ts").AuthenticationFailureReason | undefined {
@@ -410,18 +502,7 @@ function finishAuthentication<T>(
   next: number,
   validationComplete = false,
 ): ProgramResult<T> {
-  if (
-    result === null ||
-    typeof result !== "object" ||
-    (result.kind === "rejected"
-      ? !validAuthenticationFailureReason(result.reason) ||
-        (result.response !== undefined &&
-          !(result.response instanceof Response) &&
-          !isResponseResult(result.response))
-      : result.kind !== "authenticated" ||
-        result.principal === null ||
-        result.principal === undefined)
-  ) {
+  if (!isAuthenticationDecision(result)) {
     const id = program.authStages[next - 1]!.id
     const error = new TypeError(`authenticate() stage "${id}" returned an invalid decision`)
     return failAuthentication(host, entry, ctx, finalize, wrapResponse, error)
@@ -499,7 +580,7 @@ async function continueFastAuthenticatedProgram<T>(
   try {
     const settled = await pending
     if (settled !== undefined) return wrapResponse(settled as Response | ResponseResult)
-    return await runFastAuthenticatedProgram(
+    const outcome = runFastAuthenticatedProgram(
       host,
       entry,
       program,
@@ -509,6 +590,7 @@ async function continueFastAuthenticatedProgram<T>(
       wrapResponse,
       validationIndex,
     )
+    return outcome instanceof Promise ? await outcome : outcome
   } catch (error) {
     return await host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
   }
@@ -585,7 +667,7 @@ async function continueValidationBeforeAuthentication<T>(
   try {
     const settled = await pending
     if (settled !== undefined) return wrapResponse(settled as Response | ResponseResult)
-    return await runValidationBeforeAuthentication(
+    const outcome = runValidationBeforeAuthentication(
       host,
       entry,
       program,
@@ -595,6 +677,7 @@ async function continueValidationBeforeAuthentication<T>(
       wrapResponse,
       validationIndex,
     )
+    return outcome instanceof Promise ? await outcome : outcome
   } catch (error) {
     return await host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
   }
@@ -616,7 +699,7 @@ function runValidatedProgram<T>(
 type ProgramResult<T> = MaybePromise<T>
 
 /** Opt-in sensitive-route lane: run authentication/policy hooks before parsing untrusted input. */
-async function runAuthBeforeValidation<T>(
+function runAuthBeforeValidation<T>(
   host: RouteProgramRuntime,
   entry: RouteEntry,
   program: RouteProgram,
@@ -625,23 +708,53 @@ async function runAuthBeforeValidation<T>(
   finalize: (result: unknown, set: CtxSet, ctx?: RawContext) => T,
   wrapResponse: (response: Response | ResponseResult) => T,
   gated = false,
-): Promise<T> {
+  deriveStart = 0,
+  beforeStart = 0,
+  validationStart = 0,
+): ProgramResult<T> {
   try {
     if (!gated) {
-      if (program.hasDecorations) Object.assign(ctx, program.decorations)
+      if (deriveStart === 0 && beforeStart === 0 && program.hasDecorations)
+        Object.assign(ctx, program.decorations)
 
-      for (const derive of program.derives) {
-        const result = derive(ctx)
-        const settled = result instanceof Promise ? await result : result
-        if (isEarly(settled)) return finishEarly(host, entry, ctx, settled, finalize, wrapResponse)
-        Object.assign(ctx, settled)
+      for (let i = deriveStart; i < program.derives.length; i++) {
+        const result = program.derives[i]!(ctx)
+        if (result instanceof Promise) {
+          return continueProgram(
+            host,
+            entry,
+            program,
+            source,
+            ctx,
+            finalize,
+            wrapResponse,
+            { kind: "derive", next: i + 1, policy: true },
+            result,
+            undefined,
+          )
+        }
+        if (isEarly(result)) return finishEarly(host, entry, ctx, result, finalize, wrapResponse)
+        Object.assign(ctx, result)
       }
 
-      for (const before of program.beforeHandle) {
-        const result = before(ctx)
-        const settled = result instanceof Promise ? await result : result
-        if (settled !== undefined)
-          return finishEarly(host, entry, ctx, settled, finalize, wrapResponse)
+      for (let i = beforeStart; i < program.beforeHandle.length; i++) {
+        const result = program.beforeHandle[i]!(ctx)
+        if (result instanceof Promise) {
+          return continueProgram(
+            host,
+            entry,
+            program,
+            source,
+            ctx,
+            finalize,
+            wrapResponse,
+            { kind: "before", next: i + 1, policy: true },
+            result,
+            undefined,
+          )
+        }
+        if (result !== undefined)
+          return finishEarly(host, entry, ctx, result, finalize, wrapResponse)
       }
 
       // The policy hooks have passed, so the idempotency gate may buffer the body now. Not awaited:
@@ -653,30 +766,52 @@ async function runAuthBeforeValidation<T>(
       }
     }
 
-    for (const stage of program.validationStages) {
+    for (let i = validationStart; i < program.validationStages.length; i++) {
+      const stage = program.validationStages[i]!
       const result =
         stage.kind === "body"
-          ? await host.readProgramBody(entry, source, ctx)
+          ? host.readProgramBody(entry, source, ctx)
           : host.validateProgramStage(entry, stage, source, ctx)
-      const settled = result instanceof Promise ? await result : result
-      if (settled !== undefined) return wrapResponse(settled)
+      if (result instanceof Promise) {
+        return continueProgram(
+          host,
+          entry,
+          program,
+          source,
+          ctx,
+          finalize,
+          wrapResponse,
+          { kind: "validation", next: i + 1, policy: true },
+          result,
+          undefined,
+        )
+      }
+      if (result !== undefined) return wrapResponse(result)
     }
 
-    let result = await program.handler(ctx)
-    for (const after of program.afterHandle) {
-      const transformed = after(result, ctx)
-      result = transformed instanceof Promise ? await transformed : transformed
-    }
-    return await host.finishProgramResult(entry, ctx, result, finalize, wrapResponse)
+    // A pending outcome here already met the error boundary (continueProgram or the response
+    // contract), so wrapping it in another catch would only add a promise.
+    return runHooksSync(
+      host,
+      entry,
+      program,
+      source,
+      ctx,
+      finalize,
+      wrapResponse,
+      program.derives.length,
+      program.beforeHandle.length,
+      undefined,
+    )
   } catch (error) {
-    return await host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
+    return host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
   }
 }
 
 type PendingPhase =
-  | { readonly kind: "validation"; readonly next: number }
-  | { readonly kind: "derive"; readonly next: number }
-  | { readonly kind: "before"; readonly next: number }
+  | { readonly kind: "validation"; readonly next: number; readonly policy?: true }
+  | { readonly kind: "derive"; readonly next: number; readonly policy?: true }
+  | { readonly kind: "before"; readonly next: number; readonly policy?: true }
   | { readonly kind: "handler" }
   | { readonly kind: "after"; readonly next: number }
 
@@ -757,7 +892,7 @@ function runSync<T>(
     }
     if (outcome !== undefined) return wrapResponse(outcome)
   }
-  return runHooksSync(host, entry, program, source, ctx, finalize, wrapResponse, 0, 0, 0, initial)
+  return runHooksSync(host, entry, program, source, ctx, finalize, wrapResponse, 0, 0, initial)
 }
 
 function runHooksSync<T>(
@@ -770,7 +905,6 @@ function runHooksSync<T>(
   wrapResponse: (response: Response | ResponseResult) => T,
   deriveIndex: number,
   beforeIndex: number,
-  afterIndex: number,
   initial: unknown,
 ): ProgramResult<T> {
   for (let i = deriveIndex; i < program.derives.length; i++) {
@@ -826,7 +960,20 @@ function runHooksSync<T>(
       initial,
     )
   }
-  let result = output
+  return runAfterSync(host, entry, program, source, ctx, finalize, wrapResponse, 0, output)
+}
+
+function runAfterSync<T>(
+  host: RouteProgramRuntime,
+  entry: RouteEntry,
+  program: RouteProgram,
+  source: RequestSource,
+  ctx: RawContext,
+  finalize: (result: unknown, set: CtxSet, ctx?: RawContext) => T,
+  wrapResponse: (response: Response | ResponseResult) => T,
+  afterIndex: number,
+  result: unknown,
+): ProgramResult<T> {
   for (let i = afterIndex; i < program.afterHandle.length; i++) {
     const outcome = program.afterHandle[i]!(result, ctx)
     if (outcome instanceof Promise) {
@@ -876,7 +1023,7 @@ async function continueProgram<T>(
     } else {
       result = settled
     }
-    return await runAsyncStages(
+    const outcome = runAsyncStages(
       host,
       entry,
       program,
@@ -887,12 +1034,13 @@ async function continueProgram<T>(
       pendingPhase,
       result,
     )
+    return outcome instanceof Promise ? await outcome : outcome
   } catch (error) {
     return await host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
   }
 }
 
-async function runAsyncStages<T>(
+function runAsyncStages<T>(
   host: RouteProgramRuntime,
   entry: RouteEntry,
   program: RouteProgram,
@@ -902,54 +1050,74 @@ async function runAsyncStages<T>(
   wrapResponse: (response: Response | ResponseResult) => T,
   pendingPhase: PendingPhase,
   result: unknown,
-): Promise<T> {
-  try {
-    if (pendingPhase.kind === "validation") {
-      const validations = program.validationStages
-      for (let i = pendingPhase.next; i < validations.length; i++) {
-        const stage = validations[i]!
-        const outcome =
-          stage.kind === "body"
-            ? await host.readProgramBody(entry, source, ctx)
-            : host.validateProgramStage(entry, stage, source, ctx)
-        const settled = outcome instanceof Promise ? await outcome : outcome
-        if (settled !== undefined) return wrapResponse(settled)
-      }
-    }
-
-    const deriveStart = pendingPhase.kind === "derive" ? pendingPhase.next : 0
-    if (pendingPhase.kind === "validation" || pendingPhase.kind === "derive") {
-      for (let i = deriveStart; i < program.derives.length; i++) {
-        const outcome = program.derives[i]!(ctx)
-        const settled = outcome instanceof Promise ? await outcome : outcome
-        if (isEarly(settled)) return finishEarly(host, entry, ctx, settled, finalize, wrapResponse)
-        Object.assign(ctx, settled)
-      }
-    }
-
-    const beforeStart = pendingPhase.kind === "before" ? pendingPhase.next : 0
-    if (
-      pendingPhase.kind === "validation" ||
-      pendingPhase.kind === "derive" ||
-      pendingPhase.kind === "before"
-    ) {
-      for (let i = beforeStart; i < program.beforeHandle.length; i++) {
-        const outcome = program.beforeHandle[i]!(ctx)
-        const settled = outcome instanceof Promise ? await outcome : outcome
-        if (settled !== undefined)
-          return finishEarly(host, entry, ctx, settled, finalize, wrapResponse)
-      }
-      const output = program.handler(ctx)
-      result = output instanceof Promise ? await output : output
+): ProgramResult<T> {
+  // After an actual async boundary, resume the same sync runner until the next pending stage.
+  // Sync hooks and finalization need no async function wrapper or additional microtask turn.
+  if (pendingPhase.kind === "validation") {
+    if (pendingPhase.policy) {
+      return runAuthBeforeValidation(
+        host,
+        entry,
+        program,
+        source,
+        ctx,
+        finalize,
+        wrapResponse,
+        true,
+        0,
+        0,
+        pendingPhase.next,
+      )
     }
-
-    const afterStart = pendingPhase.kind === "after" ? pendingPhase.next : 0
-    for (let i = afterStart; i < program.afterHandle.length; i++) {
-      const outcome = program.afterHandle[i]!(result, ctx)
-      result = outcome instanceof Promise ? await outcome : outcome
+    return runSync(
+      host,
+      entry,
+      program,
+      source,
+      ctx,
+      finalize,
+      wrapResponse,
+      pendingPhase.next,
+      result,
+    )
+  }
+  if (pendingPhase.kind === "derive" || pendingPhase.kind === "before") {
+    if (pendingPhase.policy) {
+      return runAuthBeforeValidation(
+        host,
+        entry,
+        program,
+        source,
+        ctx,
+        finalize,
+        wrapResponse,
+        false,
+        pendingPhase.kind === "derive" ? pendingPhase.next : program.derives.length,
+        pendingPhase.kind === "before" ? pendingPhase.next : 0,
+      )
     }
-    return await host.finishProgramResult(entry, ctx, result, finalize, wrapResponse)
-  } catch (error) {
-    return await host.handleProgramError(entry, error, ctx, finalize, wrapResponse)
+    return runHooksSync(
+      host,
+      entry,
+      program,
+      source,
+      ctx,
+      finalize,
+      wrapResponse,
+      pendingPhase.kind === "derive" ? pendingPhase.next : program.derives.length,
+      pendingPhase.kind === "before" ? pendingPhase.next : 0,
+      result,
+    )
   }
+  return runAfterSync(
+    host,
+    entry,
+    program,
+    source,
+    ctx,
+    finalize,
+    wrapResponse,
+    pendingPhase.kind === "after" ? pendingPhase.next : 0,
+    result,
+  )
 }

package/src/reflection.ts

@@ -54,6 +54,11 @@ export interface SchemaReflection {
   readonly standard: StandardSchemaV1 | undefined
   /** Raw JSON Schema metadata, when the value exposes it or is itself a raw JSON Schema. */
   readonly jsonSchema: JsonSchema | undefined
+  /**
+   * Set when `jsonSchema` came from the schema's Standard JSON Schema converter (`~standard.jsonSchema`)
+   * rather than from metadata it carries. Such output may use `$defs` and `$ref`.
+   */
+  readonly converted?: true
   /** Top-level object fields, or `undefined` when the JSON Schema is absent/non-object. */
   readonly fields: readonly ReflectedSchemaField[] | undefined
   /**
@@ -61,6 +66,11 @@ export interface SchemaReflection {
    * JSON and urlencoded bodies every body schema reads. Absent when it declares none.
    */
   readonly mediaTypes?: readonly string[]
+  /**
+   * Set when the schema reads text values with `t.query`'s string coercion (`"1"` and `"TRUE"` are
+   * `true`, a lone value is a one-item list), as `t.query`, `t.headers` and `t.cookies` do.
+   */
+  readonly coerces?: true
 }
 
 export interface ReflectedRouteSchema {
@@ -83,8 +93,16 @@ export interface ReflectedRouteSchema {
   readonly errors?: Readonly<Record<string, SchemaReflection>>
   /** The SSE event-payload schema of a typed streaming route (`app.sse()`). */
   readonly sse?: SchemaReflection
+  /**
+   * Set when an `onValidationError` hook (the route's own, or the app-wide default) answers this
+   * route's validation failures, so its 422 body is whatever the hook returns.
+   */
+  readonly validationErrorHook?: true
 }
 
+/** Which side of a schema to describe: the value a request sends, or the value a response carries. */
+export type SchemaSide = "input" | "output"
+
 export interface ReflectedRoute {
   readonly method: string
   readonly path: string
@@ -118,6 +136,22 @@ const standardOf = (value: unknown): StandardSchemaV1 | undefined => {
     : undefined
 }
 
+/** The JSON Schema a Standard JSON Schema (`~standard.jsonSchema`) converts `side` to, if it has one. */
+const standardJsonSchemaOf = (
+  standard: StandardSchemaV1,
+  side: SchemaSide,
+): JsonSchema | undefined => {
+  const converters = recordOf(recordOf(standard["~standard"])?.jsonSchema)
+  const convert = converters?.[side]
+  if (typeof convert !== "function") return undefined
+  try {
+    return normalizeJsonSchema(Reflect.apply(convert, converters, [{ target: "draft-2020-12" }]))
+  } catch {
+    // A library throws for a type JSON Schema cannot express (zod's `z.date()`); the schema stays opaque.
+    return undefined
+  }
+}
+
 const jsonSchemaOf = (
   value: unknown,
   standard: StandardSchemaV1 | undefined,
@@ -194,19 +228,39 @@ const mediaTypesOf = (value: unknown): readonly string[] | undefined => {
   }
 }
 
+// The mark a coercing `@nifrajs/schema` validate carries.
+const COERCES = Symbol.for("nifra.schema.coerce")
+
+const coercesOf = (standard: StandardSchemaV1 | undefined): boolean => {
+  try {
+    const validate: unknown = standard?.["~standard"].validate
+    return typeof validate === "function" && Reflect.get(validate, COERCES) === true
+  } catch {
+    return false
+  }
+}
+
 /**
  * Reflect a Standard Schema, Nifra/TypeBox schema carrier, or raw JSON Schema. Never throws.
  * Validation-only schemas have `standard` but no `jsonSchema`; raw JSON Schema has the reverse.
+ * A Standard JSON Schema is read on `side`, since a default or a transform makes the two differ.
  */
-export function reflectSchema(value: unknown): SchemaReflection {
+export function reflectSchema(value: unknown, side: SchemaSide = "input"): SchemaReflection {
   const standard = standardOf(value)
-  const jsonSchema = jsonSchemaOf(value, standard)
+  const carried = jsonSchemaOf(value, standard)
+  const converted =
+    carried === undefined && standard !== undefined
+      ? standardJsonSchemaOf(standard, side)
+      : undefined
+  const jsonSchema = carried ?? converted
   const mediaTypes = mediaTypesOf(value)
   return {
     standard,
     jsonSchema,
+    ...(converted !== undefined ? { converted: true as const } : {}),
     fields: fieldsOf(jsonSchema),
     ...(mediaTypes !== undefined ? { mediaTypes } : {}),
+    ...(coercesOf(standard) ? { coerces: true as const } : {}),
   }
 }
 
@@ -222,14 +276,17 @@ const routeCandidates = (source: unknown): readonly unknown[] => {
   }
 }
 
-const reflectedRouteSchema = (value: unknown): ReflectedRouteSchema | undefined => {
+const reflectedRouteSchema = (
+  value: unknown,
+  appValidationHook: boolean,
+): ReflectedRouteSchema | undefined => {
   const schema = recordOf(value)
   if (schema === undefined) return undefined
   const errors = recordOf(schema.errors)
   const reflectedErrors: Record<string, SchemaReflection> = {}
   if (errors !== undefined) {
     for (const [status, errorSchema] of Object.entries(errors)) {
-      reflectedErrors[status] = reflectSchema(errorSchema)
+      reflectedErrors[status] = reflectSchema(errorSchema, "output")
     }
   }
   return {
@@ -249,9 +306,14 @@ const reflectedRouteSchema = (value: unknown): ReflectedRouteSchema | undefined
     ...(schema.body !== undefined ? { body: reflectSchema(schema.body) } : {}),
     ...(schema.query !== undefined ? { query: reflectSchema(schema.query) } : {}),
     ...(schema.params !== undefined ? { params: reflectSchema(schema.params) } : {}),
-    ...(schema.response !== undefined ? { response: reflectSchema(schema.response) } : {}),
+    ...(schema.response !== undefined
+      ? { response: reflectSchema(schema.response, "output") }
+      : {}),
     ...(Object.keys(reflectedErrors).length > 0 ? { errors: reflectedErrors } : {}),
-    ...(schema.sse !== undefined ? { sse: reflectSchema(schema.sse) } : {}),
+    ...(schema.sse !== undefined ? { sse: reflectSchema(schema.sse, "output") } : {}),
+    ...(appValidationHook || typeof schema.onValidationError === "function"
+      ? { validationErrorHook: true as const }
+      : {}),
   }
 }
 
@@ -326,10 +388,12 @@ const reflectedSockets = (source: unknown): ReflectedRoute[] => {
  */
 export function reflectRoutes(source: unknown): readonly ReflectedRoute[] {
   const reflected: ReflectedRoute[] = []
+  // The app-wide `server({ onValidationError })` lives on the server, not on each route descriptor.
+  const appValidationHook = typeof recordOf(source)?.defaultOnValidationError === "function"
   for (const candidate of routeCandidates(source)) {
     const route = recordOf(candidate)
     if (typeof route?.method !== "string" || typeof route.path !== "string") continue
-    const schema = reflectedRouteSchema(route.schema)
+    const schema = reflectedRouteSchema(route.schema, appValidationHook)
     const tool = reflectedTool(route.tool)
     const assurance = reflectedAssurance(route.assurance)
     const capabilities = normalizeRouteCapabilities(

package/src/response-observer.ts

@@ -5,6 +5,12 @@ import {
 } from "./server/response-observer-runtime.ts"
 import type { AnyServer } from "./server/server.ts"
 
+export {
+  markRepeatedPrefix,
+  type RepeatedPrefix,
+  repeatedPrefixOf,
+} from "./server/repeated-prefix.ts"
+
 export type {
   NodeResponseBodyHook,
   ResponseBodyHook,