@prisma-idb/family-idb 0.0.0

package/dist/psl-interpreter-C6Q4okuO.mjs

@@ -0,0 +1,809 @@
+import { t as validateContract } from "./validate-BLnItEKs.mjs";
+import { UNBOUND_DOMAIN_NAMESPACE_ID, crossRef } from "@prisma/orm-framework/contract/types";
+import { computeExecutionHash, computeProfileHash, computeStorageHash } from "@prisma/orm-framework/contract/hashing";
+import { notOk, ok } from "@prisma/orm-framework/utils/result";
+//#region src/core/psl-interpreter.ts
+/** The one `temporal.*` type-constructor path IDB currently understands. */
+const TEMPORAL_UPDATED_AT_PATH = ["temporal", "updatedAt"];
+/** Generator id shared by `temporal.updatedAt()`/bare `@updatedAt`/`@default(now())`. */
+const TIMESTAMP_NOW_GENERATOR_ID = "timestampNow";
+/** Synthetic generator id that just echoes `params.value` — backs `@default(<literal>)`. */
+const LITERAL_GENERATOR_ID = "literal";
+/** Parses `@default(...)`'s positional argument as a literal value: `true`/`false`/a number/a quoted string. */
+function parseDefaultLiteralValue(raw) {
+	const t = raw.trim();
+	if (t === "true") return { value: true };
+	if (t === "false") return { value: false };
+	if (/^-?\d+(\.\d+)?$/.test(t)) return { value: Number(t) };
+	const str = parseStringArg(t);
+	if (str !== void 0) return { value: str };
+}
+/**
+* `true` if a parsed `@default(<literal>)` value's JS type matches what
+* `codecId` expects (a literal's JS type must match the field's declared
+* type — a string literal on an Int field, or vice versa, is a mismatch).
+* Declared as a function (not a `codecId → JS type` const lookup) since
+* `SCALAR_TO_CODEC_ID` — which every `codecId` here is sourced from — is
+* declared further down this module; a top-level const initializer would hit
+* the temporal dead zone, but a function body only evaluates when called.
+*/
+function literalValueMatchesCodec(value, codecId) {
+	switch (codecId) {
+		case SCALAR_TO_CODEC_ID["String"]: return typeof value === "string";
+		case SCALAR_TO_CODEC_ID["Int"]:
+		case SCALAR_TO_CODEC_ID["Float"]:
+		case SCALAR_TO_CODEC_ID["Decimal"]: return typeof value === "number";
+		case SCALAR_TO_CODEC_ID["Boolean"]: return typeof value === "boolean";
+		default: return false;
+	}
+}
+/** Parses `@default(...)`'s positional argument as a function call: `name(...)` or bare `name()`. */
+function parseDefaultFunctionCall(raw) {
+	const trimmed = raw.trim();
+	const openParen = trimmed.indexOf("(");
+	const closeParen = trimmed.lastIndexOf(")");
+	if (openParen <= 0 || closeParen !== trimmed.length - 1) return void 0;
+	const name = trimmed.slice(0, openParen).trim();
+	if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name)) return void 0;
+	const arg = trimmed.slice(openParen + 1, closeParen).trim();
+	return arg ? {
+		name,
+		arg
+	} : { name };
+}
+/** Resolves a parsed `@default(...)` function call (excluding `autoincrement()`, handled separately as a storage-plane concern) to a generator id. */
+function resolveDefaultFunctionGeneratorId(name, arg) {
+	switch (name) {
+		case "now": return arg === void 0 ? {
+			ok: true,
+			generatorId: TIMESTAMP_NOW_GENERATOR_ID
+		} : {
+			ok: false,
+			reason: "invalid-argument"
+		};
+		case "uuid":
+			if (arg === void 0 || arg === "4") return {
+				ok: true,
+				generatorId: "uuidv4"
+			};
+			if (arg === "7") return {
+				ok: true,
+				generatorId: "uuidv7"
+			};
+			return {
+				ok: false,
+				reason: "invalid-argument"
+			};
+		case "cuid": return arg === void 0 ? {
+			ok: true,
+			generatorId: "cuid2"
+		} : {
+			ok: false,
+			reason: "invalid-argument"
+		};
+		default: return {
+			ok: false,
+			reason: "unknown-function"
+		};
+	}
+}
+const SCALAR_TO_CODEC_ID = {
+	String: "idb/string@1",
+	Int: "idb/int32@1",
+	Float: "idb/double@1",
+	Boolean: "idb/bool@1",
+	DateTime: "idb/date@1",
+	BigInt: "idb/bigint@1",
+	Decimal: "idb/decimal@1",
+	Json: "idb/json@1",
+	Bytes: "idb/bytes@1"
+};
+/**
+* Codecs excluded from IndexedDB's "valid key" algorithm
+* (https://w3c.github.io/IndexedDB/#key-construct: number, string, Date,
+* buffer source, or Array — nothing else).
+*
+* - `idb/bool@1` — boolean is not, and has never been, a valid IDB key type.
+* - `idb/bigint@1` — bigint round-trips fine as a stored *value* (structured
+*   clone supports it), but is explicitly absent from the key-type algorithm.
+* - `idb/json@1` — arbitrary shape (object, array, or primitive); can't be
+*   statically guaranteed to be a valid key.
+*
+* Using any of these as a model's `@id`/key throws on every write
+* (`DataError` extracting the primary key). Using one as an index `keyPath`
+* doesn't throw on write — the record is just silently omitted from that
+* index — but throws the first time anyone queries it via `IDBKeyRange`
+* (see ADR 016's Context: `OutboxEvent.synced`, `idb/bool@1`, exactly this).
+*/
+const IDB_INVALID_KEY_CODEC_IDS = /* @__PURE__ */ new Set([
+	"idb/bool@1",
+	"idb/bigint@1",
+	"idb/json@1"
+]);
+/** `true` if `codecId`'s runtime representation is a valid IndexedDB key. */
+function isValidIdbKeyCodec(codecId) {
+	return !IDB_INVALID_KEY_CODEC_IDS.has(codecId);
+}
+const REFERENTIAL_ACTION_MAP = {
+	Cascade: "cascade",
+	SetNull: "setNull",
+	SetDefault: "setDefault",
+	Restrict: "restrict",
+	NoAction: "noAction"
+};
+/**
+* ADR 013 — shared between this file and `contract-builder.ts` (which
+* already imports {@link ContractProjection} from here) so the message
+* format isn't duplicated. Called whenever a surviving model's relation is
+* dropped because its target is excluded — any cardinality, required or
+* not; the model itself is never excluded as a result, only the relation.
+*/
+function warnDroppedRelation(modelName, relationName, targetModel) {
+	console.warn(`[prisma-idb] Dropped relation "${modelName}.${relationName}" from the client contract: target model "${targetModel}" is excluded (ADR 013).`);
+}
+function findPositionalArg(args) {
+	return args.find((a) => a.kind === "positional")?.value;
+}
+function findNamedArg(args, name) {
+	return args.find((a) => a.kind === "named" && a.name === name)?.value;
+}
+function parseStringArg(raw) {
+	if (raw === void 0) return void 0;
+	const t = raw.trim();
+	if (t.startsWith("\"") && t.endsWith("\"") || t.startsWith("'") && t.endsWith("'")) return t.slice(1, -1);
+}
+function parseFieldList(raw) {
+	if (raw === void 0) return void 0;
+	const t = raw.trim();
+	if (!t.startsWith("[") || !t.endsWith("]")) return void 0;
+	const inner = t.slice(1, -1).trim();
+	if (inner === "") return [];
+	return inner.split(",").map((s) => s.trim()).filter(Boolean);
+}
+function lowerFirst(s) {
+	return s.charAt(0).toLowerCase() + s.slice(1);
+}
+function hasFieldAttribute(field, name) {
+	return field.attributes.some((a) => a.name === name);
+}
+function getFieldAttribute(field, name) {
+	return field.attributes.find((a) => a.name === name);
+}
+function hasModelAttribute(model, name) {
+	return model.attributes.some((a) => a.name === name);
+}
+const IDB_EXCLUDE_ATTR = "idb.exclude";
+function interpretModel(model, modelNames, sourceId, diagnostics, projection, excludedModelNames, excludedFieldNamesByModel) {
+	const modelFields = Object.values(model.fields);
+	const excludedFieldNames = new Set(projection === "client" ? modelFields.filter((f) => hasFieldAttribute(f, IDB_EXCLUDE_ATTR)).map((f) => f.name) : []);
+	const storeName = parseStringArg(findPositionalArg(model.attributes.find((a) => a.name === "map")?.args ?? [])) ?? lowerFirst(model.name);
+	let keyPath;
+	let idFieldName;
+	const idModelAttr = model.attributes.find((a) => a.name === "id");
+	if (idModelAttr) {
+		const fields = parseFieldList(findPositionalArg(idModelAttr.args));
+		if (!fields || fields.length === 0) {
+			diagnostics.push({
+				code: "IDB_INVALID_ID",
+				message: `Model "${model.name}" @@id([…]) is missing a field list.`,
+				sourceId,
+				span: idModelAttr.span
+			});
+			return;
+		}
+		if (fields.length > 1) {
+			diagnostics.push({
+				code: "IDB_NO_COMPOUND_KEY",
+				message: `Model "${model.name}" @@id([${fields.join(", ")}]) declares a compound key. IDB does not support compound primary keys — use a single @id field instead.`,
+				sourceId,
+				span: idModelAttr.span
+			});
+			return;
+		}
+		idFieldName = fields[0];
+		keyPath = fields[0];
+	}
+	const idFields = modelFields.filter((f) => hasFieldAttribute(f, "id"));
+	if (idFields.length > 1) {
+		diagnostics.push({
+			code: "IDB_MULTIPLE_ID_FIELDS",
+			message: `Model "${model.name}" declares @id on multiple fields (${idFields.map((f) => f.name).join(", ")}). Only one @id field is allowed.`,
+			sourceId,
+			span: model.span
+		});
+		return;
+	}
+	if (idFields.length === 1) {
+		if (keyPath !== void 0) {
+			diagnostics.push({
+				code: "IDB_INVALID_ID",
+				message: `Model "${model.name}" cannot declare both a field-level @id and a model-level @@id.`,
+				sourceId,
+				span: model.span
+			});
+			return;
+		}
+		idFieldName = idFields[0].name;
+		keyPath = idFields[0].name;
+	}
+	if (keyPath === void 0) {
+		diagnostics.push({
+			code: "IDB_MISSING_ID",
+			message: `Model "${model.name}" has no @id field. Add @id to exactly one scalar field.`,
+			sourceId,
+			span: model.span
+		});
+		return;
+	}
+	if (excludedFieldNames.has(keyPath)) {
+		diagnostics.push({
+			code: "IDB_CANNOT_EXCLUDE_KEY_FIELD",
+			message: `Field "${model.name}.${keyPath}" is the model's @id key and cannot be marked @idb.exclude — the client contract needs a primary key for every included model.`,
+			sourceId,
+			span: model.span
+		});
+		return;
+	}
+	const indexes = {};
+	for (const attr of model.attributes) {
+		if (attr.name !== "index" && attr.name !== "unique") continue;
+		const isUnique = attr.name === "unique";
+		const fields = parseFieldList(findPositionalArg(attr.args));
+		if (!fields || fields.length === 0) {
+			diagnostics.push({
+				code: "IDB_INVALID_INDEX",
+				message: `Model "${model.name}" @@${attr.name} is missing a field list.`,
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		if (fields.length > 1) {
+			diagnostics.push({
+				code: "IDB_COMPOUND_INDEX_UNSUPPORTED",
+				message: `Model "${model.name}" @@${attr.name}([${fields.join(", ")}]) declares a compound index. IDB compound indexes are not yet supported — use a single-field index.`,
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		const field = fields[0];
+		if (excludedFieldNames.has(field)) {
+			diagnostics.push({
+				code: "IDB_INDEX_ON_EXCLUDED_FIELD",
+				message: `Model "${model.name}" @@${attr.name}([${field}]) references "${field}", which is marked @idb.exclude. Remove the index or the exclusion.`,
+				sourceId,
+				span: attr.span
+			});
+			continue;
+		}
+		const indexName = parseStringArg(findNamedArg(attr.args, "name") ?? findNamedArg(attr.args, "map")) ?? (isUnique ? `${field}_unique` : field);
+		indexes[indexName] = {
+			keyPath: field,
+			unique: isUnique
+		};
+	}
+	const contractFields = {};
+	const relations = {};
+	const relationsStorage = {};
+	const fieldDefaults = {};
+	const fksByTarget = /* @__PURE__ */ new Map();
+	const fieldExecutionDefaults = [];
+	let autoIncrement = false;
+	for (const field of modelFields) {
+		if (field.name === idFieldName && field.optional) diagnostics.push({
+			code: "IDB_NULLABLE_ID",
+			message: `Field "${model.name}.${field.name}" is marked as @id but is optional (?). The primary key cannot be nullable.`,
+			sourceId,
+			span: field.span
+		});
+		if (field.list && modelNames.has(field.typeName)) {
+			if (excludedModelNames.has(field.typeName)) warnDroppedRelation(model.name, field.name, field.typeName);
+			continue;
+		}
+		const relationAttr = getFieldAttribute(field, "relation");
+		if (!field.list && modelNames.has(field.typeName) && relationAttr) {
+			if (excludedFieldNames.has(field.name)) {
+				diagnostics.push({
+					code: "IDB_EXCLUDE_ON_RELATION_FIELD_UNSUPPORTED",
+					message: `Field "${model.name}.${field.name}" is a relation field and cannot be marked @idb.exclude directly. Exclude the target model with @@idb.exclude to drop the relation, or exclude a plain scalar field.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			if (excludedModelNames.has(field.typeName)) {
+				warnDroppedRelation(model.name, field.name, field.typeName);
+				continue;
+			}
+			const args = relationAttr.args;
+			const localFieldsRaw = findNamedArg(args, "fields");
+			const targetFieldsRaw = findNamedArg(args, "references");
+			const localFields = parseFieldList(localFieldsRaw);
+			const targetFields = parseFieldList(targetFieldsRaw);
+			if (!localFields || localFields.length === 0 || !targetFields || targetFields.length === 0) {
+				diagnostics.push({
+					code: "IDB_INVALID_RELATION",
+					message: `Relation field "${model.name}.${field.name}" must declare both fields and references in @relation.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			if (localFields.length !== targetFields.length) {
+				diagnostics.push({
+					code: "IDB_INVALID_RELATION",
+					message: `Relation field "${model.name}.${field.name}" must have the same number of fields and references.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			const excludedLocalField = localFields.find((f) => excludedFieldNames.has(f));
+			if (excludedLocalField !== void 0) {
+				diagnostics.push({
+					code: "IDB_CANNOT_EXCLUDE_RELATION_FIELD",
+					message: `Field "${model.name}.${excludedLocalField}" backs relation "${model.name}.${field.name}" and cannot be excluded independently — field-level FK exclusion isn't supported (ADR 013's cascade only covers whole-model @@idb.exclude). Exclude the whole model instead, or remove the exclusion.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			const targetExcludedFields = excludedFieldNamesByModel.get(field.typeName);
+			const excludedTargetField = targetExcludedFields ? targetFields.find((f) => targetExcludedFields.has(f)) : void 0;
+			if (excludedTargetField !== void 0) {
+				diagnostics.push({
+					code: "IDB_CANNOT_EXCLUDE_RELATION_FIELD",
+					message: `Field "${field.typeName}.${excludedTargetField}" is referenced by relation "${model.name}.${field.name}" and cannot be excluded independently — field-level FK exclusion isn't supported (ADR 013's cascade only covers whole-model @@idb.exclude). Exclude the whole model instead, or remove the exclusion.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			const onDeleteRaw = findNamedArg(args, "onDelete");
+			const onDelete = onDeleteRaw ? REFERENTIAL_ACTION_MAP[onDeleteRaw.trim()] : void 0;
+			if (onDeleteRaw && onDelete === void 0) diagnostics.push({
+				code: "IDB_UNKNOWN_REFERENTIAL_ACTION",
+				message: `Relation field "${model.name}.${field.name}" has unknown onDelete value "${onDeleteRaw}". Valid values: ${Object.keys(REFERENTIAL_ACTION_MAP).join(", ")}.`,
+				sourceId,
+				span: field.span
+			});
+			const onUpdateRaw = findNamedArg(args, "onUpdate");
+			const onUpdate = onUpdateRaw ? REFERENTIAL_ACTION_MAP[onUpdateRaw.trim()] : void 0;
+			if (onUpdateRaw && onUpdate === void 0) diagnostics.push({
+				code: "IDB_UNKNOWN_REFERENTIAL_ACTION",
+				message: `Relation field "${model.name}.${field.name}" has unknown onUpdate value "${onUpdateRaw}". Valid values: ${Object.keys(REFERENTIAL_ACTION_MAP).join(", ")}.`,
+				sourceId,
+				span: field.span
+			});
+			relations[field.name] = {
+				to: crossRef(field.typeName),
+				cardinality: "N:1",
+				on: {
+					localFields,
+					targetFields
+				}
+			};
+			if (onDelete !== void 0 || onUpdate !== void 0) relationsStorage[field.name] = {
+				...onDelete !== void 0 ? { onDelete } : {},
+				...onUpdate !== void 0 ? { onUpdate } : {}
+			};
+			fksByTarget.set(field.typeName, {
+				fieldName: field.name,
+				localFields,
+				targetFields
+			});
+			for (const fkField of localFields) if (!(fkField in indexes)) indexes[fkField] = {
+				keyPath: fkField,
+				unique: false
+			};
+			continue;
+		}
+		if (!field.list && modelNames.has(field.typeName) && !relationAttr) {
+			diagnostics.push({
+				code: "IDB_MISSING_RELATION_ATTRIBUTE",
+				message: `Field "${model.name}.${field.name}" has model type "${field.typeName}" but no @relation attribute. Add @relation(fields: [...], references: [...]).`,
+				sourceId,
+				span: field.span
+			});
+			continue;
+		}
+		if (field.list) continue;
+		if (excludedFieldNames.has(field.name)) {
+			if (hasFieldAttribute(field, "unique")) diagnostics.push({
+				code: "IDB_INDEX_ON_EXCLUDED_FIELD",
+				message: `Field "${model.name}.${field.name}" is marked @unique but also @idb.exclude. Remove the @unique attribute or the exclusion.`,
+				sourceId,
+				span: field.span
+			});
+			continue;
+		}
+		if (field.typeConstructor) {
+			const path = field.typeConstructor.path;
+			if (!(path.length === TEMPORAL_UPDATED_AT_PATH.length && path.every((p, i) => p === TEMPORAL_UPDATED_AT_PATH[i]))) {
+				diagnostics.push({
+					code: "IDB_UNSUPPORTED_TYPE_CONSTRUCTOR",
+					message: `Field "${model.name}.${field.name}" uses unsupported type constructor "${path.join(".")}()". IDB currently only supports temporal.updatedAt().`,
+					sourceId,
+					span: field.typeConstructor.span
+				});
+				continue;
+			}
+			if (field.typeConstructor.args.length > 0) {
+				diagnostics.push({
+					code: "IDB_TEMPORAL_UPDATED_AT_TAKES_NO_ARGS",
+					message: `Field "${model.name}.${field.name}" — temporal.updatedAt() takes no arguments.`,
+					sourceId,
+					span: field.typeConstructor.span
+				});
+				continue;
+			}
+			if (field.name === idFieldName) {
+				diagnostics.push({
+					code: "IDB_TEMPORAL_UPDATED_AT_ON_KEY_FIELD",
+					message: `Field "${model.name}.${field.name}" is the model's @id key and cannot be temporal.updatedAt() — an auto-managed timestamp cannot also be the primary key.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			contractFields[field.name] = {
+				nullable: field.optional,
+				type: {
+					kind: "scalar",
+					codecId: SCALAR_TO_CODEC_ID["DateTime"]
+				}
+			};
+			fieldExecutionDefaults.push({
+				fieldName: field.name,
+				onCreate: {
+					kind: "generator",
+					id: TIMESTAMP_NOW_GENERATOR_ID
+				},
+				onUpdate: {
+					kind: "generator",
+					id: TIMESTAMP_NOW_GENERATOR_ID
+				}
+			});
+			continue;
+		}
+		const codecId = SCALAR_TO_CODEC_ID[field.typeName];
+		if (codecId === void 0) {
+			diagnostics.push({
+				code: "IDB_UNSUPPORTED_FIELD_TYPE",
+				message: `Field "${model.name}.${field.name}" has unsupported type "${field.typeName}". Supported types: ${Object.keys(SCALAR_TO_CODEC_ID).join(", ")}.`,
+				sourceId,
+				span: field.span
+			});
+			continue;
+		}
+		contractFields[field.name] = {
+			nullable: field.optional,
+			type: {
+				kind: "scalar",
+				codecId
+			}
+		};
+		const updatedAtAttr = getFieldAttribute(field, "updatedAt");
+		const defaultAttr = getFieldAttribute(field, "default");
+		if (updatedAtAttr && defaultAttr) {
+			diagnostics.push({
+				code: "IDB_UPDATED_AT_AND_DEFAULT_CONFLICT",
+				message: `Field "${model.name}.${field.name}" cannot combine @updatedAt with @default(...).`,
+				sourceId,
+				span: defaultAttr.span
+			});
+			continue;
+		}
+		if (updatedAtAttr) {
+			if (field.name === idFieldName) {
+				diagnostics.push({
+					code: "IDB_TEMPORAL_UPDATED_AT_ON_KEY_FIELD",
+					message: `Field "${model.name}.${field.name}" is the model's @id key and cannot be @updatedAt — an auto-managed timestamp cannot also be the primary key.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			if (field.optional) {
+				diagnostics.push({
+					code: "IDB_EXECUTION_DEFAULT_ON_OPTIONAL_FIELD",
+					message: `Field "${model.name}.${field.name}" cannot be both optional and @updatedAt — an omitted value would be ambiguous between "generate one" and "store null". Remove "?" or the attribute.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			if (codecId !== SCALAR_TO_CODEC_ID["DateTime"]) {
+				diagnostics.push({
+					code: "IDB_UPDATED_AT_NOT_DATETIME",
+					message: `Field "${model.name}.${field.name}" is marked @updatedAt but has type "${field.typeName}", not DateTime.`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			fieldExecutionDefaults.push({
+				fieldName: field.name,
+				onCreate: {
+					kind: "generator",
+					id: TIMESTAMP_NOW_GENERATOR_ID
+				},
+				onUpdate: {
+					kind: "generator",
+					id: TIMESTAMP_NOW_GENERATOR_ID
+				}
+			});
+		} else if (defaultAttr) {
+			const raw = findPositionalArg(defaultAttr.args);
+			if (raw === void 0) {
+				diagnostics.push({
+					code: "IDB_INVALID_DEFAULT_VALUE",
+					message: `Field "${model.name}.${field.name}" @default(...) requires a positional argument.`,
+					sourceId,
+					span: defaultAttr.span
+				});
+				continue;
+			}
+			const literal = parseDefaultLiteralValue(raw);
+			if (literal) {
+				if (!literalValueMatchesCodec(literal.value, codecId)) {
+					diagnostics.push({
+						code: "IDB_INVALID_DEFAULT_VALUE",
+						message: `Field "${model.name}.${field.name}" has type "${field.typeName}" but @default(${raw}) is a ${typeof literal.value} literal.`,
+						sourceId,
+						span: defaultAttr.span
+					});
+					continue;
+				}
+				fieldExecutionDefaults.push({
+					fieldName: field.name,
+					onCreate: {
+						kind: "generator",
+						id: LITERAL_GENERATOR_ID,
+						params: { value: literal.value }
+					}
+				});
+				fieldDefaults[field.name] = literal.value;
+			} else {
+				const call = parseDefaultFunctionCall(raw);
+				if (!call) {
+					diagnostics.push({
+						code: "IDB_INVALID_DEFAULT_VALUE",
+						message: `Field "${model.name}.${field.name}" has unsupported default value "${raw}".`,
+						sourceId,
+						span: defaultAttr.span
+					});
+					continue;
+				}
+				if (call.name === "autoincrement") {
+					if (field.name !== idFieldName) {
+						diagnostics.push({
+							code: "IDB_AUTOINCREMENT_NOT_ON_KEY_FIELD",
+							message: `Field "${model.name}.${field.name}" uses @default(autoincrement()) but is not the model's @id key. IndexedDB only generates keys for the primary key field.`,
+							sourceId,
+							span: defaultAttr.span
+						});
+						continue;
+					}
+					if (codecId !== SCALAR_TO_CODEC_ID["Int"]) {
+						diagnostics.push({
+							code: "IDB_AUTOINCREMENT_NOT_INT",
+							message: `Field "${model.name}.${field.name}" uses @default(autoincrement()) but has type "${field.typeName}", not Int. IndexedDB key generators only produce numbers.`,
+							sourceId,
+							span: defaultAttr.span
+						});
+						continue;
+					}
+					autoIncrement = true;
+					continue;
+				}
+				if (field.optional) {
+					diagnostics.push({
+						code: "IDB_EXECUTION_DEFAULT_ON_OPTIONAL_FIELD",
+						message: `Field "${model.name}.${field.name}" cannot be both optional and @default(${call.name}(...)) — an omitted value would be ambiguous between "generate one" and "store null". Remove "?" or the default.`,
+						sourceId,
+						span: defaultAttr.span
+					});
+					continue;
+				}
+				const resolution = resolveDefaultFunctionGeneratorId(call.name, call.arg);
+				if (!resolution.ok) {
+					diagnostics.push({
+						code: resolution.reason === "unknown-function" ? "IDB_UNKNOWN_DEFAULT_FUNCTION" : "IDB_INVALID_DEFAULT_FUNCTION_ARGUMENT",
+						message: resolution.reason === "unknown-function" ? `Field "${model.name}.${field.name}" uses unsupported default function "${call.name}(...)". Supported: now(), uuid(), uuid(7), cuid(), autoincrement().` : `Field "${model.name}.${field.name}" — @default(${call.name}(${call.arg ?? ""})) has an unsupported argument.`,
+						sourceId,
+						span: defaultAttr.span
+					});
+					continue;
+				}
+				fieldExecutionDefaults.push({
+					fieldName: field.name,
+					onCreate: {
+						kind: "generator",
+						id: resolution.generatorId
+					}
+				});
+			}
+		}
+		if (hasFieldAttribute(field, "unique")) {
+			if (!Object.entries(indexes).find(([, idx]) => idx.keyPath === field.name)?.[0]) indexes[`${field.name}_unique`] = {
+				keyPath: field.name,
+				unique: true
+			};
+		}
+	}
+	const scalarCodecOf = (fieldName) => {
+		const type = contractFields[fieldName]?.type;
+		return type?.kind === "scalar" ? type.codecId : void 0;
+	};
+	const keyFieldCodec = scalarCodecOf(keyPath);
+	if (keyFieldCodec !== void 0 && !isValidIdbKeyCodec(keyFieldCodec)) diagnostics.push({
+		code: "IDB_INVALID_KEY_TYPE",
+		message: `Model "${model.name}" @id field "${keyPath}" has type "${keyFieldCodec}", which IndexedDB cannot use as a key. Every write would throw (DataError extracting the primary key). Use String, Int, Float, DateTime, Decimal, or Bytes instead.`,
+		sourceId,
+		span: modelFields.find((f) => f.name === keyPath)?.span ?? model.span
+	});
+	for (const [indexName, idx] of Object.entries(indexes)) {
+		const fieldCodec = scalarCodecOf(idx.keyPath);
+		if (fieldCodec === void 0 || isValidIdbKeyCodec(fieldCodec)) continue;
+		diagnostics.push({
+			code: "IDB_INVALID_INDEX_KEY_TYPE",
+			message: `Model "${model.name}" index "${indexName}" is keyed on "${idx.keyPath}" (type "${fieldCodec}"), which IndexedDB cannot use as an index key. Records are silently omitted from the index on write, and any query against it throws at runtime. Use String, Int, Float, DateTime, Decimal, or Bytes instead.`,
+			sourceId,
+			span: modelFields.find((f) => f.name === idx.keyPath)?.span ?? model.span
+		});
+	}
+	return {
+		modelName: model.name,
+		storeName,
+		keyPath,
+		indexes,
+		fields: contractFields,
+		relations,
+		relationsStorage,
+		fieldDefaults,
+		fksByTarget,
+		fieldExecutionDefaults,
+		autoIncrement
+	};
+}
+function interpretPslDocumentToIdbContract(table, sourceId, options) {
+	const projection = options?.projection ?? "full";
+	const diagnostics = [];
+	const explicitNamespaces = Object.values(table.topLevel.namespaces);
+	for (const ns of explicitNamespaces) diagnostics.push({
+		code: "IDB_UNSUPPORTED_NAMESPACE_BLOCK",
+		message: `IDB does not support \`namespace ${ns.name} { … }\` blocks. All models must be declared at the top level.`,
+		sourceId,
+		span: ns.span
+	});
+	const allModelsUnprojected = [...Object.values(table.topLevel.models), ...explicitNamespaces.flatMap((ns) => Object.values(ns.models))];
+	const modelNames = new Set(allModelsUnprojected.map((m) => m.name));
+	const excludedModelNames = new Set(projection === "client" ? allModelsUnprojected.filter((m) => hasModelAttribute(m, IDB_EXCLUDE_ATTR)).map((m) => m.name) : []);
+	const allModels = projection === "client" ? allModelsUnprojected.filter((m) => !excludedModelNames.has(m.name)) : allModelsUnprojected;
+	const excludedFieldNamesByModel = new Map(projection === "client" ? allModelsUnprojected.map((m) => [m.name, new Set(Object.values(m.fields).filter((f) => hasFieldAttribute(f, IDB_EXCLUDE_ATTR)).map((f) => f.name))]) : []);
+	const interpretedByName = /* @__PURE__ */ new Map();
+	for (const model of allModels) {
+		const result = interpretModel(model, modelNames, sourceId, diagnostics, projection, excludedModelNames, excludedFieldNamesByModel);
+		if (result) interpretedByName.set(model.name, result);
+	}
+	for (const model of allModels) {
+		const interp = interpretedByName.get(model.name);
+		if (!interp) continue;
+		for (const field of Object.values(model.fields)) {
+			if (!field.list || !modelNames.has(field.typeName)) continue;
+			if (excludedModelNames.has(field.typeName)) continue;
+			const targetInterp = interpretedByName.get(field.typeName);
+			if (!targetInterp) continue;
+			const fk = targetInterp.fksByTarget.get(model.name);
+			if (!fk) {
+				diagnostics.push({
+					code: "IDB_UNRESOLVED_BACKRELATION",
+					message: `Backrelation field "${model.name}.${field.name}" (list of ${field.typeName}) has no matching @relation in "${field.typeName}" pointing to "${model.name}". Add @relation(fields: [...], references: [...]) to the FK field in "${field.typeName}".`,
+					sourceId,
+					span: field.span
+				});
+				continue;
+			}
+			const mutableInterp = interp;
+			mutableInterp.relations[field.name] = {
+				to: crossRef(field.typeName),
+				cardinality: "1:N",
+				on: {
+					localFields: fk.targetFields,
+					targetFields: fk.localFields
+				}
+			};
+		}
+	}
+	if (diagnostics.length > 0) return notOk({
+		summary: "PSL to IDB contract interpretation failed",
+		diagnostics
+	});
+	const ns = UNBOUND_DOMAIN_NAMESPACE_ID;
+	const stores = {};
+	const roots = {};
+	const domainModels = {};
+	const executionDefaults = [];
+	for (const [modelName, interp] of interpretedByName) {
+		stores[interp.storeName] = {
+			keyPath: interp.keyPath,
+			...interp.autoIncrement ? { autoIncrement: true } : {},
+			...Object.keys(interp.indexes).length > 0 ? { indexes: interp.indexes } : {}
+		};
+		roots[interp.storeName] = crossRef(modelName);
+		for (const fd of interp.fieldExecutionDefaults) executionDefaults.push({
+			ref: {
+				namespace: ns,
+				table: interp.storeName,
+				column: fd.fieldName
+			},
+			...fd.onCreate ? { onCreate: fd.onCreate } : {},
+			...fd.onUpdate ? { onUpdate: fd.onUpdate } : {}
+		});
+		const modelStorage = {
+			storeName: interp.storeName,
+			keyPath: interp.keyPath,
+			...Object.keys(interp.relationsStorage).length > 0 ? { relations: interp.relationsStorage } : {},
+			...Object.keys(interp.fieldDefaults).length > 0 ? { fieldDefaults: interp.fieldDefaults } : {}
+		};
+		domainModels[modelName] = {
+			fields: interp.fields,
+			relations: interp.relations,
+			storage: modelStorage
+		};
+	}
+	const storageBlock = {
+		stores,
+		namespaces: { [ns]: {
+			id: ns,
+			entries: {}
+		} }
+	};
+	const capabilities = { idb: {
+		ddlOnlyInUpgrade: true,
+		transactionalDDL: true
+	} };
+	const storageHash = computeStorageHash({
+		target: "idb",
+		targetFamily: "idb",
+		storage: storageBlock
+	});
+	const profileHash = computeProfileHash({
+		target: "idb",
+		targetFamily: "idb",
+		capabilities
+	});
+	const storage = {
+		...storageBlock,
+		storageHash
+	};
+	const domain = { namespaces: { [ns]: { models: domainModels } } };
+	const execution = executionDefaults.length > 0 ? {
+		executionHash: computeExecutionHash({
+			target: "idb",
+			targetFamily: "idb",
+			execution: { mutations: { defaults: executionDefaults } }
+		}),
+		mutations: { defaults: executionDefaults }
+	} : void 0;
+	const contract = {
+		target: "idb",
+		targetFamily: "idb",
+		roots,
+		domain,
+		storage,
+		capabilities,
+		extensions: {},
+		meta: {},
+		profileHash,
+		...execution ? { execution } : {}
+	};
+	validateContract(contract);
+	return ok(contract);
+}
+//#endregion
+export { warnDroppedRelation as i, isValidIdbKeyCodec as n, literalValueMatchesCodec as r, interpretPslDocumentToIdbContract as t };
+
+//# sourceMappingURL=psl-interpreter-C6Q4okuO.mjs.map