@prisma-next/sql-runtime 0.12.0 → 0.13.0-dev.10

package/README.md

@@ -23,7 +23,7 @@ Execute SQL query Plans with deterministic verification, guardrails, and feedbac
 - **Mutation Default Generator Composition**: Assemble execution default generators from composed target/adapter/extension contributors
 - **No Implicit Generator Baseline**: Runtime resolves generator ids only from composed contributors (no built-in runtime fallback table)
 - **SQL Context Creation**: Create runtime contexts with SQL contracts, adapters, and codecs
-- **SQL Marker Management**: Provide SQL statements for reading/writing contract markers
+- **SQL Marker Bootstrap**: Provide test-utility helpers for bootstrapping the marker table; marker reads and writes both go through the control adapter SPI
 - **Codec Encoding/Decoding**: Encode parameters and decode rows using SQL codec registries
 - **Codec Validation**: Validate that codec registries contain all required codecs
 - **SQL Family Adapter**: Implement `RuntimeFamilyAdapter` for SQL contracts (defined in `runtime-spi.ts`)
@@ -124,12 +124,15 @@ const runtime = createRuntime({
 - `validateCodecRegistryCompleteness` - Codec validation
 - `extractCodecIds` - Extract codec IDs from a contract
 - `validateContractCodecMappings` - Validate contract codec mappings against registry
+- `createAstCodecRegistry` - Contract-free codec registry that resolves codecs from AST-supplied `CodecRef`s
+- `deriveParamMetadata` - Walk a control DML AST and collect per-value codec metadata for encoding
+- `encodeParamsWithMetadata` - Encode lowered control DML parameters through their codecs
 
 ### SQL Marker
 
-- `readContractMarker`, `writeContractMarker` - SQL marker statements
-- `ensureSchemaStatement`, `ensureTableStatement` - DDL statements for marker table setup
-- `SqlStatement` - SQL statement type
+- Test helpers in `./test/utils` bootstrap marker tables via contract-free DDL lowering
+
+Marker reads and writes go through the control adapter SPI (`adapter.readMarker`, `adapter.initMarker`, `adapter.updateMarker`, `adapter.writeLedgerEntry`).
 
 ### Plan Lowering
 

package/dist/{exports-CXYd2w6k.mjs → exports-DDqF-xmg.mjs}

@@ -1,23 +1,143 @@
 import { AsyncIterableResult, RuntimeCore, checkAborted, checkMiddlewareCompatibility, isRuntimeError, raceAgainstAbort, runBeforeExecuteChain, runWithMiddleware, runtimeError } from "@prisma-next/framework-components/runtime";
-import { type } from "arktype";
+import { canonicalizeJson } from "@prisma-next/framework-components/utils";
 import { PreparedParamRef, collectOrderedParamRefs, isQueryAst } from "@prisma-next/sql-relational-core/ast";
 import { ifDefined } from "@prisma-next/utils/defined";
 import { checkContractComponentRequirements, mergeCapabilityMatrices } from "@prisma-next/framework-components/components";
 import { createExecutionStack } from "@prisma-next/framework-components/execution";
-import { canonicalizeJson } from "@prisma-next/framework-components/utils";
 import { isPostgresEnumStorageEntry } from "@prisma-next/sql-contract/types";
 import { blindCast } from "@prisma-next/utils/casts";
 import { createSqlOperationRegistry } from "@prisma-next/sql-operations";
 import { buildCodecDescriptorRegistry } from "@prisma-next/sql-relational-core/codec-descriptor-registry";
-import { APP_SPACE_ID } from "@prisma-next/framework-components/control";
 import { createSqlParamRefMutator } from "@prisma-next/sql-relational-core/middleware";
 import { canonicalStringify } from "@prisma-next/utils/canonical-stringify";
 import { hashContent } from "@prisma-next/utils/hash-content";
 import { createHash } from "node:crypto";
+//#region src/codecs/ast-codec-resolver.ts
+/**
+* Build an {@link AstCodecResolver} bound to a descriptor registry and a per-call instance-context factory.
+*
+* The instance-context factory lets callers control `name` / `usedAt` for refs the AST supplies (e.g. AST-embedded migration ops where the materialisation site is the AST node, not a contract column). The contract-walk pre-population path constructs its own contexts and invokes the resolver with those refs to seed the cache.
+*/
+function createAstCodecResolver(descriptors, instanceContextFor) {
+	const cache = /* @__PURE__ */ new Map();
+	return { forCodecRef(ref) {
+		const key = `${ref.codecId}:${canonicalizeJson(ref.typeParams)}`;
+		const cached = cache.get(key);
+		if (cached) return cached;
+		const descriptor = descriptors.descriptorFor(ref.codecId);
+		if (!descriptor) throw runtimeError("RUNTIME.CODEC_DESCRIPTOR_MISSING", `No codec descriptor registered for codecId '${ref.codecId}'.`, { codecId: ref.codecId });
+		const validated = validateTypeParams$1(descriptor.paramsSchema, descriptor.isParameterized && ref.typeParams === void 0 ? {
+			...ref,
+			typeParams: {}
+		} : ref);
+		const ctx = instanceContextFor(ref);
+		const codec = descriptor.factory(validated)(ctx);
+		cache.set(key, codec);
+		return codec;
+	} };
+}
+function validateTypeParams$1(paramsSchema, ref) {
+	const result = paramsSchema["~standard"].validate(ref.typeParams);
+	if (result instanceof Promise) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `paramsSchema for codec '${ref.codecId}' returned a Promise; runtime validation requires a synchronous Standard Schema validator.`, {
+		codecId: ref.codecId,
+		typeParams: ref.typeParams
+	});
+	if ("issues" in result && result.issues) {
+		const messages = result.issues.map((issue) => issue.message).join("; ");
+		throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Invalid typeParams for codec '${ref.codecId}': ${messages}`, {
+			codecId: ref.codecId,
+			typeParams: ref.typeParams
+		});
+	}
+	return result.value;
+}
+//#endregion
+//#region src/codecs/ast-codec-registry.ts
+/**
+* Build a contract-free {@link ContractCodecRegistry} that resolves codecs
+* purely from AST-supplied {@link import('@prisma-next/framework-components/codec').CodecRef}s
+* against a target's descriptor registry.
+*
+* Dispatch is driven entirely by `CodecRef`s embedded in AST nodes; no
+* contract walk is needed. `forColumn` always returns `undefined` — this
+* registry carries no column-to-codec mappings.
+*/
+function createAstCodecRegistry(descriptors) {
+	const resolver = createAstCodecResolver(descriptors, (ref) => ({
+		name: ref.codecId,
+		usedAt: []
+	}));
+	return {
+		forColumn: () => void 0,
+		forCodecRef: (ref) => resolver.forCodecRef(ref)
+	};
+}
+//#endregion
+//#region src/codecs/encoding.ts
+const NO_METADATA = Object.freeze({
+	codec: void 0,
+	name: void 0
+});
+function deriveParamMetadata(ast) {
+	return collectOrderedParamRefs(ast).map((ref) => {
+		return {
+			codec: ref.codec,
+			name: ref.name
+		};
+	});
+}
+function resolveParamCodec(metadata, contractCodecs) {
+	if (metadata.codec && contractCodecs) return contractCodecs.forCodecRef(metadata.codec);
+}
+function paramLabel(metadata, paramIndex) {
+	return metadata.name ?? `param[${paramIndex}]`;
+}
+function wrapEncodeFailure(error, metadata, paramIndex, codecId) {
+	const label = paramLabel(metadata, paramIndex);
+	const wrapped = runtimeError("RUNTIME.ENCODE_FAILED", `Failed to encode parameter ${label} with codec '${codecId}': ${error instanceof Error ? error.message : String(error)}`, {
+		label,
+		codec: codecId,
+		paramIndex
+	});
+	wrapped.cause = error;
+	throw wrapped;
+}
+async function encodeParamValue(value, metadata, paramIndex, ctx, contractCodecs) {
+	if (value === null || value === void 0) return null;
+	const codec = resolveParamCodec(metadata, contractCodecs);
+	if (!codec) return value;
+	try {
+		return await codec.encode(value, ctx);
+	} catch (error) {
+		if (isRuntimeError(error)) throw error;
+		wrapEncodeFailure(error, metadata, paramIndex, codec.id);
+	}
+}
+/**
+* Encodes all parameters concurrently via `Promise.all`. Per parameter, sync-and async-authored codecs share the same path: `codec.encode → await → return`. Param-level failures are wrapped in `RUNTIME.ENCODE_FAILED`.
+*
+* When `ctx.signal` is provided:
+*
+* - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED` (`{ phase: 'encode' }`) before any `codec.encode` call is made — codecs can pin this with a per-call counter that stays at zero.
+* - **Mid-flight abort** races the per-param `Promise.all` against `abortable(ctx.signal)`. The runtime returns `RUNTIME.ABORTED` promptly even if codec bodies ignore the signal; the in-flight bodies are abandoned and run to completion in the background (cooperative cancellation, see ADR 204).
+* - Existing `RUNTIME.ENCODE_FAILED` envelopes that surface from a codec body before the runtime observes the abort pass through unchanged (no double wrap).
+*/
+async function encodeParams(plan, ctx, contractCodecs) {
+	return encodeParamsWithMetadata(plan.params, deriveParamMetadata(plan.ast), ctx, contractCodecs);
+}
+async function encodeParamsWithMetadata(values, metadata, ctx, contractCodecs) {
+	checkAborted(ctx, "encode");
+	const signal = ctx.signal;
+	if (values.length === 0) return values;
+	const tasks = values.map((value, i) => encodeParamValue(value, metadata[i] ?? NO_METADATA, i, ctx, contractCodecs));
+	const settled = await raceAgainstAbort(Promise.all(tasks), signal, "encode");
+	return Object.freeze(settled);
+}
+//#endregion
 //#region src/codecs/validation.ts
 function extractCodecIds(contract) {
 	const codecIds = /* @__PURE__ */ new Set();
-	for (const ns of Object.values(contract.storage.namespaces)) for (const table of Object.values(ns.tables)) for (const column of Object.values(table.columns)) {
+	for (const ns of Object.values(contract.storage.namespaces)) for (const table of Object.values(ns.entries.table)) for (const column of Object.values(table.columns)) {
 		const codecId = column.codecId;
 		codecIds.add(codecId);
 	}
@@ -25,7 +145,7 @@ function extractCodecIds(contract) {
 }
 function extractCodecIdsFromColumns(contract) {
 	const codecIds = /* @__PURE__ */ new Map();
-	for (const ns of Object.values(contract.storage.namespaces)) for (const [tableName, table] of Object.entries(ns.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+	for (const ns of Object.values(contract.storage.namespaces)) for (const [tableName, table] of Object.entries(ns.entries.table)) for (const [columnName, column] of Object.entries(table.columns)) {
 		const codecId = column.codecId;
 		const key = `${tableName}.${columnName}`;
 		codecIds.set(key, codecId);
@@ -84,50 +204,6 @@ function lowerSqlPlan(adapter, contract, queryPlan) {
 	});
 }
 //#endregion
-//#region src/marker.ts
-const MetaSchema = type({ "[string]": "unknown" });
-function parseMeta(meta) {
-	if (meta === null || meta === void 0) return {};
-	let parsed;
-	if (typeof meta === "string") try {
-		parsed = JSON.parse(meta);
-	} catch {
-		return {};
-	}
-	else parsed = meta;
-	const result = MetaSchema(parsed);
-	if (result instanceof type.errors) return {};
-	return result;
-}
-const ContractMarkerRowSchema = type({
-	core_hash: "string",
-	profile_hash: "string",
-	"contract_json?": "unknown | null",
-	"canonical_version?": "number | null",
-	"updated_at?": "Date | string",
-	"app_tag?": "string | null",
-	"meta?": "unknown | null",
-	invariants: type("string").array()
-});
-function parseContractMarkerRow(row) {
-	const result = ContractMarkerRowSchema(row);
-	if (result instanceof type.errors) {
-		const messages = result.map((p) => p.message).join("; ");
-		throw new Error(`Invalid contract marker row: ${messages}`);
-	}
-	const updatedAt = result.updated_at ? result.updated_at instanceof Date ? result.updated_at : new Date(result.updated_at) : /* @__PURE__ */ new Date();
-	return {
-		storageHash: result.core_hash,
-		profileHash: result.profile_hash,
-		contractJson: result.contract_json ?? null,
-		canonicalVersion: result.canonical_version ?? null,
-		updatedAt,
-		appTag: result.app_tag ?? null,
-		meta: parseMeta(result.meta),
-		invariants: result.invariants
-	};
-}
-//#endregion
 //#region src/middleware/budgets.ts
 function hasAggregateWithoutGroupBy(ast) {
 	if (ast.groupBy !== void 0) return false;
@@ -396,46 +472,6 @@ function lints(options) {
 	});
 }
 //#endregion
-//#region src/codecs/ast-codec-resolver.ts
-/**
-* Build an {@link AstCodecResolver} bound to a descriptor registry and a per-call instance-context factory.
-*
-* The instance-context factory lets callers control `name` / `usedAt` for refs the AST supplies (e.g. AST-embedded migration ops where the materialisation site is the AST node, not a contract column). The contract-walk pre-population path constructs its own contexts and invokes the resolver with those refs to seed the cache.
-*/
-function createAstCodecResolver(descriptors, instanceContextFor) {
-	const cache = /* @__PURE__ */ new Map();
-	return { forCodecRef(ref) {
-		const key = `${ref.codecId}:${canonicalizeJson(ref.typeParams)}`;
-		const cached = cache.get(key);
-		if (cached) return cached;
-		const descriptor = descriptors.descriptorFor(ref.codecId);
-		if (!descriptor) throw runtimeError("RUNTIME.CODEC_DESCRIPTOR_MISSING", `No codec descriptor registered for codecId '${ref.codecId}'.`, { codecId: ref.codecId });
-		const validated = validateTypeParams$1(descriptor.paramsSchema, descriptor.isParameterized && ref.typeParams === void 0 ? {
-			...ref,
-			typeParams: {}
-		} : ref);
-		const ctx = instanceContextFor(ref);
-		const codec = descriptor.factory(validated)(ctx);
-		cache.set(key, codec);
-		return codec;
-	} };
-}
-function validateTypeParams$1(paramsSchema, ref) {
-	const result = paramsSchema["~standard"].validate(ref.typeParams);
-	if (result instanceof Promise) throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `paramsSchema for codec '${ref.codecId}' returned a Promise; runtime validation requires a synchronous Standard Schema validator.`, {
-		codecId: ref.codecId,
-		typeParams: ref.typeParams
-	});
-	if ("issues" in result && result.issues) {
-		const messages = result.issues.map((issue) => issue.message).join("; ");
-		throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Invalid typeParams for codec '${ref.codecId}': ${messages}`, {
-			codecId: ref.codecId,
-			typeParams: ref.typeParams
-		});
-	}
-	return result.value;
-}
-//#endregion
 //#region src/sql-context.ts
 function documentScopedCodecTypes(contract) {
 	return blindCast(contract.storage.types);
@@ -531,7 +567,7 @@ function collectCodecDescriptors(contributors) {
 }
 function collectTypeRefSites(storage) {
 	const sites = /* @__PURE__ */ new Map();
-	for (const ns of Object.values(storage.namespaces)) for (const [tableName, table] of Object.entries(ns.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+	for (const ns of Object.values(storage.namespaces)) for (const [tableName, table] of Object.entries(ns.entries.table)) for (const [columnName, column] of Object.entries(table.columns)) {
 		if (typeof column.typeRef !== "string") continue;
 		const list = sites.get(column.typeRef);
 		const entry = {
@@ -556,7 +592,7 @@ function initializeTypeHelpers(storage, documentTypes, codecDescriptors) {
 			helpers[typeName] = typeInstance;
 			continue;
 		}
-		const validatedParams = validateTypeParams(typeParams, descriptor, { typeName });
+		const validatedParams = validateTypeParams(typeParams ?? {}, descriptor, { typeName });
 		const ctx = {
 			name: typeName,
 			usedAt: typeRefSites.get(typeName) ?? []
@@ -566,7 +602,7 @@ function initializeTypeHelpers(storage, documentTypes, codecDescriptors) {
 	return helpers;
 }
 function validateColumnTypeParams(storage, codecDescriptors) {
-	for (const ns of Object.values(storage.namespaces)) for (const [tableName, table] of Object.entries(ns.tables)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeParams) {
+	for (const ns of Object.values(storage.namespaces)) for (const [tableName, table] of Object.entries(ns.entries.table)) for (const [columnName, column] of Object.entries(table.columns)) if (column.typeParams) {
 		const descriptor = codecDescriptors.get(column.codecId);
 		if (descriptor) validateTypeParams(column.typeParams, descriptor, {
 			tableName,
@@ -586,8 +622,8 @@ function validateColumnTypeParams(storage, codecDescriptors) {
 * Runs unconditionally from `createExecutionContext` so contract bugs fail fast at construction time instead of silently skipping affected columns in the codec registry's pre-population walk.
 */
 function assertColumnCodecIntegrity(storage, codecDescriptors) {
-	for (const ns of Object.values(storage.namespaces)) for (const [tableName, table] of Object.entries(ns.tables)) for (const columnName of Object.keys(table.columns)) {
-		const ref = codecDescriptors.codecRefForColumn(tableName, columnName);
+	for (const [namespaceId, ns] of Object.entries(storage.namespaces)) for (const [tableName, table] of Object.entries(ns.entries.table)) for (const columnName of Object.keys(table.columns)) {
+		const ref = codecDescriptors.codecRefForColumn(namespaceId, tableName, columnName);
 		if (!ref) continue;
 		const descriptor = codecDescriptors.descriptorFor(ref.codecId);
 		if (!descriptor) throw runtimeError("RUNTIME.CODEC_DESCRIPTOR_MISSING", `Column '${tableName}.${columnName}' references codec '${ref.codecId}' but no contributor registered a codec descriptor for that codecId. Add the extension pack that owns the codec to the runtime stack.`, {
@@ -613,7 +649,9 @@ function assertColumnCodecIntegrity(storage, codecDescriptors) {
 				actual: "no typeParams"
 			});
 		}
-		if (!descriptor.isParameterized && ref.typeParams !== void 0) throw runtimeError("RUNTIME.CODEC_PARAMETERIZATION_MISMATCH", `Column '${tableName}.${columnName}' supplies typeParams to non-parameterized codec '${ref.codecId}'. Remove the typeParams or switch to a parameterized codec id.`, {
+		const refTypeParams = ref.typeParams;
+		const refHasTypeParamKeys = refTypeParams !== void 0 && refTypeParams !== null && typeof refTypeParams === "object" && !Array.isArray(refTypeParams) && Object.keys(refTypeParams).length > 0;
+		if (!descriptor.isParameterized && refHasTypeParamKeys) throw runtimeError("RUNTIME.CODEC_PARAMETERIZATION_MISMATCH", `Column '${tableName}.${columnName}' supplies typeParams to non-parameterized codec '${ref.codecId}'. Remove the typeParams or switch to a parameterized codec id.`, {
 			table: tableName,
 			column: columnName,
 			codecId: ref.codecId,
@@ -636,7 +674,7 @@ function assertColumnCodecIntegrity(storage, codecDescriptors) {
 *
 * Contract integrity is enforced upstream by {@link assertColumnCodecIntegrity}: every column must reference a registered `codecId` whose `descriptor.isParameterized` flag matches the presence of `typeParams` (via `codecRefForColumn`). The pre-population walk and `forColumn` therefore make no defensive checks — malformed columns fail fast at `createExecutionContext` construction with `RUNTIME.CODEC_DESCRIPTOR_MISSING` or `RUNTIME.CODEC_PARAMETERIZATION_MISMATCH` rather than being silently skipped here.
 *
-* `forColumn(t, c)` is a thin delegate over `forCodecRef(codecRefForColumn(t, c))`; encode/decode hot paths read the resolver directly via `forCodecRef`. The only `undefined` `forColumn` returns is the legitimate "no such column in the contract" case.
+* `forColumn(ns, t, c)` is a thin delegate over `forCodecRef(codecRefForColumn(ns, t, c))`; encode/decode hot paths read the resolver directly via `forCodecRef`. The only `undefined` `forColumn` returns is the legitimate "no such column in the contract" case.
 */
 function buildContractCodecRegistry(contract, codecDescriptors) {
 	const refKeyOf = (ref) => `${ref.codecId}:${canonicalizeJson(ref.typeParams)}`;
@@ -645,13 +683,15 @@ function buildContractCodecRegistry(contract, codecDescriptors) {
 	const typeRefSites = collectTypeRefSites(contract.storage);
 	for (const [typeName, typeInstance] of Object.entries(documentScopedCodecTypes(contract) ?? {})) {
 		const enumView = readEnumViewIfApplicable(typeInstance);
-		const key = refKeyOf(enumView ? {
+		const instanceTypeParams = enumView ? enumView.typeParams : typeInstance.typeParams;
+		const hasParamKeys = instanceTypeParams !== void 0 && Object.keys(instanceTypeParams).length > 0;
+		const key = refKeyOf(enumView ? hasParamKeys ? {
 			codecId: enumView.codecId,
-			typeParams: enumView.typeParams
-		} : {
+			typeParams: instanceTypeParams
+		} : { codecId: enumView.codecId } : hasParamKeys ? {
 			codecId: typeInstance.codecId,
-			typeParams: typeInstance.typeParams
-		});
+			typeParams: instanceTypeParams
+		} : { codecId: typeInstance.codecId });
 		const sites = typeRefSites.get(typeName) ?? [];
 		const existing = usedAtByKey.get(key);
 		if (existing) existing.push(...sites);
@@ -660,9 +700,9 @@ function buildContractCodecRegistry(contract, codecDescriptors) {
 			nameByKey.set(key, typeName);
 		}
 	}
-	for (const ns of Object.values(contract.storage.namespaces)) for (const [tableName, table] of Object.entries(ns.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+	for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) for (const [tableName, table] of Object.entries(ns.entries.table)) for (const [columnName, column] of Object.entries(table.columns)) {
 		if (column.typeRef !== void 0) continue;
-		const ref = codecDescriptors.codecRefForColumn(tableName, columnName);
+		const ref = codecDescriptors.codecRefForColumn(namespaceId, tableName, columnName);
 		if (!ref) continue;
 		const key = refKeyOf(ref);
 		const site = {
@@ -684,14 +724,14 @@ function buildContractCodecRegistry(contract, codecDescriptors) {
 			usedAt: usedAtByKey.get(key) ?? []
 		};
 	});
-	for (const ns of Object.values(contract.storage.namespaces)) for (const [tableName, table] of Object.entries(ns.tables)) for (const columnName of Object.keys(table.columns)) {
-		const ref = codecDescriptors.codecRefForColumn(tableName, columnName);
+	for (const [namespaceId, ns] of Object.entries(contract.storage.namespaces)) for (const [tableName, table] of Object.entries(ns.entries.table)) for (const columnName of Object.keys(table.columns)) {
+		const ref = codecDescriptors.codecRefForColumn(namespaceId, tableName, columnName);
 		if (!ref) continue;
 		resolver.forCodecRef(ref);
 	}
 	return {
-		forColumn(table, column) {
-			const ref = codecDescriptors.codecRefForColumn(table, column);
+		forColumn(namespaceId, table, column) {
+			const ref = codecDescriptors.codecRefForColumn(namespaceId, table, column);
 			return ref ? resolver.forCodecRef(ref) : void 0;
 		},
 		forCodecRef(ref) {
@@ -817,125 +857,6 @@ function createExecutionContext(options) {
 	};
 }
 //#endregion
-//#region src/sql-marker.ts
-const ensureSchemaStatement = {
-	sql: "create schema if not exists prisma_contract",
-	params: []
-};
-/**
-* Schema for `prisma_contract.marker`. The `space text` primary key
-* supports one row per loaded contract space (`'app'`,
-* `'<extension-id>'`, …); brand-new databases create this shape
-* directly. Pre-1.0 single-row markers (no `space` column) are not
-* auto-migrated — the target-specific migration runner detects the
-* legacy shape at boot and surfaces a structured `LEGACY_MARKER_SHAPE`
-* failure pointing the operator at re-running `dbInit`.
-*
-* @see specs/framework-mechanism.spec.md § 2.
-*/
-const ensureTableStatement = {
-	sql: `create table if not exists prisma_contract.marker (
-    space text not null primary key default '${APP_SPACE_ID}',
-    core_hash text not null,
-    profile_hash text not null,
-    contract_json jsonb,
-    canonical_version int,
-    updated_at timestamptz not null default now(),
-    app_tag text,
-    meta jsonb not null default '{}',
-    invariants text[] not null default '{}'
-  )`,
-	params: []
-};
-function readContractMarker(space) {
-	return {
-		sql: `select
-      core_hash,
-      profile_hash,
-      contract_json,
-      canonical_version,
-      updated_at,
-      app_tag,
-      meta,
-      invariants
-    from prisma_contract.marker
-    where space = $1`,
-		params: [space]
-	};
-}
-/**
-* Variable columns that participate in INSERT/UPDATE alongside the
-* always-on `space = $1` and `updated_at = now()`. Each column declares
-* its name, optional cast type, and parameter value; the placeholder
-* (`$N`) is computed positionally below — adding or reordering a
-* column doesn't desync indices. `invariants` only appears when the
-* caller supplies it — see `WriteMarkerInput.invariants`.
-*/
-function markerColumns(input) {
-	return [
-		{
-			name: "core_hash",
-			param: input.storageHash
-		},
-		{
-			name: "profile_hash",
-			param: input.profileHash
-		},
-		{
-			name: "contract_json",
-			type: "jsonb",
-			param: input.contractJson ?? null
-		},
-		{
-			name: "canonical_version",
-			param: input.canonicalVersion ?? null
-		},
-		{
-			name: "app_tag",
-			param: input.appTag ?? null
-		},
-		{
-			name: "meta",
-			type: "jsonb",
-			param: JSON.stringify(input.meta ?? {})
-		},
-		...input.invariants !== void 0 ? [{
-			name: "invariants",
-			type: "text[]",
-			param: input.invariants
-		}] : []
-	];
-}
-function writeContractMarker(input) {
-	const placed = markerColumns(input).map((c, i) => ({
-		name: c.name,
-		expr: c.type ? `$${i + 2}::${c.type}` : `$${i + 2}`,
-		param: c.param
-	}));
-	const params = [input.space, ...placed.map((c) => c.param)];
-	const insertColumns = [
-		"space",
-		...placed.map((c) => c.name),
-		"updated_at"
-	].join(", ");
-	const insertValues = [
-		"$1",
-		...placed.map((c) => c.expr),
-		"now()"
-	].join(", ");
-	const setClauses = [...placed.map((c) => `${c.name} = ${c.expr}`), "updated_at = now()"].join(", ");
-	return {
-		insert: {
-			sql: `insert into prisma_contract.marker (${insertColumns}) values (${insertValues})`,
-			params
-		},
-		update: {
-			sql: `update prisma_contract.marker set ${setClauses} where space = $1`,
-			params
-		}
-	};
-}
-//#endregion
 //#region src/codecs/decoding.ts
 const WIRE_PREVIEW_LIMIT = 100;
 const EMPTY_INCLUDE_ALIASES = /* @__PURE__ */ new Set();
@@ -1085,67 +1006,6 @@ async function decodeRow(row, decodeCtx, rowCtx) {
 	return decoded;
 }
 //#endregion
-//#region src/codecs/encoding.ts
-const NO_METADATA = Object.freeze({
-	codec: void 0,
-	name: void 0
-});
-function deriveParamMetadata(ast) {
-	return collectOrderedParamRefs(ast).map((ref) => {
-		return {
-			codec: ref.codec,
-			name: ref.name
-		};
-	});
-}
-function resolveParamCodec(metadata, contractCodecs) {
-	if (metadata.codec && contractCodecs) return contractCodecs.forCodecRef(metadata.codec);
-}
-function paramLabel(metadata, paramIndex) {
-	return metadata.name ?? `param[${paramIndex}]`;
-}
-function wrapEncodeFailure(error, metadata, paramIndex, codecId) {
-	const label = paramLabel(metadata, paramIndex);
-	const wrapped = runtimeError("RUNTIME.ENCODE_FAILED", `Failed to encode parameter ${label} with codec '${codecId}': ${error instanceof Error ? error.message : String(error)}`, {
-		label,
-		codec: codecId,
-		paramIndex
-	});
-	wrapped.cause = error;
-	throw wrapped;
-}
-async function encodeParamValue(value, metadata, paramIndex, ctx, contractCodecs) {
-	if (value === null || value === void 0) return null;
-	const codec = resolveParamCodec(metadata, contractCodecs);
-	if (!codec) return value;
-	try {
-		return await codec.encode(value, ctx);
-	} catch (error) {
-		if (isRuntimeError(error)) throw error;
-		wrapEncodeFailure(error, metadata, paramIndex, codec.id);
-	}
-}
-/**
-* Encodes all parameters concurrently via `Promise.all`. Per parameter, sync-and async-authored codecs share the same path: `codec.encode → await → return`. Param-level failures are wrapped in `RUNTIME.ENCODE_FAILED`.
-*
-* When `ctx.signal` is provided:
-*
-* - **Already-aborted at entry** short-circuits with `RUNTIME.ABORTED` (`{ phase: 'encode' }`) before any `codec.encode` call is made — codecs can pin this with a per-call counter that stays at zero.
-* - **Mid-flight abort** races the per-param `Promise.all` against `abortable(ctx.signal)`. The runtime returns `RUNTIME.ABORTED` promptly even if codec bodies ignore the signal; the in-flight bodies are abandoned and run to completion in the background (cooperative cancellation, see ADR 204).
-* - Existing `RUNTIME.ENCODE_FAILED` envelopes that surface from a codec body before the runtime observes the abort pass through unchanged (no double wrap).
-*/
-async function encodeParams(plan, ctx, contractCodecs) {
-	return encodeParamsWithMetadata(plan.params, deriveParamMetadata(plan.ast), ctx, contractCodecs);
-}
-async function encodeParamsWithMetadata(values, metadata, ctx, contractCodecs) {
-	checkAborted(ctx, "encode");
-	const signal = ctx.signal;
-	if (values.length === 0) return values;
-	const tasks = values.map((value, i) => encodeParamValue(value, metadata[i] ?? NO_METADATA, i, ctx, contractCodecs));
-	const settled = await raceAgainstAbort(Promise.all(tasks), signal, "encode");
-	return Object.freeze(settled);
-}
-//#endregion
 //#region src/content-hash.ts
 /**
 * Computes a stable content hash for a lowered SQL execution plan.
@@ -1698,31 +1558,24 @@ async function withTransaction(runtime, fn) {
 	const connection = await runtime.connection();
 	const transaction = await connection.transaction();
 	let invalidated = false;
+	async function* guardedStream(inner) {
+		if (invalidated) throw transactionClosedError();
+		for await (const row of inner) {
+			yield row;
+			if (invalidated) throw transactionClosedError();
+		}
+	}
 	const txContext = {
 		get invalidated() {
 			return invalidated;
 		},
 		execute(plan, options) {
 			if (invalidated) throw transactionClosedError();
-			const inner = transaction.execute(plan, options);
-			const guarded = async function* () {
-				for await (const row of inner) {
-					if (invalidated) throw transactionClosedError();
-					yield row;
-				}
-			};
-			return new AsyncIterableResult(guarded());
+			return new AsyncIterableResult(guardedStream(transaction.execute(plan, options)));
 		},
 		executePrepared(ps, params, options) {
 			if (invalidated) throw transactionClosedError();
-			const inner = transaction.executePrepared(ps, params, options);
-			const guarded = async function* () {
-				for await (const row of inner) {
-					if (invalidated) throw transactionClosedError();
-					yield row;
-				}
-			};
-			return new AsyncIterableResult(guarded());
+			return new AsyncIterableResult(guardedStream(transaction.executePrepared(ps, params, options)));
 		}
 	};
 	let connectionDisposed = false;
@@ -1778,6 +1631,6 @@ function createRuntime(options) {
 	});
 }
 //#endregion
-export { ensureTableStatement as a, createExecutionContext as c, budgets as d, parseContractMarkerRow as f, validateContractCodecMappings as g, validateCodecRegistryCompleteness as h, ensureSchemaStatement as i, createSqlExecutionStack as l, extractCodecIds as m, withTransaction as n, readContractMarker as o, lowerSqlPlan as p, APP_SPACE_ID as r, writeContractMarker as s, createRuntime as t, lints as u };
+export { lints as a, extractCodecIds as c, deriveParamMetadata as d, encodeParamsWithMetadata as f, createSqlExecutionStack as i, validateCodecRegistryCompleteness as l, withTransaction as n, budgets as o, createAstCodecRegistry as p, createExecutionContext as r, lowerSqlPlan as s, createRuntime as t, validateContractCodecMappings as u };
 
-//# sourceMappingURL=exports-CXYd2w6k.mjs.map
+//# sourceMappingURL=exports-DDqF-xmg.mjs.map