@prisma-next/sql-runtime 0.3.0-dev.33 → 0.3.0-dev.36

package/dist/exports-C8hi0N-a.mjs

@@ -0,0 +1,622 @@
+import { AsyncIterableResult, budgets, createRuntimeCore, lints, runtimeError } from "@prisma-next/runtime-executor";
+import { checkContractComponentRequirements } from "@prisma-next/contract/framework-components";
+import { createExecutionStack } from "@prisma-next/core-execution-plane/stack";
+import { generateId } from "@prisma-next/ids/runtime";
+import { createOperationRegistry } from "@prisma-next/operations";
+import { createCodecRegistry } from "@prisma-next/sql-relational-core/ast";
+import { type } from "arktype";
+import { ifDefined } from "@prisma-next/utils/defined";
+
+//#region src/codecs/validation.ts
+function extractCodecIds(contract) {
+	const codecIds = /* @__PURE__ */ new Set();
+	for (const table of Object.values(contract.storage.tables)) for (const column of Object.values(table.columns)) {
+		const codecId = column.codecId;
+		codecIds.add(codecId);
+	}
+	return codecIds;
+}
+function extractCodecIdsFromColumns(contract) {
+	const codecIds = /* @__PURE__ */ new Map();
+	for (const [tableName, table] of Object.entries(contract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+		const codecId = column.codecId;
+		const key = `${tableName}.${columnName}`;
+		codecIds.set(key, codecId);
+	}
+	return codecIds;
+}
+function validateContractCodecMappings(registry, contract) {
+	const codecIds = extractCodecIdsFromColumns(contract);
+	const invalidCodecs = [];
+	for (const [key, codecId] of codecIds.entries()) if (!registry.has(codecId)) {
+		const parts = key.split(".");
+		const table = parts[0] ?? "";
+		const column = parts[1] ?? "";
+		invalidCodecs.push({
+			table,
+			column,
+			codecId
+		});
+	}
+	if (invalidCodecs.length > 0) {
+		const details = {
+			contractTarget: contract.target,
+			invalidCodecs
+		};
+		throw runtimeError("RUNTIME.CODEC_MISSING", `Missing codec implementations for column codecIds: ${invalidCodecs.map((c) => `${c.table}.${c.column} (${c.codecId})`).join(", ")}`, details);
+	}
+}
+function validateCodecRegistryCompleteness(registry, contract) {
+	validateContractCodecMappings(registry, contract);
+}
+
+//#endregion
+//#region src/lower-sql-plan.ts
+/**
+* Lowers a SQL query plan to an executable Plan by calling the adapter's lower method.
+*
+* @param adapter - Adapter to lower AST to SQL
+* @param contract - Contract for lowering context
+* @param queryPlan - SQL query plan from a lane (contains AST, params, meta, but no SQL)
+* @returns Fully executable Plan with SQL string
+*/
+function lowerSqlPlan(adapter, contract, queryPlan) {
+	const body = adapter.lower(queryPlan.ast, {
+		contract,
+		params: queryPlan.params
+	}).body;
+	return Object.freeze({
+		sql: body.sql,
+		params: body.params ?? queryPlan.params,
+		ast: queryPlan.ast,
+		meta: queryPlan.meta
+	});
+}
+
+//#endregion
+//#region src/sql-context.ts
+function createSqlExecutionStack(options) {
+	return createExecutionStack({
+		target: options.target,
+		adapter: options.adapter,
+		driver: options.driver,
+		extensionPacks: options.extensionPacks
+	});
+}
+function assertExecutionStackContractRequirements(contract, stack) {
+	const providedComponentIds = new Set([
+		stack.target.id,
+		stack.adapter.id,
+		...stack.extensionPacks.map((pack) => pack.id)
+	]);
+	const result = checkContractComponentRequirements({
+		contract,
+		expectedTargetFamily: "sql",
+		expectedTargetId: stack.target.targetId,
+		providedComponentIds
+	});
+	if (result.familyMismatch) throw runtimeError("RUNTIME.CONTRACT_FAMILY_MISMATCH", `Contract target family '${result.familyMismatch.actual}' does not match runtime family '${result.familyMismatch.expected}'.`, {
+		actual: result.familyMismatch.actual,
+		expected: result.familyMismatch.expected
+	});
+	if (result.targetMismatch) throw runtimeError("RUNTIME.CONTRACT_TARGET_MISMATCH", `Contract target '${result.targetMismatch.actual}' does not match runtime target descriptor '${result.targetMismatch.expected}'.`, {
+		actual: result.targetMismatch.actual,
+		expected: result.targetMismatch.expected
+	});
+	if (result.missingExtensionPackIds.length > 0) {
+		const packIds = result.missingExtensionPackIds;
+		throw runtimeError("RUNTIME.MISSING_EXTENSION_PACK", `Contract requires extension pack(s) ${packIds.map((id) => `'${id}'`).join(", ")}, but runtime descriptors do not provide matching component(s).`, { packIds });
+	}
+}
+function validateTypeParams(typeParams, codecDescriptor, context) {
+	const result = codecDescriptor.paramsSchema(typeParams);
+	if (result instanceof type.errors) {
+		const messages = result.map((p) => p.message).join("; ");
+		throw runtimeError("RUNTIME.TYPE_PARAMS_INVALID", `Invalid typeParams for ${context.typeName ? `type '${context.typeName}'` : `column '${context.tableName}.${context.columnName}'`} (codecId: ${codecDescriptor.codecId}): ${messages}`, {
+			...context,
+			codecId: codecDescriptor.codecId,
+			typeParams
+		});
+	}
+	return result;
+}
+function collectParameterizedCodecDescriptors(contributors) {
+	const descriptors = /* @__PURE__ */ new Map();
+	for (const contributor of contributors) for (const descriptor of contributor.parameterizedCodecs()) {
+		if (descriptors.has(descriptor.codecId)) throw runtimeError("RUNTIME.DUPLICATE_PARAMETERIZED_CODEC", `Duplicate parameterized codec descriptor for codecId '${descriptor.codecId}'.`, { codecId: descriptor.codecId });
+		descriptors.set(descriptor.codecId, descriptor);
+	}
+	return descriptors;
+}
+function initializeTypeHelpers(storageTypes, codecDescriptors) {
+	const helpers = {};
+	if (!storageTypes) return helpers;
+	for (const [typeName, typeInstance] of Object.entries(storageTypes)) {
+		const descriptor = codecDescriptors.get(typeInstance.codecId);
+		if (descriptor) {
+			const validatedParams = validateTypeParams(typeInstance.typeParams, descriptor, { typeName });
+			if (descriptor.init) helpers[typeName] = descriptor.init(validatedParams);
+			else helpers[typeName] = typeInstance;
+		} else helpers[typeName] = typeInstance;
+	}
+	return helpers;
+}
+function validateColumnTypeParams(storage, codecDescriptors) {
+	for (const [tableName, table] of Object.entries(storage.tables)) 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,
+			columnName
+		});
+	}
+}
+/**
+* Builds a registry of compiled JSON Schema validators by scanning the contract
+* for columns whose codec descriptor provides an `init` hook returning `{ validate }`.
+*
+* Handles both:
+* - Inline `typeParams.schema` on columns
+* - `typeRef` → `storage.types[ref]` with init hook results already in `types` registry
+*/
+function buildJsonSchemaValidatorRegistry(contract, types, codecDescriptors) {
+	const validators = /* @__PURE__ */ new Map();
+	const codecIdsWithInit = /* @__PURE__ */ new Set();
+	for (const [codecId, descriptor] of codecDescriptors) if (descriptor.init) codecIdsWithInit.add(codecId);
+	if (codecIdsWithInit.size === 0) return;
+	for (const [tableName, table] of Object.entries(contract.storage.tables)) for (const [columnName, column] of Object.entries(table.columns)) {
+		if (!codecIdsWithInit.has(column.codecId)) continue;
+		const key = `${tableName}.${columnName}`;
+		if (column.typeRef) {
+			const helper = types[column.typeRef];
+			if (helper?.validate) validators.set(key, helper.validate);
+			continue;
+		}
+		if (column.typeParams) {
+			const descriptor = codecDescriptors.get(column.codecId);
+			if (descriptor?.init) {
+				const helper = descriptor.init(column.typeParams);
+				if (helper?.validate) validators.set(key, helper.validate);
+			}
+		}
+	}
+	if (validators.size === 0) return void 0;
+	return {
+		get: (key) => validators.get(key),
+		size: validators.size
+	};
+}
+function computeExecutionDefaultValue(spec) {
+	switch (spec.kind) {
+		case "generator": return generateId(spec.params ? {
+			id: spec.id,
+			params: spec.params
+		} : { id: spec.id });
+	}
+}
+function applyMutationDefaults(contract, options) {
+	const defaults = contract.execution?.mutations.defaults ?? [];
+	if (defaults.length === 0) return [];
+	const applied = [];
+	const appliedColumns = /* @__PURE__ */ new Set();
+	for (const mutationDefault of defaults) {
+		if (mutationDefault.ref.table !== options.table) continue;
+		const defaultSpec = options.op === "create" ? mutationDefault.onCreate : mutationDefault.onUpdate;
+		if (!defaultSpec) continue;
+		const columnName = mutationDefault.ref.column;
+		if (Object.hasOwn(options.values, columnName) || appliedColumns.has(columnName)) continue;
+		applied.push({
+			column: columnName,
+			value: computeExecutionDefaultValue(defaultSpec)
+		});
+		appliedColumns.add(columnName);
+	}
+	return applied;
+}
+function createExecutionContext(options) {
+	const { contract, stack } = options;
+	assertExecutionStackContractRequirements(contract, stack);
+	const codecRegistry = createCodecRegistry();
+	const operationRegistry = createOperationRegistry();
+	const contributors = [
+		stack.target,
+		stack.adapter,
+		...stack.extensionPacks
+	];
+	for (const contributor of contributors) {
+		for (const c of contributor.codecs().values()) codecRegistry.register(c);
+		for (const operation of contributor.operationSignatures()) operationRegistry.register(operation);
+	}
+	const parameterizedCodecDescriptors = collectParameterizedCodecDescriptors(contributors);
+	if (parameterizedCodecDescriptors.size > 0) validateColumnTypeParams(contract.storage, parameterizedCodecDescriptors);
+	const types = initializeTypeHelpers(contract.storage.types, parameterizedCodecDescriptors);
+	const jsonSchemaValidators = buildJsonSchemaValidatorRegistry(contract, types, parameterizedCodecDescriptors);
+	return {
+		contract,
+		operations: operationRegistry,
+		codecs: codecRegistry,
+		types,
+		...jsonSchemaValidators ? { jsonSchemaValidators } : {},
+		applyMutationDefaults: (options$1) => applyMutationDefaults(contract, options$1)
+	};
+}
+
+//#endregion
+//#region src/sql-marker.ts
+const ensureSchemaStatement = {
+	sql: "create schema if not exists prisma_contract",
+	params: []
+};
+const ensureTableStatement = {
+	sql: `create table if not exists prisma_contract.marker (
+    id smallint primary key default 1,
+    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 '{}'
+  )`,
+	params: []
+};
+function readContractMarker() {
+	return {
+		sql: `select
+      core_hash,
+      profile_hash,
+      contract_json,
+      canonical_version,
+      updated_at,
+      app_tag,
+      meta
+    from prisma_contract.marker
+    where id = $1`,
+		params: [1]
+	};
+}
+function writeContractMarker(input) {
+	const baseParams = [
+		1,
+		input.storageHash,
+		input.profileHash,
+		input.contractJson ?? null,
+		input.canonicalVersion ?? null,
+		input.appTag ?? null,
+		JSON.stringify(input.meta ?? {})
+	];
+	return {
+		insert: {
+			sql: `insert into prisma_contract.marker (
+        id,
+        core_hash,
+        profile_hash,
+        contract_json,
+        canonical_version,
+        updated_at,
+        app_tag,
+        meta
+      ) values (
+        $1,
+        $2,
+        $3,
+        $4::jsonb,
+        $5,
+        now(),
+        $6,
+        $7::jsonb
+      )`,
+			params: baseParams
+		},
+		update: {
+			sql: `update prisma_contract.marker set
+        core_hash = $2,
+        profile_hash = $3,
+        contract_json = $4::jsonb,
+        canonical_version = $5,
+        updated_at = now(),
+        app_tag = $6,
+        meta = $7::jsonb
+      where id = $1`,
+			params: baseParams
+		}
+	};
+}
+
+//#endregion
+//#region src/codecs/json-schema-validation.ts
+/**
+* Validates a JSON value against its column's JSON Schema, if a validator exists.
+*
+* Throws `RUNTIME.JSON_SCHEMA_VALIDATION_FAILED` on validation failure.
+* No-ops if no validator is registered for the column.
+*/
+function validateJsonValue(registry, table, column, value, direction, codecId) {
+	const key = `${table}.${column}`;
+	const validate = registry.get(key);
+	if (!validate) return;
+	const result = validate(value);
+	if (result.valid) return;
+	throw createJsonSchemaValidationError(table, column, direction, result.errors, codecId);
+}
+function createJsonSchemaValidationError(table, column, direction, errors, codecId) {
+	return runtimeError("RUNTIME.JSON_SCHEMA_VALIDATION_FAILED", `JSON schema validation failed for column '${table}.${column}' (${direction}): ${formatErrorSummary(errors)}`, {
+		table,
+		column,
+		codecId,
+		direction,
+		errors: [...errors]
+	});
+}
+function formatErrorSummary(errors) {
+	if (errors.length === 0) return "unknown validation error";
+	if (errors.length === 1) {
+		const err = errors[0];
+		return err.path === "/" ? err.message : `${err.path}: ${err.message}`;
+	}
+	return errors.map((err) => err.path === "/" ? err.message : `${err.path}: ${err.message}`).join("; ");
+}
+
+//#endregion
+//#region src/codecs/decoding.ts
+function resolveRowCodec(alias, plan, registry) {
+	const planCodecId = plan.meta.annotations?.codecs?.[alias];
+	if (planCodecId) {
+		const codec$1 = registry.get(planCodecId);
+		if (codec$1) return codec$1;
+	}
+	if (plan.meta.projectionTypes) {
+		const typeId = plan.meta.projectionTypes[alias];
+		if (typeId) {
+			const codec$1 = registry.get(typeId);
+			if (codec$1) return codec$1;
+		}
+	}
+	return null;
+}
+/**
+* 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) {
+	const columns = plan.meta.refs?.columns;
+	if (!columns) return null;
+	const index = /* @__PURE__ */ new Map();
+	for (const ref of columns) index.set(ref.column, ref);
+	return index;
+}
+function parseProjectionRef(value) {
+	if (value.startsWith("include:") || value.startsWith("operation:")) return null;
+	const separatorIndex = value.indexOf(".");
+	if (separatorIndex <= 0 || separatorIndex === value.length - 1) return null;
+	return {
+		table: value.slice(0, separatorIndex),
+		column: value.slice(separatorIndex + 1)
+	};
+}
+function resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex) {
+	if (projection && !Array.isArray(projection)) {
+		const mappedRef = projection[alias];
+		if (typeof mappedRef !== "string") return;
+		return parseProjectionRef(mappedRef) ?? void 0;
+	}
+	return fallbackColumnRefIndex?.get(alias);
+}
+function decodeRow(row, plan, registry, jsonValidators) {
+	const decoded = {};
+	const projection = plan.meta.projection;
+	const fallbackColumnRefIndex = jsonValidators && (!projection || Array.isArray(projection)) ? buildColumnRefIndex(plan) : null;
+	let aliases;
+	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[alias] : void 0;
+		if (typeof projectionValue === "string" && projectionValue.startsWith("include:")) {
+			if (wireValue === null || wireValue === void 0) {
+				decoded[alias] = [];
+				continue;
+			}
+			try {
+				let parsed;
+				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 = /* @__PURE__ */ new Error(`Failed to parse JSON array for include alias '${alias}': ${error instanceof Error ? error.message : String(error)}`);
+				decodeError.code = "RUNTIME.DECODE_FAILED";
+				decodeError.category = "RUNTIME";
+				decodeError.severity = "error";
+				decodeError.details = {
+					alias,
+					wirePreview: typeof wireValue === "string" && wireValue.length > 100 ? `${wireValue.substring(0, 100)}...` : String(wireValue).substring(0, 100)
+				};
+				throw decodeError;
+			}
+			continue;
+		}
+		if (wireValue === null || wireValue === void 0) {
+			decoded[alias] = wireValue;
+			continue;
+		}
+		const codec$1 = resolveRowCodec(alias, plan, registry);
+		if (!codec$1) {
+			decoded[alias] = wireValue;
+			continue;
+		}
+		try {
+			const decodedValue = codec$1.decode(wireValue);
+			if (jsonValidators) {
+				const ref = resolveColumnRefForAlias(alias, projection, fallbackColumnRefIndex);
+				if (ref) validateJsonValue(jsonValidators, ref.table, ref.column, decodedValue, "decode", codec$1.id);
+			}
+			decoded[alias] = decodedValue;
+		} catch (error) {
+			if (error instanceof Error && "code" in error && error.code === "RUNTIME.JSON_SCHEMA_VALIDATION_FAILED") throw error;
+			const decodeError = /* @__PURE__ */ new Error(`Failed to decode row alias '${alias}' with codec '${codec$1.id}': ${error instanceof Error ? error.message : String(error)}`);
+			decodeError.code = "RUNTIME.DECODE_FAILED";
+			decodeError.category = "RUNTIME";
+			decodeError.severity = "error";
+			decodeError.details = {
+				alias,
+				codec: codec$1.id,
+				wirePreview: typeof wireValue === "string" && wireValue.length > 100 ? `${wireValue.substring(0, 100)}...` : String(wireValue).substring(0, 100)
+			};
+			throw decodeError;
+		}
+	}
+	return decoded;
+}
+
+//#endregion
+//#region src/codecs/encoding.ts
+function resolveParamCodec(paramDescriptor, plan, registry) {
+	const paramName = paramDescriptor.name ?? `param_${paramDescriptor.index ?? 0}`;
+	const planCodecId = plan.meta.annotations?.codecs?.[paramName];
+	if (planCodecId) {
+		const codec$1 = registry.get(planCodecId);
+		if (codec$1) return codec$1;
+	}
+	if (paramDescriptor.codecId) {
+		const codec$1 = registry.get(paramDescriptor.codecId);
+		if (codec$1) return codec$1;
+	}
+	return null;
+}
+function encodeParam(value, paramDescriptor, plan, registry, jsonValidators) {
+	if (value === null || value === void 0) return null;
+	if (jsonValidators && paramDescriptor.refs) {
+		const { table, column } = paramDescriptor.refs;
+		validateJsonValue(jsonValidators, table, column, value, "encode", paramDescriptor.codecId);
+	}
+	const codec$1 = resolveParamCodec(paramDescriptor, plan, registry);
+	if (!codec$1) return value;
+	if (codec$1.encode) try {
+		return codec$1.encode(value);
+	} catch (error) {
+		throw new Error(`Failed to encode parameter ${paramDescriptor.name ?? paramDescriptor.index}: ${error instanceof Error ? error.message : String(error)}`);
+	}
+	return value;
+}
+function encodeParams(plan, registry, jsonValidators) {
+	if (plan.params.length === 0) return plan.params;
+	const encoded = [];
+	for (let i = 0; i < plan.params.length; i++) {
+		const paramValue = plan.params[i];
+		const paramDescriptor = plan.meta.paramDescriptors[i];
+		if (paramDescriptor) encoded.push(encodeParam(paramValue, paramDescriptor, plan, registry, jsonValidators));
+		else encoded.push(paramValue);
+	}
+	return Object.freeze(encoded);
+}
+
+//#endregion
+//#region src/sql-family-adapter.ts
+var SqlMarkerReader = class {
+	readMarkerStatement() {
+		return readContractMarker();
+	}
+};
+var SqlFamilyAdapter = class {
+	contract;
+	markerReader;
+	constructor(contract) {
+		this.contract = contract;
+		this.markerReader = new SqlMarkerReader();
+	}
+	validatePlan(plan, contract) {
+		if (plan.meta.target !== contract.target) throw runtimeError("PLAN.TARGET_MISMATCH", "Plan target does not match runtime target", {
+			planTarget: plan.meta.target,
+			runtimeTarget: contract.target
+		});
+		if (plan.meta.storageHash !== contract.storageHash) throw runtimeError("PLAN.HASH_MISMATCH", "Plan storage hash does not match runtime contract", {
+			planStorageHash: plan.meta.storageHash,
+			runtimeStorageHash: contract.storageHash
+		});
+	}
+};
+
+//#endregion
+//#region src/sql-runtime.ts
+var SqlRuntimeImpl = class {
+	core;
+	contract;
+	adapter;
+	codecRegistry;
+	jsonSchemaValidators;
+	codecRegistryValidated;
+	constructor(options) {
+		const { context, adapter, driver, verify, plugins, mode, log } = options;
+		this.contract = context.contract;
+		this.adapter = adapter;
+		this.codecRegistry = context.codecs;
+		this.jsonSchemaValidators = context.jsonSchemaValidators;
+		this.codecRegistryValidated = false;
+		this.core = createRuntimeCore({
+			familyAdapter: new SqlFamilyAdapter(context.contract),
+			driver,
+			verify,
+			plugins,
+			...ifDefined("mode", mode),
+			...ifDefined("log", log),
+			operationRegistry: context.operations
+		});
+		if (verify.mode === "startup") {
+			validateCodecRegistryCompleteness(this.codecRegistry, context.contract);
+			this.codecRegistryValidated = true;
+		}
+	}
+	ensureCodecRegistryValidated(contract) {
+		if (!this.codecRegistryValidated) {
+			validateCodecRegistryCompleteness(this.codecRegistry, contract);
+			this.codecRegistryValidated = true;
+		}
+	}
+	execute(plan) {
+		this.ensureCodecRegistryValidated(this.contract);
+		const isSqlQueryPlan = (p) => {
+			return "ast" in p && !("sql" in p);
+		};
+		const executablePlan = isSqlQueryPlan(plan) ? lowerSqlPlan(this.adapter, this.contract, plan) : plan;
+		const iterator = async function* (self) {
+			const encodedParams = encodeParams(executablePlan, self.codecRegistry, self.jsonSchemaValidators);
+			const planWithEncodedParams = {
+				...executablePlan,
+				params: encodedParams
+			};
+			const coreIterator = self.core.execute(planWithEncodedParams);
+			for await (const rawRow of coreIterator) yield decodeRow(rawRow, executablePlan, self.codecRegistry, self.jsonSchemaValidators);
+		};
+		return new AsyncIterableResult(iterator(this));
+	}
+	connection() {
+		return this.core.connection();
+	}
+	telemetry() {
+		return this.core.telemetry();
+	}
+	operations() {
+		return this.core.operations();
+	}
+	close() {
+		return this.core.close();
+	}
+};
+function createRuntime(options) {
+	const { stackInstance, context, driver, verify, plugins, mode, log } = options;
+	return new SqlRuntimeImpl({
+		context,
+		adapter: stackInstance.adapter,
+		driver,
+		verify,
+		...ifDefined("plugins", plugins),
+		...ifDefined("mode", mode),
+		...ifDefined("log", log)
+	});
+}
+
+//#endregion
+export { ensureTableStatement as a, createExecutionContext as c, extractCodecIds as d, validateCodecRegistryCompleteness as f, ensureSchemaStatement as i, createSqlExecutionStack as l, lints as n, readContractMarker as o, validateContractCodecMappings as p, createRuntime as r, writeContractMarker as s, budgets as t, lowerSqlPlan as u };
+//# sourceMappingURL=exports-C8hi0N-a.mjs.map