@nifrajs/core 1.13.0 → 2.1.0

package/src/effect-ledger.ts

@@ -0,0 +1,9 @@
+/**
+ * Opt-in server integration for the per-request effect ledger.
+ *
+ * Kept separate from `@nifrajs/core/server` so a bare HTTP app does not evaluate or bundle ledger
+ * machinery. Import ledger primitives from `@nifrajs/core/ledger`.
+ */
+
+export type { EffectLedgerOptions } from "./ledger.ts"
+export { effectLedger } from "./server/ledger-lane.ts"

package/src/effect-lifecycle.ts

@@ -0,0 +1,120 @@
+import { validCapabilityId } from "./internal/capability-runtime.ts"
+import { type EffectCost, type EffectMetadata, normalizeEffectMetadata } from "./ledger.ts"
+
+/** A bounded, payload-free stage in an effect's lifecycle. */
+export type EffectLifecycleStage = "admission" | "execution" | "compensation" | "reconciliation"
+
+export type EffectLifecyclePhase = "started" | "succeeded" | "failed" | "ambiguous"
+
+/** Trace-parent tokens copied structurally from an installed tracing plugin. */
+export interface EffectTraceParent {
+  readonly traceId: string
+  readonly spanId: string
+  readonly sampled: boolean
+}
+
+/**
+ * Token-only lifecycle evidence. There is deliberately no payload, argument, result, error message,
+ * request, or context field, so observation adapters cannot accidentally export business data.
+ */
+export interface EffectLifecycleEvent extends EffectMetadata {
+  readonly effectId: string
+  readonly capability: string
+  readonly stage: EffectLifecycleStage
+  readonly phase: EffectLifecyclePhase
+  readonly at: number
+  readonly durationMs?: number
+  readonly attempt?: number
+  readonly errorCode?: string
+  readonly trace?: EffectTraceParent
+}
+
+/** Observation is fail-open: a broken sink must never change effect behavior. */
+export type EffectLifecycleObserver = (event: EffectLifecycleEvent) => void
+
+const ERROR_CODE = /^[a-z][a-z0-9_.-]{0,63}$/
+
+export function effectTraceParentOf(context: object): EffectTraceParent | undefined {
+  const trace = (
+    context as {
+      readonly trace?: {
+        readonly traceId?: unknown
+        readonly spanId?: unknown
+        readonly sampled?: unknown
+      }
+    }
+  ).trace
+  if (
+    trace === undefined ||
+    typeof trace.traceId !== "string" ||
+    !/^[0-9a-f]{32}$/.test(trace.traceId) ||
+    typeof trace.spanId !== "string" ||
+    !/^[0-9a-f]{16}$/.test(trace.spanId) ||
+    typeof trace.sampled !== "boolean"
+  ) {
+    return undefined
+  }
+  return Object.freeze({ traceId: trace.traceId, spanId: trace.spanId, sampled: trace.sampled })
+}
+
+export interface EmitEffectLifecycleInput extends EffectMetadata {
+  readonly effectId: string
+  readonly capability: string
+  readonly stage: EffectLifecycleStage
+  readonly phase: EffectLifecyclePhase
+  readonly at?: number
+  readonly durationMs?: number
+  readonly attempt?: number
+  readonly errorCode?: string
+  readonly trace?: EffectTraceParent
+}
+
+/** @internal Validate, freeze, and fan out one token-only event. */
+export function emitEffectLifecycle(
+  observers: readonly EffectLifecycleObserver[],
+  input: EmitEffectLifecycleInput,
+): void {
+  if (observers.length === 0) return
+  if (!validCapabilityId(input.capability) || !/^[!-~]{1,64}$/u.test(input.effectId)) return
+  let metadata: EffectMetadata
+  try {
+    metadata = normalizeEffectMetadata(input)
+  } catch {
+    return
+  }
+  const at = input.at ?? Date.now()
+  if (!Number.isFinite(at) || at < 0) return
+  if (
+    input.durationMs !== undefined &&
+    (!Number.isFinite(input.durationMs) || input.durationMs < 0)
+  ) {
+    return
+  }
+  if (input.attempt !== undefined && (!Number.isSafeInteger(input.attempt) || input.attempt < 1)) {
+    return
+  }
+  if (input.errorCode !== undefined && !ERROR_CODE.test(input.errorCode)) return
+  const event: EffectLifecycleEvent = Object.freeze({
+    effectId: input.effectId,
+    capability: input.capability,
+    stage: input.stage,
+    phase: input.phase,
+    at,
+    ...(input.durationMs === undefined ? {} : { durationMs: input.durationMs }),
+    ...(input.attempt === undefined ? {} : { attempt: input.attempt }),
+    ...(input.errorCode === undefined ? {} : { errorCode: input.errorCode }),
+    ...(metadata.target === undefined ? {} : { target: metadata.target }),
+    ...(metadata.cost === undefined
+      ? {}
+      : { cost: Object.freeze({ ...metadata.cost }) as EffectCost }),
+    ...(metadata.digest === undefined ? {} : { digest: metadata.digest }),
+    ...(input.trace === undefined ? {} : { trace: input.trace }),
+  })
+  for (const observer of observers) {
+    try {
+      observer(event)
+    } catch {
+      // Observation is deliberately fail-open.
+    }
+  }
+}

package/src/effect-scope.ts

@@ -0,0 +1,267 @@
+/**
+ * One cross-runtime boundary for owned external effects. It centralizes correlation, lifecycle
+ * evidence, cancellation, durable transition ordering, and token-only observation without relying
+ * on Node-only async-local state.
+ */
+
+import {
+  type EffectLifecycleObserver,
+  type EffectLifecycleStage,
+  type EffectTraceParent,
+  emitEffectLifecycle,
+} from "./effect-lifecycle.ts"
+import { validCapabilityId } from "./internal/capability-runtime.ts"
+import { type EffectMetadata, normalizeEffectMetadata } from "./ledger.ts"
+
+const ERROR_CODE = /^[a-z][a-z0-9_.-]{0,63}$/
+
+export interface EffectScopeEvidence {
+  readonly began: boolean
+  readonly committed: boolean
+  readonly ambiguous: boolean
+}
+
+export interface OwnedEffectContext extends EffectMetadata {
+  readonly effectId: string
+  readonly capability: string
+  readonly stage: Exclude<EffectLifecycleStage, "admission" | "reconciliation">
+  readonly signal: AbortSignal
+  readonly attempt?: number
+}
+
+export interface OwnedEffectTransitions<T> {
+  intent?(context: OwnedEffectContext): void | PromiseLike<void>
+  executing?(context: OwnedEffectContext): void | PromiseLike<void>
+  committed?(context: OwnedEffectContext, result: T): void | PromiseLike<void>
+  failed?(
+    context: OwnedEffectContext,
+    input: { readonly began: boolean; readonly errorCode: string; readonly error: unknown },
+  ): void | PromiseLike<void>
+}
+
+export interface OwnedEffectRunOptions<T> extends EffectMetadata {
+  readonly effectId?: string
+  readonly capability: string
+  readonly stage?: Exclude<EffectLifecycleStage, "admission" | "reconciliation">
+  readonly signal?: AbortSignal
+  readonly attempt?: number
+  readonly trace?: EffectTraceParent
+  /** Per-run observers, combined with the scope's observers. */
+  readonly observers?: readonly EffectLifecycleObserver[]
+  /** Optional admission boundary executed before the effect is marked as begun. */
+  readonly admit?: (context: OwnedEffectContext) => void | PromiseLike<void>
+  readonly transitions?: OwnedEffectTransitions<T>
+  readonly errorCode?: string | ((error: unknown, began: boolean) => string)
+  /** Classify a caught execution failure when the caller can prove it is terminal. */
+  readonly failurePhase?: (error: unknown, began: boolean) => "failed" | "ambiguous"
+}
+
+export interface EffectScopeOptions {
+  readonly observers?: readonly EffectLifecycleObserver[]
+  readonly signal?: AbortSignal
+  readonly effectId?: () => string
+}
+
+export interface EffectEvidenceScope {
+  evidence(): EffectScopeEvidence
+  /** Legacy/manual effects cannot prove a terminal outcome and therefore become ambiguous. */
+  markBegan(): void
+  /** Pair a prior manual `markBegan()` with a proven commit. */
+  markCommitted(): void
+  /** Preserve uncertainty when a caller loses the terminal outcome. */
+  markAmbiguous(): void
+  /** Settle one begun effect as a proven terminal failure without claiming it committed. */
+  markFailed(): void
+  /**
+   * Declare that the enclosing request may release its idempotency reservation if it returns a
+   * server error before any owned effect begins.
+   */
+  markSafeToRetry(): void
+  /** True only while the retry declaration remains backed by evidence that no effect began. */
+  safeToRetry(): boolean
+}
+
+export interface EffectScope extends EffectEvidenceScope {
+  run<T>(
+    options: OwnedEffectRunOptions<T>,
+    execute: (context: OwnedEffectContext) => T | PromiseLike<T>,
+  ): Promise<T>
+}
+
+let neverSignal: AbortSignal | undefined
+function signalOrNever(signal?: AbortSignal): AbortSignal {
+  neverSignal ??= new AbortController().signal
+  return signal ?? neverSignal
+}
+
+function assertEffectId(value: string): void {
+  if (!/^[!-~]{1,64}$/u.test(value))
+    throw new TypeError("effect id must be a bounded printable token")
+}
+
+function codeFor(
+  configured: OwnedEffectRunOptions<unknown>["errorCode"],
+  error: unknown,
+  began: boolean,
+): string {
+  const code =
+    typeof configured === "function"
+      ? configured(error, began)
+      : (configured ?? (began ? "execution_failed" : "admission_failed"))
+  if (!ERROR_CODE.test(code)) throw new TypeError("effect errorCode is invalid")
+  return code
+}
+
+/** Lightweight aggregate evidence shared by request idempotency and full owned-effect runners. */
+export function createEffectEvidenceScope(): EffectEvidenceScope {
+  const aggregate = { began: false, committed: false }
+  let uncertain = 0
+  let retryDeclared = false
+  return Object.freeze({
+    evidence() {
+      return Object.freeze({ ...aggregate, ambiguous: uncertain > 0 })
+    },
+    markBegan() {
+      aggregate.began = true
+      retryDeclared = false
+      uncertain++
+    },
+    markCommitted() {
+      aggregate.began = true
+      aggregate.committed = true
+      if (uncertain > 0) uncertain--
+    },
+    markAmbiguous() {
+      aggregate.began = true
+      retryDeclared = false
+      if (uncertain === 0) uncertain = 1
+    },
+    markFailed() {
+      aggregate.began = true
+      retryDeclared = false
+      if (uncertain > 0) uncertain--
+    },
+    markSafeToRetry() {
+      if (aggregate.began) {
+        throw new Error("cannot mark an idempotent request safe to retry after an effect began")
+      }
+      retryDeclared = true
+    },
+    safeToRetry() {
+      return retryDeclared && !aggregate.began
+    },
+  })
+}
+
+export function createEffectScope(
+  options: EffectScopeOptions = {},
+  evidenceScope: EffectEvidenceScope = createEffectEvidenceScope(),
+): EffectScope {
+  const observers = Object.freeze([...(options.observers ?? [])])
+  const idFor = options.effectId ?? crypto.randomUUID.bind(crypto)
+
+  const scope: EffectScope = {
+    async run<T>(
+      input: OwnedEffectRunOptions<T>,
+      execute: (context: OwnedEffectContext) => T | PromiseLike<T>,
+    ) {
+      if (typeof execute !== "function")
+        throw new TypeError("owned effect executor must be a function")
+      if (!validCapabilityId(input.capability))
+        throw new TypeError("owned effect capability is invalid")
+      const effectId = input.effectId ?? idFor()
+      assertEffectId(effectId)
+      const metadata = normalizeEffectMetadata(input)
+      const signal = input.signal ?? options.signal ?? signalOrNever()
+      const stage = input.stage ?? "execution"
+      if (
+        input.attempt !== undefined &&
+        (!Number.isSafeInteger(input.attempt) || input.attempt < 1)
+      )
+        throw new RangeError("owned effect attempt must be a positive safe integer")
+      const context: OwnedEffectContext = Object.freeze({
+        effectId,
+        capability: input.capability,
+        stage,
+        signal,
+        ...metadata,
+        ...(input.attempt === undefined ? {} : { attempt: input.attempt }),
+      })
+      const runObservers =
+        input.observers === undefined
+          ? observers
+          : Object.freeze([...observers, ...input.observers])
+      let began = false
+      const startedAt = performance.now()
+      try {
+        if (signal.aborted) throw signal.reason
+        await input.transitions?.intent?.(context)
+        if (input.admit !== undefined) {
+          emitEffectLifecycle(runObservers, {
+            ...context,
+            stage: "admission",
+            phase: "started",
+            ...(input.trace === undefined ? {} : { trace: input.trace }),
+          })
+          await input.admit(context)
+          emitEffectLifecycle(runObservers, {
+            ...context,
+            stage: "admission",
+            phase: "succeeded",
+            durationMs: Math.max(0, performance.now() - startedAt),
+            ...(input.trace === undefined ? {} : { trace: input.trace }),
+          })
+        }
+        if (signal.aborted) throw signal.reason
+        await input.transitions?.executing?.(context)
+        began = true
+        evidenceScope.markBegan()
+        const executionStartedAt = performance.now()
+        emitEffectLifecycle(runObservers, {
+          ...context,
+          phase: "started",
+          ...(input.trace === undefined ? {} : { trace: input.trace }),
+        })
+        const result = await execute(context)
+        await input.transitions?.committed?.(context, result)
+        evidenceScope.markCommitted()
+        emitEffectLifecycle(runObservers, {
+          ...context,
+          phase: "succeeded",
+          durationMs: Math.max(0, performance.now() - executionStartedAt),
+          ...(input.trace === undefined ? {} : { trace: input.trace }),
+        })
+        return result
+      } catch (error) {
+        const errorCode = codeFor(input.errorCode, error, began)
+        const failurePhase = input.failurePhase?.(error, began) ?? (began ? "ambiguous" : "failed")
+        if (failurePhase !== "failed" && failurePhase !== "ambiguous") {
+          throw new TypeError("owned effect failurePhase returned an invalid phase")
+        }
+        try {
+          await input.transitions?.failed?.(context, { began, errorCode, error })
+        } catch {
+          // Preserve the owned effect's cause. Reconciliation sees the unfinished durable state.
+        }
+        if (began && failurePhase === "failed") evidenceScope.markFailed()
+        emitEffectLifecycle(runObservers, {
+          ...context,
+          stage: began ? stage : input.admit === undefined ? stage : "admission",
+          phase: began ? failurePhase : "failed",
+          durationMs: Math.max(0, performance.now() - startedAt),
+          errorCode,
+          ...(input.trace === undefined ? {} : { trace: input.trace }),
+        })
+        throw error
+      }
+    },
+    evidence: () => evidenceScope.evidence(),
+    markBegan: () => evidenceScope.markBegan(),
+    markCommitted: () => evidenceScope.markCommitted(),
+    markAmbiguous: () => evidenceScope.markAmbiguous(),
+    markFailed: () => evidenceScope.markFailed(),
+    markSafeToRetry: () => evidenceScope.markSafeToRetry(),
+    safeToRetry: () => evidenceScope.safeToRetry(),
+  }
+  return Object.freeze(scope)
+}

package/src/idempotency-plugin.ts

@@ -0,0 +1,17 @@
+/**
+ * Opt-in server integration for request idempotency.
+ *
+ * Kept separate from `@nifrajs/core/server` so a bare HTTP app does not evaluate or bundle the
+ * dedupe lane. Import primitives and stores from `@nifrajs/core/idempotency`.
+ */
+export { type IdempotencyPluginOptions, idempotency } from "./server/idempotency-lane.ts"
+
+import { markRequestSafeToRetry } from "./internal/effect-execution.ts"
+
+/**
+ * Opt a concrete 5xx response into releasing its idempotency reservation, but only while the
+ * request-local effect scope still proves that no owned effect began.
+ */
+export function markIdempotencySafeToRetry(context: object): void {
+  markRequestSafeToRetry(context)
+}

package/src/index.ts

@@ -1,144 +1,17 @@
 /**
- * @nifrajs/core — Bun-native, contract-first HTTP framework.
+ * `@nifrajs/core` — Nifra's lean HTTP server API.
  *
- * The router is the perf-critical heart; the server and inline API are built on
- * the unified route descriptor.
+ * Nifra 2.0 keeps the package root intentionally lean. Optional systems live at documented
+ * subpaths so importing the root cannot activate unrelated runtimes.
  */
 
 /**
  * Current package version. A hardcoded literal on purpose — core runs on the edge (no fs), so it can't
  * read its own package.json at runtime. `scripts/version.ts` rewrites it on every release bump and
- * `check:publish` asserts it equals `@nifrajs/core`'s package version, so the literal can't go stale
- * (it shipped at "0.0.0" through 1.0.0 before those guards existed). Kept narrow (`as const`) so
- * consumers can pin it at the type level — see `test/version.test-d.ts`.
+ * `check:publish` asserts it equals `@nifrajs/core`'s package version.
  */
-export const VERSION = "1.13.0" as const
+export const VERSION = "2.1.0" as const
 
 export type Version = typeof VERSION
 
-export * from "./assurance.ts"
-export * from "./capabilities.ts"
-export * from "./causality.ts"
-export * from "./classification.ts"
-export * from "./diff.ts"
-export { FrameworkError, RouteConfigError, type RouteConfigErrorCode } from "./errors.ts"
-export * from "./idempotency.ts"
-export { FRAMEWORK_NAME, type FrameworkName } from "./internal/brand.ts"
-export * from "./invariants.ts"
-export * from "./ledger.ts"
-export * from "./manifest.ts"
-export * from "./mount.ts"
-export * from "./reflection.ts"
-export * from "./router/pattern.ts"
-export { METHODS, type Method, Router, type RouterMatch } from "./router/router.ts"
-export type {
-  InferInput,
-  InferOutput,
-  StandardIssue,
-  StandardResult,
-  StandardSchemaV1,
-  StandardTypes,
-  ValidationOutcome,
-} from "./schema/standard.ts"
-export { validateStandard } from "./schema/standard.ts"
-export {
-  type RobotsOptions,
-  type RobotsRule,
-  robots,
-  type SitemapChangeFreq,
-  type SitemapEntry,
-  type SitemapOptions,
-  sitemap,
-} from "./seo.ts"
-export type {
-  Context,
-  Params,
-  Platform,
-  Prettify,
-  ResponseControls,
-  RouteSchema,
-} from "./server/context.ts"
-export {
-  type ContextForOp,
-  type ContractShape,
-  defineContract,
-  type HandlersFor,
-  implement,
-  type OperationDef,
-  type RegistryFor,
-  type RegistryFromImpl,
-  type ResponseDef,
-} from "./server/contract.ts"
-export {
-  type CookieOptions,
-  parseCookies,
-  serializeCookie,
-  signValue,
-  unsignValue,
-} from "./server/cookies.ts"
-export {
-  commonSecretPatterns,
-  jsonLogger,
-  type LogFields,
-  type Logger,
-  type RedactOptions,
-  redactLogFields,
-  silentLogger,
-} from "./server/logger.ts"
-export type { Registry, RouteInfo } from "./server/registry.ts"
-export {
-  type AdmissionController,
-  type AdmissionDecision,
-  type AnyServer,
-  type DurableObjectNamespaceLike,
-  defineIdentityPlugin,
-  definePlugin,
-  defineRouterPlugin,
-  type ExecutionContext,
-  type Handler,
-  type IdentityPlugin,
-  type McpPromptDescriptor,
-  type McpResourceDescriptor,
-  type Middleware,
-  type NifraPlugin,
-  type NodeServeOutcome,
-  type OnRequestResult,
-  type PromptArgument,
-  type PromptMessage,
-  type ResponseFinalization,
-  type RouteDescriptor,
-  type RunningServer,
-  type ScheduledController,
-  type ScheduledHandler,
-  Server,
-  type ServerOptions,
-  server,
-  type ToolAnnotations,
-  toFetchHandler,
-} from "./server/server.ts"
-export {
-  type SSEContext,
-  type SSEInit,
-  type SSEMessage,
-  type SSEStream,
-  sse,
-  type TypedSSEStream,
-  typedSSEStream,
-} from "./server/sse.ts"
-export {
-  type SignatureEncoding,
-  type VerifyWebhookOptions,
-  verifyWebhook,
-  type WebhookFailureReason,
-  type WebhookProvider,
-  type WebhookResult,
-} from "./server/webhook.ts"
-export type {
-  NifraWebSocket,
-  StandardWebSocket,
-  WebSocketContext,
-  WebSocketData,
-  WebSocketHandler,
-  WebSocketUpgradeOutcome,
-} from "./server/websocket.ts"
-export { attachWebSocket, TopicRegistry } from "./server/websocket.ts"
+export * from "./server.ts"

package/src/internal/capability-runtime.ts

@@ -1,3 +1,6 @@
+import type { EffectLifecycleObserver } from "../effect-lifecycle.ts"
+import type { EffectCost } from "../ledger.ts"
+
 export const CAPABILITY_GUARD = Symbol("nifra.capability.guard")
 const CAPABILITY_ID = /^[a-z][a-z0-9]*(?:[.-][a-z0-9]+)*$/
 
@@ -11,11 +14,83 @@ export interface CapabilityUseEvent {
   readonly path: string
 }
 
+/** Token-only metadata supplied to an asynchronous capability admission interceptor. */
+export interface CapabilityInterceptorEvent extends CapabilityUseEvent {
+  readonly effectId: string
+  readonly signal: AbortSignal
+  readonly target?: string
+  readonly cost?: EffectCost
+  readonly digest?: string
+}
+
+/** Server-owned identity binding for durable admission. Values are opaque tokens, never payloads. */
+export interface CapabilityExecutionIdentity {
+  readonly tenantId: string
+  readonly principalId: string
+}
+
+export interface CapabilityApprovalInput extends CapabilityExecutionIdentity {
+  /** Signed token returned by the approval coordinator after the first suspended attempt. */
+  readonly resumeToken?: string
+}
+
+export interface CapabilityApprovalGate {
+  authorize(input: {
+    readonly effectId: string
+    readonly capability: string
+    readonly target?: string
+    readonly digest?: string
+    readonly identity: CapabilityExecutionIdentity
+    readonly resumeToken?: string
+    readonly signal: AbortSignal
+  }): void | PromiseLike<void>
+}
+
+/** Durable, token-only journal seam. Implementations must fail closed on transition failure. */
+export interface CapabilityExecutionJournal {
+  intent(input: {
+    readonly effectId: string
+    readonly capability: string
+    readonly target?: string
+    readonly digest?: string
+    readonly identity?: CapabilityExecutionIdentity
+  }): void | PromiseLike<void>
+  executing(effectId: string): void | PromiseLike<void>
+  committed(effectId: string): void | PromiseLike<void>
+  failed(
+    effectId: string,
+    input: { readonly began: boolean; readonly errorCode: string },
+  ): void | PromiseLike<void>
+}
+
+/** Continue to the next admission policy. The owned effect runs only after the full chain admits. */
+export type CapabilityInterceptorNext = () => Promise<void>
+
+export type CapabilityInterceptor = (
+  event: CapabilityInterceptorEvent,
+  next: CapabilityInterceptorNext,
+) => void | PromiseLike<void>
+
+export interface AroundCapabilityOptions {
+  /** Maximum admission time in milliseconds. Default 30_000. */
+  readonly timeoutMs?: number
+}
+
+export interface RegisteredCapabilityInterceptor {
+  readonly interceptor: CapabilityInterceptor
+  readonly timeoutMs: number
+}
+
+export const DEFAULT_CAPABILITY_INTERCEPTOR_TIMEOUT_MS = 30_000
+
 export interface CapabilityGuard {
   readonly allowed: readonly string[]
   readonly method: string
   readonly path: string
   readonly onUse?: (event: CapabilityUseEvent) => void
+  readonly trackEffect?: (context: object, committed: boolean) => void
+  readonly interceptors: readonly RegisteredCapabilityInterceptor[]
+  readonly observers: readonly EffectLifecycleObserver[]
 }
 
 export function normalizeRouteCapabilities(
@@ -44,6 +119,17 @@ export function createCapabilityGuard(
   method: string,
   path: string,
   onUse: ((event: CapabilityUseEvent) => void) | undefined,
+  trackEffect: ((context: object, committed: boolean) => void) | undefined,
+  interceptors: readonly RegisteredCapabilityInterceptor[],
+  observers: readonly EffectLifecycleObserver[],
 ): CapabilityGuard {
-  return Object.freeze({ allowed, method, path, ...(onUse !== undefined ? { onUse } : {}) })
+  return Object.freeze({
+    allowed,
+    method,
+    path,
+    ...(onUse !== undefined ? { onUse } : {}),
+    ...(trackEffect !== undefined ? { trackEffect } : {}),
+    interceptors,
+    observers,
+  })
 }