@nifrajs/core 3.1.0 → 3.2.0

package/src/internal/route-compiler.ts

@@ -0,0 +1,234 @@
+/**
+ * Registration-time route compilation.
+ *
+ * This module owns the policy decisions that turn a route declaration into the immutable facts the
+ * execution-plan builder and the route catalog consume. It deliberately runs only from `Server.register`
+ * and `Server.registerBatch`; no function here is reachable from the request path.
+ *
+ * The public Server remains the fluent registration surface. This module is the deep implementation seam
+ * behind that surface: body limits, capability and assurance evidence, optional runtimes, decorations, and
+ * lane selection are resolved once, together, so adding a new route policy does not require editing the
+ * kernel's dispatch code.
+ */
+import type { EffectLifecycleObserver } from "../effect-lifecycle.ts"
+import { RouteConfigError } from "../errors.ts"
+import { type CompiledRoutePattern, compileRoutePattern } from "../router/pattern.ts"
+import type { Method } from "../router/router.ts"
+import type { StandardSchemaV1 } from "../schema/standard.ts"
+import { assertByteLimit } from "../server/body.ts"
+import type { RouteSchema } from "../server/context.ts"
+import type { IdempotencyRuntime, ResolvedIdempotency } from "../server/idempotency-lane.ts"
+import type { EffectLedgerRuntime, ResolvedEffectLedger } from "../server/ledger-lane.ts"
+import type { ResponseContractRuntime } from "../server/response-contract-lane.ts"
+import {
+  CAPABILITY_GUARD,
+  type CapabilityUseEvent,
+  createCapabilityGuard,
+  normalizeRouteCapabilities,
+  type RegisteredCapabilityInterceptor,
+} from "./capability-runtime.ts"
+import {
+  type AssuranceDeclaration,
+  assuranceDeclarationsOf,
+  assuranceEvidenceFor,
+  NIFRA_ASSURANCE_IDS,
+  validEvidenceId,
+} from "./route-assurance.ts"
+import type {
+  RawAfterHandle,
+  RawAround,
+  RawBeforeHandle,
+  RawDerive,
+  RawErrorHandler,
+} from "./route-execution.ts"
+import { type RouteLaneSelection, selectRouteLanes } from "./route-lanes.ts"
+
+export interface RouteCompilerContext {
+  readonly maxBodyBytes: number
+  readonly activeAssurance: readonly AssuranceDeclaration[]
+  readonly globalAssurance: readonly AssuranceDeclaration[]
+  readonly decorations: Record<string, unknown>
+  readonly onCapabilityUse: ((event: CapabilityUseEvent) => void) | undefined
+  readonly capabilityInterceptors: readonly RegisteredCapabilityInterceptor[]
+  readonly capabilityObservers: readonly EffectLifecycleObserver[]
+  readonly effectLedgerRuntime: EffectLedgerRuntime | undefined
+  readonly idempotencyRuntime: IdempotencyRuntime | undefined
+  readonly responseContractRuntime: ResponseContractRuntime | undefined
+  readonly derives: readonly RawDerive[]
+  readonly beforeHandleHooks: readonly RawBeforeHandle[]
+  readonly afterHandleHooks: readonly RawAfterHandle[]
+  readonly onErrorHooks: readonly RawErrorHandler[]
+  readonly aroundHooks: readonly RawAround[]
+  readonly defaultOnValidationError: RouteSchema["onValidationError"] | undefined
+}
+
+export interface CompiledRouteOptions {
+  readonly pattern: CompiledRoutePattern
+  readonly bodyLimit: number | undefined
+  readonly capabilities: readonly string[]
+  readonly handlerAssurance: readonly AssuranceDeclaration[]
+  readonly routeDecorations: Record<PropertyKey, unknown>
+  readonly hasDecorations: boolean
+  readonly idempotent: ResolvedIdempotency | undefined
+  readonly ledgered: ResolvedEffectLedger | undefined
+  readonly responseContract:
+    | { readonly runtime: ResponseContractRuntime; readonly schema: StandardSchemaV1 }
+    | undefined
+  readonly lanes: RouteLaneSelection
+  readonly routeAssurance: readonly AssuranceDeclaration[]
+}
+
+/** Resolve all registration-time policy and lane facts for one route. */
+export function compileRouteOptions(
+  context: RouteCompilerContext,
+  method: Method,
+  path: string,
+  schema: RouteSchema | undefined,
+  handler: (context: never) => unknown,
+): CompiledRouteOptions {
+  const pattern = compileRoutePattern(path)
+  let bodyLimit: number | undefined = context.maxBodyBytes
+  const invalidBodyLimit = (message: string): never => {
+    throw new RouteConfigError("INVALID_BODY_LIMIT", `route ${method} ${path}: ${message}`)
+  }
+  if (schema?.bodyLimitReason !== undefined && schema.bodyLimit !== "unlimited") {
+    invalidBodyLimit('bodyLimitReason is only valid with bodyLimit: "unlimited"')
+  }
+  if (schema?.bodyLimit === "unlimited") {
+    if (typeof schema.bodyLimitReason !== "string" || schema.bodyLimitReason.trim().length === 0) {
+      invalidBodyLimit('bodyLimit: "unlimited" requires a non-empty bodyLimitReason')
+    }
+    if (schema.body !== undefined) {
+      invalidBodyLimit('bodyLimit: "unlimited" cannot be used with a body schema; use a finite cap')
+    }
+    if (schema.idempotency !== undefined) {
+      invalidBodyLimit('bodyLimit: "unlimited" cannot be used with idempotency')
+    }
+    bodyLimit = undefined
+  } else if (schema?.bodyLimit !== undefined) {
+    try {
+      assertByteLimit(schema.bodyLimit, "route bodyLimit")
+    } catch {
+      invalidBodyLimit('bodyLimit must be a non-negative safe integer or "unlimited"')
+    }
+    bodyLimit = schema.bodyLimit
+  }
+
+  const capabilities = normalizeRouteCapabilities(schema?.capabilities)
+  const handlerAssurance = assuranceDeclarationsOf(handler as unknown as object)
+  const invalidHandlerScope = handlerAssurance.find((declaration) => declaration.scope !== "plugin")
+  if (invalidHandlerScope !== undefined) {
+    throw new RouteConfigError(
+      "INVALID_ASSURANCE",
+      `route handler assurance must use plugin scope (received ${invalidHandlerScope.scope})`,
+    )
+  }
+
+  const authenticated = assuranceEvidenceFor(
+    [...context.activeAssurance, ...handlerAssurance, ...context.globalAssurance],
+    method,
+    path,
+  ).some((evidence) => evidence.id === NIFRA_ASSURANCE_IDS.AUTHENTICATED)
+  const routeDecorations: Record<PropertyKey, unknown> = { ...context.decorations }
+  if (capabilities.length > 0) {
+    routeDecorations[CAPABILITY_GUARD] = createCapabilityGuard(
+      capabilities,
+      method,
+      path,
+      context.onCapabilityUse,
+      context.idempotencyRuntime?.trackEffect,
+      Object.freeze([...context.capabilityInterceptors]),
+      Object.freeze([...context.capabilityObservers]),
+    )
+  }
+  const hasDecorations = Reflect.ownKeys(routeDecorations).length > 0
+
+  if (schema?.idempotency !== undefined && context.idempotencyRuntime === undefined) {
+    throw new RouteConfigError(
+      "INVALID_IDEMPOTENCY",
+      "route declares idempotency but the idempotency plugin is not installed; add .use(idempotency())",
+    )
+  }
+  const idempotent = context.idempotencyRuntime?.resolve(
+    schema,
+    authenticated,
+    context.maxBodyBytes,
+  )
+  const ledgered = context.effectLedgerRuntime?.resolve(capabilities, method, path)
+  const contracted =
+    context.responseContractRuntime !== undefined && schema?.response !== undefined
+      ? { runtime: context.responseContractRuntime, schema: schema.response }
+      : undefined
+  const lanes = selectRouteLanes({
+    schema,
+    hasIdempotency: idempotent !== undefined,
+    hasLedger: ledgered !== undefined,
+    hasResponseContract: contracted !== undefined,
+    hasDecorations,
+    derives: context.derives.length,
+    beforeHandle: context.beforeHandleHooks.length,
+    afterHandle: context.afterHandleHooks.length,
+    onError: context.onErrorHooks.length,
+    around: context.aroundHooks.length,
+    defaultOnValidationError: context.defaultOnValidationError !== undefined,
+  })
+
+  const routeAssurance: AssuranceDeclaration[] = [...context.activeAssurance, ...handlerAssurance]
+  if (contracted?.runtime.mode === "enforce" && schema?.response !== undefined) {
+    routeAssurance.push(
+      Object.freeze({
+        id: NIFRA_ASSURANCE_IDS.RESPONSE_CONTRACT,
+        source: "response-contract",
+        scope: "plugin",
+      }),
+    )
+  }
+  for (const id of schema?.assurance ?? []) {
+    if (!validEvidenceId(id)) {
+      throw new Error(
+        `route assurance: invalid evidence id ${JSON.stringify(id)} on ${method} ${path} (use lowercase dot/dash segments)`,
+      )
+    }
+    const declared = { id, source: "declared", scope: "plugin" } as AssuranceDeclaration
+    Object.defineProperty(declared, "provenance", {
+      value: "declared",
+      enumerable: false,
+      configurable: false,
+      writable: false,
+    })
+    routeAssurance.push(Object.freeze(declared))
+  }
+  const unlimitedBody = schema?.bodyLimit === "unlimited"
+  if (!unlimitedBody && (schema?.body !== undefined || typeof schema?.bodyLimit === "number")) {
+    routeAssurance.push(
+      Object.freeze({
+        id: NIFRA_ASSURANCE_IDS.BODY_BOUNDED,
+        source: "route-schema",
+        scope: "plugin",
+      }),
+    )
+  }
+  if (schema?.idempotency !== undefined) {
+    routeAssurance.push(
+      Object.freeze({
+        id: NIFRA_ASSURANCE_IDS.IDEMPOTENCY_KEY,
+        source: "route-schema",
+        scope: "plugin",
+      }),
+    )
+  }
+
+  return {
+    pattern,
+    bodyLimit,
+    capabilities,
+    handlerAssurance,
+    routeDecorations,
+    hasDecorations,
+    idempotent,
+    ledgered,
+    responseContract: contracted,
+    lanes,
+    routeAssurance: Object.freeze(routeAssurance),
+  }
+}

package/src/internal/route-execution.ts

@@ -29,6 +29,7 @@ import { RequestContext } from "../server/request-context.ts"
 import type { ResponseContractRuntime } from "../server/response-contract-lane.ts"
 import type { HandlerResult, ResponseResult } from "../server/runtime-core.ts"
 import type { CtxSet, MaybePromise, RawContext, RequestSource, Server } from "../server/server.ts"
+import type { RouteProgram } from "./route-program.ts"
 
 export type InternalHandler = (ctx: RawContext) => MaybePromise<HandlerResult>
 
@@ -98,33 +99,7 @@ interface RouteExecutionRuntime {
     finalize: (result: unknown, set: CtxSet) => T,
     wrapResponse: (response: Response | ResponseResult) => T,
   ): MaybePromise<T>
-  runLifecycleHooks<T>(
-    entry: RouteEntry,
-    ctx: RawContext,
-    finalize: (result: unknown, set: CtxSet) => T,
-    wrapResponse: (response: Response | ResponseResult) => T,
-  ): MaybePromise<T>
-  runLifecycleQuery<T>(
-    entry: RouteEntry,
-    ctx: RawContext,
-    finalize: (result: unknown, set: CtxSet) => T,
-    wrapResponse: (response: Response | ResponseResult) => T,
-  ): MaybePromise<T>
-  runLifecycleBody<T>(
-    entry: RouteEntry,
-    source: RequestSource,
-    ctx: RawContext,
-    finalize: (result: unknown, set: CtxSet) => T,
-    wrapResponse: (response: Response | ResponseResult) => T,
-  ): MaybePromise<T>
-  runLifecycleBodyQuery<T>(
-    entry: RouteEntry,
-    source: RequestSource,
-    ctx: RawContext,
-    finalize: (result: unknown, set: CtxSet) => T,
-    wrapResponse: (response: Response | ResponseResult) => T,
-  ): MaybePromise<T>
-  runLifecycle<T>(
+  runProgram<T>(
     entry: RouteEntry,
     source: RequestSource,
     ctx: RawContext,
@@ -158,13 +133,19 @@ export function compileRouteExecutionPlan(options: {
   readonly contextless: boolean
   readonly hasAround: boolean
   readonly hasLedger: boolean
-  readonly lifecycleLane: LifecycleExecutionLane
   readonly fusedWeb: FusedWebRunner | undefined
   readonly fusedBody: FusedBodyRunner | undefined
-  readonly fusedLane: "bare" | "body" | "query" | undefined
+  readonly fusedLane:
+    | "bare"
+    | "body"
+    | "query"
+    | "derive-before"
+    | "derive-before-after"
+    | "body-derive-before"
+    | "body-derive-before-after"
+    | undefined
 }): RouteExecutionPlan {
-  const { lane, contextless, hasAround, hasLedger, lifecycleLane, fusedWeb, fusedBody, fusedLane } =
-    options
+  const { lane, contextless, hasAround, hasLedger, fusedWeb, fusedBody, fusedLane } = options
 
   if (contextless) {
     const run: RouteExecutionRunner = (
@@ -191,7 +172,7 @@ export function compileRouteExecutionPlan(options: {
         finalize,
         wrapResponse,
       )
-    return Object.freeze({ run, fusedWeb, fusedBody, fusedLane })
+    return Object.freeze({ run, fusedWeb, fusedBody, fusedLane }) as RouteExecutionPlan
   }
 
   let inner: ContextRouteRunner
@@ -220,55 +201,14 @@ export function compileRouteExecutionPlan(options: {
         )
       break
     default:
-      switch (lifecycleLane) {
-        case "hooks":
-          inner = (runtime, entry, _source, ctx, finalize, wrapResponse) =>
-            (runtime as unknown as RouteExecutionRuntime).runLifecycleHooks(
-              entry,
-              ctx,
-              finalize,
-              wrapResponse,
-            )
-          break
-        case "query":
-          inner = (runtime, entry, _source, ctx, finalize, wrapResponse) =>
-            (runtime as unknown as RouteExecutionRuntime).runLifecycleQuery(
-              entry,
-              ctx,
-              finalize,
-              wrapResponse,
-            )
-          break
-        case "body":
-          inner = (runtime, entry, source, ctx, finalize, wrapResponse) =>
-            (runtime as unknown as RouteExecutionRuntime).runLifecycleBody(
-              entry,
-              source,
-              ctx,
-              finalize,
-              wrapResponse,
-            )
-          break
-        case "body-query":
-          inner = (runtime, entry, source, ctx, finalize, wrapResponse) =>
-            (runtime as unknown as RouteExecutionRuntime).runLifecycleBodyQuery(
-              entry,
-              source,
-              ctx,
-              finalize,
-              wrapResponse,
-            )
-          break
-        default:
-          inner = (runtime, entry, source, ctx, finalize, wrapResponse) =>
-            (runtime as unknown as RouteExecutionRuntime).runLifecycle(
-              entry,
-              source,
-              ctx,
-              finalize,
-              wrapResponse,
-            )
-      }
+      inner = (runtime, entry, source, ctx, finalize, wrapResponse) =>
+        (runtime as unknown as RouteExecutionRuntime).runProgram(
+          entry,
+          source,
+          ctx,
+          finalize,
+          wrapResponse,
+        )
   }
 
   const execute: ContextRouteRunner = hasAround
@@ -329,7 +269,7 @@ export function compileRouteExecutionPlan(options: {
     }
     return outcome
   }
-  return Object.freeze({ run, fusedWeb, fusedBody, fusedLane })
+  return Object.freeze({ run, fusedWeb, fusedBody, fusedLane }) as RouteExecutionPlan
 }
 
 /** Registration-compiled route behavior. Every adapter invokes the same runner; the optional fused
@@ -341,7 +281,15 @@ export interface RouteExecutionPlan {
   /** Which builder produced {@link fusedWeb} - a merge rebinds the closure to the executing server
    * and must rebuild it with the SAME semantics (a query-fused route rebuilt as bare would skip its
    * validation). `undefined` iff `fusedWeb` is. */
-  readonly fusedLane: "bare" | "body" | "query" | undefined
+  readonly fusedLane:
+    | "bare"
+    | "body"
+    | "query"
+    | "derive-before"
+    | "derive-before-after"
+    | "body-derive-before"
+    | "body-derive-before-after"
+    | undefined
 }
 
 export interface RouteEntry {
@@ -377,11 +325,13 @@ export interface RouteEntry {
   readonly afterHandle: ReadonlyArray<RawAfterHandle>
   readonly onError: ReadonlyArray<RawErrorHandler>
   /** Registration-specialized hook shape for the common derive + before middleware route. */
-  readonly lifecycleHookLane: "derive-before" | undefined
+  readonly lifecycleHookLane: "derive-before" | "derive-before-after" | undefined
   /** Wraps the matched route lifecycle. Empty for the common no-around path. */
   readonly around: ReadonlyArray<RawAround>
   /** The single immutable execution decision consumed by portable, Node-direct, and Bun-native paths. */
   readonly execution: RouteExecutionPlan
+  /** One immutable general lifecycle program compiled at registration. */
+  readonly program: RouteProgram
 }
 
 /** The fused Web lane: same inputs `routeAndRun` would hand the generic path, a `Response` out. */

package/src/internal/route-lanes.ts

@@ -0,0 +1,221 @@
+/**
+ * Registration-time route-lane selection.
+ *
+ * A route's lane is a property of its registered shape, not of an individual request. Keeping this
+ * decision in a small internal module gives the server kernel one vocabulary for bare/body/query/
+ * lifecycle execution while preserving the important invariant: this module is never called from the
+ * request path. The returned booleans are consumed by the existing compiled execution plan and fused
+ * builders; no adapter or extra dispatch hop is introduced at runtime.
+ */
+import type { RouteSchema } from "../server/context.ts"
+import type { LifecycleExecutionLane, RouteExecutionLane } from "./route-execution.ts"
+
+export interface RouteLaneSelection {
+  readonly bare: boolean
+  readonly fusedQuery: boolean
+  readonly bodyOnly: boolean
+  readonly fusedBody: boolean
+  readonly lane: RouteExecutionLane
+  readonly lifecycleLane: LifecycleExecutionLane
+  readonly lifecycleHookLane: "derive-before" | "derive-before-after" | undefined
+  readonly fusedLane:
+    | "bare"
+    | "body"
+    | "query"
+    | "derive-before"
+    | "derive-before-after"
+    | "body-derive-before"
+    | "body-derive-before-after"
+    | undefined
+}
+
+export function selectRouteLanes(options: {
+  readonly schema: RouteSchema | undefined
+  readonly hasIdempotency: boolean
+  readonly hasLedger: boolean
+  readonly hasResponseContract: boolean
+  readonly hasDecorations: boolean
+  readonly derives: number
+  readonly beforeHandle: number
+  readonly afterHandle: number
+  readonly onError: number
+  readonly around: number
+  readonly defaultOnValidationError: boolean
+}): RouteLaneSelection {
+  const {
+    schema,
+    hasIdempotency,
+    hasLedger,
+    hasResponseContract,
+    hasDecorations,
+    derives,
+    beforeHandle,
+    afterHandle,
+    onError,
+    around,
+    defaultOnValidationError,
+  } = options
+
+  const bare =
+    schema?.params === undefined &&
+    schema?.headers === undefined &&
+    schema?.body === undefined &&
+    schema?.query === undefined &&
+    !hasIdempotency &&
+    !hasLedger &&
+    !hasResponseContract &&
+    derives === 0 &&
+    beforeHandle === 0 &&
+    afterHandle === 0 &&
+    onError === 0
+
+  // A route whose ONLY lifecycle step is a query schema can fuse too: the parse + validate + handler +
+  // respond collapse into one closure with no lifecycle promise on the sync path. The guards mirror the
+  // query lane below PLUS everything the fused dispatch skips: around hooks, the idempotency/ledger
+  // wrappers, and validation-error recovery (schema or server default) - the fused invalid path is
+  // exactly `validationError(issues)`, so any recovery semantics keep the generic lane.
+  const fusedQuery =
+    !bare &&
+    !hasResponseContract &&
+    schema?.query !== undefined &&
+    schema.body === undefined &&
+    schema.params === undefined &&
+    schema.headers === undefined &&
+    schema.onValidationError === undefined &&
+    !defaultOnValidationError &&
+    !hasIdempotency &&
+    !hasLedger &&
+    derives === 0 &&
+    beforeHandle === 0 &&
+    afterHandle === 0 &&
+    onError === 0 &&
+    around === 0
+
+  const bodyOnly =
+    !hasResponseContract &&
+    schema?.body !== undefined &&
+    schema.query === undefined &&
+    schema.params === undefined &&
+    schema.headers === undefined &&
+    derives === 0 &&
+    beforeHandle === 0 &&
+    afterHandle === 0 &&
+    onError === 0
+
+  const fusedBody =
+    !bare &&
+    bodyOnly &&
+    schema.onValidationError === undefined &&
+    !defaultOnValidationError &&
+    !hasIdempotency &&
+    !hasLedger &&
+    around === 0
+
+  const lane: RouteExecutionLane = bare
+    ? "bare"
+    : bodyOnly
+      ? "body"
+      : !hasResponseContract &&
+          schema?.body === undefined &&
+          schema?.query !== undefined &&
+          schema.params === undefined &&
+          schema.headers === undefined &&
+          derives === 0 &&
+          beforeHandle === 0 &&
+          afterHandle === 0 &&
+          onError === 0
+        ? "query"
+        : "lifecycle"
+
+  // Lifecycle routes with no params schema are the common middleware shape: derive/before plus an
+  // optional query or body schema. Select their complete validation stage at registration so the
+  // request path never re-checks params/body presence. Parameter-schema routes retain the generic
+  // lifecycle runner until their more involved recovery matrix is selected explicitly.
+  const lifecycleLane: LifecycleExecutionLane =
+    lane !== "lifecycle" || schema?.params !== undefined || schema?.headers !== undefined
+      ? undefined
+      : schema?.body !== undefined
+        ? schema.query !== undefined
+          ? "body-query"
+          : "body"
+        : schema?.query !== undefined
+          ? "query"
+          : "hooks"
+
+  // The realistic middleware shape is commonly exactly one synchronous-or-async derive followed by
+  // one before hook. Keep the generic runner for every route that can observe decorations, after hooks,
+  // error hooks, or response contracts; this lane only removes the two per-request hook-loop dispatches
+  // and preserves the same async continuations and error handling. A params or headers schema routes
+  // back to the generic lane because the fused builder has no `params` / `headers` validation step
+  // baked in - adding them would be more code than it saves. A `body` schema is the same story
+  // because the fused derive-before / derive-before-after builders don't parse the body: routes with a
+  // body schema are routed to the `body-derive-before` / `body-derive-before-after` lane below.
+  const lifecycleHookLane =
+    lane === "lifecycle" &&
+    !hasResponseContract &&
+    !hasDecorations &&
+    !hasIdempotency &&
+    !hasLedger &&
+    schema?.onValidationError === undefined &&
+    !defaultOnValidationError &&
+    schema?.params === undefined &&
+    schema?.headers === undefined &&
+    schema?.body === undefined &&
+    derives === 1 &&
+    beforeHandle === 1 &&
+    afterHandle <= 1 &&
+    onError === 0 &&
+    around === 0
+      ? afterHandle === 0
+        ? "derive-before"
+        : "derive-before-after"
+      : undefined
+
+  // Body + lifecycle hooks in a closed shape: a body schema plus the same 1-derive + 1-before +
+  // 0-or-1-after + 0-onError shape, with no other body/query/path conflict. The fused closure runs
+  // parse → validate → derive → before → handler → after → respond in one function frame, the same
+  // win `fusedBody` already gives for the no-hooks body shape.
+  const fusedBodyLifecycle =
+    lane === "lifecycle" &&
+    schema?.body !== undefined &&
+    schema?.query === undefined &&
+    schema?.params === undefined &&
+    schema?.headers === undefined &&
+    schema?.onValidationError === undefined &&
+    !defaultOnValidationError &&
+    !hasResponseContract &&
+    !hasDecorations &&
+    !hasIdempotency &&
+    !hasLedger &&
+    derives === 1 &&
+    beforeHandle === 1 &&
+    afterHandle <= 1 &&
+    onError === 0 &&
+    around === 0
+
+  return {
+    bare,
+    fusedQuery,
+    bodyOnly,
+    fusedBody,
+    lane,
+    lifecycleLane,
+    lifecycleHookLane,
+    fusedLane:
+      around === 0
+        ? fusedQuery
+          ? "query"
+          : fusedBody
+            ? "body"
+            : bare
+              ? "bare"
+              : lifecycleHookLane !== undefined
+                ? (lifecycleHookLane as "derive-before" | "derive-before-after")
+                : fusedBodyLifecycle
+                  ? afterHandle === 0
+                    ? "body-derive-before"
+                    : "body-derive-before-after"
+                  : undefined
+        : undefined,
+  }
+}