@prisma-next/sql-runtime 0.5.0-dev.4 → 0.5.0-dev.40

package/dist/test/utils.mjs

@@ -1,4 +1,4 @@
-import { c as createSqlExecutionStack, i as ensureTableStatement, o as writeContractMarker, r as ensureSchemaStatement, s as createExecutionContext } from "../exports-BQZSVXXt.mjs";
+import { c as createSqlExecutionStack, d as parseContractMarkerRow, i as ensureTableStatement, o as writeContractMarker, r as ensureSchemaStatement, s as createExecutionContext } from "../exports-CrHMfIKo.mjs";
 import { codec, createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
 import { instantiateExecutionStack } from "@prisma-next/framework-components/execution";
 import { coreHash, profileHash } from "@prisma-next/contract/types";
@@ -163,8 +163,13 @@ function createStubAdapter() {
 	codecRegistry.register(codec({
 		typeId: "pg/timestamptz@1",
 		targetTypes: ["timestamptz"],
-		encode: (value) => value instanceof Date ? value.toISOString() : value,
-		decode: (wire) => wire instanceof Date ? wire : new Date(wire)
+		encode: (value) => value,
+		decode: (wire) => wire,
+		encodeJson: (value) => value.toISOString(),
+		decodeJson: (json) => {
+			if (typeof json !== "string") throw new Error("expected ISO date string");
+			return new Date(json);
+		}
 	}));
 	return {
 		profile: {
@@ -176,10 +181,11 @@ function createStubAdapter() {
 			},
 			readMarkerStatement() {
 				return {
-					sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1",
+					sql: "select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from prisma_contract.marker where id = $1",
 					params: [1]
 				};
-			}
+			},
+			parseMarkerRow: parseContractMarkerRow
 		},
 		lower(ast, ctx) {
 			const sqlText = JSON.stringify(ast);

package/dist/test/utils.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"utils.mjs","names":["collectAsync"],"sources":["../../test/utils.ts"],"sourcesContent":["import type { Contract, ExecutionPlan, ResultType } from '@prisma-next/contract/types';\nimport { coreHash, profileHash } from '@prisma-next/contract/types';\nimport {\n  instantiateExecutionStack,\n  type RuntimeDriverDescriptor,\n} from '@prisma-next/framework-components/execution';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { Adapter, LoweredStatement, SelectAst } from '@prisma-next/sql-relational-core/ast';\nimport { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\nimport { collectAsync, drainAsyncIterable } from '@prisma-next/test-utils';\nimport type { Client } from 'pg';\nimport type { SqlStatement } from '../src/exports';\nimport {\n  createExecutionContext,\n  type createRuntime,\n  createSqlExecutionStack,\n  ensureSchemaStatement,\n  ensureTableStatement,\n  writeContractMarker,\n} from '../src/exports';\nimport type {\n  ExecutionContext,\n  SqlRuntimeAdapterDescriptor,\n  SqlRuntimeAdapterInstance,\n  SqlRuntimeDriverInstance,\n  SqlRuntimeExtensionDescriptor,\n  SqlRuntimeTargetDescriptor,\n} from '../src/sql-context';\n\nfunction createTestMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => generateId(params ? { id, params } : { id }),\n  }));\n}\n\n/**\n * Executes a plan and collects all results into an array.\n * This helper DRYs up the common pattern of executing plans in tests.\n * The return type is inferred from the plan's type parameter.\n */\nexport async function executePlanAndCollect<\n  P extends ExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>,\n>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]> {\n  type Row = ResultType<P>;\n  return collectAsync<Row>(runtime.execute<Row>(plan));\n}\n\n/**\n * Drains a plan execution, consuming all results without collecting them.\n * Useful for testing side effects without memory overhead.\n */\nexport async function drainPlanExecution(\n  runtime: ReturnType<typeof createRuntime>,\n  plan: ExecutionPlan | SqlQueryPlan<unknown>,\n): Promise<void> {\n  return drainAsyncIterable(runtime.execute(plan));\n}\n\n/**\n * Executes a SQL statement on a database client.\n */\nexport async function executeStatement(client: Client, statement: SqlStatement): Promise<void> {\n  if (statement.params.length > 0) {\n    await client.query(statement.sql, [...statement.params]);\n    return;\n  }\n\n  await client.query(statement.sql);\n}\n\n/**\n * Sets up database schema and data, then writes the contract marker.\n * This helper DRYs up the common pattern of database setup in tests.\n */\nexport async function setupTestDatabase(\n  client: Client,\n  contract: Contract<SqlStorage>,\n  setupFn: (client: Client) => Promise<void>,\n): Promise<void> {\n  await client.query('drop schema if exists prisma_contract cascade');\n  await client.query('create schema if not exists public');\n\n  await setupFn(client);\n\n  await executeStatement(client, ensureSchemaStatement);\n  await executeStatement(client, ensureTableStatement);\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Writes a contract marker to the database.\n * This helper DRYs up the common pattern of writing contract markers in tests.\n */\nexport async function writeTestContractMarker(\n  client: Client,\n  contract: Contract<SqlStorage>,\n): Promise<void> {\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Creates a test adapter descriptor from a raw adapter.\n * Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions\n * derived from the adapter's codec registry.\n */\nexport function createTestAdapterDescriptor(\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n): SqlRuntimeAdapterDescriptor<'postgres'> {\n  const codecRegistry = adapter.profile.codecs();\n  return {\n    kind: 'adapter' as const,\n    id: 'test-adapter',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => codecRegistry,\n    parameterizedCodecs: () => [],\n    mutationDefaultGenerators: createTestMutationDefaultGenerators,\n    create(_stack): SqlRuntimeAdapterInstance<'postgres'> {\n      return Object.assign({ familyId: 'sql' as const, targetId: 'postgres' as const }, adapter);\n    },\n  };\n}\n\n/**\n * Creates a test target descriptor with empty static contributions.\n */\nexport function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {\n  return {\n    kind: 'target' as const,\n    id: 'postgres',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => createCodecRegistry(),\n    parameterizedCodecs: () => [],\n    create() {\n      return { familyId: 'sql' as const, targetId: 'postgres' as const };\n    },\n  };\n}\n\n/**\n * Creates an ExecutionContext for testing.\n * This helper DRYs up the common pattern of context creation in tests.\n *\n * Accepts a raw adapter and optional extension descriptors, wrapping the\n * adapter in a descriptor internally for descriptor-first context creation.\n */\nexport function createTestContext<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n  options?: {\n    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  },\n): ExecutionContext<TContract> {\n  return createExecutionContext({\n    contract,\n    stack: {\n      target: createTestTargetDescriptor(),\n      adapter: createTestAdapterDescriptor(adapter),\n      extensionPacks: options?.extensionPacks ?? [],\n    },\n  });\n}\n\nexport function createTestStackInstance(options?: {\n  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  driver?: RuntimeDriverDescriptor<\n    'sql',\n    'postgres',\n    unknown,\n    SqlRuntimeDriverInstance<'postgres'>\n  >;\n}) {\n  const stack = createSqlExecutionStack({\n    target: createTestTargetDescriptor(),\n    adapter: createTestAdapterDescriptor(createStubAdapter()),\n    driver: options?.driver,\n    extensionPacks: options?.extensionPacks ?? [],\n  });\n\n  return instantiateExecutionStack(stack);\n}\n\n/**\n * Creates a stub adapter for testing.\n * This helper DRYs up the common pattern of adapter creation in tests.\n *\n * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)\n * to enable type inference in tests without requiring the postgres adapter package.\n */\nexport function createStubAdapter(): Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement> {\n  const codecRegistry = createCodecRegistry();\n\n  // Register stub codecs for common test types\n  // These match the codec IDs used in test contracts (pg/int4@1, pg/text@1, pg/timestamptz@1)\n  // but don't require importing from the postgres adapter package\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/int4@1',\n      targetTypes: ['int4'],\n      encode: (value: number) => value,\n      decode: (wire: number) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/text@1',\n      targetTypes: ['text'],\n      encode: (value: string) => value,\n      decode: (wire: string) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/timestamptz@1',\n      targetTypes: ['timestamptz'],\n      encode: (value: string | Date) => (value instanceof Date ? value.toISOString() : value),\n      decode: (wire: string | Date) => (wire instanceof Date ? wire : new Date(wire)),\n    }),\n  );\n\n  return {\n    profile: {\n      id: 'stub-profile',\n      target: 'postgres',\n      capabilities: {},\n      codecs() {\n        return codecRegistry;\n      },\n      readMarkerStatement() {\n        return {\n          sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta from prisma_contract.marker where id = $1',\n          params: [1],\n        };\n      },\n    },\n    lower(ast: SelectAst, ctx: { contract: Contract<SqlStorage>; params?: readonly unknown[] }) {\n      const sqlText = JSON.stringify(ast);\n      return Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] });\n    },\n  };\n}\n\nexport function createTestContract(\n  contract: Partial<Omit<Contract<SqlStorage>, 'profileHash' | 'storage'>> & {\n    storageHash?: string;\n    profileHash?: string;\n    storage?: Omit<SqlStorage, 'storageHash'>;\n  },\n): Contract<SqlStorage> {\n  const { execution, ...rest } = contract;\n  const storageHashValue = coreHash(rest['storageHash'] ?? 'sha256:testcore');\n\n  return {\n    target: rest['target'] ?? 'postgres',\n    targetFamily: rest['targetFamily'] ?? 'sql',\n    storage: rest['storage']\n      ? { ...rest['storage'], storageHash: storageHashValue }\n      : { storageHash: storageHashValue, tables: {} },\n    models: rest['models'] ?? {},\n    roots: rest['roots'] ?? {},\n    capabilities: rest['capabilities'] ?? {},\n    extensionPacks: rest['extensionPacks'] ?? {},\n    meta: rest['meta'] ?? {},\n    ...(execution ? { execution } : {}),\n    profileHash: profileHash(rest['profileHash'] ?? 'sha256:testprofile'),\n  };\n}\n\n// Re-export generic utilities from test-utils\nexport {\n  collectAsync,\n  createDevDatabase,\n  type DevDatabase,\n  teardownTestDatabase,\n  withClient,\n} from '@prisma-next/test-utils';\n"],"mappings":"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"}
+{"version":3,"file":"utils.mjs","names":["collectAsync"],"sources":["../../test/utils.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { coreHash, profileHash } from '@prisma-next/contract/types';\nimport {\n  instantiateExecutionStack,\n  type RuntimeDriverDescriptor,\n} from '@prisma-next/framework-components/execution';\nimport type { ResultType } from '@prisma-next/framework-components/runtime';\nimport { builtinGeneratorIds } from '@prisma-next/ids';\nimport { generateId } from '@prisma-next/ids/runtime';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport type { Adapter, LoweredStatement, SelectAst } from '@prisma-next/sql-relational-core/ast';\nimport { codec, createCodecRegistry } from '@prisma-next/sql-relational-core/ast';\nimport type { SqlExecutionPlan, SqlQueryPlan } from '@prisma-next/sql-relational-core/plan';\nimport { collectAsync, drainAsyncIterable } from '@prisma-next/test-utils';\nimport type { Client } from 'pg';\nimport type { SqlStatement } from '../src/exports';\nimport {\n  createExecutionContext,\n  type createRuntime,\n  createSqlExecutionStack,\n  ensureSchemaStatement,\n  ensureTableStatement,\n  parseContractMarkerRow,\n  writeContractMarker,\n} from '../src/exports';\nimport type {\n  ExecutionContext,\n  SqlRuntimeAdapterDescriptor,\n  SqlRuntimeAdapterInstance,\n  SqlRuntimeDriverInstance,\n  SqlRuntimeExtensionDescriptor,\n  SqlRuntimeTargetDescriptor,\n} from '../src/sql-context';\n\nfunction createTestMutationDefaultGenerators() {\n  return builtinGeneratorIds.map((id) => ({\n    id,\n    generate: (params?: Record<string, unknown>) => generateId(params ? { id, params } : { id }),\n  }));\n}\n\n/**\n * Executes a plan and collects all results into an array.\n * This helper DRYs up the common pattern of executing plans in tests.\n * The return type is inferred from the plan's type parameter.\n */\nexport async function executePlanAndCollect<\n  P extends SqlExecutionPlan<ResultType<P>> | SqlQueryPlan<ResultType<P>>,\n>(runtime: ReturnType<typeof createRuntime>, plan: P): Promise<ResultType<P>[]> {\n  type Row = ResultType<P>;\n  return collectAsync<Row>(runtime.execute<Row>(plan));\n}\n\n/**\n * Drains a plan execution, consuming all results without collecting them.\n * Useful for testing side effects without memory overhead.\n */\nexport async function drainPlanExecution(\n  runtime: ReturnType<typeof createRuntime>,\n  plan: SqlExecutionPlan | SqlQueryPlan<unknown>,\n): Promise<void> {\n  return drainAsyncIterable(runtime.execute(plan));\n}\n\n/**\n * Executes a SQL statement on a database client.\n */\nexport async function executeStatement(client: Client, statement: SqlStatement): Promise<void> {\n  if (statement.params.length > 0) {\n    await client.query(statement.sql, [...statement.params]);\n    return;\n  }\n\n  await client.query(statement.sql);\n}\n\n/**\n * Sets up database schema and data, then writes the contract marker.\n * This helper DRYs up the common pattern of database setup in tests.\n */\nexport async function setupTestDatabase(\n  client: Client,\n  contract: Contract<SqlStorage>,\n  setupFn: (client: Client) => Promise<void>,\n): Promise<void> {\n  await client.query('drop schema if exists prisma_contract cascade');\n  await client.query('create schema if not exists public');\n\n  await setupFn(client);\n\n  await executeStatement(client, ensureSchemaStatement);\n  await executeStatement(client, ensureTableStatement);\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Writes a contract marker to the database.\n * This helper DRYs up the common pattern of writing contract markers in tests.\n */\nexport async function writeTestContractMarker(\n  client: Client,\n  contract: Contract<SqlStorage>,\n): Promise<void> {\n  const write = writeContractMarker({\n    storageHash: contract.storage.storageHash,\n    profileHash: contract.profileHash,\n    contractJson: contract,\n    canonicalVersion: 1,\n  });\n  await executeStatement(client, write.insert);\n}\n\n/**\n * Creates a test adapter descriptor from a raw adapter.\n * Wraps the adapter in an SqlRuntimeAdapterDescriptor with static contributions\n * derived from the adapter's codec registry.\n */\nexport function createTestAdapterDescriptor(\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n): SqlRuntimeAdapterDescriptor<'postgres'> {\n  const codecRegistry = adapter.profile.codecs();\n  return {\n    kind: 'adapter' as const,\n    id: 'test-adapter',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => codecRegistry,\n    parameterizedCodecs: () => [],\n    mutationDefaultGenerators: createTestMutationDefaultGenerators,\n    create(_stack): SqlRuntimeAdapterInstance<'postgres'> {\n      return Object.assign({ familyId: 'sql' as const, targetId: 'postgres' as const }, adapter);\n    },\n  };\n}\n\n/**\n * Creates a test target descriptor with empty static contributions.\n */\nexport function createTestTargetDescriptor(): SqlRuntimeTargetDescriptor<'postgres'> {\n  return {\n    kind: 'target' as const,\n    id: 'postgres',\n    version: '0.0.1',\n    familyId: 'sql' as const,\n    targetId: 'postgres' as const,\n    codecs: () => createCodecRegistry(),\n    parameterizedCodecs: () => [],\n    create() {\n      return { familyId: 'sql' as const, targetId: 'postgres' as const };\n    },\n  };\n}\n\n/**\n * Creates an ExecutionContext for testing.\n * This helper DRYs up the common pattern of context creation in tests.\n *\n * Accepts a raw adapter and optional extension descriptors, wrapping the\n * adapter in a descriptor internally for descriptor-first context creation.\n */\nexport function createTestContext<TContract extends Contract<SqlStorage>>(\n  contract: TContract,\n  adapter: Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement>,\n  options?: {\n    extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  },\n): ExecutionContext<TContract> {\n  return createExecutionContext({\n    contract,\n    stack: {\n      target: createTestTargetDescriptor(),\n      adapter: createTestAdapterDescriptor(adapter),\n      extensionPacks: options?.extensionPacks ?? [],\n    },\n  });\n}\n\nexport function createTestStackInstance(options?: {\n  extensionPacks?: ReadonlyArray<SqlRuntimeExtensionDescriptor<'postgres'>>;\n  driver?: RuntimeDriverDescriptor<\n    'sql',\n    'postgres',\n    unknown,\n    SqlRuntimeDriverInstance<'postgres'>\n  >;\n}) {\n  const stack = createSqlExecutionStack({\n    target: createTestTargetDescriptor(),\n    adapter: createTestAdapterDescriptor(createStubAdapter()),\n    driver: options?.driver,\n    extensionPacks: options?.extensionPacks ?? [],\n  });\n\n  return instantiateExecutionStack(stack);\n}\n\n/**\n * Creates a stub adapter for testing.\n * This helper DRYs up the common pattern of adapter creation in tests.\n *\n * The stub adapter includes simple codecs for common test types (pg/int4@1, pg/text@1, pg/timestamptz@1)\n * to enable type inference in tests without requiring the postgres adapter package.\n */\nexport function createStubAdapter(): Adapter<SelectAst, Contract<SqlStorage>, LoweredStatement> {\n  const codecRegistry = createCodecRegistry();\n\n  // Register stub codecs for common test types\n  // These match the codec IDs used in test contracts (pg/int4@1, pg/text@1, pg/timestamptz@1)\n  // but don't require importing from the postgres adapter package\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/int4@1',\n      targetTypes: ['int4'],\n      encode: (value: number) => value,\n      decode: (wire: number) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/text@1',\n      targetTypes: ['text'],\n      encode: (value: string) => value,\n      decode: (wire: string) => wire,\n    }),\n  );\n\n  codecRegistry.register(\n    codec({\n      typeId: 'pg/timestamptz@1',\n      targetTypes: ['timestamptz'],\n      encode: (value: Date) => value,\n      decode: (wire: Date) => wire,\n      // Date is not assignable to JsonValue, so the JSON round-trip pair\n      // must be supplied explicitly.\n      encodeJson: (value: Date) => value.toISOString(),\n      decodeJson: (json) => {\n        if (typeof json !== 'string') throw new Error('expected ISO date string');\n        return new Date(json);\n      },\n    }),\n  );\n\n  return {\n    profile: {\n      id: 'stub-profile',\n      target: 'postgres',\n      capabilities: {},\n      codecs() {\n        return codecRegistry;\n      },\n      readMarkerStatement() {\n        return {\n          sql: 'select core_hash, profile_hash, contract_json, canonical_version, updated_at, app_tag, meta, invariants from prisma_contract.marker where id = $1',\n          params: [1],\n        };\n      },\n      parseMarkerRow: parseContractMarkerRow,\n    },\n    lower(ast: SelectAst, ctx: { contract: Contract<SqlStorage>; params?: readonly unknown[] }) {\n      const sqlText = JSON.stringify(ast);\n      return Object.freeze({ sql: sqlText, params: ctx.params ? [...ctx.params] : [] });\n    },\n  };\n}\n\nexport function createTestContract(\n  contract: Partial<Omit<Contract<SqlStorage>, 'profileHash' | 'storage'>> & {\n    storageHash?: string;\n    profileHash?: string;\n    storage?: Omit<SqlStorage, 'storageHash'>;\n  },\n): Contract<SqlStorage> {\n  const { execution, ...rest } = contract;\n  const storageHashValue = coreHash(rest['storageHash'] ?? 'sha256:testcore');\n\n  return {\n    target: rest['target'] ?? 'postgres',\n    targetFamily: rest['targetFamily'] ?? 'sql',\n    storage: rest['storage']\n      ? { ...rest['storage'], storageHash: storageHashValue }\n      : { storageHash: storageHashValue, tables: {} },\n    models: rest['models'] ?? {},\n    roots: rest['roots'] ?? {},\n    capabilities: rest['capabilities'] ?? {},\n    extensionPacks: rest['extensionPacks'] ?? {},\n    meta: rest['meta'] ?? {},\n    ...(execution ? { execution } : {}),\n    profileHash: profileHash(rest['profileHash'] ?? 'sha256:testprofile'),\n  };\n}\n\n// Re-export generic utilities from test-utils\nexport {\n  collectAsync,\n  createDevDatabase,\n  type DevDatabase,\n  teardownTestDatabase,\n  withClient,\n} from '@prisma-next/test-utils';\n"],"mappings":"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"}

package/package.json

@@ -1,20 +1,19 @@
 {
   "name": "@prisma-next/sql-runtime",
-  "version": "0.5.0-dev.4",
+  "version": "0.5.0-dev.40",
   "type": "module",
   "sideEffects": false,
   "description": "SQL runtime implementation for Prisma Next",
   "dependencies": {
     "arktype": "^2.1.26",
-    "@prisma-next/contract": "0.5.0-dev.4",
-    "@prisma-next/utils": "0.5.0-dev.4",
-    "@prisma-next/ids": "0.5.0-dev.4",
-    "@prisma-next/operations": "0.5.0-dev.4",
-    "@prisma-next/runtime-executor": "0.5.0-dev.4",
-    "@prisma-next/framework-components": "0.5.0-dev.4",
-    "@prisma-next/sql-contract": "0.5.0-dev.4",
-    "@prisma-next/sql-operations": "0.5.0-dev.4",
-    "@prisma-next/sql-relational-core": "0.5.0-dev.4"
+    "@prisma-next/contract": "0.5.0-dev.40",
+    "@prisma-next/ids": "0.5.0-dev.40",
+    "@prisma-next/utils": "0.5.0-dev.40",
+    "@prisma-next/operations": "0.5.0-dev.40",
+    "@prisma-next/sql-contract": "0.5.0-dev.40",
+    "@prisma-next/framework-components": "0.5.0-dev.40",
+    "@prisma-next/sql-operations": "0.5.0-dev.40",
+    "@prisma-next/sql-relational-core": "0.5.0-dev.40"
   },
   "devDependencies": {
     "@types/pg": "8.16.0",
@@ -28,8 +27,7 @@
   },
   "files": [
     "dist",
-    "src",
-    "test"
+    "src"
   ],
   "exports": {
     ".": "./dist/index.mjs",

package/src/codecs/decoding.ts

@@ -1,221 +1,342 @@
-import type { ExecutionPlan } from '@prisma-next/contract/types';
-import type { Codec, CodecRegistry } from '@prisma-next/sql-relational-core/ast';
+import {
+  checkAborted,
+  isRuntimeError,
+  raceAgainstAbort,
+  runtimeError,
+} from '@prisma-next/framework-components/runtime';
+import type {
+  AnyQueryAst,
+  Codec,
+  CodecRegistry,
+  ContractCodecRegistry,
+  ProjectionItem,
+  SqlCodecCallContext,
+} from '@prisma-next/sql-relational-core/ast';
+import type { SqlExecutionPlan } from '@prisma-next/sql-relational-core/plan';
 import type { JsonSchemaValidatorRegistry } from '@prisma-next/sql-relational-core/query-lane-context';
 import { validateJsonValue } from './json-schema-validation';
 
-function resolveRowCodec(
-  alias: string,
-  plan: ExecutionPlan,
+type ColumnRef = { table: string; column: string };
+
+interface DecodeContext {
+  readonly aliases: ReadonlyArray<string> | undefined;
+  readonly codecs: ReadonlyMap<string, Codec>;
+  readonly columnRefs: ReadonlyMap<string, ColumnRef>;
+  readonly includeAliases: ReadonlySet<string>;
+}
+
+const WIRE_PREVIEW_LIMIT = 100;
+const EMPTY_INCLUDE_ALIASES: ReadonlySet<string> = new Set<string>();
+
+function isAstBackedPlan(
+  plan: SqlExecutionPlan,
+): plan is SqlExecutionPlan & { readonly ast: AnyQueryAst } {
+  return plan.ast !== undefined;
+}
+
+function projectionListFromAst(ast: AnyQueryAst): ReadonlyArray<ProjectionItem> | undefined {
+  if (ast.kind === 'select') {
+    return ast.projection;
+  }
+  return ast.returning;
+}
+
+/**
+ * Resolve the per-cell codec for a projection item.
+ *
+ * Phase B: when a `(table, column)` ref is available for the projection,
+ * prefer `contractCodecs.forColumn(table, column)` — that's the per-
+ * instance resolved codec materialized from the codec descriptor's
+ * factory at context-construction time (carries any per-instance state
+ * such as the compiled JSON-Schema validator). When the projection
+ * resolves to a non-`column-ref` expression (computed projections, raw
+ * SQL aliases) but still carries a codec id (ADR 205 stamps every
+ * `ProjectionItem` with the producer's codec id), fall back to the
+ * codec-id-keyed `forCodecId(codecId)` lookup, which itself falls back
+ * to the legacy `CodecRegistry` for codec ids the contract walk
+ * couldn't resolve.
+ *
+ * Codec-registry-unification spec § AC-4.
+ */
+function resolveProjectionCodec(
+  item: ProjectionItem,
+  registry: CodecRegistry,
+  contractCodecs: ContractCodecRegistry | undefined,
+): Codec | undefined {
+  if (item.expr.kind === 'column-ref' && contractCodecs) {
+    const byColumn = contractCodecs.forColumn(item.expr.table, item.expr.column);
+    if (byColumn) return byColumn;
+  }
+  if (item.codecId) {
+    const fromContract = contractCodecs?.forCodecId(item.codecId);
+    if (fromContract) return fromContract;
+    return registry.get(item.codecId);
+  }
+  return undefined;
+}
+
+function buildDecodeContext(
+  plan: SqlExecutionPlan,
   registry: CodecRegistry,
-): Codec | null {
-  const planCodecId = plan.meta.annotations?.codecs?.[alias] as string | undefined;
-  if (planCodecId) {
-    const codec = registry.get(planCodecId);
+  contractCodecs: ContractCodecRegistry | undefined,
+): DecodeContext {
+  if (!isAstBackedPlan(plan)) {
+    return {
+      aliases: undefined,
+      codecs: new Map(),
+      columnRefs: new Map(),
+      includeAliases: EMPTY_INCLUDE_ALIASES,
+    };
+  }
+
+  const projection = projectionListFromAst(plan.ast);
+  if (!projection) {
+    return {
+      aliases: undefined,
+      codecs: new Map(),
+      columnRefs: new Map(),
+      includeAliases: EMPTY_INCLUDE_ALIASES,
+    };
+  }
+
+  const aliases: string[] = [];
+  const codecs = new Map<string, Codec>();
+  const columnRefs = new Map<string, ColumnRef>();
+  const includeAliases = new Set<string>();
+
+  for (const item of projection) {
+    aliases.push(item.alias);
+
+    const codec = resolveProjectionCodec(item, registry, contractCodecs);
     if (codec) {
-      return codec;
+      codecs.set(item.alias, codec);
     }
-  }
 
-  if (plan.meta.projectionTypes) {
-    const typeId = plan.meta.projectionTypes[alias];
-    if (typeId) {
-      const codec = registry.get(typeId);
-      if (codec) {
-        return codec;
-      }
+    if (item.expr.kind === 'column-ref') {
+      columnRefs.set(item.alias, { table: item.expr.table, column: item.expr.column });
+    } else if (item.expr.kind === 'subquery' || item.expr.kind === 'json-array-agg') {
+      includeAliases.add(item.alias);
     }
   }
 
-  return null;
+  return { aliases, codecs, columnRefs, includeAliases };
 }
 
-type ColumnRefIndex = Map<string, { table: string; column: string }>;
+function previewWireValue(wireValue: unknown): string {
+  if (typeof wireValue === 'string') {
+    return wireValue.length > WIRE_PREVIEW_LIMIT
+      ? `${wireValue.substring(0, WIRE_PREVIEW_LIMIT)}...`
+      : wireValue;
+  }
+  return String(wireValue).substring(0, WIRE_PREVIEW_LIMIT);
+}
 
-/**
- * Builds a lookup index from column name → { table, column } ref.
- * Called once per decodeRow invocation to avoid O(aliases × refs) linear scans.
- */
-function buildColumnRefIndex(plan: ExecutionPlan): ColumnRefIndex | null {
-  const columns = plan.meta.refs?.columns;
-  if (!columns) return null;
+function isJsonSchemaValidationError(error: unknown): boolean {
+  return isRuntimeError(error) && error.code === 'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED';
+}
+
+function wrapDecodeFailure(
+  error: unknown,
+  alias: string,
+  ref: ColumnRef | undefined,
+  codec: Codec,
+  wireValue: unknown,
+): never {
+  const message = error instanceof Error ? error.message : String(error);
+  const target = ref ? `${ref.table}.${ref.column}` : alias;
+  const wrapped = runtimeError(
+    'RUNTIME.DECODE_FAILED',
+    `Failed to decode column ${target} with codec '${codec.id}': ${message}`,
+    {
+      ...(ref ? { table: ref.table, column: ref.column } : { alias }),
+      codec: codec.id,
+      wirePreview: previewWireValue(wireValue),
+    },
+  );
+  wrapped.cause = error;
+  throw wrapped;
+}
+
+function wrapIncludeAggregateFailure(error: unknown, alias: string, wireValue: unknown): never {
+  const message = error instanceof Error ? error.message : String(error);
+  const wrapped = runtimeError(
+    'RUNTIME.DECODE_FAILED',
+    `Failed to parse JSON array for include alias '${alias}': ${message}`,
+    {
+      alias,
+      wirePreview: previewWireValue(wireValue),
+    },
+  );
+  wrapped.cause = error;
+  throw wrapped;
+}
+
+function decodeIncludeAggregate(alias: string, wireValue: unknown): unknown {
+  if (wireValue === null || wireValue === undefined) {
+    return [];
+  }
+
+  try {
+    let parsed: unknown;
+    if (typeof wireValue === 'string') {
+      parsed = JSON.parse(wireValue);
+    } else if (Array.isArray(wireValue)) {
+      parsed = wireValue;
+    } else {
+      parsed = JSON.parse(String(wireValue));
+    }
 
-  const index: ColumnRefIndex = new Map();
-  for (const ref of columns) {
-    index.set(ref.column, ref);
+    if (!Array.isArray(parsed)) {
+      throw new Error(`Expected array for include alias '${alias}', got ${typeof parsed}`);
+    }
+
+    return parsed;
+  } catch (error) {
+    wrapIncludeAggregateFailure(error, alias, wireValue);
   }
-  return index;
 }
 
-function parseProjectionRef(value: string): { table: string; column: string } | null {
-  if (value.startsWith('include:') || value.startsWith('operation:')) {
+/**
+ * Decodes a single field. Single-armed: every cell takes the same path —
+ * `codec.decode → await → JSON-Schema validate → return plain value` — so
+ * sync- and async-authored codecs are indistinguishable to callers.
+ *
+ * The row-level `rowCtx` is repackaged into a per-cell
+ * `SqlCodecCallContext` whose `column = { table, name }` is a structural
+ * projection of the per-cell `ColumnRef = { table, column }` resolved from
+ * the AST-backed `DecodeContext` (the same resolution `wrapDecodeFailure`
+ * uses for envelope construction — one resolution per cell, two consumers).
+ * Cells the runtime cannot resolve to a single underlying column (aggregate
+ * aliases, computed projections without a simple ref) get
+ * `column: undefined`, matching the spec contract that the runtime never
+ * silently defaults this field.
+ */
+async function decodeField(
+  alias: string,
+  wireValue: unknown,
+  decodeCtx: DecodeContext,
+  jsonValidators: JsonSchemaValidatorRegistry | undefined,
+  rowCtx: SqlCodecCallContext,
+): Promise<unknown> {
+  if (wireValue === null) {
     return null;
   }
 
-  const separatorIndex = value.indexOf('.');
-  if (separatorIndex <= 0 || separatorIndex === value.length - 1) {
-    return null;
+  const codec = decodeCtx.codecs.get(alias);
+  if (!codec) {
+    return wireValue;
   }
 
-  return {
-    table: value.slice(0, separatorIndex),
-    column: value.slice(separatorIndex + 1),
-  };
-}
+  const ref = decodeCtx.columnRefs.get(alias);
 
-function resolveColumnRefForAlias(
-  alias: string,
-  projection: ExecutionPlan['meta']['projection'],
-  fallbackColumnRefIndex: ColumnRefIndex | null,
-): { table: string; column: string } | undefined {
-  if (projection && !Array.isArray(projection)) {
-    const mappedRef = (projection as Record<string, string>)[alias];
-    if (typeof mappedRef !== 'string') {
-      return undefined;
+  // Per-cell ctx: the cell-level `column` is a `SqlColumnRef = { table, name }`
+  // projection of the resolved `ColumnRef = { table, column }` (same
+  // resolution `wrapDecodeFailure` uses below — no double work). Cells the
+  // runtime cannot resolve (aggregate aliases, computed projections without
+  // a simple ref) drop the `column` field entirely — explicitly cleared so
+  // a previously-populated `rowCtx.column` cannot leak through to unrelated
+  // cells. Destructuring (rather than `column: undefined`) is required
+  // because `SqlCodecCallContext.column` is declared `column?: SqlColumnRef`
+  // under `exactOptionalPropertyTypes`.
+  let cellCtx: SqlCodecCallContext;
+  if (ref) {
+    cellCtx = { ...rowCtx, column: { table: ref.table, name: ref.column } };
+  } else {
+    const { column: _drop, ...rowCtxWithoutColumn } = rowCtx;
+    cellCtx = rowCtxWithoutColumn;
+  }
+
+  let decoded: unknown;
+  try {
+    decoded = await codec.decode(wireValue, cellCtx);
+  } catch (error) {
+    wrapDecodeFailure(error, alias, ref, codec, wireValue);
+  }
+
+  if (jsonValidators && ref) {
+    try {
+      validateJsonValue(jsonValidators, ref.table, ref.column, decoded, 'decode', codec.id);
+    } catch (error) {
+      if (isJsonSchemaValidationError(error)) throw error;
+      wrapDecodeFailure(error, alias, ref, codec, wireValue);
     }
-    return parseProjectionRef(mappedRef) ?? undefined;
   }
 
-  return fallbackColumnRefIndex?.get(alias);
+  return decoded;
 }
 
-export function decodeRow(
+/**
+ * Decodes a row by dispatching all per-cell codec calls concurrently via
+ * `Promise.all`. Each cell follows the single-armed `decodeField` path.
+ * Failures are wrapped in `RUNTIME.DECODE_FAILED` with `{ table, column,
+ * codec }` (or `{ alias, codec }` when no column ref is resolvable) and the
+ * original error attached on `cause`.
+ *
+ * When `rowCtx.signal` is provided:
+ *
+ * - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED`
+ *   (`{ phase: 'decode' }`) before any `codec.decode` call is made.
+ * - **Mid-flight aborts** race the per-cell `Promise.all` against the
+ *   signal so the runtime returns promptly even when codec bodies ignore
+ *   it. In-flight bodies that ignore the signal complete in the
+ *   background (cooperative cancellation).
+ * - Existing `RUNTIME.DECODE_FAILED` envelopes from codec bodies pass
+ *   through unchanged (no double wrap).
+ */
+export async function decodeRow(
   row: Record<string, unknown>,
-  plan: ExecutionPlan,
+  plan: SqlExecutionPlan,
   registry: CodecRegistry,
-  jsonValidators?: JsonSchemaValidatorRegistry,
-): Record<string, unknown> {
-  const decoded: Record<string, unknown> = {};
-  const projection = plan.meta.projection;
+  jsonValidators: JsonSchemaValidatorRegistry | undefined,
+  rowCtx: SqlCodecCallContext,
+  contractCodecs?: ContractCodecRegistry,
+): Promise<Record<string, unknown>> {
+  checkAborted(rowCtx, 'decode');
+  const signal = rowCtx.signal;
 
-  // Fallback for plans that do not provide projection alias -> table.column mapping.
-  const fallbackColumnRefIndex =
-    jsonValidators && (!projection || Array.isArray(projection)) ? buildColumnRefIndex(plan) : null;
+  const decodeCtx = buildDecodeContext(plan, registry, contractCodecs);
 
-  let aliases: readonly string[];
-  if (projection && !Array.isArray(projection)) {
-    aliases = Object.keys(projection);
-  } else if (projection && Array.isArray(projection)) {
-    aliases = projection;
-  } else {
-    aliases = Object.keys(row);
-  }
-
-  for (const alias of aliases) {
-    const wireValue = row[alias];
-
-    const projectionValue =
-      projection && typeof projection === 'object' && !Array.isArray(projection)
-        ? (projection as Record<string, string>)[alias]
-        : undefined;
-
-    if (typeof projectionValue === 'string' && projectionValue.startsWith('include:')) {
-      if (wireValue === null || wireValue === undefined) {
-        decoded[alias] = [];
-        continue;
-      }
+  const aliases = decodeCtx.aliases ?? Object.keys(row);
 
-      try {
-        let parsed: unknown;
-        if (typeof wireValue === 'string') {
-          parsed = JSON.parse(wireValue);
-        } else if (Array.isArray(wireValue)) {
-          parsed = wireValue;
-        } else {
-          parsed = JSON.parse(String(wireValue));
-        }
-
-        if (!Array.isArray(parsed)) {
-          throw new Error(`Expected array for include alias '${alias}', got ${typeof parsed}`);
-        }
-
-        decoded[alias] = parsed;
-      } catch (error) {
-        const decodeError = new Error(
-          `Failed to parse JSON array for include alias '${alias}': ${error instanceof Error ? error.message : String(error)}`,
-        ) as Error & {
-          code: string;
-          category: string;
-          severity: string;
-          details?: Record<string, unknown>;
-        };
-        decodeError.code = 'RUNTIME.DECODE_FAILED';
-        decodeError.category = 'RUNTIME';
-        decodeError.severity = 'error';
-        decodeError.details = {
+  if (decodeCtx.aliases !== undefined) {
+    for (const alias of decodeCtx.aliases) {
+      if (!Object.hasOwn(row, alias)) {
+        throw runtimeError('RUNTIME.DECODE_FAILED', `Row missing projection alias "${alias}"`, {
           alias,
-          wirePreview:
-            typeof wireValue === 'string' && wireValue.length > 100
-              ? `${wireValue.substring(0, 100)}...`
-              : String(wireValue).substring(0, 100),
-        };
-        throw decodeError;
+          expectedAliases: decodeCtx.aliases,
+          presentKeys: Object.keys(row),
+        });
       }
-      continue;
     }
+  }
 
-    if (wireValue === null || wireValue === undefined) {
-      decoded[alias] = wireValue;
-      continue;
-    }
+  const tasks: Promise<unknown>[] = [];
+  const includeIndices: { index: number; alias: string; value: unknown }[] = [];
 
-    const codec = resolveRowCodec(alias, plan, registry);
+  for (let i = 0; i < aliases.length; i++) {
+    const alias = aliases[i] as string;
+    const wireValue = row[alias];
 
-    if (!codec) {
-      decoded[alias] = wireValue;
+    if (decodeCtx.includeAliases.has(alias)) {
+      includeIndices.push({ index: i, alias, value: wireValue });
+      tasks.push(Promise.resolve(undefined));
       continue;
     }
 
-    try {
-      const decodedValue = codec.decode(wireValue);
-
-      // Validate decoded JSON value against schema
-      if (jsonValidators) {
-        const ref = resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex);
-        if (ref) {
-          validateJsonValue(
-            jsonValidators,
-            ref.table,
-            ref.column,
-            decodedValue,
-            'decode',
-            codec.id,
-          );
-        }
-      }
+    tasks.push(decodeField(alias, wireValue, decodeCtx, jsonValidators, rowCtx));
+  }
 
-      decoded[alias] = decodedValue;
-    } catch (error) {
-      // Re-throw JSON schema validation errors as-is
-      if (
-        error instanceof Error &&
-        'code' in error &&
-        (error as Error & { code: string }).code === 'RUNTIME.JSON_SCHEMA_VALIDATION_FAILED'
-      ) {
-        throw error;
-      }
+  const settled = await raceAgainstAbort(Promise.all(tasks), signal, 'decode');
 
-      const decodeError = new Error(
-        `Failed to decode row alias '${alias}' with codec '${codec.id}': ${error instanceof Error ? error.message : String(error)}`,
-      ) as Error & {
-        code: string;
-        category: string;
-        severity: string;
-        details?: Record<string, unknown>;
-      };
-      decodeError.code = 'RUNTIME.DECODE_FAILED';
-      decodeError.category = 'RUNTIME';
-      decodeError.severity = 'error';
-      decodeError.details = {
-        alias,
-        codec: codec.id,
-        wirePreview:
-          typeof wireValue === 'string' && wireValue.length > 100
-            ? `${wireValue.substring(0, 100)}...`
-            : String(wireValue).substring(0, 100),
-      };
-      throw decodeError;
-    }
+  // Include aggregates are decoded synchronously after concurrent codec
+  // dispatch settles, so any decode failures upstream propagate first.
+  for (const entry of includeIndices) {
+    settled[entry.index] = decodeIncludeAggregate(entry.alias, entry.value);
   }
 
+  const decoded: Record<string, unknown> = {};
+  for (let i = 0; i < aliases.length; i++) {
+    decoded[aliases[i] as string] = settled[i];
+  }
   return decoded;
 }