@prisma-next/framework-components 0.5.0-dev.66 → 0.5.0-dev.68

package/dist/runtime.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/execution/async-iterable-result.ts","../src/execution/query-plan.ts","../src/execution/runtime-error.ts","../src/execution/race-against-abort.ts","../src/execution/runtime-middleware.ts","../src/execution/run-with-middleware.ts","../src/execution/runtime-core.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"runtime.d.mts","names":[],"sources":["../src/execution/async-iterable-result.ts","../src/execution/query-plan.ts","../src/execution/runtime-error.ts","../src/execution/race-against-abort.ts","../src/execution/runtime-middleware.ts","../src/execution/run-with-middleware.ts","../src/execution/runtime-core.ts"],"mappings":"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"}

package/dist/runtime.mjs

@@ -55,7 +55,6 @@ function runtimeAborted(phase, cause) {
 	const envelope = runtimeError(RUNTIME_ABORTED, `Operation aborted during ${phase}`, { phase });
 	return Object.assign(envelope, { cause });
 }
-
 //#endregion
 //#region src/execution/async-iterable-result.ts
 var AsyncIterableResult = class {
@@ -102,7 +101,6 @@ var AsyncIterableResult = class {
 		return this.toArray().then(onfulfilled, onrejected);
 	}
 };
-
 //#endregion
 //#region src/execution/race-against-abort.ts
 /**
@@ -171,7 +169,6 @@ async function raceAgainstAbort(work, signal, phase) {
 		if (onAbort) signal.removeEventListener("abort", onAbort);
 	}
 }
-
 //#endregion
 //#region src/execution/run-with-middleware.ts
 /**
@@ -245,11 +242,11 @@ function runWithMiddleware(exec, middleware, ctx, runDriver) {
 			}
 			completed = true;
 		} catch (error) {
-			const latencyMs$1 = Date.now() - startedAt;
+			const latencyMs = Date.now() - startedAt;
 			for (const mw of middleware) if (mw.afterExecute) try {
 				await mw.afterExecute(exec, {
 					rowCount,
-					latencyMs: latencyMs$1,
+					latencyMs,
 					completed,
 					source
 				}, ctx);
@@ -266,7 +263,6 @@ function runWithMiddleware(exec, middleware, ctx, runDriver) {
 	};
 	return new AsyncIterableResult(iterator());
 }
-
 //#endregion
 //#region src/execution/runtime-core.ts
 /**
@@ -322,7 +318,6 @@ var RuntimeCore = class {
 		return new AsyncIterableResult(generator());
 	}
 };
-
 //#endregion
 //#region src/execution/runtime-middleware.ts
 function checkMiddlewareCompatibility(middleware, runtimeFamilyId, runtimeTargetId) {
@@ -341,7 +336,7 @@ function checkMiddlewareCompatibility(middleware, runtimeFamilyId, runtimeTarget
 		runtimeTargetId
 	});
 }
-
 //#endregion
 export { AsyncIterableResult, RUNTIME_ABORTED, RuntimeCore, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runWithMiddleware, runtimeAborted, runtimeError };
+
 //# sourceMappingURL=runtime.mjs.map

package/dist/runtime.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"runtime.mjs","names":["out: Row[]","sentinel: { reason: unknown }","onAbort: (() => void) | undefined","source: 'driver' | 'middleware'","rowSource: AsyncIterable<Row> | Iterable<Row> | undefined","latencyMs","codecCtx: CodecCallContext"],"sources":["../src/execution/runtime-error.ts","../src/execution/async-iterable-result.ts","../src/execution/race-against-abort.ts","../src/execution/run-with-middleware.ts","../src/execution/runtime-core.ts","../src/execution/runtime-middleware.ts"],"sourcesContent":["export interface RuntimeErrorEnvelope extends Error {\n  readonly code: string;\n  readonly category: 'PLAN' | 'CONTRACT' | 'LINT' | 'BUDGET' | 'RUNTIME';\n  readonly severity: 'error';\n  readonly details?: Record<string, unknown>;\n}\n\n/**\n * Stable code emitted by the runtime when an in-flight `execute()`\n * is cancelled via the per-query `AbortSignal`. The envelope's\n * `details.phase` distinguishes where the abort was observed:\n *\n * - `'encode'` — abort fired during `encodeParams` (SQL) or\n *   `resolveValue` (Mongo).\n * - `'decode'` — abort fired during `decodeRow` / `decodeField`.\n * - `'stream'` — abort fired between rows or before any codec call\n *   (already-aborted at entry).\n */\nexport const RUNTIME_ABORTED = 'RUNTIME.ABORTED' as const;\n\n/** Discriminator placed in `details.phase` of a `RUNTIME.ABORTED` envelope. */\nexport type RuntimeAbortedPhase = 'encode' | 'decode' | 'stream';\n\n/**\n * Type guard for the runtime-error envelope produced by `runtimeError`.\n *\n * Prefer this over duck-typing on `error.code` directly so consumers stay\n * insulated from the envelope's internal shape.\n */\nexport function isRuntimeError(error: unknown): error is RuntimeErrorEnvelope {\n  return (\n    error instanceof Error &&\n    'code' in error &&\n    typeof (error as { code?: unknown }).code === 'string' &&\n    'category' in error &&\n    'severity' in error\n  );\n}\n\nexport function runtimeError(\n  code: string,\n  message: string,\n  details?: Record<string, unknown>,\n): RuntimeErrorEnvelope {\n  const error = new Error(message) as RuntimeErrorEnvelope;\n  Object.defineProperty(error, 'name', {\n    value: 'RuntimeError',\n    configurable: true,\n  });\n\n  return Object.assign(error, {\n    code,\n    category: resolveCategory(code),\n    severity: 'error' as const,\n    message,\n    details,\n  });\n}\n\nfunction resolveCategory(code: string): RuntimeErrorEnvelope['category'] {\n  const prefix = code.split('.')[0] ?? 'RUNTIME';\n  switch (prefix) {\n    case 'PLAN':\n    case 'CONTRACT':\n    case 'LINT':\n    case 'BUDGET':\n      return prefix;\n    default:\n      return 'RUNTIME';\n  }\n}\n\n/**\n * Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the\n * abort was observed (encode / decode / stream); cause carries `signal.reason`\n * verbatim from the platform — native abort produces a `DOMException`,\n * explicit `controller.abort(reason)` produces whatever the caller passed.\n * No synthesis happens here.\n */\nexport function runtimeAborted(phase: RuntimeAbortedPhase, cause?: unknown): RuntimeErrorEnvelope {\n  const envelope = runtimeError(RUNTIME_ABORTED, `Operation aborted during ${phase}`, { phase });\n  return Object.assign(envelope, { cause });\n}\n","import { runtimeError } from './runtime-error';\n\nexport class AsyncIterableResult<Row> implements AsyncIterable<Row>, PromiseLike<Row[]> {\n  private readonly generator: AsyncGenerator<Row, void, unknown>;\n  private consumed = false;\n  private consumedBy: 'bufferedArray' | 'iterator' | undefined;\n  private bufferedArrayPromise: Promise<Row[]> | undefined;\n\n  constructor(generator: AsyncGenerator<Row, void, unknown>) {\n    this.generator = generator;\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<Row> {\n    if (this.consumed) {\n      throw runtimeError(\n        'RUNTIME.ITERATOR_CONSUMED',\n        `AsyncIterableResult iterator has already been consumed via ${this.consumedBy === 'bufferedArray' ? 'toArray()/then()' : 'for-await loop'}. Each AsyncIterableResult can only be iterated once.`,\n        {\n          consumedBy: this.consumedBy,\n          suggestion:\n            this.consumedBy === 'bufferedArray'\n              ? 'If you need to iterate multiple times, store the results from toArray() in a variable and reuse that.'\n              : 'If you need to iterate multiple times, use toArray() to collect all results first.',\n        },\n      );\n    }\n    this.consumed = true;\n    this.consumedBy = 'iterator';\n    return this.generator;\n  }\n\n  toArray(): Promise<Row[]> {\n    if (this.consumedBy === 'iterator') {\n      return Promise.reject(\n        runtimeError(\n          'RUNTIME.ITERATOR_CONSUMED',\n          'AsyncIterableResult iterator has already been consumed via for-await loop. Each AsyncIterableResult can only be iterated once.',\n          {\n            consumedBy: this.consumedBy,\n            suggestion:\n              'The iterator was already consumed by a for-await loop. Use toArray() or await the result before iterating.',\n          },\n        ),\n      );\n    }\n\n    if (this.bufferedArrayPromise) {\n      return this.bufferedArrayPromise;\n    }\n\n    this.consumed = true;\n    this.consumedBy = 'bufferedArray';\n    this.bufferedArrayPromise = (async () => {\n      const out: Row[] = [];\n      for await (const item of this.generator) {\n        out.push(item);\n      }\n      return out;\n    })();\n    return this.bufferedArrayPromise;\n  }\n\n  async first(): Promise<Row | null> {\n    const rows = await this.toArray();\n    return rows[0] ?? null;\n  }\n\n  async firstOrThrow(): Promise<Row> {\n    const row = await this.first();\n    if (row === null)\n      throw runtimeError(\n        'RUNTIME.NO_ROWS',\n        'Expected at least one row, but none were returned',\n        {},\n      );\n    return row;\n  }\n\n  // biome-ignore lint/suspicious/noThenProperty: PromiseLike implementation is intentional for await support.\n  then<TResult1 = Row[], TResult2 = never>(\n    onfulfilled?: ((value: Row[]) => TResult1 | PromiseLike<TResult1>) | undefined | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return this.toArray().then(onfulfilled, onrejected);\n  }\n}\n","import type { CodecCallContext } from '../shared/codec-types';\nimport type { RuntimeAbortedPhase } from './runtime-error';\nimport { runtimeAborted } from './runtime-error';\n\n/**\n * Throw a phase-tagged `RUNTIME.ABORTED` envelope if the supplied\n * codec-call context is already aborted at the precheck site. Centralises\n * the `if (ctx.signal?.aborted) throw runtimeAborted(...)` pattern that\n * every codec dispatch site repeats.\n */\nexport function checkAborted(ctx: CodecCallContext, phase: RuntimeAbortedPhase): void {\n  if (ctx.signal?.aborted) {\n    throw runtimeAborted(phase, ctx.signal.reason);\n  }\n}\n\n/**\n * Race a per-cell `Promise.all` (or any other in-flight work promise) against\n * the supplied abort signal so the runtime returns `RUNTIME.ABORTED` promptly\n * even when codec bodies ignore the signal. In-flight bodies that ignore the\n * signal are abandoned and run to completion in the background — the\n * cooperative-cancellation contract documented in ADR 204.\n *\n * Call sites still SHOULD pre-check `signal.aborted` and short-circuit with\n * a phase-tagged `RUNTIME.ABORTED` envelope before invoking this helper —\n * that path is the canonical \"aborted at entry\" surface and avoids\n * scheduling the work promise. As a defensive belt-and-braces, this helper\n * also handles the already-aborted case internally: `AbortSignal` does not\n * replay past abort events to listeners registered after the abort, so we\n * inspect `signal.aborted` synchronously and reject with the sentinel\n * before installing the listener. The rejection is still attributed to the\n * abort path via the sentinel-identity check.\n *\n * Distinguishing the rejection source is load-bearing for AC-ERR4\n * (`RUNTIME.ENCODE_FAILED` / `RUNTIME.DECODE_FAILED` pass through unchanged).\n * The semantically equivalent `abortable(signal)` helper in\n * `@prisma-next/utils` rejects with `signal.reason ?? new DOMException(...)`,\n * which is not stably distinguishable from a codec-thrown error by identity\n * alone (a fresh fallback DOMException is allocated per call). We instead\n * track abort attribution with a unique sentinel: only the `onAbort` listener\n * installed here ever rejects with the sentinel, so an `error === sentinel`\n * identity check after the race is unambiguous.\n *\n * Lives in `framework-components` (rather than the SQL family, where it\n * originated in m2) so every family runtime that needs cooperative\n * cancellation around a codec-dispatch `Promise.all` (SQL encode + decode\n * today, Mongo encode in m3) shares the same attribution logic.\n */\nexport async function raceAgainstAbort<T>(\n  work: Promise<T>,\n  signal: AbortSignal | undefined,\n  phase: RuntimeAbortedPhase,\n): Promise<T> {\n  if (signal === undefined) {\n    return await work;\n  }\n  const sentinel: { reason: unknown } = { reason: undefined };\n  let onAbort: (() => void) | undefined;\n\n  const abortPromise = new Promise<never>((_, reject) => {\n    if (signal.aborted) {\n      sentinel.reason = signal.reason;\n      reject(sentinel);\n      return;\n    }\n    onAbort = () => {\n      sentinel.reason = signal.reason;\n      reject(sentinel);\n    };\n    signal.addEventListener('abort', onAbort, { once: true });\n  });\n\n  try {\n    return await Promise.race([work, abortPromise]);\n  } catch (error) {\n    if (error === sentinel) {\n      throw runtimeAborted(phase, sentinel.reason);\n    }\n    throw error;\n  } finally {\n    if (onAbort) {\n      signal.removeEventListener('abort', onAbort);\n    }\n  }\n}\n","import { AsyncIterableResult } from './async-iterable-result';\nimport type { ExecutionPlan } from './query-plan';\nimport type { RuntimeMiddleware, RuntimeMiddlewareContext } from './runtime-middleware';\n\n/**\n * Drives a single execution of `runDriver()` through the middleware lifecycle.\n *\n * Lifecycle, in order:\n *  1. For each middleware in registration order: `intercept(exec, ctx)`. The\n *     first non-`undefined` result wins; subsequent middleware's `intercept`\n *     does not fire. On a hit, the runtime emits a `middleware.intercept`\n *     debug event naming the winning middleware, switches the row source to\n *     the intercepted rows, and proceeds with `source: 'middleware'`. On\n *     all-passthrough (every `intercept` returns `undefined` or is omitted),\n *     `source: 'driver'` is used and the row source is `runDriver()`.\n *  2. If `source === 'driver'`: for each middleware in registration order,\n *     `beforeExecute(exec, ctx)`. Skipped on the intercepted hit path —\n *     `beforeExecute` semantically means \"about to hit the driver\".\n *  3. Iterate the row source. On the driver path, for each row, for each\n *     middleware in registration order: `onRow(row, exec, ctx)`; then yield\n *     the row. On the intercepted hit path, `onRow` is skipped — intercepted\n *     rows did not originate from a driver row stream — but rows are still\n *     yielded to the consumer in order.\n *  4. On successful completion: for each middleware in registration order:\n *     `afterExecute(exec, { rowCount, latencyMs, completed: true, source },\n *     ctx)`.\n *  5. On any error thrown during steps 1–3: for each middleware in\n *     registration order: `afterExecute(exec, { rowCount, latencyMs,\n *     completed: false, source }, ctx)`. Errors thrown by `afterExecute`\n *     during the error path are swallowed so they do not mask the original\n *     error. The original error is then rethrown.\n *\n * The `source` field on `AfterExecuteResult` lets observers (telemetry,\n * lints, budgets) distinguish driver-served from middleware-served\n * executions without needing their own out-of-band signal.\n *\n * This helper is the single canonical implementation of the middleware\n * orchestration loop; family runtimes should not reimplement it.\n */\nexport function runWithMiddleware<TExec extends ExecutionPlan, Row>(\n  exec: TExec,\n  middleware: ReadonlyArray<RuntimeMiddleware<TExec>>,\n  ctx: RuntimeMiddlewareContext,\n  runDriver: () => AsyncIterable<Row>,\n): AsyncIterableResult<Row> {\n  const iterator = async function* (): AsyncGenerator<Row, void, unknown> {\n    const startedAt = Date.now();\n    let rowCount = 0;\n    let completed = false;\n    let source: 'driver' | 'middleware' = 'driver';\n    // Deferred so a winning interceptor can skip `runDriver()` entirely.\n    // For factories that lazily produce async generators this is a no-op,\n    // but factories that do eager work (e.g. acquiring a connection,\n    // sending a query) must not run on the intercepted hit path.\n    let rowSource: AsyncIterable<Row> | Iterable<Row> | undefined;\n\n    try {\n      for (const mw of middleware) {\n        if (!mw.intercept) {\n          continue;\n        }\n        // Mark the lifecycle as middleware-driven *before* awaiting the\n        // hook. If `intercept` throws, the catch block reports the failure\n        // as `source: 'middleware'` — the failure originated in the\n        // intercept chain, not in the driver. If `intercept` returns\n        // `undefined` (passthrough), we revert to `'driver'` and continue.\n        source = 'middleware';\n        const result = await mw.intercept(exec, ctx);\n        if (result === undefined) {\n          source = 'driver';\n          continue;\n        }\n        ctx.log.debug?.({ event: 'middleware.intercept', middleware: mw.name });\n        // The intercepted rows are typed as `Record<string, unknown>` at\n        // the SPI level; the consumer's `Row` type parameter is enforced by\n        // the caller (via the plan's phantom `_row`) the same way driver\n        // rows are. Cast through unknown to bridge the SPI shape to the\n        // caller-supplied Row.\n        rowSource = result.rows as unknown as AsyncIterable<Row> | Iterable<Row>;\n        break;\n      }\n\n      if (source === 'driver') {\n        for (const mw of middleware) {\n          if (mw.beforeExecute) {\n            await mw.beforeExecute(exec, ctx);\n          }\n        }\n        rowSource = runDriver();\n      }\n\n      // `rowSource` is always assigned by this point: either the intercepted\n      // rows (on a hit) or `runDriver()` (on the driver path).\n      for await (const row of rowSource as AsyncIterable<Row> | Iterable<Row>) {\n        if (source === 'driver') {\n          for (const mw of middleware) {\n            if (mw.onRow) {\n              await mw.onRow(row as Record<string, unknown>, exec, ctx);\n            }\n          }\n        }\n        rowCount++;\n        yield row;\n      }\n\n      completed = true;\n    } catch (error) {\n      const latencyMs = Date.now() - startedAt;\n      for (const mw of middleware) {\n        if (mw.afterExecute) {\n          try {\n            await mw.afterExecute(exec, { rowCount, latencyMs, completed, source }, ctx);\n          } catch {\n            // Swallow afterExecute errors during the error path so they do not\n            // mask the original error.\n          }\n        }\n      }\n\n      throw error;\n    }\n\n    const latencyMs = Date.now() - startedAt;\n    for (const mw of middleware) {\n      if (mw.afterExecute) {\n        await mw.afterExecute(exec, { rowCount, latencyMs, completed, source }, ctx);\n      }\n    }\n  };\n\n  return new AsyncIterableResult(iterator());\n}\n","import type { CodecCallContext } from '../shared/codec-types';\nimport { AsyncIterableResult } from './async-iterable-result';\nimport type { ExecutionPlan, QueryPlan } from './query-plan';\nimport { checkAborted } from './race-against-abort';\nimport { runWithMiddleware } from './run-with-middleware';\nimport type {\n  RuntimeExecuteOptions,\n  RuntimeExecutor,\n  RuntimeMiddleware,\n  RuntimeMiddlewareContext,\n} from './runtime-middleware';\n\n/**\n * Constructor options shared by every concrete `RuntimeCore` subclass.\n *\n * Family runtimes typically build the middleware list and the\n * `RuntimeMiddlewareContext` themselves (running compatibility checks,\n * narrowing the context's `contract` field, etc.) before calling `super`.\n */\nexport interface RuntimeCoreOptions<TMiddleware extends RuntimeMiddleware<ExecutionPlan>> {\n  readonly middleware: ReadonlyArray<TMiddleware>;\n  readonly ctx: RuntimeMiddlewareContext;\n}\n\n/**\n * Family-agnostic abstract runtime base.\n *\n * Defines the entire `execute(plan)` template in one place:\n *\n * 1. `runBeforeCompile(plan)` — concrete; defaults to identity. SQL overrides\n *    this to run its `beforeCompile` middleware-hook chain.\n * 2. `lower(plan)` — abstract. Each family produces its `*ExecutionPlan`\n *    (SQL via `lowerSqlPlan`, Mongo via `adapter.lower`).\n * 3. `runWithMiddleware(exec, this.middleware, this.ctx,\n *    () => runDriver(exec))` — concrete; lifts the middleware lifecycle\n *    out of the family runtimes into the canonical helper.\n *\n * Concrete subclasses must implement `lower`, `runDriver`, and `close`.\n *\n * The class is generic over:\n * - `TPlan` — the family's pre-lowering plan type.\n * - `TExec` — the family's post-lowering (executable) plan type.\n * - `TMiddleware` — the family's middleware type. Constrained to\n *   `RuntimeMiddleware<TExec>` because `runWithMiddleware` invokes the\n *   `beforeExecute` / `onRow` / `afterExecute` hooks with the lowered\n *   `TExec`. (The spec/plan wording \"RuntimeMiddleware<TPlan>\" is\n *   tightened to `<TExec>` here so the helper call typechecks; the\n *   intent is unchanged — middleware sees the post-lowering plan.)\n */\nexport abstract class RuntimeCore<\n  TPlan extends QueryPlan,\n  TExec extends ExecutionPlan,\n  TMiddleware extends RuntimeMiddleware<TExec>,\n> implements RuntimeExecutor<TPlan>\n{\n  protected readonly middleware: ReadonlyArray<TMiddleware>;\n  protected readonly ctx: RuntimeMiddlewareContext;\n\n  constructor(options: RuntimeCoreOptions<TMiddleware>) {\n    this.middleware = options.middleware;\n    this.ctx = options.ctx;\n  }\n\n  /**\n   * Pre-lowering hook for plan rewriting. Defaults to identity. Subclasses\n   * may override to run a `beforeCompile` middleware chain (SQL does this\n   * to support typed AST rewrites — see `before-compile-chain.ts`).\n   */\n  protected runBeforeCompile(plan: TPlan): TPlan | Promise<TPlan> {\n    return plan;\n  }\n\n  /**\n   * Lower a pre-lowering `TPlan` into the family's executable `TExec`.\n   * Family-specific: SQL produces `{ sql, params, ast?, ... }`; Mongo\n   * produces `{ command, ... }`.\n   *\n   * `ctx` carries per-query cancellation (and any future fields on\n   * `CodecCallContext`); concrete subclasses forward it to the\n   * encode-side codec dispatch site (e.g. SQL's `encodeParams` in m2,\n   * Mongo's `resolveValue` in m3). The runtime allocates one ctx per\n   * `execute()` call and threads the same reference everywhere; the\n   * `signal` field inside may be `undefined`, but the ctx object itself\n   * is always present.\n   */\n  protected abstract lower(plan: TPlan, ctx: CodecCallContext): TExec | Promise<TExec>;\n\n  /**\n   * Drive the underlying transport for a lowered `TExec`. Yields raw rows\n   * directly from the driver as `Record<string, unknown>`; codec decoding\n   * (if any) is the subclass's responsibility, applied by wrapping\n   * `execute()` rather than living inside this hook.\n   *\n   * The `Row` type parameter on `execute()` is satisfied by the caller via\n   * the plan's phantom `_row`; the runtime treats rows as opaque records\n   * here and trusts the caller's row typing.\n   */\n  protected abstract runDriver(exec: TExec): AsyncIterable<Record<string, unknown>>;\n\n  abstract close(): Promise<void>;\n\n  execute<Row>(\n    plan: TPlan & { readonly _row?: Row },\n    options?: RuntimeExecuteOptions,\n  ): AsyncIterableResult<Row> {\n    const self = this;\n    const signal = options?.signal;\n    // One ctx per execute() call. The ctx object is always allocated; the\n    // `signal` field is only included when a signal was supplied (required\n    // under exactOptionalPropertyTypes — `{ signal: undefined }` would not\n    // satisfy `signal?: AbortSignal`).\n    const codecCtx: CodecCallContext = signal === undefined ? {} : { signal };\n\n    async function* generator(): AsyncGenerator<Row, void, unknown> {\n      // Pre-check the signal at entry so an already-aborted caller observes\n      // RUNTIME.ABORTED on the first `next()` without any work being done.\n      checkAborted(codecCtx, 'stream');\n\n      const compiled = await self.runBeforeCompile(plan);\n      const exec = await self.lower(compiled, codecCtx);\n      // The driver yields raw `Record<string, unknown>`; we cast to `Row` here.\n      // The Row contract is enforced by the caller via `plan._row`.\n      yield* runWithMiddleware<TExec, Row>(\n        exec,\n        self.middleware,\n        self.ctx,\n        () => self.runDriver(exec) as AsyncIterable<Row>,\n      );\n    }\n\n    return new AsyncIterableResult(generator());\n  }\n}\n","import type { AsyncIterableResult } from './async-iterable-result';\nimport type { ExecutionPlan, QueryPlan } from './query-plan';\nimport { runtimeError } from './runtime-error';\n\nexport interface RuntimeLog {\n  info(event: unknown): void;\n  warn(event: unknown): void;\n  error(event: unknown): void;\n  debug?(event: unknown): void;\n}\n\nexport interface RuntimeMiddlewareContext {\n  readonly contract: unknown;\n  readonly mode: 'strict' | 'permissive';\n  readonly now: () => number;\n  readonly log: RuntimeLog;\n  /**\n   * Returns a stable string identifying the (storage, statement, params)\n   * tuple of an execution. Two semantically equivalent executions return\n   * the same string. Used by middleware that need per-execution identity\n   * (caching, request coalescing).\n   *\n   * The family runtime owns the implementation:\n   * - SQL: `meta.storageHash` + `exec.sql` + `canonicalStringify(exec.params)`\n   * - Mongo: `meta.storageHash` + `canonicalStringify({ ...exec.command })`\n   *\n   * The method is `async` because the underlying digest helper\n   * (`hashContent`) uses the WebCrypto API, whose `crypto.subtle.digest`\n   * primitive is asynchronous by design.\n   *\n   * The returned string is intended to be consumed directly as a `Map` key\n   * — it is not (and should not be) further hashed by callers.\n   */\n  contentHash(exec: ExecutionPlan): Promise<string>;\n}\n\nexport interface AfterExecuteResult {\n  readonly rowCount: number;\n  readonly latencyMs: number;\n  readonly completed: boolean;\n  /**\n   * Indicates where the rows observed during this execution came from.\n   *\n   * - `'driver'` — the default. Rows came from the underlying driver via\n   *   `runDriver` / `runWithMiddleware`'s normal path.\n   * - `'middleware'` — a `RuntimeMiddleware.intercept` hook short-circuited\n   *   execution and supplied the rows directly. The driver was not invoked.\n   *\n   * Observers (telemetry, lints, budgets) that need to distinguish between\n   * driver-served and middleware-served executions read this field.\n   * Observers that don't care can ignore it.\n   */\n  readonly source: 'driver' | 'middleware';\n}\n\n/**\n * Result of a successful `RuntimeMiddleware.intercept` hook.\n *\n * Carries the rows that the middleware wishes to return in place of\n * invoking the driver. The runtime iterates `rows` in order and yields\n * each row to the consumer; `beforeExecute`, `runDriver`, and `onRow` are\n * all skipped on the hit path. `afterExecute` still fires with\n * `source: 'middleware'`.\n *\n * `rows` accepts both `Iterable` (arrays, sync generators) and\n * `AsyncIterable` (async generators). `for await` natively handles both\n * via `Symbol.asyncIterator` / `Symbol.iterator` fallback, so the\n * orchestrator does not need to branch on the variant. Cached arrays in\n * the cache middleware are the common case; streaming variants support\n * future use cases like mock layers replaying recordings.\n *\n * Row shape is `Record<string, unknown>` — the same untyped shape\n * `onRow` receives. The SQL runtime decodes intercepted rows through its\n * normal codec pass, so interceptors cache and return raw (undecoded)\n * rows.\n */\nexport interface InterceptResult {\n  readonly rows: AsyncIterable<Record<string, unknown>> | Iterable<Record<string, unknown>>;\n}\n\n/**\n * Family-agnostic middleware SPI parameterized over the plan marker.\n *\n * `TPlan` defaults to the framework `QueryPlan` marker so a generic\n * middleware (e.g. cross-family telemetry) can be authored without\n * naming a family. Family-specific middleware (`SqlMiddleware`,\n * `MongoMiddleware`) narrow `TPlan` to their concrete plan type.\n */\nexport interface RuntimeMiddleware<TPlan extends QueryPlan = QueryPlan> {\n  readonly name: string;\n  readonly familyId?: string;\n  readonly targetId?: string;\n  /**\n   * Optional short-circuit hook. Runs inside `runWithMiddleware`, after\n   * the orchestrator receives the lowered plan and before any\n   * `beforeExecute` hook fires. Middleware run in registration order; the\n   * first to return a non-`undefined` `InterceptResult` wins, and\n   * subsequent middleware's `intercept` does not fire.\n   *\n   * On a hit, `beforeExecute`, `runDriver`, and `onRow` are all skipped.\n   * `afterExecute` still fires with `source: 'middleware'`.\n   *\n   * Returning `undefined` (or omitting the hook entirely) signals\n   * passthrough — execution proceeds through the normal driver path.\n   *\n   * Errors thrown inside `intercept` are rethrown by `runWithMiddleware`\n   * as the original `Error` — no envelope is guaranteed at this layer.\n   * Before rethrowing, `afterExecute` fires with `completed: false` and\n   * `source: 'middleware'`. Errors thrown by `afterExecute` during the\n   * error path remain swallowed (existing semantics, unchanged).\n   *\n   * Used by middleware that need to short-circuit execution and supply\n   * rows directly: caching, mocks, rate limiting, circuit breaking.\n   */\n  intercept?(plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<InterceptResult | undefined>;\n  beforeExecute?(plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<void>;\n  onRow?(row: Record<string, unknown>, plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<void>;\n  afterExecute?(\n    plan: TPlan,\n    result: AfterExecuteResult,\n    ctx: RuntimeMiddlewareContext,\n  ): Promise<void>;\n}\n\n/**\n * Optional per-`execute` options accepted by every family runtime.\n *\n * `signal` is the per-query cancellation signal. The runtime threads the\n * signal through to every codec call for the query and uses it to short-\n * circuit the row stream with `RUNTIME.ABORTED` when the caller aborts.\n * Omitting the option (or passing `undefined`) preserves today's behavior\n * bit-for-bit.\n */\nexport interface RuntimeExecuteOptions {\n  readonly signal?: AbortSignal;\n}\n\n/**\n * Cross-family SPI for any runtime that can execute plans and be shut down.\n * Each family runtime (SQL, Mongo) satisfies this interface — SQL nominally,\n * Mongo structurally (due to its phantom Row parameter using a unique symbol).\n *\n * The `_row` intersection on `execute` connects the `Row` type parameter to the\n * plan, mirroring how `QueryPlan<Row>` carries a phantom `_row?: Row`.\n */\nexport interface RuntimeExecutor<TPlan extends QueryPlan> {\n  execute<Row>(\n    plan: TPlan & { readonly _row?: Row },\n    options?: RuntimeExecuteOptions,\n  ): AsyncIterableResult<Row>;\n  close(): Promise<void>;\n}\n\nexport function checkMiddlewareCompatibility(\n  middleware: RuntimeMiddleware,\n  runtimeFamilyId: string,\n  runtimeTargetId: string,\n): void {\n  if (middleware.targetId !== undefined && middleware.familyId === undefined) {\n    throw runtimeError(\n      'RUNTIME.MIDDLEWARE_INCOMPATIBLE',\n      `Middleware '${middleware.name}' specifies targetId '${middleware.targetId}' without familyId`,\n      { middleware: middleware.name, targetId: middleware.targetId },\n    );\n  }\n\n  if (middleware.familyId !== undefined && middleware.familyId !== runtimeFamilyId) {\n    throw runtimeError(\n      'RUNTIME.MIDDLEWARE_FAMILY_MISMATCH',\n      `Middleware '${middleware.name}' requires family '${middleware.familyId}' but the runtime is configured for family '${runtimeFamilyId}'`,\n      { middleware: middleware.name, middlewareFamilyId: middleware.familyId, runtimeFamilyId },\n    );\n  }\n\n  if (middleware.targetId !== undefined && middleware.targetId !== runtimeTargetId) {\n    throw runtimeError(\n      'RUNTIME.MIDDLEWARE_TARGET_MISMATCH',\n      `Middleware '${middleware.name}' requires target '${middleware.targetId}' but the runtime is configured for target '${runtimeTargetId}'`,\n      { middleware: middleware.name, middlewareTargetId: middleware.targetId, runtimeTargetId },\n    );\n  }\n}\n"],"mappings":"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"}
+{"version":3,"file":"runtime.mjs","names":[],"sources":["../src/execution/runtime-error.ts","../src/execution/async-iterable-result.ts","../src/execution/race-against-abort.ts","../src/execution/run-with-middleware.ts","../src/execution/runtime-core.ts","../src/execution/runtime-middleware.ts"],"sourcesContent":["export interface RuntimeErrorEnvelope extends Error {\n  readonly code: string;\n  readonly category: 'PLAN' | 'CONTRACT' | 'LINT' | 'BUDGET' | 'RUNTIME';\n  readonly severity: 'error';\n  readonly details?: Record<string, unknown>;\n}\n\n/**\n * Stable code emitted by the runtime when an in-flight `execute()`\n * is cancelled via the per-query `AbortSignal`. The envelope's\n * `details.phase` distinguishes where the abort was observed:\n *\n * - `'encode'` — abort fired during `encodeParams` (SQL) or\n *   `resolveValue` (Mongo).\n * - `'decode'` — abort fired during `decodeRow` / `decodeField`.\n * - `'stream'` — abort fired between rows or before any codec call\n *   (already-aborted at entry).\n */\nexport const RUNTIME_ABORTED = 'RUNTIME.ABORTED' as const;\n\n/** Discriminator placed in `details.phase` of a `RUNTIME.ABORTED` envelope. */\nexport type RuntimeAbortedPhase = 'encode' | 'decode' | 'stream';\n\n/**\n * Type guard for the runtime-error envelope produced by `runtimeError`.\n *\n * Prefer this over duck-typing on `error.code` directly so consumers stay\n * insulated from the envelope's internal shape.\n */\nexport function isRuntimeError(error: unknown): error is RuntimeErrorEnvelope {\n  return (\n    error instanceof Error &&\n    'code' in error &&\n    typeof (error as { code?: unknown }).code === 'string' &&\n    'category' in error &&\n    'severity' in error\n  );\n}\n\nexport function runtimeError(\n  code: string,\n  message: string,\n  details?: Record<string, unknown>,\n): RuntimeErrorEnvelope {\n  const error = new Error(message) as RuntimeErrorEnvelope;\n  Object.defineProperty(error, 'name', {\n    value: 'RuntimeError',\n    configurable: true,\n  });\n\n  return Object.assign(error, {\n    code,\n    category: resolveCategory(code),\n    severity: 'error' as const,\n    message,\n    details,\n  });\n}\n\nfunction resolveCategory(code: string): RuntimeErrorEnvelope['category'] {\n  const prefix = code.split('.')[0] ?? 'RUNTIME';\n  switch (prefix) {\n    case 'PLAN':\n    case 'CONTRACT':\n    case 'LINT':\n    case 'BUDGET':\n      return prefix;\n    default:\n      return 'RUNTIME';\n  }\n}\n\n/**\n * Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the\n * abort was observed (encode / decode / stream); cause carries `signal.reason`\n * verbatim from the platform — native abort produces a `DOMException`,\n * explicit `controller.abort(reason)` produces whatever the caller passed.\n * No synthesis happens here.\n */\nexport function runtimeAborted(phase: RuntimeAbortedPhase, cause?: unknown): RuntimeErrorEnvelope {\n  const envelope = runtimeError(RUNTIME_ABORTED, `Operation aborted during ${phase}`, { phase });\n  return Object.assign(envelope, { cause });\n}\n","import { runtimeError } from './runtime-error';\n\nexport class AsyncIterableResult<Row> implements AsyncIterable<Row>, PromiseLike<Row[]> {\n  private readonly generator: AsyncGenerator<Row, void, unknown>;\n  private consumed = false;\n  private consumedBy: 'bufferedArray' | 'iterator' | undefined;\n  private bufferedArrayPromise: Promise<Row[]> | undefined;\n\n  constructor(generator: AsyncGenerator<Row, void, unknown>) {\n    this.generator = generator;\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<Row> {\n    if (this.consumed) {\n      throw runtimeError(\n        'RUNTIME.ITERATOR_CONSUMED',\n        `AsyncIterableResult iterator has already been consumed via ${this.consumedBy === 'bufferedArray' ? 'toArray()/then()' : 'for-await loop'}. Each AsyncIterableResult can only be iterated once.`,\n        {\n          consumedBy: this.consumedBy,\n          suggestion:\n            this.consumedBy === 'bufferedArray'\n              ? 'If you need to iterate multiple times, store the results from toArray() in a variable and reuse that.'\n              : 'If you need to iterate multiple times, use toArray() to collect all results first.',\n        },\n      );\n    }\n    this.consumed = true;\n    this.consumedBy = 'iterator';\n    return this.generator;\n  }\n\n  toArray(): Promise<Row[]> {\n    if (this.consumedBy === 'iterator') {\n      return Promise.reject(\n        runtimeError(\n          'RUNTIME.ITERATOR_CONSUMED',\n          'AsyncIterableResult iterator has already been consumed via for-await loop. Each AsyncIterableResult can only be iterated once.',\n          {\n            consumedBy: this.consumedBy,\n            suggestion:\n              'The iterator was already consumed by a for-await loop. Use toArray() or await the result before iterating.',\n          },\n        ),\n      );\n    }\n\n    if (this.bufferedArrayPromise) {\n      return this.bufferedArrayPromise;\n    }\n\n    this.consumed = true;\n    this.consumedBy = 'bufferedArray';\n    this.bufferedArrayPromise = (async () => {\n      const out: Row[] = [];\n      for await (const item of this.generator) {\n        out.push(item);\n      }\n      return out;\n    })();\n    return this.bufferedArrayPromise;\n  }\n\n  async first(): Promise<Row | null> {\n    const rows = await this.toArray();\n    return rows[0] ?? null;\n  }\n\n  async firstOrThrow(): Promise<Row> {\n    const row = await this.first();\n    if (row === null)\n      throw runtimeError(\n        'RUNTIME.NO_ROWS',\n        'Expected at least one row, but none were returned',\n        {},\n      );\n    return row;\n  }\n\n  // biome-ignore lint/suspicious/noThenProperty: PromiseLike implementation is intentional for await support.\n  then<TResult1 = Row[], TResult2 = never>(\n    onfulfilled?: ((value: Row[]) => TResult1 | PromiseLike<TResult1>) | undefined | null,\n    onrejected?: ((reason: unknown) => TResult2 | PromiseLike<TResult2>) | undefined | null,\n  ): PromiseLike<TResult1 | TResult2> {\n    return this.toArray().then(onfulfilled, onrejected);\n  }\n}\n","import type { CodecCallContext } from '../shared/codec-types';\nimport type { RuntimeAbortedPhase } from './runtime-error';\nimport { runtimeAborted } from './runtime-error';\n\n/**\n * Throw a phase-tagged `RUNTIME.ABORTED` envelope if the supplied\n * codec-call context is already aborted at the precheck site. Centralises\n * the `if (ctx.signal?.aborted) throw runtimeAborted(...)` pattern that\n * every codec dispatch site repeats.\n */\nexport function checkAborted(ctx: CodecCallContext, phase: RuntimeAbortedPhase): void {\n  if (ctx.signal?.aborted) {\n    throw runtimeAborted(phase, ctx.signal.reason);\n  }\n}\n\n/**\n * Race a per-cell `Promise.all` (or any other in-flight work promise) against\n * the supplied abort signal so the runtime returns `RUNTIME.ABORTED` promptly\n * even when codec bodies ignore the signal. In-flight bodies that ignore the\n * signal are abandoned and run to completion in the background — the\n * cooperative-cancellation contract documented in ADR 204.\n *\n * Call sites still SHOULD pre-check `signal.aborted` and short-circuit with\n * a phase-tagged `RUNTIME.ABORTED` envelope before invoking this helper —\n * that path is the canonical \"aborted at entry\" surface and avoids\n * scheduling the work promise. As a defensive belt-and-braces, this helper\n * also handles the already-aborted case internally: `AbortSignal` does not\n * replay past abort events to listeners registered after the abort, so we\n * inspect `signal.aborted` synchronously and reject with the sentinel\n * before installing the listener. The rejection is still attributed to the\n * abort path via the sentinel-identity check.\n *\n * Distinguishing the rejection source is load-bearing for AC-ERR4\n * (`RUNTIME.ENCODE_FAILED` / `RUNTIME.DECODE_FAILED` pass through unchanged).\n * The semantically equivalent `abortable(signal)` helper in\n * `@prisma-next/utils` rejects with `signal.reason ?? new DOMException(...)`,\n * which is not stably distinguishable from a codec-thrown error by identity\n * alone (a fresh fallback DOMException is allocated per call). We instead\n * track abort attribution with a unique sentinel: only the `onAbort` listener\n * installed here ever rejects with the sentinel, so an `error === sentinel`\n * identity check after the race is unambiguous.\n *\n * Lives in `framework-components` (rather than the SQL family, where it\n * originated in m2) so every family runtime that needs cooperative\n * cancellation around a codec-dispatch `Promise.all` (SQL encode + decode\n * today, Mongo encode in m3) shares the same attribution logic.\n */\nexport async function raceAgainstAbort<T>(\n  work: Promise<T>,\n  signal: AbortSignal | undefined,\n  phase: RuntimeAbortedPhase,\n): Promise<T> {\n  if (signal === undefined) {\n    return await work;\n  }\n  const sentinel: { reason: unknown } = { reason: undefined };\n  let onAbort: (() => void) | undefined;\n\n  const abortPromise = new Promise<never>((_, reject) => {\n    if (signal.aborted) {\n      sentinel.reason = signal.reason;\n      reject(sentinel);\n      return;\n    }\n    onAbort = () => {\n      sentinel.reason = signal.reason;\n      reject(sentinel);\n    };\n    signal.addEventListener('abort', onAbort, { once: true });\n  });\n\n  try {\n    return await Promise.race([work, abortPromise]);\n  } catch (error) {\n    if (error === sentinel) {\n      throw runtimeAborted(phase, sentinel.reason);\n    }\n    throw error;\n  } finally {\n    if (onAbort) {\n      signal.removeEventListener('abort', onAbort);\n    }\n  }\n}\n","import { AsyncIterableResult } from './async-iterable-result';\nimport type { ExecutionPlan } from './query-plan';\nimport type { RuntimeMiddleware, RuntimeMiddlewareContext } from './runtime-middleware';\n\n/**\n * Drives a single execution of `runDriver()` through the middleware lifecycle.\n *\n * Lifecycle, in order:\n *  1. For each middleware in registration order: `intercept(exec, ctx)`. The\n *     first non-`undefined` result wins; subsequent middleware's `intercept`\n *     does not fire. On a hit, the runtime emits a `middleware.intercept`\n *     debug event naming the winning middleware, switches the row source to\n *     the intercepted rows, and proceeds with `source: 'middleware'`. On\n *     all-passthrough (every `intercept` returns `undefined` or is omitted),\n *     `source: 'driver'` is used and the row source is `runDriver()`.\n *  2. If `source === 'driver'`: for each middleware in registration order,\n *     `beforeExecute(exec, ctx)`. Skipped on the intercepted hit path —\n *     `beforeExecute` semantically means \"about to hit the driver\".\n *  3. Iterate the row source. On the driver path, for each row, for each\n *     middleware in registration order: `onRow(row, exec, ctx)`; then yield\n *     the row. On the intercepted hit path, `onRow` is skipped — intercepted\n *     rows did not originate from a driver row stream — but rows are still\n *     yielded to the consumer in order.\n *  4. On successful completion: for each middleware in registration order:\n *     `afterExecute(exec, { rowCount, latencyMs, completed: true, source },\n *     ctx)`.\n *  5. On any error thrown during steps 1–3: for each middleware in\n *     registration order: `afterExecute(exec, { rowCount, latencyMs,\n *     completed: false, source }, ctx)`. Errors thrown by `afterExecute`\n *     during the error path are swallowed so they do not mask the original\n *     error. The original error is then rethrown.\n *\n * The `source` field on `AfterExecuteResult` lets observers (telemetry,\n * lints, budgets) distinguish driver-served from middleware-served\n * executions without needing their own out-of-band signal.\n *\n * This helper is the single canonical implementation of the middleware\n * orchestration loop; family runtimes should not reimplement it.\n */\nexport function runWithMiddleware<TExec extends ExecutionPlan, Row>(\n  exec: TExec,\n  middleware: ReadonlyArray<RuntimeMiddleware<TExec>>,\n  ctx: RuntimeMiddlewareContext,\n  runDriver: () => AsyncIterable<Row>,\n): AsyncIterableResult<Row> {\n  const iterator = async function* (): AsyncGenerator<Row, void, unknown> {\n    const startedAt = Date.now();\n    let rowCount = 0;\n    let completed = false;\n    let source: 'driver' | 'middleware' = 'driver';\n    // Deferred so a winning interceptor can skip `runDriver()` entirely.\n    // For factories that lazily produce async generators this is a no-op,\n    // but factories that do eager work (e.g. acquiring a connection,\n    // sending a query) must not run on the intercepted hit path.\n    let rowSource: AsyncIterable<Row> | Iterable<Row> | undefined;\n\n    try {\n      for (const mw of middleware) {\n        if (!mw.intercept) {\n          continue;\n        }\n        // Mark the lifecycle as middleware-driven *before* awaiting the\n        // hook. If `intercept` throws, the catch block reports the failure\n        // as `source: 'middleware'` — the failure originated in the\n        // intercept chain, not in the driver. If `intercept` returns\n        // `undefined` (passthrough), we revert to `'driver'` and continue.\n        source = 'middleware';\n        const result = await mw.intercept(exec, ctx);\n        if (result === undefined) {\n          source = 'driver';\n          continue;\n        }\n        ctx.log.debug?.({ event: 'middleware.intercept', middleware: mw.name });\n        // The intercepted rows are typed as `Record<string, unknown>` at\n        // the SPI level; the consumer's `Row` type parameter is enforced by\n        // the caller (via the plan's phantom `_row`) the same way driver\n        // rows are. Cast through unknown to bridge the SPI shape to the\n        // caller-supplied Row.\n        rowSource = result.rows as unknown as AsyncIterable<Row> | Iterable<Row>;\n        break;\n      }\n\n      if (source === 'driver') {\n        for (const mw of middleware) {\n          if (mw.beforeExecute) {\n            await mw.beforeExecute(exec, ctx);\n          }\n        }\n        rowSource = runDriver();\n      }\n\n      // `rowSource` is always assigned by this point: either the intercepted\n      // rows (on a hit) or `runDriver()` (on the driver path).\n      for await (const row of rowSource as AsyncIterable<Row> | Iterable<Row>) {\n        if (source === 'driver') {\n          for (const mw of middleware) {\n            if (mw.onRow) {\n              await mw.onRow(row as Record<string, unknown>, exec, ctx);\n            }\n          }\n        }\n        rowCount++;\n        yield row;\n      }\n\n      completed = true;\n    } catch (error) {\n      const latencyMs = Date.now() - startedAt;\n      for (const mw of middleware) {\n        if (mw.afterExecute) {\n          try {\n            await mw.afterExecute(exec, { rowCount, latencyMs, completed, source }, ctx);\n          } catch {\n            // Swallow afterExecute errors during the error path so they do not\n            // mask the original error.\n          }\n        }\n      }\n\n      throw error;\n    }\n\n    const latencyMs = Date.now() - startedAt;\n    for (const mw of middleware) {\n      if (mw.afterExecute) {\n        await mw.afterExecute(exec, { rowCount, latencyMs, completed, source }, ctx);\n      }\n    }\n  };\n\n  return new AsyncIterableResult(iterator());\n}\n","import type { CodecCallContext } from '../shared/codec-types';\nimport { AsyncIterableResult } from './async-iterable-result';\nimport type { ExecutionPlan, QueryPlan } from './query-plan';\nimport { checkAborted } from './race-against-abort';\nimport { runWithMiddleware } from './run-with-middleware';\nimport type {\n  RuntimeExecuteOptions,\n  RuntimeExecutor,\n  RuntimeMiddleware,\n  RuntimeMiddlewareContext,\n} from './runtime-middleware';\n\n/**\n * Constructor options shared by every concrete `RuntimeCore` subclass.\n *\n * Family runtimes typically build the middleware list and the\n * `RuntimeMiddlewareContext` themselves (running compatibility checks,\n * narrowing the context's `contract` field, etc.) before calling `super`.\n */\nexport interface RuntimeCoreOptions<TMiddleware extends RuntimeMiddleware<ExecutionPlan>> {\n  readonly middleware: ReadonlyArray<TMiddleware>;\n  readonly ctx: RuntimeMiddlewareContext;\n}\n\n/**\n * Family-agnostic abstract runtime base.\n *\n * Defines the entire `execute(plan)` template in one place:\n *\n * 1. `runBeforeCompile(plan)` — concrete; defaults to identity. SQL overrides\n *    this to run its `beforeCompile` middleware-hook chain.\n * 2. `lower(plan)` — abstract. Each family produces its `*ExecutionPlan`\n *    (SQL via `lowerSqlPlan`, Mongo via `adapter.lower`).\n * 3. `runWithMiddleware(exec, this.middleware, this.ctx,\n *    () => runDriver(exec))` — concrete; lifts the middleware lifecycle\n *    out of the family runtimes into the canonical helper.\n *\n * Concrete subclasses must implement `lower`, `runDriver`, and `close`.\n *\n * The class is generic over:\n * - `TPlan` — the family's pre-lowering plan type.\n * - `TExec` — the family's post-lowering (executable) plan type.\n * - `TMiddleware` — the family's middleware type. Constrained to\n *   `RuntimeMiddleware<TExec>` because `runWithMiddleware` invokes the\n *   `beforeExecute` / `onRow` / `afterExecute` hooks with the lowered\n *   `TExec`. (The spec/plan wording \"RuntimeMiddleware<TPlan>\" is\n *   tightened to `<TExec>` here so the helper call typechecks; the\n *   intent is unchanged — middleware sees the post-lowering plan.)\n */\nexport abstract class RuntimeCore<\n  TPlan extends QueryPlan,\n  TExec extends ExecutionPlan,\n  TMiddleware extends RuntimeMiddleware<TExec>,\n> implements RuntimeExecutor<TPlan>\n{\n  protected readonly middleware: ReadonlyArray<TMiddleware>;\n  protected readonly ctx: RuntimeMiddlewareContext;\n\n  constructor(options: RuntimeCoreOptions<TMiddleware>) {\n    this.middleware = options.middleware;\n    this.ctx = options.ctx;\n  }\n\n  /**\n   * Pre-lowering hook for plan rewriting. Defaults to identity. Subclasses\n   * may override to run a `beforeCompile` middleware chain (SQL does this\n   * to support typed AST rewrites — see `before-compile-chain.ts`).\n   */\n  protected runBeforeCompile(plan: TPlan): TPlan | Promise<TPlan> {\n    return plan;\n  }\n\n  /**\n   * Lower a pre-lowering `TPlan` into the family's executable `TExec`.\n   * Family-specific: SQL produces `{ sql, params, ast?, ... }`; Mongo\n   * produces `{ command, ... }`.\n   *\n   * `ctx` carries per-query cancellation (and any future fields on\n   * `CodecCallContext`); concrete subclasses forward it to the\n   * encode-side codec dispatch site (e.g. SQL's `encodeParams` in m2,\n   * Mongo's `resolveValue` in m3). The runtime allocates one ctx per\n   * `execute()` call and threads the same reference everywhere; the\n   * `signal` field inside may be `undefined`, but the ctx object itself\n   * is always present.\n   */\n  protected abstract lower(plan: TPlan, ctx: CodecCallContext): TExec | Promise<TExec>;\n\n  /**\n   * Drive the underlying transport for a lowered `TExec`. Yields raw rows\n   * directly from the driver as `Record<string, unknown>`; codec decoding\n   * (if any) is the subclass's responsibility, applied by wrapping\n   * `execute()` rather than living inside this hook.\n   *\n   * The `Row` type parameter on `execute()` is satisfied by the caller via\n   * the plan's phantom `_row`; the runtime treats rows as opaque records\n   * here and trusts the caller's row typing.\n   */\n  protected abstract runDriver(exec: TExec): AsyncIterable<Record<string, unknown>>;\n\n  abstract close(): Promise<void>;\n\n  execute<Row>(\n    plan: TPlan & { readonly _row?: Row },\n    options?: RuntimeExecuteOptions,\n  ): AsyncIterableResult<Row> {\n    const self = this;\n    const signal = options?.signal;\n    // One ctx per execute() call. The ctx object is always allocated; the\n    // `signal` field is only included when a signal was supplied (required\n    // under exactOptionalPropertyTypes — `{ signal: undefined }` would not\n    // satisfy `signal?: AbortSignal`).\n    const codecCtx: CodecCallContext = signal === undefined ? {} : { signal };\n\n    async function* generator(): AsyncGenerator<Row, void, unknown> {\n      // Pre-check the signal at entry so an already-aborted caller observes\n      // RUNTIME.ABORTED on the first `next()` without any work being done.\n      checkAborted(codecCtx, 'stream');\n\n      const compiled = await self.runBeforeCompile(plan);\n      const exec = await self.lower(compiled, codecCtx);\n      // The driver yields raw `Record<string, unknown>`; we cast to `Row` here.\n      // The Row contract is enforced by the caller via `plan._row`.\n      yield* runWithMiddleware<TExec, Row>(\n        exec,\n        self.middleware,\n        self.ctx,\n        () => self.runDriver(exec) as AsyncIterable<Row>,\n      );\n    }\n\n    return new AsyncIterableResult(generator());\n  }\n}\n","import type { AsyncIterableResult } from './async-iterable-result';\nimport type { ExecutionPlan, QueryPlan } from './query-plan';\nimport { runtimeError } from './runtime-error';\n\nexport interface RuntimeLog {\n  info(event: unknown): void;\n  warn(event: unknown): void;\n  error(event: unknown): void;\n  debug?(event: unknown): void;\n}\n\nexport interface RuntimeMiddlewareContext {\n  readonly contract: unknown;\n  readonly mode: 'strict' | 'permissive';\n  readonly now: () => number;\n  readonly log: RuntimeLog;\n  /**\n   * Returns a stable string identifying the (storage, statement, params)\n   * tuple of an execution. Two semantically equivalent executions return\n   * the same string. Used by middleware that need per-execution identity\n   * (caching, request coalescing).\n   *\n   * The family runtime owns the implementation:\n   * - SQL: `meta.storageHash` + `exec.sql` + `canonicalStringify(exec.params)`\n   * - Mongo: `meta.storageHash` + `canonicalStringify({ ...exec.command })`\n   *\n   * The method is `async` because the underlying digest helper\n   * (`hashContent`) uses the WebCrypto API, whose `crypto.subtle.digest`\n   * primitive is asynchronous by design.\n   *\n   * The returned string is intended to be consumed directly as a `Map` key\n   * — it is not (and should not be) further hashed by callers.\n   */\n  contentHash(exec: ExecutionPlan): Promise<string>;\n}\n\nexport interface AfterExecuteResult {\n  readonly rowCount: number;\n  readonly latencyMs: number;\n  readonly completed: boolean;\n  /**\n   * Indicates where the rows observed during this execution came from.\n   *\n   * - `'driver'` — the default. Rows came from the underlying driver via\n   *   `runDriver` / `runWithMiddleware`'s normal path.\n   * - `'middleware'` — a `RuntimeMiddleware.intercept` hook short-circuited\n   *   execution and supplied the rows directly. The driver was not invoked.\n   *\n   * Observers (telemetry, lints, budgets) that need to distinguish between\n   * driver-served and middleware-served executions read this field.\n   * Observers that don't care can ignore it.\n   */\n  readonly source: 'driver' | 'middleware';\n}\n\n/**\n * Result of a successful `RuntimeMiddleware.intercept` hook.\n *\n * Carries the rows that the middleware wishes to return in place of\n * invoking the driver. The runtime iterates `rows` in order and yields\n * each row to the consumer; `beforeExecute`, `runDriver`, and `onRow` are\n * all skipped on the hit path. `afterExecute` still fires with\n * `source: 'middleware'`.\n *\n * `rows` accepts both `Iterable` (arrays, sync generators) and\n * `AsyncIterable` (async generators). `for await` natively handles both\n * via `Symbol.asyncIterator` / `Symbol.iterator` fallback, so the\n * orchestrator does not need to branch on the variant. Cached arrays in\n * the cache middleware are the common case; streaming variants support\n * future use cases like mock layers replaying recordings.\n *\n * Row shape is `Record<string, unknown>` — the same untyped shape\n * `onRow` receives. The SQL runtime decodes intercepted rows through its\n * normal codec pass, so interceptors cache and return raw (undecoded)\n * rows.\n */\nexport interface InterceptResult {\n  readonly rows: AsyncIterable<Record<string, unknown>> | Iterable<Record<string, unknown>>;\n}\n\n/**\n * Family-agnostic middleware SPI parameterized over the plan marker.\n *\n * `TPlan` defaults to the framework `QueryPlan` marker so a generic\n * middleware (e.g. cross-family telemetry) can be authored without\n * naming a family. Family-specific middleware (`SqlMiddleware`,\n * `MongoMiddleware`) narrow `TPlan` to their concrete plan type.\n */\nexport interface RuntimeMiddleware<TPlan extends QueryPlan = QueryPlan> {\n  readonly name: string;\n  readonly familyId?: string;\n  readonly targetId?: string;\n  /**\n   * Optional short-circuit hook. Runs inside `runWithMiddleware`, after\n   * the orchestrator receives the lowered plan and before any\n   * `beforeExecute` hook fires. Middleware run in registration order; the\n   * first to return a non-`undefined` `InterceptResult` wins, and\n   * subsequent middleware's `intercept` does not fire.\n   *\n   * On a hit, `beforeExecute`, `runDriver`, and `onRow` are all skipped.\n   * `afterExecute` still fires with `source: 'middleware'`.\n   *\n   * Returning `undefined` (or omitting the hook entirely) signals\n   * passthrough — execution proceeds through the normal driver path.\n   *\n   * Errors thrown inside `intercept` are rethrown by `runWithMiddleware`\n   * as the original `Error` — no envelope is guaranteed at this layer.\n   * Before rethrowing, `afterExecute` fires with `completed: false` and\n   * `source: 'middleware'`. Errors thrown by `afterExecute` during the\n   * error path remain swallowed (existing semantics, unchanged).\n   *\n   * Used by middleware that need to short-circuit execution and supply\n   * rows directly: caching, mocks, rate limiting, circuit breaking.\n   */\n  intercept?(plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<InterceptResult | undefined>;\n  beforeExecute?(plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<void>;\n  onRow?(row: Record<string, unknown>, plan: TPlan, ctx: RuntimeMiddlewareContext): Promise<void>;\n  afterExecute?(\n    plan: TPlan,\n    result: AfterExecuteResult,\n    ctx: RuntimeMiddlewareContext,\n  ): Promise<void>;\n}\n\n/**\n * Optional per-`execute` options accepted by every family runtime.\n *\n * `signal` is the per-query cancellation signal. The runtime threads the\n * signal through to every codec call for the query and uses it to short-\n * circuit the row stream with `RUNTIME.ABORTED` when the caller aborts.\n * Omitting the option (or passing `undefined`) preserves today's behavior\n * bit-for-bit.\n */\nexport interface RuntimeExecuteOptions {\n  readonly signal?: AbortSignal;\n}\n\n/**\n * Cross-family SPI for any runtime that can execute plans and be shut down.\n * Each family runtime (SQL, Mongo) satisfies this interface — SQL nominally,\n * Mongo structurally (due to its phantom Row parameter using a unique symbol).\n *\n * The `_row` intersection on `execute` connects the `Row` type parameter to the\n * plan, mirroring how `QueryPlan<Row>` carries a phantom `_row?: Row`.\n */\nexport interface RuntimeExecutor<TPlan extends QueryPlan> {\n  execute<Row>(\n    plan: TPlan & { readonly _row?: Row },\n    options?: RuntimeExecuteOptions,\n  ): AsyncIterableResult<Row>;\n  close(): Promise<void>;\n}\n\nexport function checkMiddlewareCompatibility(\n  middleware: RuntimeMiddleware,\n  runtimeFamilyId: string,\n  runtimeTargetId: string,\n): void {\n  if (middleware.targetId !== undefined && middleware.familyId === undefined) {\n    throw runtimeError(\n      'RUNTIME.MIDDLEWARE_INCOMPATIBLE',\n      `Middleware '${middleware.name}' specifies targetId '${middleware.targetId}' without familyId`,\n      { middleware: middleware.name, targetId: middleware.targetId },\n    );\n  }\n\n  if (middleware.familyId !== undefined && middleware.familyId !== runtimeFamilyId) {\n    throw runtimeError(\n      'RUNTIME.MIDDLEWARE_FAMILY_MISMATCH',\n      `Middleware '${middleware.name}' requires family '${middleware.familyId}' but the runtime is configured for family '${runtimeFamilyId}'`,\n      { middleware: middleware.name, middlewareFamilyId: middleware.familyId, runtimeFamilyId },\n    );\n  }\n\n  if (middleware.targetId !== undefined && middleware.targetId !== runtimeTargetId) {\n    throw runtimeError(\n      'RUNTIME.MIDDLEWARE_TARGET_MISMATCH',\n      `Middleware '${middleware.name}' requires target '${middleware.targetId}' but the runtime is configured for target '${runtimeTargetId}'`,\n      { middleware: middleware.name, middlewareTargetId: middleware.targetId, runtimeTargetId },\n    );\n  }\n}\n"],"mappings":"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"}

package/dist/{types-import-spec-CPhrNJIV.d.mts → types-import-spec-BxI5cSQy.d.mts}

@@ -10,4 +10,4 @@ interface TypesImportSpec {
 }
 //#endregion
 export { TypesImportSpec as t };
-//# sourceMappingURL=types-import-spec-CPhrNJIV.d.mts.map
+//# sourceMappingURL=types-import-spec-BxI5cSQy.d.mts.map

package/dist/types-import-spec-BxI5cSQy.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-import-spec-BxI5cSQy.d.mts","names":[],"sources":["../src/shared/types-import-spec.ts"],"mappings":";;AAIA;;;UAAiB,eAAA;EAAA,SACN,OAAA;EAAA,SACA,KAAA;EAAA,SACA,KAAA;AAAA"}

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@prisma-next/framework-components",
-  "version": "0.5.0-dev.66",
+  "version": "0.5.0-dev.68",
   "license": "Apache-2.0",
   "type": "module",
   "sideEffects": false,
   "description": "Framework component types, assembly logic, and stack creation for Prisma Next",
   "dependencies": {
     "@standard-schema/spec": "^1.1.0",
-    "@prisma-next/contract": "0.5.0-dev.66",
-    "@prisma-next/operations": "0.5.0-dev.66",
-    "@prisma-next/utils": "0.5.0-dev.66"
+    "@prisma-next/contract": "0.5.0-dev.68",
+    "@prisma-next/utils": "0.5.0-dev.68",
+    "@prisma-next/operations": "0.5.0-dev.68"
   },
   "devDependencies": {
-    "tsdown": "0.18.4",
+    "tsdown": "0.22.0",
     "typescript": "5.9.3",
-    "vitest": "4.0.17",
+    "vitest": "4.1.5",
     "@prisma-next/tsconfig": "0.0.0",
     "@prisma-next/tsdown": "0.0.0"
   },

package/src/control/control-capabilities.ts

@@ -1,6 +1,11 @@
 import type { ControlTargetDescriptor } from './control-descriptors';
 import type { ControlFamilyInstance } from './control-instances';
-import type { MigrationPlanOperation, TargetMigrationsCapability } from './control-migration-types';
+import type {
+  MigrationPlanOperation,
+  MigrationRunner,
+  MultiSpaceCapableRunner,
+  TargetMigrationsCapability,
+} from './control-migration-types';
 import type { OperationPreview } from './control-operation-preview';
 import type { CoreSchemaView } from './control-schema-view';
 import type { PslDocumentAst } from './psl-ast';
@@ -69,3 +74,22 @@ export function hasOperationPreview<TFamilyId extends string, TSchemaIR>(
     typeof (instance as Record<string, unknown>)['toOperationPreview'] === 'function'
   );
 }
+
+/**
+ * Capability declaring that a runner can apply per-space plans inside a
+ * single outer transaction. Today's only implementer is the SQL family
+ * (`SqlMigrationRunner`); Mongo per-space is a non-goal per the project
+ * spec for extension contract spaces (TML-2397).
+ *
+ * The CLI uses this guard to route `db init` / `db update` through a
+ * per-space wiring when extensions expose a `contractSpace`, falling back
+ * to the single-space path when no multi-space capability is present.
+ */
+export function hasMultiSpaceRunner<TFamilyId extends string, TTargetId extends string>(
+  runner: MigrationRunner<TFamilyId, TTargetId>,
+): runner is MigrationRunner<TFamilyId, TTargetId> & MultiSpaceCapableRunner<TFamilyId, TTargetId> {
+  return (
+    'executeAcrossSpaces' in runner &&
+    typeof (runner as Record<string, unknown>)['executeAcrossSpaces'] === 'function'
+  );
+}

package/src/control/control-instances.ts

@@ -34,6 +34,24 @@ export interface ControlFamilyInstance<TFamilyId extends string, TSchemaIR>
     readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, string>>;
   }): Promise<VerifyDatabaseSchemaResult>;
 
+  /**
+   * Verify a contract against an already-introspected schema slice.
+   *
+   * Difference from {@link schemaVerify}: no `driver`, no introspection
+   * — the caller hands over the schema directly. Used by the aggregate
+   * verifier to invoke the family's verification logic per member,
+   * with the schema **pre-projected** to that member's claimed slice
+   * via {@link import('@prisma-next/migration-tools/aggregate').projectSchemaToSpace}.
+   *
+   * Synchronous — no I/O. Idempotent.
+   */
+  schemaVerifyAgainstSchema(options: {
+    readonly contract: unknown;
+    readonly schema: TSchemaIR;
+    readonly strict: boolean;
+    readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, string>>;
+  }): VerifyDatabaseSchemaResult;
+
   sign(options: {
     readonly driver: ControlDriverInstance<TFamilyId, string>;
     readonly contract: unknown;
@@ -64,6 +82,15 @@ export interface ControlFamilyInstance<TFamilyId extends string, TSchemaIR>
     readonly space: string;
   }): Promise<ContractMarkerRecord | null>;
 
+  /**
+   * Reads every marker row keyed by `space`. Used by the per-space
+   * verifier to detect orphan marker rows and marker-vs-on-disk drift.
+   * Returns an empty map when the marker table does not yet exist.
+   */
+  readAllMarkers(options: {
+    readonly driver: ControlDriverInstance<TFamilyId, string>;
+  }): Promise<ReadonlyMap<string, ContractMarkerRecord>>;
+
   introspect(options: {
     readonly driver: ControlDriverInstance<TFamilyId, string>;
     readonly contract?: unknown;

package/src/control/control-migration-types.ts

@@ -164,6 +164,16 @@ export interface OpFactoryCall {
 export interface MigrationPlan {
   /** The target ID this plan is for (e.g., 'postgres'). */
   readonly targetId: string;
+  /**
+   * Contract space this plan applies to. Runners cross-check
+   * `options.space` against `plan.spaceId` so the marker row gets keyed
+   * by the right space when applying via `executeAcrossSpaces`.
+   *
+   * Optional for backward compatibility with single-space callers that
+   * pre-date the contract-space aggregate; when present, runners
+   * enforce that it matches `options.space`.
+   */
+  readonly spaceId?: string;
   /**
    * Origin contract identity that the plan expects the database to currently be at.
    * If omitted or null, the runner skips origin validation entirely.
@@ -425,6 +435,71 @@ export interface MigrationRunner<
   }): Promise<MigrationRunnerResult>;
 }
 
+// ============================================================================
+// Multi-space runner protocol (extension contract spaces, TML-2397)
+// ============================================================================
+
+/**
+ * Per-space input for {@link MultiSpaceCapableRunner.executeAcrossSpaces}.
+ *
+ * Mirrors the single-space `MigrationRunner.execute` options, extended with a
+ * required `space` identifier. Each entry's `driver` must reference the same
+ * connection the outer transaction is opened on (typically the same value as
+ * the top-level `driver` on `executeAcrossSpaces`).
+ *
+ * Family-specific runners (e.g. the SQL family's `SqlMigrationRunner`) define
+ * a richer per-space option shape that is structurally compatible with this
+ * one — additional optional fields (e.g. SQL's `strictVerification`,
+ * `schemaName`, `callbacks`) are tolerated by the underlying runner without
+ * affecting cross-target wiring.
+ */
+export interface MultiSpaceRunnerPerSpaceOptions<
+  TFamilyId extends string = string,
+  TTargetId extends string = string,
+> {
+  readonly space: string;
+  readonly plan: MigrationPlan;
+  readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
+  readonly destinationContract: unknown;
+  readonly policy: MigrationOperationPolicy;
+  readonly executionChecks?: MigrationRunnerExecutionChecks;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<TFamilyId, TTargetId>>;
+}
+
+export interface MultiSpaceRunnerSuccessValue {
+  readonly perSpaceResults: ReadonlyArray<{
+    readonly space: string;
+    readonly value: MigrationRunnerSuccessValue;
+  }>;
+}
+
+export interface MultiSpaceRunnerFailure extends MigrationRunnerFailure {
+  /** Identifier of the space whose plan caused the rollback. */
+  readonly failingSpace: string;
+}
+
+export type MultiSpaceRunnerResult = Result<MultiSpaceRunnerSuccessValue, MultiSpaceRunnerFailure>;
+
+/**
+ * Optional capability for runners that can apply a list of per-space plans
+ * inside a single outer transaction. A failure on any space rolls back every
+ * space's writes.
+ *
+ * Today's only implementer is the SQL family (`SqlMigrationRunner`); Mongo
+ * per-space is a non-goal per the project spec. The capability is declared
+ * at the framework layer so CLI utilities can route through it without
+ * importing the SQL family directly.
+ */
+export interface MultiSpaceCapableRunner<
+  TFamilyId extends string = string,
+  TTargetId extends string = string,
+> {
+  executeAcrossSpaces(options: {
+    readonly driver: ControlDriverInstance<TFamilyId, TTargetId>;
+    readonly perSpaceOptions: ReadonlyArray<MultiSpaceRunnerPerSpaceOptions<TFamilyId, TTargetId>>;
+  }): Promise<MultiSpaceRunnerResult>;
+}
+
 // ============================================================================
 // Target Migrations Capability
 // ============================================================================

package/src/control/control-spaces.ts

@@ -23,7 +23,7 @@ import type { MigrationMetadata, MigrationPlanOperation } from './control-migrat
 export const APP_SPACE_ID = 'app' as const;
 
 /**
- * Pinned head ref for a contract space — the `(hash, invariants)` tuple
+ * Head ref for a contract space — the `(hash, invariants)` tuple
  * a runner targets when applying that space's migration graph. Identical
  * in shape to the on-disk `migrations/<space-id>/refs/head.json` the
  * framework writes per loaded extension, and to the app-space

package/src/exports/control.ts

@@ -6,6 +6,7 @@ export type {
 } from '../control/control-capabilities';
 export {
   hasMigrations,
+  hasMultiSpaceRunner,
   hasOperationPreview,
   hasPslContractInfer,
   hasSchemaView,
@@ -43,6 +44,11 @@ export type {
   MigrationRunnerResult,
   MigrationRunnerSuccessValue,
   MigrationScaffoldContext,
+  MultiSpaceCapableRunner,
+  MultiSpaceRunnerFailure,
+  MultiSpaceRunnerPerSpaceOptions,
+  MultiSpaceRunnerResult,
+  MultiSpaceRunnerSuccessValue,
   OpFactoryCall,
   SerializedQueryPlan,
   TargetMigrationsCapability,

package/dist/codec-BUBJeOk4.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"codec-BUBJeOk4.d.mts","names":[],"sources":["../src/shared/codec-types.ts","../src/shared/codec-descriptor.ts","../src/shared/codec.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/emission-types-DzNgwiFC.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"emission-types-DzNgwiFC.d.mts","names":[],"sources":["../src/control/emission-types.ts"],"sourcesContent":[],"mappings":";;;;UAGiB,4BAAA;uCACsB,cAAc;AADrD;AAIiB,UAAA,iBAAA,CAAiB;EACU,SAAA,gBAAA,CAAA,EAAd,aAAc,CAAA,eAAA,CAAA;EAAd,SAAA,oBAAA,CAAA,EACI,aADJ,CACkB,eADlB,CAAA;EACkB,SAAA,YAAA,CAAA,EACtB,aADsB,CAAA,MAAA,CAAA;;AACtB,UAGT,WAAA,CAHS;EAAa,SAAA,EAAA,EAAA,MAAA;EAGtB,mBAAW,CAAA,QAAA,EAGI,QAHJ,EAAA,mBAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EAGI,wBAAA,CAAA,SAAA,EAAA,MAAA,EAAA,KAAA,EAEqB,aAFrB,CAAA,EAAA,MAAA;EAEqB,gBAAA,EAAA,EAAA,MAAA,EAAA;EAIpB,oBAAA,CAAA,OAAA,CAAA,EAAA,4BAAA,CAAA,EAAA,MAAA;EAuBtB,qBAAA,EAAA,EAAA,MAAA;EACG,kBAAA,CAAA,gBAAA,EAAA,MAAA,EAAA,YAAA,EAAA,MAAA,CAAA,EAAA,MAAA;EACT;;;;;;;;;;;;;;uEAFM,yBACG,WACT"}

package/dist/framework-authoring-DJbiXhmf.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework-authoring-DJbiXhmf.d.mts","names":[],"sources":["../src/shared/framework-authoring.ts"],"sourcesContent":[],"mappings":";;;KAWY,eAAA;;EAAA,SAAA,KAAA,EAAA,MAAe;EAOf,SAAA,IAAA,CAAA,EAAA,SAAsB,MAAA,EAAA;EAK9B,SAAA,OAAA,CAAA,EARiB,sBAQjB;CACS;AACiB,KAPlB,sBAAA,GAOkB,MAAA,GAAA,MAAA,GAAA,OAAA,GAAA,IAAA,GAF1B,eAE0B,GAAA,SADjB,sBACiB,EAAA,GAAA;EAAsB,UAAA,GAAA,EAAA,MAAA,CAAA,EAAtB,sBAAsB;AAAG,CAAA;AAOvD,UALU,iCAAA,CAK6B;EAAG,SAAA,IAAA,CAAA,EAAA,MAAA;EAYE,SAAA,QAAA,CAAA,EAAA,OAAA;;AAAT,KAZvB,2BAAA,GAA8B,iCAYP,GAAA,CAAA;EAIlB,SAAA,IAAA,EAAA,QAAA;CAEM,GAAA;EACgB,SAAA,IAAA,EAAA,QAAA;EAAf,SAAA,OAAA,CAAA,EAAA,OAAA;EAAM,SAAA,OAAA,CAAA,EAAA,MAAA;EAGb,SAAA,OAAA,CAAA,EAAA,MAAA;AAMjB,CAAA,GAAiB;EAKA,SAAA,IAAA,EAAA,aAAA;AAKjB,CAAA,GAAY;EAIK,SAAA,IAAA,EAAA,QAAA;EAKA,SAAA,UAAA,EAnCY,MAmCZ,CAAA,MAA2B,EAnCA,2BAmCA,CAAA;CAEvB,CAAA;AACU,UAlCd,4BAAA,CAkCc;EAHqB,SAAA,OAAA,EAAA,MAAA;EAA4B,SAAA,UAAA,EA7BzD,sBA6ByD;EAQ/D,SAAA,UAAA,CAAA,EApCO,MAoCP,CAAA,MAA8B,EApCR,sBAsCZ,CAAA;AAI3B;AAIY,UA3CK,kCAAA,CA4CU;EAGV,SAAA,IAAA,EAAA,iBAAsB;EAKvB,SAAA,IAAA,CAAA,EAAA,SAlDW,2BAkDgD,EAAA;EAkB3D,SAAA,MAAA,EAnEG,4BAmEiC;AAYpD;AAoBgB,UAhGC,qCAAA,CAiGA;EA+BD,SAAA,IAAA,EAAA,SAAA;EAyEA,SAAA,KAAA,EAvME,sBAuM6B;AA6B/C;AA4GgB,UA7UC,sCAAA,CA+UO;EAoHR,SAAA,IAAA,EAAA,UAAA;EAWA,SAAA,UAAA,EA5cO,sBA4cwB;;AAOrB,KAhdd,8BAAA,GACR,qCA+csB,GA9ctB,sCA8csB;AAGL,UA/cJ,kCAAA,CA+cI;EACU,SAAA,QAAA,CAAA,EA/cT,sBA+cS;EAA8B,SAAA,QAAA,CAAA,EA9cvC,sBA8cuC;;UA3c5C,0BAAA,SAAmC;;qBAE/B;+BACU;;;;UAKd,8BAAA;;2BAEU;mBACR;;KAGP,sBAAA;2BACe,qCAAqC;;KAGpD,uBAAA;2BACe,iCAAiC;;UAG3C,sBAAA;kBACC;mBACC;;iBAGH,iBAAA,2BAA4C;iBAkB5C,oCAAA,2BAEJ;iBAUI,gCAAA,2BAEJ;;;;;;;;;iBAkBI,2BAAA,gBACC;;;;;;;;;;;;;;;;;;;iBA+BD,wBAAA,SACN,iCACA;iBAuEM,+BAAA,gBACC,wCACC;iBA2BF,6BAAA,WACJ;iBA2GI,gCAAA,2CAEQ;iBAoHR,mCAAA,aACF;;;wBAKU;;iBAKR,+BAAA,aACF;;;;0BAMY;;;qBAGL;+BACU"}

package/dist/framework-authoring-gi_BJlNO.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework-authoring-gi_BJlNO.mjs","names":["paths: string[]","resolved: Record<string, unknown>"],"sources":["../src/shared/framework-authoring.ts"],"sourcesContent":["import type {\n  ColumnDefault,\n  ExecutionMutationDefaultPhases,\n  ExecutionMutationDefaultValue,\n} from '@prisma-next/contract/types';\nimport {\n  isColumnDefaultLiteralInputValue,\n  isExecutionMutationDefaultValue,\n} from '@prisma-next/contract/types';\nimport { ifDefined } from '@prisma-next/utils/defined';\n\nexport type AuthoringArgRef = {\n  readonly kind: 'arg';\n  readonly index: number;\n  readonly path?: readonly string[];\n  readonly default?: AuthoringTemplateValue;\n};\n\nexport type AuthoringTemplateValue =\n  | string\n  | number\n  | boolean\n  | null\n  | AuthoringArgRef\n  | readonly AuthoringTemplateValue[]\n  | { readonly [key: string]: AuthoringTemplateValue };\n\ninterface AuthoringArgumentDescriptorCommon {\n  readonly name?: string;\n  readonly optional?: boolean;\n}\n\nexport type AuthoringArgumentDescriptor = AuthoringArgumentDescriptorCommon &\n  (\n    | { readonly kind: 'string' }\n    | {\n        readonly kind: 'number';\n        readonly integer?: boolean;\n        readonly minimum?: number;\n        readonly maximum?: number;\n      }\n    | { readonly kind: 'stringArray' }\n    | {\n        readonly kind: 'object';\n        readonly properties: Record<string, AuthoringArgumentDescriptor>;\n      }\n  );\n\nexport interface AuthoringStorageTypeTemplate {\n  readonly codecId: string;\n  readonly nativeType: AuthoringTemplateValue;\n  readonly typeParams?: Record<string, AuthoringTemplateValue>;\n}\n\nexport interface AuthoringTypeConstructorDescriptor {\n  readonly kind: 'typeConstructor';\n  readonly args?: readonly AuthoringArgumentDescriptor[];\n  readonly output: AuthoringStorageTypeTemplate;\n}\n\nexport interface AuthoringColumnDefaultTemplateLiteral {\n  readonly kind: 'literal';\n  readonly value: AuthoringTemplateValue;\n}\n\nexport interface AuthoringColumnDefaultTemplateFunction {\n  readonly kind: 'function';\n  readonly expression: AuthoringTemplateValue;\n}\n\nexport type AuthoringColumnDefaultTemplate =\n  | AuthoringColumnDefaultTemplateLiteral\n  | AuthoringColumnDefaultTemplateFunction;\n\nexport interface AuthoringExecutionDefaultsTemplate {\n  readonly onCreate?: AuthoringTemplateValue;\n  readonly onUpdate?: AuthoringTemplateValue;\n}\n\nexport interface AuthoringFieldPresetOutput extends AuthoringStorageTypeTemplate {\n  readonly nullable?: boolean;\n  readonly default?: AuthoringColumnDefaultTemplate;\n  readonly executionDefaults?: AuthoringExecutionDefaultsTemplate;\n  readonly id?: boolean;\n  readonly unique?: boolean;\n}\n\nexport interface AuthoringFieldPresetDescriptor {\n  readonly kind: 'fieldPreset';\n  readonly args?: readonly AuthoringArgumentDescriptor[];\n  readonly output: AuthoringFieldPresetOutput;\n}\n\nexport type AuthoringTypeNamespace = {\n  readonly [name: string]: AuthoringTypeConstructorDescriptor | AuthoringTypeNamespace;\n};\n\nexport type AuthoringFieldNamespace = {\n  readonly [name: string]: AuthoringFieldPresetDescriptor | AuthoringFieldNamespace;\n};\n\nexport interface AuthoringContributions {\n  readonly type?: AuthoringTypeNamespace;\n  readonly field?: AuthoringFieldNamespace;\n}\n\nexport function isAuthoringArgRef(value: unknown): value is AuthoringArgRef {\n  if (typeof value !== 'object' || value === null || (value as { kind?: unknown }).kind !== 'arg') {\n    return false;\n  }\n  const { index, path } = value as { index?: unknown; path?: unknown };\n  if (typeof index !== 'number' || !Number.isInteger(index) || index < 0) {\n    return false;\n  }\n  if (path !== undefined && (!Array.isArray(path) || path.some((s) => typeof s !== 'string'))) {\n    return false;\n  }\n  return true;\n}\n\nfunction isAuthoringTemplateRecord(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\nexport function isAuthoringTypeConstructorDescriptor(\n  value: unknown,\n): value is AuthoringTypeConstructorDescriptor {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'typeConstructor' &&\n    typeof (value as { output?: unknown }).output === 'object' &&\n    (value as { output?: unknown }).output !== null\n  );\n}\n\nexport function isAuthoringFieldPresetDescriptor(\n  value: unknown,\n): value is AuthoringFieldPresetDescriptor {\n  return (\n    typeof value === 'object' &&\n    value !== null &&\n    (value as { kind?: unknown }).kind === 'fieldPreset' &&\n    typeof (value as { output?: unknown }).output === 'object' &&\n    (value as { output?: unknown }).output !== null\n  );\n}\n\n/**\n * Returns true when `namespace` is a non-leaf key in `contributions.field`.\n *\n * `AuthoringFieldNamespace` permits a leaf descriptor at any depth — including\n * the root — so a top-level `field: { Foo: { kind: 'fieldPreset', ... } }`\n * registration must NOT be treated as a \"namespace\" with sub-paths. Callers\n * use this predicate to gate dot-namespaced lookups (e.g. PSL `@Foo.bar`).\n */\nexport function hasRegisteredFieldNamespace(\n  contributions: AuthoringContributions | undefined,\n  namespace: string,\n): boolean {\n  if (contributions?.field === undefined || !Object.hasOwn(contributions.field, namespace)) {\n    return false;\n  }\n  return !isAuthoringFieldPresetDescriptor(contributions.field[namespace]);\n}\n\nfunction isPlainNamespaceObject(value: unknown): value is Record<string, unknown> {\n  return typeof value === 'object' && value !== null && !Array.isArray(value);\n}\n\n/**\n * Merges `source` into `target` recursively at the descriptor-namespace\n * level. `leafGuard` decides which values are descriptors (terminal\n * merge points; same-path registrations across components are reported\n * as duplicates) versus sub-namespaces (recursion targets).\n *\n * Path segments are validated against prototype-pollution names\n * (`__proto__`, `constructor`, `prototype`). A value that is neither a\n * recognized leaf nor a plain object — e.g. a malformed descriptor\n * where the canonical leaf guard rejected it for missing `output` —\n * is reported as an invalid contribution rather than recursed into,\n * which would either silently mangle state or infinite-loop on\n * primitive properties.\n *\n * Within-registry duplicate detection is this walker's job;\n * cross-registry detection runs separately via\n * `assertNoCrossRegistryCollisions` after merging completes.\n */\nexport function mergeAuthoringNamespaces(\n  target: Record<string, unknown>,\n  source: Record<string, unknown>,\n  path: readonly string[],\n  leafGuard: (value: unknown) => boolean,\n  label: string,\n): void {\n  const assertSafePath = (currentPath: readonly string[]) => {\n    const blockedSegment = currentPath.find(\n      (segment) => segment === '__proto__' || segment === 'constructor' || segment === 'prototype',\n    );\n    if (blockedSegment) {\n      throw new Error(\n        `Invalid authoring ${label} helper \"${currentPath.join('.')}\". Helper path segments must not use \"${blockedSegment}\".`,\n      );\n    }\n  };\n\n  for (const [key, sourceValue] of Object.entries(source)) {\n    const currentPath = [...path, key];\n    assertSafePath(currentPath);\n    const hasExistingValue = Object.hasOwn(target, key);\n    const existingValue = hasExistingValue ? target[key] : undefined;\n\n    if (!hasExistingValue) {\n      target[key] = sourceValue;\n      continue;\n    }\n\n    const existingIsLeaf = leafGuard(existingValue);\n    const sourceIsLeaf = leafGuard(sourceValue);\n\n    if (existingIsLeaf || sourceIsLeaf) {\n      throw new Error(\n        `Duplicate authoring ${label} helper \"${currentPath.join('.')}\". Helper names must be unique across composed packs.`,\n      );\n    }\n\n    if (!isPlainNamespaceObject(existingValue) || !isPlainNamespaceObject(sourceValue)) {\n      throw new Error(\n        `Invalid authoring ${label} helper \"${currentPath.join('.')}\". Expected a sub-namespace object or a recognized descriptor; received a malformed value.`,\n      );\n    }\n\n    mergeAuthoringNamespaces(existingValue, sourceValue, currentPath, leafGuard, label);\n  }\n}\n\nfunction collectAuthoringLeafPaths(\n  namespace: Readonly<Record<string, unknown>>,\n  isLeaf: (value: unknown) => boolean,\n  path: readonly string[] = [],\n): string[] {\n  const paths: string[] = [];\n  for (const [key, value] of Object.entries(namespace)) {\n    const currentPath = [...path, key];\n    if (isLeaf(value)) {\n      paths.push(currentPath.join('.'));\n      continue;\n    }\n    if (typeof value === 'object' && value !== null && !Array.isArray(value)) {\n      paths.push(\n        ...collectAuthoringLeafPaths(\n          value as Readonly<Record<string, unknown>>,\n          isLeaf,\n          currentPath,\n        ),\n      );\n    }\n  }\n  return paths;\n}\n\nexport function assertNoCrossRegistryCollisions(\n  typeNamespace: AuthoringTypeNamespace,\n  fieldNamespace: AuthoringFieldNamespace,\n): void {\n  const typePaths = new Set(\n    collectAuthoringLeafPaths(typeNamespace, isAuthoringTypeConstructorDescriptor),\n  );\n  // Within-registry duplicate detection is handled upstream by the merge\n  // walker (`mergeAuthoringNamespaces` in control-stack.ts and\n  // `mergeHelperNamespaces` in composed-authoring-helpers.ts), which throws\n  // on same-path registrations within either registry before this check\n  // runs. This function only handles the cross-registry case — and an\n  // empty type namespace makes a cross-registry collision structurally\n  // impossible, so the early-out is sound.\n  if (typePaths.size === 0) {\n    return;\n  }\n  for (const fieldPath of collectAuthoringLeafPaths(\n    fieldNamespace,\n    isAuthoringFieldPresetDescriptor,\n  )) {\n    if (typePaths.has(fieldPath)) {\n      throw new Error(\n        `Ambiguous authoring registry path \"${fieldPath}\". The same path is registered as both a type constructor and a field preset; PSL resolution would be ambiguous. Register each path in only one of authoringContributions.field / authoringContributions.type.`,\n      );\n    }\n  }\n}\n\nexport function resolveAuthoringTemplateValue(\n  template: AuthoringTemplateValue,\n  args: readonly unknown[],\n): unknown {\n  if (isAuthoringArgRef(template)) {\n    let value = args[template.index];\n\n    for (const segment of template.path ?? []) {\n      if (!isAuthoringTemplateRecord(value) || !Object.hasOwn(value, segment)) {\n        value = undefined;\n        break;\n      }\n      value = (value as Record<string, unknown>)[segment];\n    }\n\n    if (value === undefined && template.default !== undefined) {\n      return resolveAuthoringTemplateValue(template.default, args);\n    }\n\n    return value;\n  }\n  if (Array.isArray(template)) {\n    return template.map((value) => resolveAuthoringTemplateValue(value, args));\n  }\n  if (typeof template === 'object' && template !== null) {\n    const resolved: Record<string, unknown> = {};\n    for (const [key, value] of Object.entries(template)) {\n      const resolvedValue = resolveAuthoringTemplateValue(value, args);\n      if (resolvedValue !== undefined) {\n        resolved[key] = resolvedValue;\n      }\n    }\n    return resolved;\n  }\n  return template;\n}\n\nfunction validateAuthoringArgument(\n  descriptor: AuthoringArgumentDescriptor,\n  value: unknown,\n  path: string,\n): void {\n  if (value === undefined) {\n    if (descriptor.optional) {\n      return;\n    }\n    throw new Error(`Missing required authoring helper argument at ${path}`);\n  }\n\n  if (descriptor.kind === 'string') {\n    if (typeof value !== 'string') {\n      throw new Error(`Authoring helper argument at ${path} must be a string`);\n    }\n    return;\n  }\n\n  if (descriptor.kind === 'stringArray') {\n    if (!Array.isArray(value)) {\n      throw new Error(`Authoring helper argument at ${path} must be an array of strings`);\n    }\n    for (const entry of value) {\n      if (typeof entry !== 'string') {\n        throw new Error(`Authoring helper argument at ${path} must be an array of strings`);\n      }\n    }\n    return;\n  }\n\n  if (descriptor.kind === 'object') {\n    if (typeof value !== 'object' || value === null || Array.isArray(value)) {\n      throw new Error(`Authoring helper argument at ${path} must be an object`);\n    }\n\n    const input = value as Record<string, unknown>;\n    const expectedKeys = new Set(Object.keys(descriptor.properties));\n\n    for (const key of Object.keys(input)) {\n      if (!expectedKeys.has(key)) {\n        throw new Error(`Authoring helper argument at ${path} contains unknown property \"${key}\"`);\n      }\n    }\n\n    for (const [key, propertyDescriptor] of Object.entries(descriptor.properties)) {\n      validateAuthoringArgument(propertyDescriptor, input[key], `${path}.${key}`);\n    }\n\n    return;\n  }\n\n  if (typeof value !== 'number' || Number.isNaN(value)) {\n    throw new Error(`Authoring helper argument at ${path} must be a number`);\n  }\n\n  if (descriptor.integer && !Number.isInteger(value)) {\n    throw new Error(`Authoring helper argument at ${path} must be an integer`);\n  }\n  if (descriptor.minimum !== undefined && value < descriptor.minimum) {\n    throw new Error(\n      `Authoring helper argument at ${path} must be >= ${descriptor.minimum}, received ${value}`,\n    );\n  }\n  if (descriptor.maximum !== undefined && value > descriptor.maximum) {\n    throw new Error(\n      `Authoring helper argument at ${path} must be <= ${descriptor.maximum}, received ${value}`,\n    );\n  }\n}\n\nexport function validateAuthoringHelperArguments(\n  helperPath: string,\n  descriptors: readonly AuthoringArgumentDescriptor[] | undefined,\n  args: readonly unknown[],\n): void {\n  const expected = descriptors ?? [];\n  const minimumArgs = expected.reduce(\n    (count, descriptor, index) => (descriptor.optional ? count : index + 1),\n    0,\n  );\n  if (args.length < minimumArgs || args.length > expected.length) {\n    throw new Error(\n      `${helperPath} expects ${minimumArgs === expected.length ? expected.length : `${minimumArgs}-${expected.length}`} argument(s), received ${args.length}`,\n    );\n  }\n\n  expected.forEach((descriptor, index) => {\n    validateAuthoringArgument(descriptor, args[index], `${helperPath}[${index}]`);\n  });\n}\n\nfunction resolveAuthoringStorageTypeTemplate(\n  template: AuthoringStorageTypeTemplate,\n  args: readonly unknown[],\n): {\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams?: Record<string, unknown>;\n} {\n  const nativeType = resolveAuthoringTemplateValue(template.nativeType, args);\n  if (typeof nativeType !== 'string') {\n    throw new Error(\n      `Resolved authoring nativeType must be a string for codec \"${template.codecId}\", received ${String(nativeType)}`,\n    );\n  }\n  const typeParams =\n    template.typeParams === undefined\n      ? undefined\n      : resolveAuthoringTemplateValue(template.typeParams, args);\n  if (typeParams !== undefined && !isAuthoringTemplateRecord(typeParams)) {\n    throw new Error(\n      `Resolved authoring typeParams must be an object for codec \"${template.codecId}\", received ${String(typeParams)}`,\n    );\n  }\n\n  return {\n    codecId: template.codecId,\n    nativeType,\n    ...(typeParams === undefined ? {} : { typeParams }),\n  };\n}\n\nfunction resolveAuthoringColumnDefaultTemplate(\n  template: AuthoringColumnDefaultTemplate,\n  args: readonly unknown[],\n): ColumnDefault {\n  if (template.kind === 'literal') {\n    const value = resolveAuthoringTemplateValue(template.value, args);\n    if (value === undefined) {\n      throw new Error('Resolved authoring literal default must not be undefined');\n    }\n    if (!isColumnDefaultLiteralInputValue(value)) {\n      throw new Error(\n        `Resolved authoring literal default must be a JSON-serializable value or Date, received ${String(value)}`,\n      );\n    }\n    return {\n      kind: 'literal',\n      value,\n    };\n  }\n\n  const expression = resolveAuthoringTemplateValue(template.expression, args);\n  if (expression === undefined || (typeof expression === 'object' && expression !== null)) {\n    throw new Error(\n      `Resolved authoring function default expression must resolve to a primitive, received ${String(expression)}`,\n    );\n  }\n  return {\n    kind: 'function',\n    expression: String(expression),\n  };\n}\n\nfunction resolveExecutionMutationDefaultPhase(\n  phase: 'onCreate' | 'onUpdate',\n  template: AuthoringTemplateValue,\n  args: readonly unknown[],\n): ExecutionMutationDefaultValue {\n  const value = resolveAuthoringTemplateValue(template, args);\n  if (!isExecutionMutationDefaultValue(value)) {\n    throw new Error(\n      `Authoring preset executionDefaults.${phase} did not resolve to a valid generator descriptor (kind: 'generator', id: string).`,\n    );\n  }\n  return value;\n}\n\nfunction resolveAuthoringExecutionDefaultsTemplate(\n  template: AuthoringExecutionDefaultsTemplate,\n  args: readonly unknown[],\n): ExecutionMutationDefaultPhases {\n  return {\n    ...ifDefined(\n      'onCreate',\n      template.onCreate !== undefined\n        ? resolveExecutionMutationDefaultPhase('onCreate', template.onCreate, args)\n        : undefined,\n    ),\n    ...ifDefined(\n      'onUpdate',\n      template.onUpdate !== undefined\n        ? resolveExecutionMutationDefaultPhase('onUpdate', template.onUpdate, args)\n        : undefined,\n    ),\n  };\n}\n\nexport function instantiateAuthoringTypeConstructor(\n  descriptor: AuthoringTypeConstructorDescriptor,\n  args: readonly unknown[],\n): {\n  readonly codecId: string;\n  readonly nativeType: string;\n  readonly typeParams?: Record<string, unknown>;\n} {\n  return resolveAuthoringStorageTypeTemplate(descriptor.output, args);\n}\n\nexport function instantiateAuthoringFieldPreset(\n  descriptor: AuthoringFieldPresetDescriptor,\n  args: readonly unknown[],\n): {\n  readonly descriptor: {\n    readonly codecId: string;\n    readonly nativeType: string;\n    readonly typeParams?: Record<string, unknown>;\n  };\n  readonly nullable: boolean;\n  readonly default?: ColumnDefault;\n  readonly executionDefaults?: ExecutionMutationDefaultPhases;\n  readonly id: boolean;\n  readonly unique: boolean;\n} {\n  return {\n    descriptor: resolveAuthoringStorageTypeTemplate(descriptor.output, args),\n    nullable: descriptor.output.nullable ?? false,\n    ...ifDefined(\n      'default',\n      descriptor.output.default !== undefined\n        ? resolveAuthoringColumnDefaultTemplate(descriptor.output.default, args)\n        : undefined,\n    ),\n    ...ifDefined(\n      'executionDefaults',\n      descriptor.output.executionDefaults !== undefined\n        ? resolveAuthoringExecutionDefaultsTemplate(descriptor.output.executionDefaults, args)\n        : undefined,\n    ),\n    id: descriptor.output.id ?? false,\n    unique: descriptor.output.unique ?? false,\n  };\n}\n"],"mappings":"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"}

package/dist/framework-components-BVqm1I48.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"framework-components-BVqm1I48.d.mts","names":[],"sources":["../src/shared/mutation-default-types.ts","../src/shared/framework-components.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/psl-ast-BlDveJZ4.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"psl-ast-BlDveJZ4.d.mts","names":[],"sources":["../src/control/psl-ast.ts"],"sourcesContent":[],"mappings":";UAAiB,WAAA;EAAA,SAAA,MAAW,EAAA,MAAA;EAMX,SAAA,IAAO,EAAA,MACN;EAIN,SAAA,MAAA,EAAA,MAAiB;AAa7B;AAOiB,UAzBA,OAAA,CAyBA;EAKA,SAAA,KAAA,EA7BC,WA6BqB;EAK3B,SAAA,GAAA,EAjCI,WAiCW;AAE3B;AAEiB,KAlCL,iBAAA,GAkCK,wBAGO,GAAA,iCAAA,GAAA,8BAAA,GAAA,0BAAA,GAAA,iCAAA,GAAA,iCAAA,GAAA,gCAAA,GAAA,gCAAA,GAAA,2BAAA,GAAA,yBAAA,GAAA,0BAAA;AAGP,UA3BA,aAAA,CA2BA;EAOL,SAAA,IAAA,EAjCK,iBAiCe;EAEf,SAAA,OAAA,EAAA,MAAA;EAOA,SAAA,QAAY,EAAA,MAAA;EAEV,SAAA,IAAA,EAzCF,OAyCE;;AAGF,UAzCA,uBAAA,CAyCA;EAAO,SAAA,IAAA,EAAA,UAAA;EAGZ,SAAA,IAAA,EAAA,eAAoB,GAAA,KAAA;AAEhC;AAEiB,UA3CA,sBAAA,CA2CQ;EAII,SAAA,IAAA,EAAA,SAAA;EAIG,SAAA,KAAA,EAAA,MAAA,GAAA,MAAA,GAAA,OAAA;;AACR,KA/CZ,eAAA,GAAkB,uBA+CN,GA/CgC,sBA+ChC;AAGP,KAhDL,kBAAA,GAgDwB,OAGnB,GAAA,OAAO,GAAA,MAAA,GAAA,WAAA;AAGP,UApDA,8BAAA,CAuDO;EAGZ,SAAA,IAAA,EAAA,YAAiB;EAEZ,SAAA,KAAQ,EAAA,MAAA;EAGG,SAAA,IAAA,EA5DX,OA4DW;;AAEX,UA3DA,yBAAA,CA2DA;EAAO,SAAA,IAAA,EAAA,OAAA;EAWP,SAAA,IAAA,EAAY,MAAA;EAgBZ,SAAA,KAAO,EAAA,MAAA;EAGI,SAAA,IAAA,EArFX,OAqFW;;AAEX,KApFL,oBAAA,GAAuB,8BAoFlB,GApFmD,yBAoFnD;AAAO,UAlFP,sBAAA,CAkFO;EAGP,SAAA,IAAA,EAAA,iBAAgB;EAGL,SAAA,IAAA,EAAA,SAAA,MAAA,EAAA;EACI,SAAA,IAAA,EAAA,SAtFN,oBAsFM,EAAA;EACf,SAAA,IAAA,EAtFA,OAsFA;;AAGA,UAtFA,YAAA,CAsFuB;EASX,SAAA,IAAA,EAAA,WAAA;EACG,SAAA,MAAA,EA9Fb,kBA8Fa;EACf,SAAA,IAAA,EAAA,MAAA;EAAO,SAAA,IAAA,EAAA,SA7FE,oBA6FF,EAAA;EAGP,SAAA,IAAA,EA/FA,OA+Fa;AAM9B;AAG4B,KArGhB,oBAAA,GAqGgB,MAAA;AACD,KApGf,iBAAA,GAAoB,YAoGL;AACS,UAnGnB,QAAA,CAmGmB;EACjB,SAAA,IAAA,EAAA,OAAA;EACF,SAAA,IAAA,EAAA,MAAA;EAAO,SAAA,QAAA,EAAA,MAAA;EAGP,SAAA,eAAqB,CAAA,EApGT,sBAoGS;EAKrB,SAAA,QAAA,EAAA,OAAsB;;;gCArGP;iBACf;;UAGA,mBAAA;;;iBAGA;;UAGA,kBAAA;;;iBAGA;;KAGL,iBAAA,GAAoB;UAEf,QAAA;;;4BAGW;gCACI;iBACf;;;;;;;;;;UAWA,YAAA;;;;;;;;;;;;;iBAaA;;UAGA,OAAA;;;4BAGW;gCACI;iBACf;;UAGA,gBAAA;;;4BAGW;gCACI;iBACf;;UAGA,uBAAA;;;;;;;;;6BASY;gCACG;iBACf;;UAGA,aAAA;;kCAEiB;iBACjB;;UAGA,cAAA;;;4BAGW;2BACD;oCACS;mBACjB;iBACF;;UAGA,qBAAA;;;;UAKA,sBAAA;gBACD;iCACiB"}

package/dist/types-import-spec-CPhrNJIV.d.mts.map

@@ -1 +0,0 @@
-{"version":3,"file":"types-import-spec-CPhrNJIV.d.mts","names":[],"sources":["../src/shared/types-import-spec.ts"],"sourcesContent":[],"mappings":";;AAIA;;;UAAiB,eAAA"}