@prisma/composer-prisma-cloud 0.18.0-dev.1 → 0.18.0-dev.2

package/dist/auth/testing.mjs

@@ -18391,7 +18391,7 @@ const ZodRecord = /*@__PURE__*/ $constructor("ZodRecord", (inst, def) => {
 	inst.keyType = def.keyType;
 	inst.valueType = def.valueType;
 });
-function record(keyType, valueType, params) {
+function record$1(keyType, valueType, params) {
 	if (!valueType || !valueType._zod) return new ZodRecord({
 		type: "record",
 		keyType: string$1(),
@@ -28188,7 +28188,7 @@ const linkSocialAccount = createAuthEndpoint("/link-social", {
 		/**
 		* Any additional data to pass through the oauth flow.
 		*/
-		additionalData: record(string$1(), any()).optional()
+		additionalData: record$1(string$1(), any()).optional()
 	}),
 	use: [sessionMiddleware],
 	metadata: { openapi: {
@@ -29514,7 +29514,7 @@ const socialSignInBodySchema = object({
 	/**
 	* Additional data to be passed through the OAuth flow
 	*/
-	additionalData: record(string$1(), any()).optional().meta({ description: "Additional data to be passed through the OAuth flow" })
+	additionalData: record$1(string$1(), any()).optional().meta({ description: "Additional data to be passed through the OAuth flow" })
 });
 const signInSocial = () => createAuthEndpoint("/sign-in/social", {
 	method: "POST",
@@ -29788,7 +29788,7 @@ const signUpEmailBodySchema = object({
 	image: string$1().optional(),
 	callbackURL: string$1().optional(),
 	rememberMe: boolean$1().optional()
-}).and(record(string$1(), any()));
+}).and(record$1(string$1(), any()));
 const signUpEmail = () => createAuthEndpoint("/sign-up/email", {
 	method: "POST",
 	operationId: "signUpWithEmailAndPassword",
@@ -30036,7 +30036,7 @@ const signUpEmail = () => createAuthEndpoint("/sign-up/email", {
 	});
 });
 init_error();
-const updateSessionBodySchema = record(string$1().meta({ description: "Field name must be a string" }), any());
+const updateSessionBodySchema = record$1(string$1().meta({ description: "Field name must be a string" }), any());
 const updateSession = () => createAuthEndpoint("/update-session", {
 	method: "POST",
 	operationId: "updateSession",
@@ -30085,7 +30085,7 @@ const updateSession = () => createAuthEndpoint("/update-session", {
 	return ctx.json({ session: parseSessionOutput(ctx.context.options, newSession) });
 });
 init_error();
-const updateUserBodySchema = record(string$1().meta({ description: "Field name must be a string" }), any());
+const updateUserBodySchema = record$1(string$1().meta({ description: "Field name must be a string" }), any());
 const updateUser = () => createAuthEndpoint("/update-user", {
 	method: "POST",
 	operationId: "updateUser",
@@ -52211,7 +52211,7 @@ const createUserBodySchema = object({
 	/**
 	* extra fields for user
 	*/
-	data: record(string$1(), any()).optional().meta({ description: "Extra fields for the user. Including custom additional fields." })
+	data: record$1(string$1(), any()).optional().meta({ description: "Extra fields for the user. Including custom additional fields." })
 });
 /**
 * ### Endpoint
@@ -52309,7 +52309,7 @@ const createUser = (opts) => createAuthEndpoint("/admin/create-user", {
 });
 const adminUpdateUserBodySchema = object({
 	userId: string().meta({ description: "The user id" }),
-	data: record(any(), any()).meta({ description: "The user data to update" })
+	data: record$1(any(), any()).meta({ description: "The user data to update" })
 });
 /**
 * ### Endpoint
@@ -52945,7 +52945,7 @@ const setUserPassword = (opts) => createAuthEndpoint("/admin/set-user-password",
 const userHasPermissionBodySchema = object({
 	userId: string().optional().meta({ description: `The user id. Eg: "user-id"` }),
 	role: string$1().optional().meta({ description: `The role to check permission for. Eg: "admin"` })
-}).and(xor([object({ permission: record(string$1(), array$1(string$1())) }), object({ permissions: record(string$1(), array$1(string$1())) })]));
+}).and(xor([object({ permission: record$1(string$1(), array$1(string$1())) }), object({ permissions: record$1(string$1(), array$1(string$1())) })]));
 /**
 * ### Endpoint
 *
@@ -53397,8 +53397,8 @@ const schema = { jwks: { fields: {
 } } };
 init_error();
 const signJWTBodySchema = object({
-	payload: record(string$1(), any()),
-	overrideOptions: record(string$1(), any()).optional()
+	payload: record$1(string$1(), any()),
+	overrideOptions: record$1(string$1(), any()).optional()
 });
 const verifyJWTBodySchema = object({
 	token: string$1(),
@@ -53592,7 +53592,7 @@ const signInMagicLinkBodySchema = object({
 	callbackURL: string$1().meta({ description: "URL to redirect after magic link verification" }).optional(),
 	newUserCallbackURL: string$1().meta({ description: "URL to redirect after new user signup. Only used if the user is registering for the first time." }).optional(),
 	errorCallbackURL: string$1().meta({ description: "URL to redirect after error." }).optional(),
-	metadata: record(string$1(), any()).meta({ description: "Additional metadata to pass to sendMagicLink." }).optional()
+	metadata: record$1(string$1(), any()).meta({ description: "Additional metadata to pass to sendMagicLink." }).optional()
 });
 const magicLinkVerifyQuerySchema = object({
 	token: string$1().meta({ description: "Verification token" }),
@@ -58072,6 +58072,7 @@ var contract_default = {
 			},
 			"relations": { "user": {
 				"cardinality": "N:1",
+				"nullable": false,
 				"on": {
 					"localFields": ["userId"],
 					"targetFields": ["id"]
@@ -58220,6 +58221,7 @@ var contract_default = {
 			},
 			"relations": { "user": {
 				"cardinality": "N:1",
+				"nullable": false,
 				"on": {
 					"localFields": ["userId"],
 					"targetFields": ["id"]
@@ -60018,7 +60020,7 @@ function postgresResolveDefault(def, resolvedNativeType) {
 	return parsePostgresDefault(def.expression, resolvedNativeType) ?? def;
 }
 /**
-* A bug in Prisma Next, not a user error. Never catch this except at the
+* A bug in Prisma 8, not a user error. Never catch this except at the
 * outermost boundary for crash reporting — an InternalError means an invariant
 * broke and the process cannot reliably continue. User-facing failures use
 * `structuredError` with a dotted code instead.
@@ -61399,7 +61401,7 @@ function isCodecTrait(value) {
 */
 const voidParamsSchema = { "~standard": {
 	version: 1,
-	vendor: "prisma-next",
+	vendor: "prisma",
 	validate: (input) => input === void 0 ? { value: void 0 } : { issues: [{ message: "unexpected typeParams for non-parameterized codec (void params expected)" }] }
 } };
 function runtimeError(code, message, details) {
@@ -61469,16 +61471,13 @@ function validateCodecTypeParams(descriptor, ref) {
 }
 /**
 * Resolves a `Codec` instance: validates `ref.typeParams` via
-* {@link validateCodecTypeParams} then calls `descriptor.factory(validated)(ctx)`.
-*
-* The descriptor's `factory` is typed against its own `P`; the registry erases
-* `P` to `any`, so the factory is narrowed to `(params: unknown) => (ctx) => Codec`
-* at the call boundary. The `paramsSchema` validates the input above before we
-* forward it, so the narrowing is safe by construction.
+* {@link validateCodecTypeParams} then calls `descriptor.factory(validated)(ctx)`
+* as a method on `descriptor`, preserving `this` for factories that build
+* their returned codec from the descriptor instance (e.g. `new XCodec(this)`).
 */
 function materializeCodec(descriptor, ref, ctx) {
 	const validated = validateCodecTypeParams(descriptor, ref);
-	return blindCast(descriptor.factory)(validated)(ctx);
+	return descriptor.factory(validated)(ctx);
 }
 /**
 * Renders a string as a TypeScript source-text literal.
@@ -62783,6 +62782,103 @@ function indexInputFromSerialized(flat) {
 	};
 }
 /**
+* Stable code emitted by the runtime when an in-flight `execute()`
+* is cancelled via the per-query `AbortSignal`. The envelope's
+* `details.phase` distinguishes where the abort was observed:
+*
+* - `'encode'` — abort fired during `encodeParams` (SQL) or
+*   `resolveValue` (Mongo).
+* - `'decode'` — abort fired during `decodeRow` / `decodeField`.
+* - `'stream'` — abort fired between rows or before any codec call
+*   (already-aborted at entry).
+* - `'beforeQuery'` / `'beforeExecute'` / `'afterQuery'` /
+*   `'afterExecute'` / `'onRow'` — abort fired on entry to or during
+*   the corresponding middleware phase
+*   (cooperative cancellation per the param-transform seam).
+*/
+const RUNTIME_ABORTED = "RUNTIME.ABORTED";
+/**
+* Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the
+* abort was observed — codec call sites (`encode` / `decode` / `stream`)
+* or operation-specific middleware seams, as
+* enumerated on {@link RuntimeAbortedPhase}. Cause carries
+* `signal.reason` verbatim from the platform — native abort produces a
+* `DOMException`, explicit `controller.abort(reason)` produces whatever
+* the caller passed. No synthesis happens here.
+*/
+function runtimeAborted(phase, cause) {
+	const envelope = runtimeError(RUNTIME_ABORTED, `Operation aborted during ${phase}`, { phase });
+	return Object.assign(envelope, { cause });
+}
+/**
+* Throw a phase-tagged `RUNTIME.ABORTED` envelope if the supplied
+* context is already aborted at the precheck site. Centralises the
+* `if (ctx.signal?.aborted) throw runtimeAborted(...)` pattern that
+* every codec dispatch site (and the `beforeExecute` middleware phase)
+* repeats. Accepts both the framework `CodecCallContext` and the
+* `RuntimeMiddlewareContext`; both expose `signal?: AbortSignal`.
+*/
+function checkAborted(ctx, phase) {
+	if (ctx.signal?.aborted) throw runtimeAborted(phase, ctx.signal.reason);
+}
+/**
+* Race a per-cell `Promise.all` (or any other in-flight work promise) against
+* the supplied abort signal so the runtime returns `RUNTIME.ABORTED` promptly
+* even when codec bodies ignore the signal. In-flight bodies that ignore the
+* signal are abandoned and run to completion in the background — the
+* cooperative-cancellation contract documented in ADR 204.
+*
+* Call sites still SHOULD pre-check `signal.aborted` and short-circuit with
+* a phase-tagged `RUNTIME.ABORTED` envelope before invoking this helper —
+* that path is the canonical "aborted at entry" surface and avoids
+* scheduling the work promise. As a defensive belt-and-braces, this helper
+* also handles the already-aborted case internally: `AbortSignal` does not
+* replay past abort events to listeners registered after the abort, so we
+* inspect `signal.aborted` synchronously and reject with the sentinel
+* before installing the listener. The rejection is still attributed to the
+* abort path via the sentinel-identity check.
+*
+* Distinguishing the rejection source is load-bearing for AC-ERR4
+* (`RUNTIME.ENCODE_FAILED` / `RUNTIME.DECODE_FAILED` pass through unchanged).
+* The semantically equivalent `abortable(signal)` helper in
+* `@internal/utils` rejects with `signal.reason ?? new DOMException(...)`,
+* which is not stably distinguishable from a codec-thrown error by identity
+* alone (a fresh fallback DOMException is allocated per call). We instead
+* track abort attribution with a unique sentinel: only the `onAbort` listener
+* installed here ever rejects with the sentinel, so an `error === sentinel`
+* identity check after the race is unambiguous.
+*
+* Lives in `framework-components` (rather than the SQL family, where it
+* originated in m2) so every family runtime that needs cooperative
+* cancellation around a codec-dispatch `Promise.all` (SQL encode + decode
+* today, Mongo encode in m3) shares the same attribution logic.
+*/
+async function raceAgainstAbort(work, signal, phase) {
+	if (signal === void 0) return await work;
+	const sentinel = { reason: void 0 };
+	let onAbort;
+	const abortPromise = new Promise((_, reject) => {
+		if (signal.aborted) {
+			sentinel.reason = signal.reason;
+			reject(sentinel);
+			return;
+		}
+		onAbort = () => {
+			sentinel.reason = signal.reason;
+			reject(sentinel);
+		};
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+	try {
+		return await Promise.race([work, abortPromise]);
+	} catch (error) {
+		if (error === sentinel) throw runtimeAborted(phase, sentinel.reason);
+		throw error;
+	} finally {
+		if (onAbort) signal.removeEventListener("abort", onAbort);
+	}
+}
+/**
 * Sentinel kind for the legacy codec-triple shape persisted under
 * `SqlStorage.types`. Plain JSON-clean object literals carry this
 * discriminator so the polymorphic slot dispatch can route them down
@@ -63942,7 +64038,7 @@ function classifyEnumMemberType(block) {
 */
 function resolveEnumCodecId(block, ctx) {
 	const sourceId = ctx.sourceId ?? "unknown";
-	const typeAttr = block.blockAttributes.find((a) => a.name === "type");
+	const typeAttr = block.attributes["type"];
 	if (typeAttr === void 0) {
 		const inferredKind = classifyEnumMemberType(block);
 		if (inferredKind === null || ctx.enumInferenceCodecs === void 0) {
@@ -63959,20 +64055,11 @@ function resolveEnumCodecId(block, ctx) {
 			codecSpan: block.span
 		};
 	}
-	const rawCodecArg = typeAttr.args[0]?.value;
-	const codecId = rawCodecArg?.startsWith("\"") && rawCodecArg.endsWith("\"") && rawCodecArg.length >= 2 ? rawCodecArg.slice(1, -1) : void 0;
-	if (codecId === void 0) {
-		ctx.diagnostics?.push({
-			code: "PSL_ENUM_MISSING_TYPE",
-			message: `enum "${block.name}" @@type attribute must have a quoted codec id argument`,
-			sourceId,
-			span: typeAttr.span
-		});
-		return;
-	}
+	const codecId = typeAttr.args["codecId"];
+	invariant(typeof codecId === "string", "@@type on an enum block parses one string argument");
 	return {
 		codecId,
-		codecSpan: typeAttr.args[0]?.span ?? typeAttr.span
+		codecSpan: typeAttr.span
 	};
 }
 function isAuthoringArgRef(value) {
@@ -64064,7 +64151,11 @@ function isWellFormedDescriptor(value, descriptorKind) {
 			if (!("required" in name) || typeof name.required !== "boolean") return false;
 			if (!("parameters" in value)) return false;
 			const parameters = value.parameters;
-			return typeof parameters === "object" && parameters !== null && !Array.isArray(parameters);
+			if (typeof parameters !== "object" || parameters === null || Array.isArray(parameters)) return false;
+			if (!("attributes" in value) || value.attributes === void 0) return true;
+			const attributes = value.attributes;
+			if (typeof attributes !== "object" || attributes === null || Array.isArray(attributes)) return false;
+			return Object.values(attributes).every((factory) => typeof factory === "function");
 		}
 		case "modelAttribute":
 			if (!("attribute" in value) || typeof value.attribute !== "string" || value.attribute.length === 0) return false;
@@ -64118,6 +64209,25 @@ function mergeAuthoringNamespaces(target, source, path, descriptorKind, label) {
 		mergeAuthoringNamespaces(existingValue, sourceValue, currentPath, descriptorKind, label);
 	}
 }
+const ATTRIBUTE_SPEC_LEVELS = ["model", "field"];
+function mergeAuthoringAttributeSpecs(target, source, contributedBy, owners) {
+	const invalidContribution = (detail) => runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Invalid authoring attributeSpecs contribution from descriptor "${contributedBy}". ${detail}`);
+	if (!isCopyableNamespaceObject(source)) throw invalidContribution("Expected a record carrying a \"model\" and a \"field\" level.");
+	for (const level of ATTRIBUTE_SPEC_LEVELS) {
+		const contributed = source[level];
+		if (!isCopyableNamespaceObject(contributed)) throw invalidContribution(`The "${level}" level must be a record of spec factories keyed by attribute name.`);
+		for (const [attribute, factory] of Object.entries(contributed)) {
+			const entryPath = `${level}.${attribute}`;
+			const invalidEntry = (detail) => runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Invalid authoring attributeSpecs entry "${entryPath}" contributed by descriptor "${contributedBy}". ${detail}`);
+			if (attribute === "__proto__" || attribute === "constructor" || attribute === "prototype") throw invalidEntry(`Attribute names must not use "${attribute}".`);
+			if (typeof factory !== "function") throw invalidEntry("Each entry must be a spec factory function.");
+			const existingOwner = owners.get(entryPath);
+			if (existingOwner !== void 0) throw runtimeError("CONTRACT.PACK_CONTRIBUTION_INVALID", `Duplicate authoring attributeSpecs entry "${entryPath}". Descriptor "${contributedBy}" conflicts with "${existingOwner}". Each attribute name may be claimed once per level.`);
+			owners.set(entryPath, contributedBy);
+			target[level][attribute] = factory;
+		}
+	}
+}
 /**
 * Collects the full dotted paths of every well-formed descriptor of
 * `descriptorKind` in a raw contribution tree, using the same boundary
@@ -64654,6 +64764,11 @@ function assembleAuthoringContributions(descriptors) {
 	const entityTypes = {};
 	const pslBlockDescriptors = {};
 	const modelAttributes = {};
+	const attributeSpecs = {
+		model: {},
+		field: {}
+	};
+	const attributeSpecOwners = /* @__PURE__ */ new Map();
 	const pathOwners = /* @__PURE__ */ new Map();
 	const claimContributedPaths = (namespace, descriptorKind, label, descriptorId) => {
 		for (const path of collectContributedDescriptorPaths(namespace, descriptorKind)) {
@@ -64692,6 +64807,7 @@ function assembleAuthoringContributions(descriptors) {
 			mergeAuthoringNamespaces(pslBlockDescriptors, descriptor.authoring.pslBlockDescriptors, [], "pslBlock", "pslBlock");
 		}
 		if (descriptor.authoring?.modelAttributes) mergeAuthoringNamespaces(modelAttributes, descriptor.authoring.modelAttributes, [], "modelAttribute", "modelAttribute");
+		if (descriptor.authoring?.attributeSpecs) mergeAuthoringAttributeSpecs(attributeSpecs, descriptor.authoring.attributeSpecs, descriptorId, attributeSpecOwners);
 	}
 	const fieldNamespace = field;
 	const typeNamespace = type;
@@ -64706,6 +64822,7 @@ function assembleAuthoringContributions(descriptors) {
 		entityTypes: entityTypeNamespace,
 		pslBlockDescriptors: pslBlockDescriptorNamespace,
 		modelAttributes: modelAttributeNamespace,
+		attributeSpecs,
 		...valueObjectStorageDeclaration !== void 0 ? { valueObjectStorageType: valueObjectStorageDeclaration.name } : {}
 	};
 }
@@ -66019,12 +66136,13 @@ var SqlCheckConstraintIR = class SqlCheckConstraintIR extends SqlSchemaIRNode {
 * Structural equality for two resolved column defaults, ported from the
 * relational walk's `columnDefaultsEqual` normalized branch: kinds must
 * match; literal values are normalized (Date and temporal-typed strings to
-* ISO instants) then compared canonically (JSON objects match their
-* canonical string form); function expressions compare case- and
+* ISO instants, and a 64-bit-integer native type's safe-integer number to
+* its decimal-text spelling) then compared canonically (JSON objects match
+* their canonical string form); function expressions compare case- and
 * whitespace-insensitively.
 *
-* `nativeType` provides the temporal-normalization context (the actual
-* side's resolved native type in a diff comparison).
+* `nativeType` provides the temporal- and int64-normalization context (the
+* actual side's resolved native type in a diff comparison).
 */
 function resolvedDefaultsEqual(expected, actual, nativeType) {
 	if (expected.kind !== actual.kind) return false;
@@ -66040,12 +66158,18 @@ function isTemporalNativeType(nativeType) {
 	const normalized = nativeType.toLowerCase();
 	return normalized.includes("timestamp") || normalized === "date";
 }
+function isInt64NativeType(nativeType) {
+	if (!nativeType) return false;
+	const normalized = nativeType.toLowerCase();
+	return normalized === "int8" || normalized === "bigint";
+}
 function normalizeLiteralValue(value, nativeType) {
 	if (value instanceof Date) return value.toISOString();
 	if (typeof value === "string" && isTemporalNativeType(nativeType)) {
 		const parsed = new Date(value);
 		if (!Number.isNaN(parsed.getTime())) return parsed.toISOString();
 	}
+	if (typeof value === "number" && Number.isSafeInteger(value) && isInt64NativeType(nativeType)) return String(value);
 	return value;
 }
 function literalValuesEqual(a, b) {
@@ -66509,6 +66633,1487 @@ var SqlSchemaIR = class extends SqlSchemaIRNode {
 		return Object.values(this.tables);
 	}
 };
+/**
+* Generic Result type for representing success or failure outcomes.
+*
+* This is the standard way to return "expected failures" as values rather than
+* throwing exceptions. See docs/Error Handling.md for the full taxonomy.
+*
+* Naming rationale:
+* - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator
+* - `NotOk` avoids collision with domain types like "Failure" or "Error"
+* - `failure` property distinguishes from JS Error semantics
+*/
+/**
+* Result class that implements both Ok and NotOk variants.
+*/
+var ResultImpl = class ResultImpl {
+	ok;
+	_value;
+	_failure;
+	constructor(ok, valueOrFailure) {
+		this.ok = ok;
+		if (ok) this._value = valueOrFailure;
+		else this._failure = valueOrFailure;
+		Object.freeze(this);
+	}
+	get value() {
+		if (!this.ok) throw new InternalError("Cannot access value on NotOk result");
+		return this._value;
+	}
+	get failure() {
+		if (this.ok) throw new InternalError("Cannot access failure on Ok result");
+		return this._failure;
+	}
+	/**
+	* Creates a successful result.
+	*/
+	static ok(value) {
+		return blindCast(new ResultImpl(true, value));
+	}
+	/**
+	* Creates an unsuccessful result.
+	*/
+	static notOk(failure) {
+		return blindCast(new ResultImpl(false, failure));
+	}
+	/**
+	* Asserts that this result is Ok and returns the value.
+	* Throws if the result is NotOk.
+	*/
+	assertOk() {
+		if (!this.ok) throw new InternalError("Expected Ok result but got NotOk");
+		return this.value;
+	}
+	/**
+	* Asserts that this result is NotOk and returns the failure.
+	* Throws if the result is Ok.
+	*/
+	assertNotOk() {
+		if (this.ok) throw new InternalError("Expected NotOk result but got Ok");
+		return this.failure;
+	}
+};
+/**
+* Creates a successful result.
+*/
+function ok$1(value) {
+	return ResultImpl.ok(value);
+}
+/**
+* Creates an unsuccessful result.
+*/
+function notOk(failure) {
+	return ResultImpl.notOk(failure);
+}
+/**
+* Singleton for void success results.
+* Use this for validation checks that don't produce a value.
+*/
+const OK_VOID = ResultImpl.ok(void 0);
+/**
+* Returns a successful void result.
+* Use this for validation checks that don't produce a value.
+*/
+function okVoid() {
+	return OK_VOID;
+}
+/**
+* Name of the synthesised namespace bucket the framework parser uses for
+* top-level declarations that appear outside any `namespace { … }` block.
+* The double-underscore decoration signals that the identifier is parser-
+* synthesised and never appears in user-authored PSL source — writing
+* `namespace __unspecified__ { … }` is a parse error.
+*
+* Distinct from the IR sentinel `__unbound__`: the PSL bucket describes
+* syntactic absence at the parser layer; the IR sentinel describes a late-
+* bound storage slot at the IR layer. Per-target interpreters decide how
+* (or whether) to map the PSL bucket to the IR sentinel.
+*/
+const UNSPECIFIED_PSL_NAMESPACE_ID = "__unspecified__";
+/**
+* Stores `entries`; exposes `models`/`enums`/`compositeTypes` as getters over
+* it. The getters are prototype members (non-enumerable), so spreading or
+* `JSON.stringify`-ing a namespace copies only `entries`, never a duplicate view.
+*/
+var PslNamespaceNode = class {
+	kind = "namespace";
+	name;
+	entries;
+	span;
+	constructor(init) {
+		this.name = init.name;
+		this.entries = init.entries;
+		this.span = init.span;
+		Object.freeze(this);
+	}
+	get models() {
+		return blindCast(Object.values(this.entries["model"] ?? {}));
+	}
+	get compositeTypes() {
+		return blindCast(Object.values(this.entries["compositeType"] ?? {}));
+	}
+};
+/** Constructs a {@link PslNamespace}. Use this, never a namespace literal — the accessors must derive from `entries`. */
+function makePslNamespace(init) {
+	return new PslNamespaceNode(init);
+}
+/**
+* Builds the frozen `entries[kind][name]` container from per-kind arrays.
+* Built-ins key on their PSL keyword; extension blocks key on their `kind`
+* discriminator. Call this rather than hand-building the literal.
+*/
+function makePslNamespaceEntries(models, compositeTypes, extensionBlocks) {
+	const container = {};
+	if (models.length > 0) {
+		const map = {};
+		for (const m of models) map[m.name] = m;
+		container["model"] = Object.freeze(map);
+	}
+	if (compositeTypes.length > 0) {
+		const map = {};
+		for (const ct of compositeTypes) map[ct.name] = ct;
+		container["compositeType"] = Object.freeze(map);
+	}
+	for (const block of extensionBlocks) {
+		const existing = container[block.kind];
+		const newMap = existing ? blindCast({ ...existing }) : {};
+		newMap[block.name] = block;
+		container[block.kind] = Object.freeze(newMap);
+	}
+	return Object.freeze(container);
+}
+/**
+* A token in the red tree. Unlike the green-layer {@link Token} (kind + text
+* only), a red token also carries its absolute `offset` within the source and a
+* link back to its `parent` {@link SyntaxNode}, so a cursor anchored on a token
+* can walk outward (parent, previous/next token, siblings) without re-scanning
+* from the document root.
+*/
+var SyntaxToken = class {
+	green;
+	kind;
+	text;
+	offset;
+	parent;
+	/** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
+	index;
+	constructor(green, offset, parent, index) {
+		this.green = green;
+		this.kind = green.kind;
+		this.text = green.text;
+		this.offset = offset;
+		this.parent = parent;
+		this.index = index;
+	}
+	get textLength() {
+		return this.text.length;
+	}
+	get endOffset() {
+		return this.offset + this.textLength;
+	}
+	/** Whether `offset` falls within this token, inclusive of both ends. */
+	isInside(offset) {
+		return offset >= this.offset && offset <= this.endOffset;
+	}
+	isOutside(offset) {
+		return !this.isInside(offset);
+	}
+	/** The sibling element immediately after this token within its parent. */
+	get nextSiblingOrToken() {
+		return childAt(this.parent, this.index + 1);
+	}
+	/** The sibling element immediately before this token within its parent. */
+	get prevSiblingOrToken() {
+		return childAt(this.parent, this.index - 1);
+	}
+	/** The next token in document order, crossing node boundaries. */
+	get nextToken() {
+		for (let el = climbingNext(this); el !== void 0; el = climbingNext(el)) {
+			const token = firstToken(el);
+			if (token !== void 0) return token;
+		}
+	}
+	/** The previous token in document order, crossing node boundaries. */
+	get prevToken() {
+		for (let el = climbingPrev(this); el !== void 0; el = climbingPrev(el)) {
+			const token = lastToken(el);
+			if (token !== void 0) return token;
+		}
+	}
+};
+var TokenAtOffset = class TokenAtOffset {
+	#state;
+	constructor(state) {
+		this.#state = state;
+	}
+	static none() {
+		return new TokenAtOffset({ kind: "none" });
+	}
+	static single(token) {
+		return new TokenAtOffset({
+			kind: "single",
+			token
+		});
+	}
+	static between(left, right) {
+		return new TokenAtOffset({
+			kind: "between",
+			left,
+			right
+		});
+	}
+	get isEmpty() {
+		return this.#state.kind === "none";
+	}
+	get isBetween() {
+		return this.#state.kind === "between";
+	}
+	leftBiased() {
+		switch (this.#state.kind) {
+			case "none": return;
+			case "single": return this.#state.token;
+			case "between": return this.#state.left;
+		}
+	}
+	rightBiased() {
+		switch (this.#state.kind) {
+			case "none": return;
+			case "single": return this.#state.token;
+			case "between": return this.#state.right;
+		}
+	}
+};
+var SyntaxNode = class SyntaxNode {
+	green;
+	offset;
+	parent;
+	/** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
+	index;
+	constructor(green, offset, parent, index) {
+		this.green = green;
+		this.offset = offset;
+		this.parent = parent;
+		this.index = index;
+	}
+	get kind() {
+		return this.green.kind;
+	}
+	get textLength() {
+		return this.green.textLength;
+	}
+	get endOffset() {
+		return this.offset + this.textLength;
+	}
+	/** Whether `offset` falls within this node, inclusive of both ends. */
+	isInside(offset) {
+		return offset >= this.offset && offset <= this.endOffset;
+	}
+	isOutside(offset) {
+		return !this.isInside(offset);
+	}
+	get firstChild() {
+		return childAt(this, 0);
+	}
+	get lastChild() {
+		const len = this.green.children.length;
+		if (len === 0) return void 0;
+		return childAt(this, len - 1);
+	}
+	get nextSibling() {
+		return this.parent === void 0 ? void 0 : childAt(this.parent, this.index + 1);
+	}
+	get prevSibling() {
+		return this.parent === void 0 ? void 0 : childAt(this.parent, this.index - 1);
+	}
+	/** The sibling element immediately after this node within its parent. */
+	get nextSiblingOrToken() {
+		return this.nextSibling;
+	}
+	/** The sibling element immediately before this node within its parent. */
+	get prevSiblingOrToken() {
+		return this.prevSibling;
+	}
+	/** The first token in this subtree (depth-first), or `undefined` if empty. */
+	get firstToken() {
+		return firstToken(this);
+	}
+	/** The last token in this subtree (depth-first), or `undefined` if empty. */
+	get lastToken() {
+		return lastToken(this);
+	}
+	*children() {
+		let offset = this.offset;
+		let index = 0;
+		for (const child of this.green.children) {
+			yield wrapElement(child, offset, this, index);
+			offset += elementTextLength(child);
+			index++;
+		}
+	}
+	*childNodes() {
+		for (const child of this.children()) if (child instanceof SyntaxNode) yield child;
+	}
+	*ancestors() {
+		let current = this.parent;
+		while (current) {
+			yield current;
+			current = current.parent;
+		}
+	}
+	/** The nearest match, testing this node itself before walking its ancestors. */
+	findAncestor(cast) {
+		const self = cast(this);
+		if (self !== void 0) return self;
+		for (const ancestor of this.ancestors()) {
+			const result = cast(ancestor);
+			if (result !== void 0) return result;
+		}
+	}
+	*descendants() {
+		const stack = [this];
+		for (let el = stack.pop(); el !== void 0; el = stack.pop()) {
+			yield el;
+			if (el instanceof SyntaxNode) {
+				const children = Array.from(el.children());
+				for (let i = children.length - 1; i >= 0; i--) {
+					const child = children[i];
+					if (child !== void 0) stack.push(child);
+				}
+			}
+		}
+	}
+	*tokens() {
+		for (const el of this.descendants()) if (el instanceof SyntaxToken) yield el;
+	}
+	/**
+	* The token(s) at `offset`. The between-two-tokens case (offset exactly on a
+	* token seam) is represented explicitly so callers can left/right bias.
+	*/
+	tokenAtOffset(offset) {
+		return tokenAtOffsetOf(this, offset);
+	}
+	/**
+	* The smallest element fully containing the range `[start, end]`. At a seam
+	* (and for empty ranges) the left-hand element is preferred, matching
+	* {@link containsOffset}'s inclusive span.
+	*/
+	coveringElement(start, end) {
+		let result = this;
+		for (;;) {
+			if (result instanceof SyntaxToken) return result;
+			let next;
+			for (const child of result.children()) if (containsRange(child, start, end)) {
+				next = child;
+				break;
+			}
+			if (next === void 0) return result;
+			result = next;
+		}
+	}
+};
+function elementTextLength(el) {
+	return el.type === "token" ? el.text.length : el.textLength;
+}
+function elementLength(el) {
+	return el instanceof SyntaxToken ? el.text.length : el.textLength;
+}
+/**
+* Whether `el` contains `offset`. The span is inclusive on both ends so a seam
+* offset touches both neighbours.
+*/
+function containsOffset(el, offset) {
+	const start = el.offset;
+	const len = elementLength(el);
+	return offset >= start && offset <= start + len;
+}
+function containsRange(el, start, end) {
+	const elStart = el.offset;
+	const len = elementLength(el);
+	return elStart <= start && end <= elStart + len;
+}
+function tokenAtOffsetOf(el, offset) {
+	if (el instanceof SyntaxToken) return TokenAtOffset.single(el);
+	let left;
+	let right;
+	for (const child of el.children()) {
+		if (!containsOffset(child, offset)) continue;
+		if (left === void 0) left = child;
+		else {
+			right = child;
+			break;
+		}
+	}
+	if (left === void 0) return TokenAtOffset.none();
+	if (right === void 0) return tokenAtOffsetOf(left, offset);
+	const leftToken = tokenAtOffsetOf(left, offset).rightBiased();
+	const rightToken = tokenAtOffsetOf(right, offset).leftBiased();
+	if (leftToken !== void 0 && rightToken !== void 0) return TokenAtOffset.between(leftToken, rightToken);
+	if (leftToken !== void 0) return TokenAtOffset.single(leftToken);
+	if (rightToken !== void 0) return TokenAtOffset.single(rightToken);
+	return TokenAtOffset.none();
+}
+function firstToken(el) {
+	if (el instanceof SyntaxToken) return el;
+	for (const child of el.children()) {
+		const token = firstToken(child);
+		if (token !== void 0) return token;
+	}
+}
+function lastToken(el) {
+	if (el instanceof SyntaxToken) return el;
+	const children = Array.from(el.children());
+	for (let i = children.length - 1; i >= 0; i--) {
+		const child = children[i];
+		if (child !== void 0) {
+			const token = lastToken(child);
+			if (token !== void 0) return token;
+		}
+	}
+}
+function climbingNext(el) {
+	let current = el;
+	for (;;) {
+		const parent = current.parent;
+		if (parent === void 0) return void 0;
+		const sibling = childAt(parent, current.index + 1);
+		if (sibling !== void 0) return sibling;
+		current = parent;
+	}
+}
+function climbingPrev(el) {
+	let current = el;
+	for (;;) {
+		const parent = current.parent;
+		if (parent === void 0) return void 0;
+		const sibling = childAt(parent, current.index - 1);
+		if (sibling !== void 0) return sibling;
+		current = parent;
+	}
+}
+function wrapElement(green, offset, parent, index) {
+	if (green.type === "token") return new SyntaxToken(green, offset, parent, index);
+	return new SyntaxNode(green, offset, parent, index);
+}
+function childAt(node, index) {
+	const children = node.green.children;
+	const target = children[index];
+	if (target === void 0) return void 0;
+	let offset = node.offset;
+	for (let i = 0; i < index; i++) {
+		const child = children[i];
+		if (child !== void 0) offset += elementTextLength(child);
+	}
+	return wrapElement(target, offset, node, index);
+}
+function findChildToken(node, kind) {
+	for (const child of node.children()) if (!(child instanceof SyntaxNode) && child.kind === kind) return child;
+}
+function findFirstChild(node, cast) {
+	for (const child of node.childNodes()) {
+		const result = cast(child);
+		if (result !== void 0) return result;
+	}
+}
+function* filterChildren(node, cast) {
+	for (const child of node.childNodes()) {
+		const result = cast(child);
+		if (result !== void 0) yield result;
+	}
+}
+var IdentifierAst = class IdentifierAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	token() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	name() {
+		return this.token()?.text;
+	}
+	static cast(node) {
+		return node.kind === "Identifier" ? new IdentifierAst(node) : void 0;
+	}
+};
+/** A namespace-qualified name, e.g. `pgvector.Vector` or `supabase:auth.User`. */
+var QualifiedNameAst = class QualifiedNameAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	#segmentBefore(boundary) {
+		let found;
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+			if (segment.syntax.offset >= boundary) break;
+			found = segment;
+		}
+		return found;
+	}
+	#segmentAfter(boundary) {
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) if (segment.syntax.offset > boundary) return segment;
+	}
+	#separatorCount(kind) {
+		let count = 0;
+		for (const child of this.syntax.children()) if (!(child instanceof SyntaxNode) && child.kind === kind) count++;
+		return count;
+	}
+	colon() {
+		return findChildToken(this.syntax, "Colon");
+	}
+	dot() {
+		return findChildToken(this.syntax, "Dot");
+	}
+	space() {
+		const colon = this.colon();
+		if (!colon) return void 0;
+		return this.#segmentBefore(colon.offset);
+	}
+	namespace() {
+		const dot = this.dot();
+		if (!dot) return void 0;
+		return this.#segmentBefore(dot.offset);
+	}
+	identifier() {
+		const dot = this.dot();
+		if (dot) return this.#segmentAfter(dot.offset);
+		const colon = this.colon();
+		if (colon) return this.#segmentAfter(colon.offset);
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	/**
+	* Every identifier segment, in source order. A bare `Vector` yields
+	* `['Vector']`; a qualified `pgvector.Vector` yields `['pgvector', 'Vector']`.
+	*/
+	path() {
+		const segments = [];
+		for (const segment of filterChildren(this.syntax, IdentifierAst.cast)) {
+			const text = segment.token()?.text;
+			if (text !== void 0) segments.push(text);
+		}
+		return segments;
+	}
+	/** True iff this is a single unqualified identifier whose text equals `name`. */
+	isSimpleName(name) {
+		if (this.dot() !== void 0 || this.colon() !== void 0) return false;
+		return this.identifier()?.token()?.text === name;
+	}
+	/**
+	* Flags a malformed name with more qualifier segments than allowed (a second
+	* `:`-space or a second `.`-namespace).
+	*/
+	isOverQualified() {
+		return this.#separatorCount("Dot") > 1 || this.#separatorCount("Colon") > 1;
+	}
+	static cast(node) {
+		return node.kind === "QualifiedName" ? new QualifiedNameAst(node) : void 0;
+	}
+};
+var FunctionCallAst = class FunctionCallAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	/** The qualified-name callee, or `undefined` when identifier segments sit directly under the node. */
+	name() {
+		return findFirstChild(this.syntax, QualifiedNameAst.cast);
+	}
+	/**
+	* The dotted call path, in source order. A bare `Vector(…)` yields
+	* `['Vector']`; a namespace-qualified `pgvector.Vector(…)` yields
+	* `['pgvector', 'Vector']`. Empty when the call carries no identifier.
+	*/
+	path() {
+		const qualified = this.name();
+		const segments = [];
+		for (const segment of filterChildren(qualified?.syntax ?? this.syntax, IdentifierAst.cast)) {
+			const text = segment.token()?.text;
+			if (text !== void 0) segments.push(text);
+		}
+		return segments;
+	}
+	lparen() {
+		return findChildToken(this.syntax, "LParen");
+	}
+	rparen() {
+		return findChildToken(this.syntax, "RParen");
+	}
+	*args() {
+		yield* filterChildren(this.syntax, AttributeArgAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "FunctionCall" ? new FunctionCallAst(node) : void 0;
+	}
+};
+var ArrayLiteralAst = class ArrayLiteralAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	lbracket() {
+		return findChildToken(this.syntax, "LBracket");
+	}
+	rbracket() {
+		return findChildToken(this.syntax, "RBracket");
+	}
+	*elements() {
+		yield* filterChildren(this.syntax, castExpression);
+	}
+	static cast(node) {
+		return node.kind === "ArrayLiteral" ? new ArrayLiteralAst(node) : void 0;
+	}
+};
+const HEX = /^[0-9a-fA-F]+$/;
+function decodeFixedHex(raw, start, width) {
+	if (start + width > raw.length) return void 0;
+	const hex = raw.slice(start, start + width);
+	if (!HEX.test(hex)) return void 0;
+	return String.fromCharCode(Number.parseInt(hex, 16));
+}
+function decodeStringLiteral(raw) {
+	let out = "";
+	let i = 0;
+	while (i < raw.length) {
+		const ch = raw.charAt(i);
+		if (ch !== "\\" || i + 1 >= raw.length) {
+			out += ch;
+			i++;
+			continue;
+		}
+		const next = raw.charAt(i + 1);
+		switch (next) {
+			case "n":
+				out += "\n";
+				i += 2;
+				continue;
+			case "r":
+				out += "\r";
+				i += 2;
+				continue;
+			case "t":
+				out += "	";
+				i += 2;
+				continue;
+			case "\"":
+				out += "\"";
+				i += 2;
+				continue;
+			case "'":
+				out += "'";
+				i += 2;
+				continue;
+			case "\\":
+				out += "\\";
+				i += 2;
+				continue;
+			case "x": {
+				const decoded = decodeFixedHex(raw, i + 2, 2);
+				if (decoded === void 0) {
+					out += "\\x";
+					i += 2;
+					continue;
+				}
+				out += decoded;
+				i += 4;
+				continue;
+			}
+			case "u": {
+				const decoded = decodeFixedHex(raw, i + 2, 4);
+				if (decoded === void 0) {
+					out += "\\u";
+					i += 2;
+					continue;
+				}
+				out += decoded;
+				i += 6;
+				continue;
+			}
+			default:
+				out += `\\${next}`;
+				i += 2;
+				continue;
+		}
+	}
+	return out;
+}
+var StringLiteralExprAst = class StringLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	token() {
+		return findChildToken(this.syntax, "StringLiteral");
+	}
+	value() {
+		const tok = this.token();
+		if (!tok) return void 0;
+		return decodeStringLiteral(tok.text.slice(1, -1));
+	}
+	static cast(node) {
+		return node.kind === "StringLiteralExpr" ? new StringLiteralExprAst(node) : void 0;
+	}
+};
+var NumberLiteralExprAst = class NumberLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	token() {
+		return findChildToken(this.syntax, "NumberLiteral");
+	}
+	value() {
+		const tok = this.token();
+		if (!tok) return void 0;
+		return Number(tok.text);
+	}
+	static cast(node) {
+		return node.kind === "NumberLiteralExpr" ? new NumberLiteralExprAst(node) : void 0;
+	}
+};
+var BooleanLiteralExprAst = class BooleanLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	token() {
+		return findChildToken(this.syntax, "Ident");
+	}
+	value() {
+		const tok = this.token();
+		if (!tok) return void 0;
+		if (tok.text === "true") return true;
+		if (tok.text === "false") return false;
+	}
+	static cast(node) {
+		return node.kind === "BooleanLiteralExpr" ? new BooleanLiteralExprAst(node) : void 0;
+	}
+};
+var ObjectLiteralExprAst = class ObjectLiteralExprAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	lbrace() {
+		return findChildToken(this.syntax, "LBrace");
+	}
+	rbrace() {
+		return findChildToken(this.syntax, "RBrace");
+	}
+	*fields() {
+		yield* filterChildren(this.syntax, ObjectFieldAst.cast);
+	}
+	static cast(node) {
+		return node.kind === "ObjectLiteralExpr" ? new ObjectLiteralExprAst(node) : void 0;
+	}
+};
+var ObjectFieldAst = class ObjectFieldAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	key() {
+		for (const child of this.syntax.children()) {
+			if (!(child instanceof SyntaxNode)) {
+				if (child.kind === "Colon") break;
+				continue;
+			}
+			return IdentifierAst.cast(child);
+		}
+	}
+	/**
+	* The field's logical key name, unquoted. An identifier key (`length:`) yields
+	* its text; a string-literal key (`"length":`) yields the decoded string.
+	* `undefined` when the field carries no key node.
+	*/
+	keyName() {
+		for (const child of this.syntax.children()) {
+			if (!(child instanceof SyntaxNode)) {
+				if (child.kind === "Colon") break;
+				continue;
+			}
+			const identifier = IdentifierAst.cast(child);
+			if (identifier) return identifier.token()?.text;
+			const stringKey = StringLiteralExprAst.cast(child);
+			if (stringKey) return stringKey.value();
+			return;
+		}
+	}
+	colon() {
+		return findChildToken(this.syntax, "Colon");
+	}
+	value() {
+		if (this.colon()) {
+			let pastColon = false;
+			for (const child of this.syntax.children()) {
+				if (!(child instanceof SyntaxNode)) {
+					if (child.kind === "Colon") pastColon = true;
+					continue;
+				}
+				if (pastColon) {
+					const expr = castExpression(child);
+					if (expr) return expr;
+				}
+			}
+			return;
+		}
+		return findFirstChild(this.syntax, castExpression);
+	}
+	static cast(node) {
+		return node.kind === "ObjectField" ? new ObjectFieldAst(node) : void 0;
+	}
+};
+function castExpression(node) {
+	return FunctionCallAst.cast(node) ?? ArrayLiteralAst.cast(node) ?? StringLiteralExprAst.cast(node) ?? NumberLiteralExprAst.cast(node) ?? BooleanLiteralExprAst.cast(node) ?? ObjectLiteralExprAst.cast(node) ?? IdentifierAst.cast(node);
+}
+var AttributeArgAst = class AttributeArgAst {
+	syntax;
+	constructor(syntax) {
+		this.syntax = syntax;
+	}
+	name() {
+		if (!this.colon()) return void 0;
+		return findFirstChild(this.syntax, IdentifierAst.cast);
+	}
+	colon() {
+		return findChildToken(this.syntax, "Colon");
+	}
+	value() {
+		if (this.colon()) {
+			let pastColon = false;
+			for (const child of this.syntax.children()) {
+				if (!(child instanceof SyntaxNode)) {
+					if (child.kind === "Colon") pastColon = true;
+					continue;
+				}
+				if (pastColon) {
+					const expr = castExpression(child);
+					if (expr) return expr;
+				}
+			}
+			return;
+		}
+		return findFirstChild(this.syntax, castExpression);
+	}
+	static cast(node) {
+		return node.kind === "AttributeArg" ? new AttributeArgAst(node) : void 0;
+	}
+};
+function blockAttribute(name, config) {
+	return {
+		level: "block",
+		name,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
+	};
+}
+function nodePslSpan(node, sourceFile) {
+	const start = node.offset;
+	const end = start + node.green.textLength;
+	return {
+		start: offsetToPslPosition(start, sourceFile),
+		end: offsetToPslPosition(end, sourceFile)
+	};
+}
+function offsetToPslPosition(offset, sourceFile) {
+	const position = sourceFile.positionAt(offset);
+	return {
+		offset,
+		line: position.line + 1,
+		column: position.character + 1
+	};
+}
+const ATTRIBUTE_DIAGNOSTIC_CODE = "PSL_INVALID_ATTRIBUTE_SYNTAX";
+function leafDiagnostic(ctx, node, message, code = ATTRIBUTE_DIAGNOSTIC_CODE) {
+	return {
+		code,
+		message,
+		sourceId: ctx.sourceId,
+		span: nodePslSpan(node.syntax, ctx.sourceFile)
+	};
+}
+function bool() {
+	return {
+		kind: "bool",
+		label: "boolean",
+		parse: (arg, ctx) => {
+			const literal = BooleanLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const value = literal.value();
+				if (value !== void 0) return ok$1(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a boolean literal")]);
+		}
+	};
+}
+function entityRef() {
+	return {
+		kind: "entityRef",
+		label: "model name",
+		parse: (arg, ctx) => {
+			const identifier = IdentifierAst.cast(arg.syntax);
+			if (identifier === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a model name")]);
+			const name = identifier.name();
+			if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a model name")]);
+			return ok$1(name);
+		}
+	};
+}
+function parseFieldName(arg, ctx, model) {
+	const identifier = IdentifierAst.cast(arg.syntax);
+	if (identifier === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
+	const name = identifier.name();
+	if (name === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a field name")]);
+	if (model !== void 0 && !Object.hasOwn(model.fields, name)) return notOk([leafDiagnostic(ctx, arg, `Field "${name}" does not exist on model "${model.name}"`)]);
+	return ok$1(name);
+}
+function fieldRef() {
+	return {
+		kind: "fieldRef",
+		label: "field name",
+		parse: (arg, ctx) => parseFieldName(arg, ctx, ctx.selfModel)
+	};
+}
+function referencedFieldRef() {
+	return {
+		kind: "referencedFieldRef",
+		label: "field name",
+		parse: (arg, ctx) => parseFieldName(arg, ctx, ctx.resolveReferencedModel())
+	};
+}
+function interpretArgs(args, spec, ctx, span) {
+	const diagnostics = [];
+	const output = {};
+	const seen = /* @__PURE__ */ new Set();
+	let positionalSlot = 0;
+	let reportedExcess = false;
+	for (const arg of args) {
+		const name = arg.name()?.name();
+		let key;
+		let param;
+		if (name === void 0) {
+			const posParam = spec.positional[positionalSlot];
+			if (posParam === void 0) {
+				if (!reportedExcess) {
+					diagnostics.push(diagnostic(`Attribute "${spec.name}" received too many positional arguments`, ctx, span));
+					reportedExcess = true;
+				}
+				continue;
+			}
+			positionalSlot += 1;
+			key = posParam.key;
+			param = posParam.type;
+		} else {
+			const namedParam = Object.hasOwn(spec.named, name) ? spec.named[name] : void 0;
+			if (namedParam === void 0) {
+				diagnostics.push(diagnostic(`Attribute "${spec.name}" received unknown argument "${name}"`, ctx, nodePslSpan(arg.syntax, ctx.sourceFile)));
+				continue;
+			}
+			key = name;
+			param = namedParam;
+		}
+		if (seen.has(key)) {
+			diagnostics.push(diagnostic(`Attribute "${spec.name}" received duplicate argument "${key}"`, ctx, nodePslSpan(arg.syntax, ctx.sourceFile)));
+			continue;
+		}
+		seen.add(key);
+		const result = parseArgValue(arg, param, ctx, diagnostics);
+		if (result.ok) output[key] = result.value;
+	}
+	const finalized = /* @__PURE__ */ new Set();
+	const finalizeAbsentKey = (key, positionalParam, namedParam) => {
+		if (finalized.has(key) || seen.has(key)) return;
+		finalized.add(key);
+		const effective = namedParam ?? positionalParam;
+		if (effective === void 0) return;
+		if (isOptionalArgType(effective)) {
+			if (effective.hasDefault) output[key] = effective.defaultValue;
+			return;
+		}
+		diagnostics.push(diagnostic(`Attribute "${spec.name}" is missing required argument "${key}"`, ctx, span));
+	};
+	for (const param of spec.positional) {
+		const namedParam = Object.hasOwn(spec.named, param.key) ? spec.named[param.key] : void 0;
+		finalizeAbsentKey(param.key, param.type, namedParam);
+	}
+	for (const key of Object.keys(spec.named)) finalizeAbsentKey(key, void 0, spec.named[key]);
+	if (diagnostics.length > 0) return notOk(diagnostics);
+	return ok$1(output);
+}
+function parseArgValue(arg, argType, ctx, diagnostics) {
+	const value = arg.value();
+	if (value === void 0) {
+		const missing = diagnostic("Attribute argument is missing a value", ctx, nodePslSpan(arg.syntax, ctx.sourceFile));
+		diagnostics.push(missing);
+		return notOk([missing]);
+	}
+	const result = argType.parse(value, ctx);
+	if (!result.ok) for (const failure of result.failure) diagnostics.push(failure);
+	return result;
+}
+function isOptionalArgType(param) {
+	return "optional" in param && param.optional === true;
+}
+function diagnostic(message, ctx, span) {
+	return {
+		code: ATTRIBUTE_DIAGNOSTIC_CODE,
+		message,
+		sourceId: ctx.sourceId,
+		span
+	};
+}
+function funcCall(name, sig) {
+	return {
+		kind: "funcCall",
+		label: `${name}()`,
+		name,
+		signature: sig,
+		parse: (arg, ctx) => {
+			const guard = matchCallee(arg, name, ctx);
+			if (!guard.ok) return guard;
+			const span = nodePslSpan(guard.value.syntax, ctx.sourceFile);
+			const bound = interpretArgs(guard.value.args(), {
+				name,
+				positional: sig.positional ?? [],
+				named: sig.named ?? {}
+			}, ctx, span);
+			if (!bound.ok) return notOk(bound.failure);
+			return ok$1({
+				fn: name,
+				span,
+				args: bound.value
+			});
+		}
+	};
+}
+function matchCallee(arg, name, ctx) {
+	const call = FunctionCallAst.cast(arg.syntax);
+	if (call === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	const qname = call.name();
+	if (qname === void 0 || qname.dot() !== void 0 || qname.colon() !== void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	const calleeName = qname.identifier()?.token()?.text;
+	if (calleeName === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected a function call")]);
+	if (calleeName !== name) return notOk([leafDiagnostic(ctx, arg, `Expected ${name}()`)]);
+	return ok$1(call);
+}
+function identifier(name) {
+	return {
+		kind: "identifier",
+		label: name,
+		name,
+		parse: (arg, ctx) => {
+			const identifier = IdentifierAst.cast(arg.syntax);
+			if (identifier !== void 0 && identifier.name() === name) return ok$1(name);
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${name}`)]);
+		}
+	};
+}
+function int(opts) {
+	const min = opts?.min;
+	const max = opts?.max;
+	return {
+		kind: "int",
+		label: "integer",
+		...min === void 0 ? {} : { min },
+		...max === void 0 ? {} : { max },
+		parse: (arg, ctx) => {
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const value = literal.value();
+				if (value !== void 0 && Number.isInteger(value)) {
+					if ((min === void 0 || value >= min) && (max === void 0 || value <= max)) return ok$1(value);
+					return notOk([leafDiagnostic(ctx, arg, rangeMessage(min, max))]);
+				}
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected an integer literal")]);
+		}
+	};
+}
+function rangeMessage(min, max) {
+	if (min !== void 0 && max !== void 0) return `Expected an integer between ${min} and ${max}`;
+	if (min !== void 0) return `Expected an integer greater than or equal to ${min}`;
+	return `Expected an integer less than or equal to ${max}`;
+}
+function list(of, opts) {
+	const allowEmpty = opts?.allowEmpty ?? true;
+	const unique = opts?.unique ?? false;
+	return {
+		kind: "list",
+		label: `${of.label}[]`,
+		of,
+		allowEmpty,
+		unique,
+		parse: (arg, ctx) => {
+			const literal = ArrayLiteralAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, `Expected a list of ${of.label}`)]);
+			const diagnostics = [];
+			const parsed = [];
+			let count = 0;
+			for (const element of literal.elements()) {
+				count += 1;
+				const result = of.parse(element, ctx);
+				if (result.ok) parsed.push({
+					node: element,
+					value: result.value
+				});
+				else diagnostics.push(...result.failure);
+			}
+			if (!allowEmpty && count === 0) diagnostics.push(leafDiagnostic(ctx, arg, "Expected a non-empty list"));
+			if (unique) {
+				const seen = /* @__PURE__ */ new Set();
+				for (const { node, value } of parsed) if (seen.has(value)) diagnostics.push(leafDiagnostic(ctx, node, "Duplicate list entry"));
+				else seen.add(value);
+			}
+			if (diagnostics.length > 0) return notOk(diagnostics);
+			return ok$1(parsed.map((entry) => entry.value));
+		}
+	};
+}
+function num(value) {
+	if (value === void 0) return {
+		kind: "num",
+		label: "number",
+		value: void 0,
+		parse: (arg, ctx) => {
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const parsed = literal.value();
+				if (parsed !== void 0) return ok$1(parsed);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a number literal")]);
+		}
+	};
+	return {
+		kind: "num",
+		label: String(value),
+		value,
+		parse: (arg, ctx) => {
+			const literal = NumberLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				if (literal.value() === value) return ok$1(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${value}`)]);
+		}
+	};
+}
+function oneOf(...alts) {
+	const label = alts.map((alt) => alt.label).join(" | ");
+	return {
+		kind: "oneOf",
+		label,
+		alternatives: alts,
+		parse: (arg, ctx) => {
+			for (const alt of alts) {
+				const result = blindCast(alt.parse)(arg, ctx);
+				if (result.ok) return ok$1(blindCast(result.value));
+			}
+			return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
+		}
+	};
+}
+function record(of) {
+	return {
+		kind: "record",
+		label: `{ [key]: ${of.label} }`,
+		of,
+		parse: (arg, ctx) => {
+			const literal = ObjectLiteralExprAst.cast(arg.syntax);
+			if (literal === void 0) return notOk([leafDiagnostic(ctx, arg, "Expected an object literal")]);
+			const diagnostics = [];
+			const entries = [];
+			const keys = /* @__PURE__ */ new Set();
+			for (const field of Array.from(literal.fields())) {
+				const key = field.keyName();
+				if (key === void 0) {
+					diagnostics.push(leafDiagnostic(ctx, field, "Expected a key"));
+					continue;
+				}
+				const value = field.value();
+				if (value === void 0) {
+					diagnostics.push(leafDiagnostic(ctx, field, `Expected a value for key "${key}"`));
+					continue;
+				}
+				const parsed = of.parse(value, ctx);
+				if (!parsed.ok) {
+					diagnostics.push(...parsed.failure);
+					continue;
+				}
+				if (keys.has(key)) {
+					diagnostics.push(leafDiagnostic(ctx, field, `Duplicate key "${key}"`));
+					continue;
+				}
+				keys.add(key);
+				entries.push([key, parsed.value]);
+			}
+			if (diagnostics.length > 0) return notOk(diagnostics);
+			return ok$1(Object.fromEntries(entries));
+		}
+	};
+}
+function str(value) {
+	if (value === void 0) return {
+		kind: "str",
+		label: "string",
+		value: void 0,
+		parse: (arg, ctx) => {
+			const literal = StringLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				const parsed = literal.value();
+				if (parsed !== void 0) return ok$1(parsed);
+			}
+			return notOk([leafDiagnostic(ctx, arg, "Expected a string literal")]);
+		}
+	};
+	return {
+		kind: "str",
+		label: JSON.stringify(value),
+		value,
+		parse: (arg, ctx) => {
+			const literal = StringLiteralExprAst.cast(arg.syntax);
+			if (literal !== void 0) {
+				if (literal.value() === value) return ok$1(value);
+			}
+			return notOk([leafDiagnostic(ctx, arg, `Expected ${JSON.stringify(value)}`)]);
+		}
+	};
+}
+function fieldAttribute(name, config) {
+	return {
+		level: "field",
+		name,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
+	};
+}
+function modelAttribute(name, config) {
+	return {
+		level: "model",
+		name,
+		positional: config.positional ?? [],
+		named: config.named ?? {},
+		...config.refine !== void 0 ? { refine: config.refine } : {}
+	};
+}
+function optional(type, ...rest) {
+	if (rest.length === 0) return {
+		...type,
+		optional: true,
+		hasDefault: false
+	};
+	return {
+		...type,
+		optional: true,
+		hasDefault: true,
+		defaultValue: rest[0]
+	};
+}
+function findFieldAttributeNode(field, name) {
+	for (const attribute of field.node.attributes()) if (attribute.name()?.isSimpleName(name) === true) return attribute;
+}
+const mapModelSpec = modelAttribute("map", { positional: [{
+	key: "name",
+	type: str()
+}] });
+const mapFieldSpec = fieldAttribute("map", { positional: [{
+	key: "name",
+	type: str()
+}] });
+function scalarDefaultArms(isList, registry) {
+	const literal = () => oneOf(str(), num(), bool());
+	const funcArms = [...registry.entries()].map(([name, entry]) => funcCall(name, blindCast(entry.signature)));
+	return isList ? [list(literal()), ...funcArms] : [
+		str(),
+		num(),
+		bool(),
+		...funcArms
+	];
+}
+function noEnumMember() {
+	return {
+		kind: "rejecting",
+		label: "enum member",
+		message: "Enum declares no members",
+		parse: (arg, ctx) => notOk([leafDiagnostic(ctx, arg, "Enum declares no members")])
+	};
+}
+function enumMemberNames(ctx) {
+	const block = (ctx.field.typeNamespaceId === void 0 ? ctx.symbols.topLevel : ctx.symbols.topLevel.namespaces[ctx.field.typeNamespaceId])?.blocks[ctx.field.typeName];
+	if (block === void 0 || block.keyword !== "enum") return void 0;
+	return Object.keys(block.block.parameters);
+}
+function enumDefaultArms(members) {
+	const [first, ...rest] = members;
+	if (first === void 0) return [noEnumMember()];
+	return [identifier(first), ...rest.map((name) => identifier(name))];
+}
+function defaultFieldSpec(ctx) {
+	const members = enumMemberNames(ctx);
+	return fieldAttribute("default", { positional: [{
+		key: "value",
+		type: oneOf(...members === void 0 ? scalarDefaultArms(ctx.field.list, ctx.controlMutationDefaults) : enumDefaultArms(members))
+	}] });
+}
+const idFieldSpec = fieldAttribute("id", { named: { map: optional(str()) } });
+const uniqueFieldSpec = fieldAttribute("unique", { named: { map: optional(str()) } });
+const noCheckKindArgument = () => oneOf(identifier("membership"), identifier("elementNotNull"));
+/**
+* `@noCheck` waives generated CHECK constraints on one column: bare for every
+* kind the column's shape derives, or naming concrete kinds. Two optional
+* positional slots cover the whole kind vocabulary; a third argument is
+* necessarily a duplicate and fails as excess arity.
+*/
+const noCheckFieldSpec = fieldAttribute("noCheck", {
+	positional: [{
+		key: "first",
+		type: optional(noCheckKindArgument())
+	}, {
+		key: "second",
+		type: optional(noCheckKindArgument())
+	}],
+	refine: (value, ctx, attributeNode) => {
+		if (value.first !== void 0 && value.first === value.second) return [leafDiagnostic(ctx, attributeNode, "`@noCheck` names the same kind twice")];
+		return [];
+	}
+});
+const idModelSpec = modelAttribute("id", {
+	positional: [{
+		key: "fields",
+		type: list(fieldRef(), {
+			allowEmpty: false,
+			unique: true
+		})
+	}],
+	named: { map: optional(str()) }
+});
+const uniqueModelSpec = modelAttribute("unique", {
+	positional: [{
+		key: "fields",
+		type: list(fieldRef(), {
+			allowEmpty: false,
+			unique: true
+		})
+	}],
+	named: { map: optional(str()) }
+});
+const PSL_INDEX_FIELDS_XOR_EXPRESSION = "PSL_INDEX_FIELDS_XOR_EXPRESSION";
+const PSL_INDEX_EXPRESSION_REQUIRES_NAME = "PSL_INDEX_EXPRESSION_REQUIRES_NAME";
+const PSL_INDEX_NAME_XOR_MAP = "PSL_INDEX_NAME_XOR_MAP";
+const indexModelSpec = modelAttribute("index", {
+	positional: [{
+		key: "fields",
+		type: optional(list(fieldRef(), {
+			allowEmpty: false,
+			unique: true
+		}))
+	}],
+	named: {
+		expression: optional(str()),
+		where: optional(str()),
+		unique: optional(bool()),
+		name: optional(str()),
+		map: optional(str()),
+		type: optional(str()),
+		options: optional(record(str()))
+	},
+	refine: (value, ctx, attributeNode) => {
+		const diagnostics = [];
+		if (value.fields === void 0 === (value.expression === void 0)) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` requires exactly one of a fields list or an `expression` argument", PSL_INDEX_FIELDS_XOR_EXPRESSION));
+		if (value.expression !== void 0 && value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` with an `expression` argument requires a `name` or `map` argument (a default name cannot be derived from an expression)", PSL_INDEX_EXPRESSION_REQUIRES_NAME));
+		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` takes at most one of `name` and `map`", PSL_INDEX_NAME_XOR_MAP));
+		if (value.options !== void 0 && value.type === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@index` options argument requires a type argument"));
+		return diagnostics;
+	}
+});
+const PSL_CHECK_REQUIRES_NAME_OR_MAP = "PSL_CHECK_REQUIRES_NAME_OR_MAP";
+const PSL_CHECK_NAME_XOR_MAP = "PSL_CHECK_NAME_XOR_MAP";
+const PSL_CHECK_EXPRESSION_EMPTY = "PSL_CHECK_EXPRESSION_EMPTY";
+const checkModelSpec = modelAttribute("check", {
+	named: {
+		expression: str(),
+		name: optional(str()),
+		map: optional(str())
+	},
+	refine: (value, ctx, attributeNode) => {
+		const diagnostics = [];
+		if (value.expression.trim().length === 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` expression must not be empty — an empty predicate is not a constraint", PSL_CHECK_EXPRESSION_EMPTY));
+		if (value.name === void 0 && value.map === void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` requires a `name` or `map` argument (a default name cannot be derived — a check has no column tuple to name itself after)", PSL_CHECK_REQUIRES_NAME_OR_MAP));
+		if (value.name !== void 0 && value.map !== void 0) diagnostics.push(leafDiagnostic(ctx, attributeNode, "`@@check` takes at most one of `name` and `map`", PSL_CHECK_NAME_XOR_MAP));
+		return diagnostics;
+	}
+});
+const controlModelSpec = modelAttribute("control", { positional: [{
+	key: "policy",
+	type: oneOf(identifier("managed"), identifier("tolerated"), identifier("external"), identifier("observed"))
+}] });
+const discriminatorModelSpec = modelAttribute("discriminator", { positional: [{
+	key: "field",
+	type: fieldRef()
+}] });
+const baseModelSpec = modelAttribute("base", { positional: [{
+	key: "base",
+	type: entityRef()
+}, {
+	key: "value",
+	type: str()
+}] });
+function relationAttributeSpan(ctx) {
+	const node = findFieldAttributeNode(ctx.field, "relation");
+	if (node !== void 0) return nodePslSpan(node.syntax, ctx.sourceFile);
+	return ctx.field.span;
+}
+function relationInvariants(parsed, ctx) {
+	if (parsed.fields !== void 0 !== (parsed.references !== void 0)) return [{
+		code: "PSL_INVALID_ATTRIBUTE_SYNTAX",
+		message: `Relation field "${ctx.selfModel.name}.${ctx.field.name}" requires fields and references arguments`,
+		sourceId: ctx.sourceId,
+		span: relationAttributeSpan(ctx)
+	}];
+	return [];
+}
+const referentialActionArgument = () => oneOf(identifier("NoAction"), identifier("Restrict"), identifier("Cascade"), identifier("SetNull"), identifier("SetDefault"));
+const relationFieldSpec = fieldAttribute("relation", {
+	positional: [{
+		key: "name",
+		type: optional(str())
+	}],
+	named: {
+		name: optional(str()),
+		fields: optional(list(fieldRef(), {
+			allowEmpty: false,
+			unique: true
+		})),
+		references: optional(list(referencedFieldRef(), {
+			allowEmpty: false,
+			unique: true
+		})),
+		map: optional(str()),
+		onDelete: optional(referentialActionArgument()),
+		onUpdate: optional(referentialActionArgument()),
+		index: optional(bool())
+	},
+	refine: relationInvariants
+});
+const sqlAttributeSpecs = {
+	model: {
+		map: () => mapModelSpec,
+		id: () => idModelSpec,
+		unique: () => uniqueModelSpec,
+		index: () => indexModelSpec,
+		check: () => checkModelSpec,
+		control: () => controlModelSpec,
+		discriminator: () => discriminatorModelSpec,
+		base: () => baseModelSpec
+	},
+	field: {
+		map: () => mapFieldSpec,
+		id: () => idFieldSpec,
+		unique: () => uniqueFieldSpec,
+		noCheck: () => noCheckFieldSpec,
+		relation: () => relationFieldSpec,
+		default: defaultFieldSpec
+	}
+};
 function isSafeTypeExpression(expr) {
 	return !/import\s*\(|require\s*\(|declare\s|export\s|eval\s*\(/.test(expr);
 }
@@ -66595,6 +68200,7 @@ function generateModelRelationsType(relations) {
 		const parts = [];
 		if (toRef) parts.push(`readonly to: ${serializeCrossReference(blindCast(toRef))}`);
 		if (relObj["cardinality"]) parts.push(`readonly cardinality: ${serializeValue(relObj["cardinality"])}`);
+		if (typeof relObj["nullable"] === "boolean") parts.push(`readonly nullable: ${relObj["nullable"]}`);
 		const on = relObj["on"];
 		if (on && (!on.localFields || !on.targetFields)) throw emitterError("CONTRACT.RELATION_INVALID", `Relation "${relName}" has an "on" block but is missing localFields or targetFields`, { meta: { relation: relName } });
 		if (on?.localFields && on.targetFields) {
@@ -66748,11 +68354,26 @@ function resolveFieldType(field, codecLookup, resolvedTypeParams, resolvedValueS
 		};
 	}
 }
+/**
+* Resolves one model field's input and output types the way `FieldOutputTypes` /
+* `FieldInputTypes` do: inline type params win over the family resolver, and a family-resolved
+* value set renders as a literal union.
+*/
+function resolveModelFieldType(modelName, fieldName, field, model, resolvers) {
+	const resolvedTypeParams = (field.type.kind === "scalar" && field.type.typeParams && Object.keys(field.type.typeParams).length > 0 ? field.type.typeParams : void 0) ?? resolvers.resolveFieldTypeParams?.(modelName, fieldName, model);
+	const resolvedValueSet = resolvers.resolveFieldValueSet?.(modelName, fieldName, model);
+	return resolveFieldType(field, resolvers.codecLookup, resolvedTypeParams, resolvedValueSet);
+}
 function generateBothFieldTypesMaps(models, codecLookup, resolveFieldTypeParams, resolveFieldValueSet) {
 	if (!models || Object.keys(models).length === 0) return {
 		output: "Record<string, never>",
 		input: "Record<string, never>"
 	};
+	const resolvers = {
+		codecLookup,
+		resolveFieldTypeParams,
+		resolveFieldValueSet
+	};
 	const outputModelEntries = [];
 	const inputModelEntries = [];
 	for (const [modelName, model] of Object.entries(models).sort(([a], [b]) => a.localeCompare(b))) {
@@ -66760,9 +68381,7 @@ function generateBothFieldTypesMaps(models, codecLookup, resolveFieldTypeParams,
 		const outputFieldEntries = [];
 		const inputFieldEntries = [];
 		for (const [fieldName, field] of Object.entries(model.fields)) {
-			const resolvedTypeParams = (field.type.kind === "scalar" && field.type.typeParams && Object.keys(field.type.typeParams).length > 0 ? field.type.typeParams : void 0) ?? resolveFieldTypeParams?.(modelName, fieldName, model);
-			const resolvedValueSet = resolveFieldValueSet?.(modelName, fieldName, model);
-			const resolved = resolveFieldType(field, codecLookup, resolvedTypeParams, resolvedValueSet);
+			const resolved = resolveModelFieldType(modelName, fieldName, field, model, resolvers);
 			const key = `readonly ${serializeObjectKey(fieldName)}`;
 			outputFieldEntries.push(`${key}: ${resolved.output}`);
 			inputFieldEntries.push(`${key}: ${resolved.input}`);
@@ -67197,6 +68816,7 @@ const sqlEmission = {
 		return [
 			"import type {",
 			"  ContractWithTypeMaps,",
+			"  RelationKeys,",
 			"  TypeMaps as TypeMapsType,",
 			`} from '${resolveImportSpecifier("@internal/sql-contract/types")}';`
 		];
@@ -67390,9 +69010,9 @@ const EXACT_NAME_BODY_PREAMBLE = "Drift detection compares the authored SQL text
 * block's head the wire prefix.
 */
 const EXACT_NAME_BODY_REMEDIATION = {
-	index: "For hand-authored definitions, use name: and let Prisma Next manage the physical name; to migrate an adopted object to wire naming, replace map: with name: (keeping the body text unchanged) and apply the resulting rename migration.",
+	index: "For hand-authored definitions, use name: and let Prisma 8 manage the physical name; to migrate an adopted object to wire naming, replace map: with name: (keeping the body text unchanged) and apply the resulting rename migration.",
 	policy: "For hand-authored definitions, drop @@map and let the policy block's head name the policy; to migrate an adopted policy to wire naming, remove @@map (keeping the body text unchanged) and apply the resulting rename migration.",
-	check: "For hand-authored definitions, use name: and let Prisma Next manage the physical name; to migrate an adopted check to wire naming, replace map: with name: (keeping the body text unchanged) and apply the resulting rename migration."
+	check: "For hand-authored definitions, use name: and let Prisma 8 manage the physical name; to migrate an adopted check to wire naming, replace map: with name: (keeping the body text unchanged) and apply the resulting rename migration."
 };
 /** What the user actually wrote, per subject: index and check `map:`, policy `@@map`. */
 const EXACT_NAME_FEATURE = {
@@ -67493,6 +69113,7 @@ function validateContractDomain(contract) {
 	validateRoots(contract, modelIndex, errors);
 	validateVariantsAndBases(modelIndex, errors);
 	validateRelationTargets(modelIndex, errors);
+	validateRelationNullability(modelIndex, errors);
 	validateDiscriminators(modelIndex, errors);
 	validateOwnership(contract, modelIndex, errors);
 	validateValueObjectReferences(contract, errors);
@@ -67542,6 +69163,19 @@ function validateRelationTargets(modelIndex, errors) {
 		if (!lookupModel(modelIndex, relation.to)) errors.push(`Relation "${relName}" on model "${namespaceId}:${modelName}" targets "${relation.to.namespace}:${relation.to.model}" which does not exist in domain.namespaces`);
 	}
 }
+function relationKindLabel(relation) {
+	return relation.on === void 0 ? "embed relation" : `${relation.cardinality} relation`;
+}
+function validateRelationNullability(modelIndex, errors) {
+	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) for (const [relName, relation] of Object.entries(model.relations ?? {})) {
+		const location = `Relation "${relName}" on model "${namespaceId}:${modelName}"`;
+		if (relation.on !== void 0 && (relation.cardinality === "1:1" || relation.cardinality === "N:1")) {
+			if (relation.nullable !== void 0 && typeof relation.nullable !== "boolean") errors.push(`${location} is a ${relation.cardinality} relation and its "nullable" must be a boolean`);
+			continue;
+		}
+		if (relation.nullable !== void 0) errors.push(`${location} is a ${relationKindLabel(relation)} and must not carry "nullable"`);
+	}
+}
 function validateDiscriminators(modelIndex, errors) {
 	for (const { namespaceId, name: modelName, model } of iterateIndexedModels(modelIndex)) {
 		if (model.discriminator) {
@@ -67600,6 +69234,29 @@ function validateFieldModifiers(modelIndex, contract, errors) {
 		}
 	}
 }
+function sameColumns(left, right) {
+	return left.length === right.length && left.every((column, index) => column === right[index]);
+}
+/**
+* The storage facts behind a same-space to-one relation's nullability: which side owns the
+* foreign key, and whether each local column is nullable.
+*/
+function resolveSqlToOneRelationStorage(contract, modelStorage, relation) {
+	const table = blindCast(contract.storage.namespaces[modelStorage.namespaceId]?.entries.table?.[modelStorage.table]);
+	const columns = relation.on.localFields.map((fieldName) => {
+		const columnName = modelStorage.fields[fieldName]?.column;
+		const column = columnName === void 0 ? void 0 : table?.columns[columnName];
+		return {
+			name: columnName ?? fieldName,
+			nullable: column?.nullable ?? true
+		};
+	});
+	const columnNames = columns.map((column) => column.name);
+	return {
+		ownsForeignKey: relation.cardinality === "N:1" || (table?.foreignKeys ?? []).some((foreignKey) => sameColumns(foreignKey.source.columns, columnNames)),
+		columns
+	};
+}
 const generatorKindSchema = type("'generator'");
 const ControlPolicySchema = type("'managed' | 'tolerated' | 'external' | 'observed'");
 const ExecutionMutationDefaultValueSchema = type({
@@ -67849,13 +69506,20 @@ const ContractManyToManyRelationSchema = type({
 	on: ContractRelationOnSchema,
 	through: ContractRelationThroughSchema
 });
-const ContractNonJunctionRelationSchema = type({
+const ContractToOneRelationSchema = type({
+	"+": "reject",
+	to: CrossReferenceSchema,
+	cardinality: "'1:1' | 'N:1'",
+	"nullable?": "boolean",
+	on: ContractRelationOnSchema
+});
+const ContractToManyRelationSchema = type({
 	"+": "reject",
 	to: CrossReferenceSchema,
-	cardinality: "'1:1' | '1:N' | 'N:1'",
+	cardinality: "'1:N'",
 	on: ContractRelationOnSchema
 });
-const ContractReferenceRelationSchema = ContractManyToManyRelationSchema.or(ContractNonJunctionRelationSchema);
+const ContractReferenceRelationSchema = ContractManyToManyRelationSchema.or(ContractToOneRelationSchema).or(ContractToManyRelationSchema);
 const ContractEmbedRelationSchema = type({
 	"+": "reject",
 	to: CrossReferenceSchema,
@@ -68070,8 +69734,32 @@ function validateSqlContractFully(value, options) {
 	if (semanticErrors.length > 0) throw new ContractValidationError(`Contract semantic validation failed: ${semanticErrors.join("; ")}`, "storage");
 	validateModelStorageReferences(validated);
 	validateRelationThroughConsistency(validated);
+	validateToOneRelationNullabilityAgainstStorage(validated);
 	return validated;
 }
+/**
+* A same-space to-one relation that states `nullable` must agree with its local FK columns:
+* nullable exactly when one of them is nullable (a column that cannot be resolved counts as
+* nullable). A relation without the flag is left to hydration, which derives it the same way.
+*/
+function validateToOneRelationNullabilityAgainstStorage(contract) {
+	for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespace.models)) {
+		const storage = blindCast(model.storage);
+		for (const [relationName, relation] of Object.entries(model.relations)) {
+			if (!("on" in relation && (relation.cardinality === "1:1" || relation.cardinality === "N:1") && relation.to.space === void 0) || relation.nullable === void 0) continue;
+			const location = `Relation "${relationName}" on model "${namespaceId}:${modelName}"`;
+			const { ownsForeignKey, columns } = resolveSqlToOneRelationStorage(contract, storage, relation);
+			if (!ownsForeignKey) {
+				if (relation.nullable) continue;
+				throw new ContractValidationError(`${location} is required but does not own the foreign key, so nothing in storage guarantees the related row exists`, "storage");
+			}
+			const anyNullable = columns.some((column) => column.nullable);
+			if (relation.nullable === anyNullable) continue;
+			const columnList = columns.filter((column) => column.nullable !== relation.nullable).map((column) => `"${column.name}"`).join(", ");
+			throw new ContractValidationError(relation.nullable ? `${location} is nullable but every local FK column is NOT NULL (columns ${columnList})` : `${location} is required but a local FK column is nullable (columns ${columnList})`, "storage");
+		}
+	}
+}
 /** Storage column lookup for through-consistency validation. */
 function lookupStorageColumn(contract, namespaceId, tableName, columnName) {
 	const rawTable = contract.storage.namespaces[namespaceId]?.entries.table?.[tableName];
@@ -68173,188 +69861,6 @@ function validateRelationThroughConsistency(contract) {
 		});
 	}
 }
-const DOMAIN_NAMESPACE_SLOT_PATTERN = [
-	"domain",
-	"namespaces",
-	"*"
-];
-const DOMAIN_MODELS_CONTAINER_PATTERN = [
-	"domain",
-	"namespaces",
-	"*",
-	"models"
-];
-const DOMAIN_MODEL_RELATIONS_PATTERN = [
-	"domain",
-	"namespaces",
-	"*",
-	"models",
-	"*",
-	"relations"
-];
-const DOMAIN_MODEL_STORAGE_PATTERN = [
-	"domain",
-	"namespaces",
-	"*",
-	"models",
-	"*",
-	"storage"
-];
-const STORAGE_NAMESPACE_ENTRIES_PATTERN = [
-	"storage",
-	"namespaces",
-	"*",
-	"entries"
-];
-const TOP_LEVEL_ORDER = [
-	"schemaVersion",
-	"canonicalVersion",
-	"targetFamily",
-	"target",
-	"profileHash",
-	"roots",
-	"domain",
-	"storage",
-	"execution",
-	"capabilities",
-	"extensions",
-	"defaultControlPolicy",
-	"meta"
-];
-function isDefaultValue(value) {
-	if (value === false) return true;
-	if (value === null) return false;
-	if (Array.isArray(value) && value.length === 0) return true;
-	if (typeof value === "object" && value !== null) return Object.keys(value).length === 0;
-	return false;
-}
-function omitDefaults(obj, path, shouldPreserveEmpty) {
-	if (obj === null || typeof obj !== "object") return obj;
-	if (Array.isArray(obj)) return obj.map((item) => omitDefaults(item, path, shouldPreserveEmpty));
-	const result = {};
-	for (const [key, value] of Object.entries(obj)) {
-		const currentPath = [...path, key];
-		if (key === "_generated") continue;
-		if (key === "generated" && value === false) continue;
-		if ((key === "onDelete" || key === "onUpdate") && value === "noAction") continue;
-		if (isDefaultValue(value)) {
-			const isRequiredDomainNamespaces = isArrayEqual(currentPath, ["domain", "namespaces"]);
-			const isDomainNamespaceSlot = matchesPathPattern(currentPath, DOMAIN_NAMESPACE_SLOT_PATTERN);
-			const isRequiredDomainModels = matchesPathPattern(currentPath, DOMAIN_MODELS_CONTAINER_PATTERN);
-			const isRequiredStorageNamespaces = isArrayEqual(currentPath, ["storage", "namespaces"]);
-			const isStorageNamespaceEntries = matchesPathPattern(currentPath, STORAGE_NAMESPACE_ENTRIES_PATTERN);
-			const isRequiredRoots = isArrayEqual(currentPath, ["roots"]);
-			const isRequiredExtensions = isArrayEqual(currentPath, ["extensions"]);
-			const isRequiredCapabilities = isArrayEqual(currentPath, ["capabilities"]);
-			const isRequiredMeta = isArrayEqual(currentPath, ["meta"]);
-			const isRequiredExecutionDefaults = isArrayEqual(currentPath, [
-				"execution",
-				"mutations",
-				"defaults"
-			]);
-			const isExtensionNamespace = currentPath.length === 2 && currentPath[0] === "extensions";
-			const isModelRelations = matchesPathPattern(currentPath, DOMAIN_MODEL_RELATIONS_PATTERN);
-			const isModelStorage = matchesPathPattern(currentPath, DOMAIN_MODEL_STORAGE_PATTERN);
-			const isNullableField = key === "nullable";
-			const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;
-			if (!isRequiredDomainNamespaces && !isDomainNamespaceSlot && !isRequiredDomainModels && !isRequiredStorageNamespaces && !isStorageNamespaceEntries && !isRequiredRoots && !isRequiredExtensions && !isRequiredCapabilities && !isRequiredMeta && !isRequiredExecutionDefaults && !isExtensionNamespace && !isModelRelations && !isModelStorage && !isNullableField && !isFamilyPreserved) continue;
-		}
-		result[key] = omitDefaults(value, currentPath, shouldPreserveEmpty);
-	}
-	return result;
-}
-function sortObjectKeys(obj) {
-	if (obj === null || typeof obj !== "object") return obj;
-	if (Array.isArray(obj)) return obj.map((item) => sortObjectKeys(item));
-	const sorted = {};
-	const keys = Object.keys(obj).sort();
-	for (const key of keys) sorted[key] = sortObjectKeys(obj[key]);
-	return sorted;
-}
-function orderTopLevel(obj) {
-	const ordered = {};
-	const remaining = new Set(Object.keys(obj));
-	for (const key of TOP_LEVEL_ORDER) if (remaining.has(key)) {
-		ordered[key] = obj[key];
-		remaining.delete(key);
-	}
-	for (const key of Array.from(remaining).sort()) ordered[key] = obj[key];
-	return ordered;
-}
-/**
-* Object-form variant of {@link canonicalizeContract}. Exported because the
-* emitter writes the canonical contract through a separate JSON-stringify
-* pass and consumes the structured object directly.
-*/
-function canonicalizeContractToObject(contract, options) {
-	const serialized = options.serializeContract(contract);
-	const withDefaultsOmitted = omitDefaults({
-		...ifDefined("schemaVersion", options.schemaVersion),
-		targetFamily: serialized["targetFamily"],
-		target: serialized["target"],
-		profileHash: serialized["profileHash"],
-		roots: serialized["roots"],
-		domain: serialized["domain"],
-		storage: serialized["storage"],
-		...ifDefined("execution", serialized["execution"]),
-		extensions: serialized["extensions"],
-		capabilities: serialized["capabilities"],
-		...ifDefined("defaultControlPolicy", serialized["defaultControlPolicy"]),
-		meta: serialized["meta"]
-	}, [], options.shouldPreserveEmpty);
-	return orderTopLevel(sortObjectKeys(options.sortStorage ? {
-		...withDefaultsOmitted,
-		storage: options.sortStorage(withDefaultsOmitted["storage"])
-	} : withDefaultsOmitted));
-}
-function canonicalizeContract(contract, options) {
-	return JSON.stringify(canonicalizeContractToObject(contract, options), null, 2);
-}
-const SCHEMA_VERSION$1 = "1";
-function omitNamespaceKindsForHash(storage) {
-	if (!isPlainRecord(storage)) return storage;
-	const namespaces = storage["namespaces"];
-	if (!isPlainRecord(namespaces)) return storage;
-	const stripped = {};
-	for (const [nsId, ns] of Object.entries(namespaces)) if (isPlainRecord(ns)) {
-		const { kind: _kind, ...rest } = ns;
-		stripped[nsId] = rest;
-	} else stripped[nsId] = ns;
-	return {
-		...storage,
-		namespaces: stripped
-	};
-}
-function sha256(content) {
-	const hash = createHash("sha256");
-	hash.update(content);
-	return hash.digest("hex");
-}
-function hashContract(section) {
-	const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;
-	const storageForHash = omitNamespaceKindsForHash(sectionData["storage"] ?? {});
-	return canonicalizeContract(blindCast({
-		targetFamily: sectionData["targetFamily"],
-		target: sectionData["target"],
-		roots: {},
-		domain: { namespaces: {} },
-		execution: sectionData["execution"],
-		extensions: {},
-		capabilities: sectionData["capabilities"] ?? {},
-		meta: {},
-		profileHash: "",
-		...sectionData,
-		storage: storageForHash
-	}), {
-		schemaVersion: SCHEMA_VERSION$1,
-		serializeContract: (c) => castAs(JSON.parse(JSON.stringify(c))),
-		...ifDefined("shouldPreserveEmpty", shouldPreserveEmpty),
-		...ifDefined("sortStorage", sortStorage)
-	});
-}
-function computeStorageHash(args) {
-	return blindCast(sha256(hashContract(args)));
-}
 function contractError$1(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -68405,6 +69911,251 @@ function enumType(name, codec, ...members) {
 		ordinalOf: (v) => valueToOrdinal.get(v) ?? -1
 	};
 }
+/**
+* The one rule for whether a to-one relation may be absent. The side that holds the reference
+* (in SQL, the foreign key) is nullable exactly when one of its local fields is; the other side
+* is always nullable, because nothing in storage guarantees the related record exists. A
+* declaration that disagrees is reported as a contradiction; `nullable` is always the derived
+* value.
+*/
+function resolveToOneRelationNullable(input) {
+	const nullable = input.ownsReference ? input.localFieldNullability.some(Boolean) : true;
+	const declared = input.declaredNullable;
+	if (declared === void 0 || declared === nullable) return {
+		nullable,
+		contradiction: void 0
+	};
+	return {
+		nullable,
+		contradiction: declared ? "declared-optional" : "declared-required"
+	};
+}
+function isToOneReference(relation) {
+	return "on" in relation && (relation.cardinality === "1:1" || relation.cardinality === "N:1");
+}
+/**
+* Fills in `nullable` on every same-space to-one relation that lacks it from the ownership and
+* local-field nullability the lookup reports. A cross-space relation defaults to nullable.
+* Relations that already carry the flag are left as they are.
+*/
+function withDerivedToOneRelationNullability(domain, localFieldNullability) {
+	const namespaces = Object.fromEntries(Object.entries(domain.namespaces).map(([namespaceId, namespace]) => [namespaceId, withDerivedNamespace(namespaceId, namespace, localFieldNullability)]));
+	return {
+		...domain,
+		namespaces
+	};
+}
+function withDerivedNamespace(namespaceId, namespace, localFieldNullability) {
+	const models = Object.fromEntries(Object.entries(namespace.models).map(([modelName, model]) => [modelName, withDerivedModel(namespaceId, modelName, model, localFieldNullability)]));
+	return {
+		...namespace,
+		models
+	};
+}
+function withDerivedModel(namespaceId, modelName, model, localFieldNullability) {
+	const relations = Object.fromEntries(Object.entries(model.relations ?? {}).map(([relationName, relation]) => {
+		if (!isToOneReference(relation) || relation.nullable !== void 0) return [relationName, relation];
+		const nullable = relation.to.space !== void 0 ? true : resolveToOneRelationNullable({
+			declaredNullable: void 0,
+			...localFieldNullability({
+				namespaceId,
+				modelName,
+				model,
+				relation
+			})
+		}).nullable;
+		return [relationName, {
+			...relation,
+			nullable
+		}];
+	}));
+	return {
+		...model,
+		relations
+	};
+}
+const DOMAIN_NAMESPACE_SLOT_PATTERN = [
+	"domain",
+	"namespaces",
+	"*"
+];
+const DOMAIN_MODELS_CONTAINER_PATTERN = [
+	"domain",
+	"namespaces",
+	"*",
+	"models"
+];
+const DOMAIN_MODEL_RELATIONS_PATTERN = [
+	"domain",
+	"namespaces",
+	"*",
+	"models",
+	"*",
+	"relations"
+];
+const DOMAIN_MODEL_STORAGE_PATTERN = [
+	"domain",
+	"namespaces",
+	"*",
+	"models",
+	"*",
+	"storage"
+];
+const STORAGE_NAMESPACE_ENTRIES_PATTERN = [
+	"storage",
+	"namespaces",
+	"*",
+	"entries"
+];
+const TOP_LEVEL_ORDER = [
+	"schemaVersion",
+	"canonicalVersion",
+	"targetFamily",
+	"target",
+	"profileHash",
+	"roots",
+	"domain",
+	"storage",
+	"execution",
+	"capabilities",
+	"extensions",
+	"defaultControlPolicy",
+	"meta"
+];
+function isDefaultValue(value) {
+	if (value === false) return true;
+	if (value === null) return false;
+	if (Array.isArray(value) && value.length === 0) return true;
+	if (typeof value === "object" && value !== null) return Object.keys(value).length === 0;
+	return false;
+}
+function omitDefaults(obj, path, shouldPreserveEmpty) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => omitDefaults(item, path, shouldPreserveEmpty));
+	const result = {};
+	for (const [key, value] of Object.entries(obj)) {
+		const currentPath = [...path, key];
+		if (key === "_generated") continue;
+		if (key === "generated" && value === false) continue;
+		if ((key === "onDelete" || key === "onUpdate") && value === "noAction") continue;
+		if (isDefaultValue(value)) {
+			const isRequiredDomainNamespaces = isArrayEqual(currentPath, ["domain", "namespaces"]);
+			const isDomainNamespaceSlot = matchesPathPattern(currentPath, DOMAIN_NAMESPACE_SLOT_PATTERN);
+			const isRequiredDomainModels = matchesPathPattern(currentPath, DOMAIN_MODELS_CONTAINER_PATTERN);
+			const isRequiredStorageNamespaces = isArrayEqual(currentPath, ["storage", "namespaces"]);
+			const isStorageNamespaceEntries = matchesPathPattern(currentPath, STORAGE_NAMESPACE_ENTRIES_PATTERN);
+			const isRequiredRoots = isArrayEqual(currentPath, ["roots"]);
+			const isRequiredExtensions = isArrayEqual(currentPath, ["extensions"]);
+			const isRequiredCapabilities = isArrayEqual(currentPath, ["capabilities"]);
+			const isRequiredMeta = isArrayEqual(currentPath, ["meta"]);
+			const isRequiredExecutionDefaults = isArrayEqual(currentPath, [
+				"execution",
+				"mutations",
+				"defaults"
+			]);
+			const isExtensionNamespace = currentPath.length === 2 && currentPath[0] === "extensions";
+			const isModelRelations = matchesPathPattern(currentPath, DOMAIN_MODEL_RELATIONS_PATTERN);
+			const isModelStorage = matchesPathPattern(currentPath, DOMAIN_MODEL_STORAGE_PATTERN);
+			const isNullableField = key === "nullable";
+			const isFamilyPreserved = shouldPreserveEmpty?.(currentPath) ?? false;
+			if (!isRequiredDomainNamespaces && !isDomainNamespaceSlot && !isRequiredDomainModels && !isRequiredStorageNamespaces && !isStorageNamespaceEntries && !isRequiredRoots && !isRequiredExtensions && !isRequiredCapabilities && !isRequiredMeta && !isRequiredExecutionDefaults && !isExtensionNamespace && !isModelRelations && !isModelStorage && !isNullableField && !isFamilyPreserved) continue;
+		}
+		result[key] = omitDefaults(value, currentPath, shouldPreserveEmpty);
+	}
+	return result;
+}
+function sortObjectKeys(obj) {
+	if (obj === null || typeof obj !== "object") return obj;
+	if (Array.isArray(obj)) return obj.map((item) => sortObjectKeys(item));
+	const sorted = {};
+	const keys = Object.keys(obj).sort();
+	for (const key of keys) sorted[key] = sortObjectKeys(obj[key]);
+	return sorted;
+}
+function orderTopLevel(obj) {
+	const ordered = {};
+	const remaining = new Set(Object.keys(obj));
+	for (const key of TOP_LEVEL_ORDER) if (remaining.has(key)) {
+		ordered[key] = obj[key];
+		remaining.delete(key);
+	}
+	for (const key of Array.from(remaining).sort()) ordered[key] = obj[key];
+	return ordered;
+}
+/**
+* Object-form variant of {@link canonicalizeContract}. Exported because the
+* emitter writes the canonical contract through a separate JSON-stringify
+* pass and consumes the structured object directly.
+*/
+function canonicalizeContractToObject(contract, options) {
+	const serialized = options.serializeContract(contract);
+	const withDefaultsOmitted = omitDefaults({
+		...ifDefined("schemaVersion", options.schemaVersion),
+		targetFamily: serialized["targetFamily"],
+		target: serialized["target"],
+		profileHash: serialized["profileHash"],
+		roots: serialized["roots"],
+		domain: serialized["domain"],
+		storage: serialized["storage"],
+		...ifDefined("execution", serialized["execution"]),
+		extensions: serialized["extensions"],
+		capabilities: serialized["capabilities"],
+		...ifDefined("defaultControlPolicy", serialized["defaultControlPolicy"]),
+		meta: serialized["meta"]
+	}, [], options.shouldPreserveEmpty);
+	return orderTopLevel(sortObjectKeys(options.sortStorage ? {
+		...withDefaultsOmitted,
+		storage: options.sortStorage(withDefaultsOmitted["storage"])
+	} : withDefaultsOmitted));
+}
+function canonicalizeContract(contract, options) {
+	return JSON.stringify(canonicalizeContractToObject(contract, options), null, 2);
+}
+const SCHEMA_VERSION$1 = "1";
+function omitNamespaceKindsForHash(storage) {
+	if (!isPlainRecord(storage)) return storage;
+	const namespaces = storage["namespaces"];
+	if (!isPlainRecord(namespaces)) return storage;
+	const stripped = {};
+	for (const [nsId, ns] of Object.entries(namespaces)) if (isPlainRecord(ns)) {
+		const { kind: _kind, ...rest } = ns;
+		stripped[nsId] = rest;
+	} else stripped[nsId] = ns;
+	return {
+		...storage,
+		namespaces: stripped
+	};
+}
+function sha256(content) {
+	const hash = createHash("sha256");
+	hash.update(content);
+	return hash.digest("hex");
+}
+function hashContract(section) {
+	const { shouldPreserveEmpty, sortStorage, ...sectionData } = section;
+	const storageForHash = omitNamespaceKindsForHash(sectionData["storage"] ?? {});
+	return canonicalizeContract(blindCast({
+		targetFamily: sectionData["targetFamily"],
+		target: sectionData["target"],
+		roots: {},
+		domain: { namespaces: {} },
+		execution: sectionData["execution"],
+		extensions: {},
+		capabilities: sectionData["capabilities"] ?? {},
+		meta: {},
+		profileHash: "",
+		...sectionData,
+		storage: storageForHash
+	}), {
+		schemaVersion: SCHEMA_VERSION$1,
+		serializeContract: (c) => castAs(JSON.parse(JSON.stringify(c))),
+		...ifDefined("shouldPreserveEmpty", shouldPreserveEmpty),
+		...ifDefined("sortStorage", sortStorage)
+	});
+}
+function computeStorageHash(args) {
+	return blindCast(sha256(hashContract(args)));
+}
 const sqlFamilyEntityTypes = { enum: {
 	kind: "entity",
 	discriminator: "enum",
@@ -68515,13 +70266,18 @@ const sqlFamilyEntityTypes = { enum: {
 		})));
 	} }
 } };
+const enumTypeBlockAttribute = blockAttribute("type", { positional: [{
+	key: "codecId",
+	type: str()
+}] });
 const sqlFamilyPslBlockDescriptors = { enum: {
 	kind: "pslBlock",
 	keyword: "enum",
 	discriminator: "enum",
 	name: { required: true },
 	parameters: {},
-	variadicParameters: true
+	variadicParameters: true,
+	attributes: { type: () => enumTypeBlockAttribute }
 } };
 /**
 * Family-level SQL authoring field presets.
@@ -68722,6 +70478,24 @@ const NamespaceRawSchema = type({
 	entries: type({ "+": "ignore" })
 });
 /**
+* A `contract.json` written before to-one relations recorded `nullable` (rc.9 and earlier)
+* loads with the flag derived from storage: nullable when any local FK column is nullable or
+* cannot be resolved.
+*/
+function withSqlToOneRelationNullability(contract) {
+	const domain = withDerivedToOneRelationNullability(contract.domain, ({ model, relation }) => {
+		const { ownsForeignKey, columns } = resolveSqlToOneRelationStorage(contract, blindCast(model.storage), relation);
+		return {
+			ownsReference: ownsForeignKey,
+			localFieldNullability: columns.map((column) => column.nullable)
+		};
+	});
+	return {
+		...contract,
+		domain
+	};
+}
+/**
 * SQL family `ContractSerializer` abstract base. Carries the SQL-shared
 * deserialization pipeline:
 *
@@ -68755,7 +70529,7 @@ var SqlContractSerializerBase = class {
 		this.contractSchema = packEntityKinds.length > 0 ? createSqlContractSchema(this.entryKinds) : void 0;
 	}
 	deserializeContract(json) {
-		const validated = this.parseSqlContractStructure(json);
+		const validated = withSqlToOneRelationNullability(this.parseSqlContractStructure(json));
 		const hydrated = this.hydrateSqlStorage(validated);
 		return this.constructTargetContract(hydrated);
 	}
@@ -68959,91 +70733,6 @@ function parseContractMarkerRow(row) {
 function collectSupportedCodecTypeIds(descriptors) {
 	return [];
 }
-/**
-* Generic Result type for representing success or failure outcomes.
-*
-* This is the standard way to return "expected failures" as values rather than
-* throwing exceptions. See docs/Error Handling.md for the full taxonomy.
-*
-* Naming rationale:
-* - `Ok<T>` / `NotOk<F>` mirror the `ok: true/false` discriminator
-* - `NotOk` avoids collision with domain types like "Failure" or "Error"
-* - `failure` property distinguishes from JS Error semantics
-*/
-/**
-* Result class that implements both Ok and NotOk variants.
-*/
-var ResultImpl = class ResultImpl {
-	ok;
-	_value;
-	_failure;
-	constructor(ok, valueOrFailure) {
-		this.ok = ok;
-		if (ok) this._value = valueOrFailure;
-		else this._failure = valueOrFailure;
-		Object.freeze(this);
-	}
-	get value() {
-		if (!this.ok) throw new InternalError("Cannot access value on NotOk result");
-		return this._value;
-	}
-	get failure() {
-		if (this.ok) throw new InternalError("Cannot access failure on Ok result");
-		return this._failure;
-	}
-	/**
-	* Creates a successful result.
-	*/
-	static ok(value) {
-		return blindCast(new ResultImpl(true, value));
-	}
-	/**
-	* Creates an unsuccessful result.
-	*/
-	static notOk(failure) {
-		return blindCast(new ResultImpl(false, failure));
-	}
-	/**
-	* Asserts that this result is Ok and returns the value.
-	* Throws if the result is NotOk.
-	*/
-	assertOk() {
-		if (!this.ok) throw new InternalError("Expected Ok result but got NotOk");
-		return this.value;
-	}
-	/**
-	* Asserts that this result is NotOk and returns the failure.
-	* Throws if the result is Ok.
-	*/
-	assertNotOk() {
-		if (this.ok) throw new InternalError("Expected NotOk result but got Ok");
-		return this.failure;
-	}
-};
-/**
-* Creates a successful result.
-*/
-function ok$1(value) {
-	return ResultImpl.ok(value);
-}
-/**
-* Creates an unsuccessful result.
-*/
-function notOk(failure) {
-	return ResultImpl.notOk(failure);
-}
-/**
-* Singleton for void success results.
-* Use this for validation checks that don't produce a value.
-*/
-const OK_VOID = ResultImpl.ok(void 0);
-/**
-* Returns a successful void result.
-* Use this for validation checks that don't produce a value.
-*/
-function okVoid() {
-	return OK_VOID;
-}
 const _DRIVE_LETTER_START_RE = /^[A-Za-z]:\//;
 function normalizeWindowsPath(input = "") {
 	if (!input) return input;
@@ -71133,7 +72822,8 @@ var SqlFamilyDescriptor = class {
 		field: sqlFamilyAuthoringFieldPresets,
 		type: sqlFamilyAuthoringTypes,
 		entityTypes: sqlFamilyEntityTypes,
-		pslBlockDescriptors: sqlFamilyPslBlockDescriptors
+		pslBlockDescriptors: sqlFamilyPslBlockDescriptors,
+		attributeSpecs: sqlAttributeSpecs
 	};
 	create(stack) {
 		return createSqlFamilyInstance(stack);
@@ -71666,614 +73356,6 @@ function runnerFailure(code, summary, options) {
 }
 Object.freeze({ allowedOperationClasses: Object.freeze(["additive"]) });
 var control_default = new SqlFamilyDescriptor();
-/**
-* Name of the synthesised namespace bucket the framework parser uses for
-* top-level declarations that appear outside any `namespace { … }` block.
-* The double-underscore decoration signals that the identifier is parser-
-* synthesised and never appears in user-authored PSL source — writing
-* `namespace __unspecified__ { … }` is a parse error.
-*
-* Distinct from the IR sentinel `__unbound__`: the PSL bucket describes
-* syntactic absence at the parser layer; the IR sentinel describes a late-
-* bound storage slot at the IR layer. Per-target interpreters decide how
-* (or whether) to map the PSL bucket to the IR sentinel.
-*/
-const UNSPECIFIED_PSL_NAMESPACE_ID = "__unspecified__";
-/**
-* Stores `entries`; exposes `models`/`enums`/`compositeTypes` as getters over
-* it. The getters are prototype members (non-enumerable), so spreading or
-* `JSON.stringify`-ing a namespace copies only `entries`, never a duplicate view.
-*/
-var PslNamespaceNode = class {
-	kind = "namespace";
-	name;
-	entries;
-	span;
-	constructor(init) {
-		this.name = init.name;
-		this.entries = init.entries;
-		this.span = init.span;
-		Object.freeze(this);
-	}
-	get models() {
-		return blindCast(Object.values(this.entries["model"] ?? {}));
-	}
-	get compositeTypes() {
-		return blindCast(Object.values(this.entries["compositeType"] ?? {}));
-	}
-};
-/** Constructs a {@link PslNamespace}. Use this, never a namespace literal — the accessors must derive from `entries`. */
-function makePslNamespace(init) {
-	return new PslNamespaceNode(init);
-}
-/**
-* Builds the frozen `entries[kind][name]` container from per-kind arrays.
-* Built-ins key on their PSL keyword; extension blocks key on their `kind`
-* discriminator. Call this rather than hand-building the literal.
-*/
-function makePslNamespaceEntries(models, compositeTypes, extensionBlocks) {
-	const container = {};
-	if (models.length > 0) {
-		const map = {};
-		for (const m of models) map[m.name] = m;
-		container["model"] = Object.freeze(map);
-	}
-	if (compositeTypes.length > 0) {
-		const map = {};
-		for (const ct of compositeTypes) map[ct.name] = ct;
-		container["compositeType"] = Object.freeze(map);
-	}
-	for (const block of extensionBlocks) {
-		const existing = container[block.kind];
-		const newMap = existing ? blindCast({ ...existing }) : {};
-		newMap[block.name] = block;
-		container[block.kind] = Object.freeze(newMap);
-	}
-	return Object.freeze(container);
-}
-/**
-* A token in the red tree. Unlike the green-layer {@link Token} (kind + text
-* only), a red token also carries its absolute `offset` within the source and a
-* link back to its `parent` {@link SyntaxNode}, so a cursor anchored on a token
-* can walk outward (parent, previous/next token, siblings) without re-scanning
-* from the document root.
-*/
-var SyntaxToken = class {
-	green;
-	kind;
-	text;
-	offset;
-	parent;
-	/** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
-	index;
-	constructor(green, offset, parent, index) {
-		this.green = green;
-		this.kind = green.kind;
-		this.text = green.text;
-		this.offset = offset;
-		this.parent = parent;
-		this.index = index;
-	}
-	get textLength() {
-		return this.text.length;
-	}
-	get endOffset() {
-		return this.offset + this.textLength;
-	}
-	/** Whether `offset` falls within this token, inclusive of both ends. */
-	isInside(offset) {
-		return offset >= this.offset && offset <= this.endOffset;
-	}
-	isOutside(offset) {
-		return !this.isInside(offset);
-	}
-	/** The sibling element immediately after this token within its parent. */
-	get nextSiblingOrToken() {
-		return childAt(this.parent, this.index + 1);
-	}
-	/** The sibling element immediately before this token within its parent. */
-	get prevSiblingOrToken() {
-		return childAt(this.parent, this.index - 1);
-	}
-	/** The next token in document order, crossing node boundaries. */
-	get nextToken() {
-		for (let el = climbingNext(this); el !== void 0; el = climbingNext(el)) {
-			const token = firstToken(el);
-			if (token !== void 0) return token;
-		}
-	}
-	/** The previous token in document order, crossing node boundaries. */
-	get prevToken() {
-		for (let el = climbingPrev(this); el !== void 0; el = climbingPrev(el)) {
-			const token = lastToken(el);
-			if (token !== void 0) return token;
-		}
-	}
-};
-var TokenAtOffset = class TokenAtOffset {
-	#state;
-	constructor(state) {
-		this.#state = state;
-	}
-	static none() {
-		return new TokenAtOffset({ kind: "none" });
-	}
-	static single(token) {
-		return new TokenAtOffset({
-			kind: "single",
-			token
-		});
-	}
-	static between(left, right) {
-		return new TokenAtOffset({
-			kind: "between",
-			left,
-			right
-		});
-	}
-	get isEmpty() {
-		return this.#state.kind === "none";
-	}
-	get isBetween() {
-		return this.#state.kind === "between";
-	}
-	leftBiased() {
-		switch (this.#state.kind) {
-			case "none": return;
-			case "single": return this.#state.token;
-			case "between": return this.#state.left;
-		}
-	}
-	rightBiased() {
-		switch (this.#state.kind) {
-			case "none": return;
-			case "single": return this.#state.token;
-			case "between": return this.#state.right;
-		}
-	}
-};
-var SyntaxNode = class SyntaxNode {
-	green;
-	offset;
-	parent;
-	/** Position within the parent's children, enabling O(1) sibling navigation without rescanning the green layer. */
-	index;
-	constructor(green, offset, parent, index) {
-		this.green = green;
-		this.offset = offset;
-		this.parent = parent;
-		this.index = index;
-	}
-	get kind() {
-		return this.green.kind;
-	}
-	get textLength() {
-		return this.green.textLength;
-	}
-	get endOffset() {
-		return this.offset + this.textLength;
-	}
-	/** Whether `offset` falls within this node, inclusive of both ends. */
-	isInside(offset) {
-		return offset >= this.offset && offset <= this.endOffset;
-	}
-	isOutside(offset) {
-		return !this.isInside(offset);
-	}
-	get firstChild() {
-		return childAt(this, 0);
-	}
-	get lastChild() {
-		const len = this.green.children.length;
-		if (len === 0) return void 0;
-		return childAt(this, len - 1);
-	}
-	get nextSibling() {
-		return this.parent === void 0 ? void 0 : childAt(this.parent, this.index + 1);
-	}
-	get prevSibling() {
-		return this.parent === void 0 ? void 0 : childAt(this.parent, this.index - 1);
-	}
-	/** The sibling element immediately after this node within its parent. */
-	get nextSiblingOrToken() {
-		return this.nextSibling;
-	}
-	/** The sibling element immediately before this node within its parent. */
-	get prevSiblingOrToken() {
-		return this.prevSibling;
-	}
-	/** The first token in this subtree (depth-first), or `undefined` if empty. */
-	get firstToken() {
-		return firstToken(this);
-	}
-	/** The last token in this subtree (depth-first), or `undefined` if empty. */
-	get lastToken() {
-		return lastToken(this);
-	}
-	*children() {
-		let offset = this.offset;
-		let index = 0;
-		for (const child of this.green.children) {
-			yield wrapElement(child, offset, this, index);
-			offset += elementTextLength(child);
-			index++;
-		}
-	}
-	*childNodes() {
-		for (const child of this.children()) if (child instanceof SyntaxNode) yield child;
-	}
-	*ancestors() {
-		let current = this.parent;
-		while (current) {
-			yield current;
-			current = current.parent;
-		}
-	}
-	/** The nearest match, testing this node itself before walking its ancestors. */
-	findAncestor(cast) {
-		const self = cast(this);
-		if (self !== void 0) return self;
-		for (const ancestor of this.ancestors()) {
-			const result = cast(ancestor);
-			if (result !== void 0) return result;
-		}
-	}
-	*descendants() {
-		const stack = [this];
-		for (let el = stack.pop(); el !== void 0; el = stack.pop()) {
-			yield el;
-			if (el instanceof SyntaxNode) {
-				const children = Array.from(el.children());
-				for (let i = children.length - 1; i >= 0; i--) {
-					const child = children[i];
-					if (child !== void 0) stack.push(child);
-				}
-			}
-		}
-	}
-	*tokens() {
-		for (const el of this.descendants()) if (el instanceof SyntaxToken) yield el;
-	}
-	/**
-	* The token(s) at `offset`. The between-two-tokens case (offset exactly on a
-	* token seam) is represented explicitly so callers can left/right bias.
-	*/
-	tokenAtOffset(offset) {
-		return tokenAtOffsetOf(this, offset);
-	}
-	/**
-	* The smallest element fully containing the range `[start, end]`. At a seam
-	* (and for empty ranges) the left-hand element is preferred, matching
-	* {@link containsOffset}'s inclusive span.
-	*/
-	coveringElement(start, end) {
-		let result = this;
-		for (;;) {
-			if (result instanceof SyntaxToken) return result;
-			let next;
-			for (const child of result.children()) if (containsRange(child, start, end)) {
-				next = child;
-				break;
-			}
-			if (next === void 0) return result;
-			result = next;
-		}
-	}
-};
-function elementTextLength(el) {
-	return el.type === "token" ? el.text.length : el.textLength;
-}
-function elementLength(el) {
-	return el instanceof SyntaxToken ? el.text.length : el.textLength;
-}
-/**
-* Whether `el` contains `offset`. The span is inclusive on both ends so a seam
-* offset touches both neighbours.
-*/
-function containsOffset(el, offset) {
-	const start = el.offset;
-	const len = elementLength(el);
-	return offset >= start && offset <= start + len;
-}
-function containsRange(el, start, end) {
-	const elStart = el.offset;
-	const len = elementLength(el);
-	return elStart <= start && end <= elStart + len;
-}
-function tokenAtOffsetOf(el, offset) {
-	if (el instanceof SyntaxToken) return TokenAtOffset.single(el);
-	let left;
-	let right;
-	for (const child of el.children()) {
-		if (!containsOffset(child, offset)) continue;
-		if (left === void 0) left = child;
-		else {
-			right = child;
-			break;
-		}
-	}
-	if (left === void 0) return TokenAtOffset.none();
-	if (right === void 0) return tokenAtOffsetOf(left, offset);
-	const leftToken = tokenAtOffsetOf(left, offset).rightBiased();
-	const rightToken = tokenAtOffsetOf(right, offset).leftBiased();
-	if (leftToken !== void 0 && rightToken !== void 0) return TokenAtOffset.between(leftToken, rightToken);
-	if (leftToken !== void 0) return TokenAtOffset.single(leftToken);
-	if (rightToken !== void 0) return TokenAtOffset.single(rightToken);
-	return TokenAtOffset.none();
-}
-function firstToken(el) {
-	if (el instanceof SyntaxToken) return el;
-	for (const child of el.children()) {
-		const token = firstToken(child);
-		if (token !== void 0) return token;
-	}
-}
-function lastToken(el) {
-	if (el instanceof SyntaxToken) return el;
-	const children = Array.from(el.children());
-	for (let i = children.length - 1; i >= 0; i--) {
-		const child = children[i];
-		if (child !== void 0) {
-			const token = lastToken(child);
-			if (token !== void 0) return token;
-		}
-	}
-}
-function climbingNext(el) {
-	let current = el;
-	for (;;) {
-		const parent = current.parent;
-		if (parent === void 0) return void 0;
-		const sibling = childAt(parent, current.index + 1);
-		if (sibling !== void 0) return sibling;
-		current = parent;
-	}
-}
-function climbingPrev(el) {
-	let current = el;
-	for (;;) {
-		const parent = current.parent;
-		if (parent === void 0) return void 0;
-		const sibling = childAt(parent, current.index - 1);
-		if (sibling !== void 0) return sibling;
-		current = parent;
-	}
-}
-function wrapElement(green, offset, parent, index) {
-	if (green.type === "token") return new SyntaxToken(green, offset, parent, index);
-	return new SyntaxNode(green, offset, parent, index);
-}
-function childAt(node, index) {
-	const children = node.green.children;
-	const target = children[index];
-	if (target === void 0) return void 0;
-	let offset = node.offset;
-	for (let i = 0; i < index; i++) {
-		const child = children[i];
-		if (child !== void 0) offset += elementTextLength(child);
-	}
-	return wrapElement(target, offset, node, index);
-}
-function findChildToken(node, kind) {
-	for (const child of node.children()) if (!(child instanceof SyntaxNode) && child.kind === kind) return child;
-}
-const HEX = /^[0-9a-fA-F]+$/;
-function decodeFixedHex(raw, start, width) {
-	if (start + width > raw.length) return void 0;
-	const hex = raw.slice(start, start + width);
-	if (!HEX.test(hex)) return void 0;
-	return String.fromCharCode(Number.parseInt(hex, 16));
-}
-function decodeStringLiteral(raw) {
-	let out = "";
-	let i = 0;
-	while (i < raw.length) {
-		const ch = raw.charAt(i);
-		if (ch !== "\\" || i + 1 >= raw.length) {
-			out += ch;
-			i++;
-			continue;
-		}
-		const next = raw.charAt(i + 1);
-		switch (next) {
-			case "n":
-				out += "\n";
-				i += 2;
-				continue;
-			case "r":
-				out += "\r";
-				i += 2;
-				continue;
-			case "t":
-				out += "	";
-				i += 2;
-				continue;
-			case "\"":
-				out += "\"";
-				i += 2;
-				continue;
-			case "'":
-				out += "'";
-				i += 2;
-				continue;
-			case "\\":
-				out += "\\";
-				i += 2;
-				continue;
-			case "x": {
-				const decoded = decodeFixedHex(raw, i + 2, 2);
-				if (decoded === void 0) {
-					out += "\\x";
-					i += 2;
-					continue;
-				}
-				out += decoded;
-				i += 4;
-				continue;
-			}
-			case "u": {
-				const decoded = decodeFixedHex(raw, i + 2, 4);
-				if (decoded === void 0) {
-					out += "\\u";
-					i += 2;
-					continue;
-				}
-				out += decoded;
-				i += 6;
-				continue;
-			}
-			default:
-				out += `\\${next}`;
-				i += 2;
-				continue;
-		}
-	}
-	return out;
-}
-var StringLiteralExprAst = class StringLiteralExprAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	token() {
-		return findChildToken(this.syntax, "StringLiteral");
-	}
-	value() {
-		const tok = this.token();
-		if (!tok) return void 0;
-		return decodeStringLiteral(tok.text.slice(1, -1));
-	}
-	static cast(node) {
-		return node.kind === "StringLiteralExpr" ? new StringLiteralExprAst(node) : void 0;
-	}
-};
-var NumberLiteralExprAst = class NumberLiteralExprAst {
-	syntax;
-	constructor(syntax) {
-		this.syntax = syntax;
-	}
-	token() {
-		return findChildToken(this.syntax, "NumberLiteral");
-	}
-	value() {
-		const tok = this.token();
-		if (!tok) return void 0;
-		return Number(tok.text);
-	}
-	static cast(node) {
-		return node.kind === "NumberLiteralExpr" ? new NumberLiteralExprAst(node) : void 0;
-	}
-};
-function nodePslSpan(node, sourceFile) {
-	const start = node.offset;
-	const end = start + node.green.textLength;
-	return {
-		start: offsetToPslPosition(start, sourceFile),
-		end: offsetToPslPosition(end, sourceFile)
-	};
-}
-function offsetToPslPosition(offset, sourceFile) {
-	const position = sourceFile.positionAt(offset);
-	return {
-		offset,
-		line: position.line + 1,
-		column: position.character + 1
-	};
-}
-const ATTRIBUTE_DIAGNOSTIC_CODE = "PSL_INVALID_ATTRIBUTE_SYNTAX";
-function leafDiagnostic(ctx, node, message, code = ATTRIBUTE_DIAGNOSTIC_CODE) {
-	return {
-		code,
-		message,
-		sourceId: ctx.sourceId,
-		span: nodePslSpan(node.syntax, ctx.sourceFile)
-	};
-}
-function int(opts) {
-	const min = opts?.min;
-	const max = opts?.max;
-	return {
-		kind: "int",
-		label: "integer",
-		parse: (arg, ctx) => {
-			if (arg instanceof NumberLiteralExprAst) {
-				const value = arg.value();
-				if (value !== void 0 && Number.isInteger(value)) {
-					if ((min === void 0 || value >= min) && (max === void 0 || value <= max)) return ok$1(value);
-					return notOk([leafDiagnostic(ctx, arg, rangeMessage(min, max))]);
-				}
-			}
-			return notOk([leafDiagnostic(ctx, arg, "Expected an integer literal")]);
-		}
-	};
-}
-function rangeMessage(min, max) {
-	if (min !== void 0 && max !== void 0) return `Expected an integer between ${min} and ${max}`;
-	if (min !== void 0) return `Expected an integer greater than or equal to ${min}`;
-	return `Expected an integer less than or equal to ${max}`;
-}
-function num(value) {
-	return {
-		kind: "num",
-		label: value === void 0 ? "number" : String(value),
-		parse: (arg, ctx) => {
-			if (arg instanceof NumberLiteralExprAst) {
-				const parsed = arg.value();
-				if (parsed !== void 0 && (value === void 0 || parsed === value)) return ok$1(parsed);
-			}
-			return notOk([leafDiagnostic(ctx, arg, value === void 0 ? "Expected a number literal" : `Expected ${value}`)]);
-		}
-	};
-}
-function oneOf(...alts) {
-	const label = alts.map((alt) => alt.label).join(" | ");
-	return {
-		kind: "oneOf",
-		label,
-		parse: (arg, ctx) => {
-			for (const alt of alts) {
-				const result = alt.parse(arg, ctx);
-				if (result.ok) return ok$1(blindCast(result.value));
-			}
-			return notOk([leafDiagnostic(ctx, arg, `Expected one of: ${label}`)]);
-		}
-	};
-}
-function str() {
-	return {
-		kind: "str",
-		label: "string",
-		parse: (arg, ctx) => {
-			if (arg instanceof StringLiteralExprAst) {
-				const value = arg.value();
-				if (value !== void 0) return ok$1(value);
-			}
-			return notOk([leafDiagnostic(ctx, arg, "Expected a string literal")]);
-		}
-	};
-}
-function modelAttribute(name, config) {
-	return {
-		level: "model",
-		name,
-		positional: config.positional ?? [],
-		named: config.named ?? {},
-		...config.refine !== void 0 ? { refine: config.refine } : {}
-	};
-}
-function optional(type, ...rest) {
-	if (rest.length === 0) return {
-		...type,
-		optional: true,
-		hasDefault: false
-	};
-	return {
-		...type,
-		optional: true,
-		hasDefault: true,
-		defaultValue: rest[0]
-	};
-}
 const INSTANT_NOW_GENERATOR_ID = "instantNow";
 function instantNowControlDescriptor() {
 	return {
@@ -72292,7 +73374,6 @@ function instantNowControlDescriptor() {
 }
 const PSL_RLS_PREDICATE_NOT_FOR_OPERATION = "PSL_RLS_PREDICATE_NOT_FOR_OPERATION";
 const PSL_POLICY_INVALID_MAP = "PSL_POLICY_INVALID_MAP";
-const PSL_NATIVE_ENUM_INVALID_MAP = "PSL_NATIVE_ENUM_INVALID_MAP";
 const PSL_NATIVE_ENUM_BARE_MEMBER = "PSL_NATIVE_ENUM_BARE_MEMBER";
 const PSL_EXTENSION_INVALID_VALUE = "PSL_EXTENSION_INVALID_VALUE";
 const PSL_NATIVE_ENUM_DUPLICATE_MEMBER_VALUE = "PSL_NATIVE_ENUM_DUPLICATE_MEMBER_VALUE";
@@ -72441,19 +73522,10 @@ function lowerRlsPolicyFromBlock(block, ctx) {
 		return;
 	}
 	const permissive = permissiveRaw !== "false";
-	const mapAttr = block.blockAttributes.find((a) => a.name === "map");
-	if (mapAttr) {
-		const rawArg = mapAttr.args[0]?.value;
-		const exactName = rawArg?.startsWith("\"") && rawArg.endsWith("\"") && rawArg.length >= 2 ? unwrapQuotedString(rawArg) : void 0;
-		if (exactName === void 0 || exactName === "") {
-			ctx.diagnostics?.push({
-				code: PSL_POLICY_INVALID_MAP,
-				message: `\`${block.keyword}\` policy "${block.name}" @@map attribute must have a quoted, non-empty policy-name argument`,
-				sourceId: ctx.sourceId ?? "unknown",
-				span: mapAttr.span
-			});
-			return;
-		}
+	const mapAttr = block.attributes["map"];
+	if (mapAttr !== void 0) {
+		const exactName = mapAttr.args["name"];
+		invariant(typeof exactName === "string", "@@map on a policy block parses one string argument");
 		ctx.warnings?.push(exactNameBodyWarning("policy", exactName));
 		return new PostgresRlsPolicy({
 			naming: {
@@ -72493,20 +73565,11 @@ function lowerRlsPolicyFromBlock(block, ctx) {
 function lowerNativeEnumFromBlock(block, ctx) {
 	const sourceId = ctx.sourceId ?? "unknown";
 	const diagnostics = ctx.diagnostics;
-	const mapAttr = block.blockAttributes.find((a) => a.name === "map");
+	const mapAttr = block.attributes["map"];
 	let typeName = block.name;
-	if (mapAttr) {
-		const rawArg = mapAttr.args[0]?.value;
-		const mapped = rawArg !== void 0 ? unwrapQuotedString(rawArg) : void 0;
-		if (mapped === void 0) {
-			diagnostics?.push({
-				code: PSL_NATIVE_ENUM_INVALID_MAP,
-				message: `native_enum "${block.name}" @@map attribute must have a quoted type-name argument`,
-				sourceId,
-				span: mapAttr.span
-			});
-			return;
-		}
+	if (mapAttr !== void 0) {
+		const mapped = mapAttr.args["name"];
+		invariant(typeof mapped === "string", "@@map on a native_enum block parses one string argument");
 		typeName = mapped;
 	}
 	let memberError = false;
@@ -72692,6 +73755,18 @@ const policyRequiresRls = {
 	parameter: "target",
 	attribute: "rls"
 };
+const policyMapAttribute = blockAttribute("map", {
+	positional: [{
+		key: "name",
+		type: str()
+	}],
+	refine: (parsed, ctx, attributeNode) => parsed.name === "" ? [leafDiagnostic(ctx, attributeNode, "@@map policy name must be a non-empty string", PSL_POLICY_INVALID_MAP)] : []
+});
+const policyBlockAttributes = { map: () => policyMapAttribute };
+const nativeEnumMapAttribute = blockAttribute("map", { positional: [{
+	key: "name",
+	type: str()
+}] });
 const postgresAuthoringPslBlockDescriptors = {
 	policy_select: {
 		kind: "pslBlock",
@@ -72704,7 +73779,8 @@ const postgresAuthoringPslBlockDescriptors = {
 			using: policyPredicateParam,
 			permissive: policyPermissiveParam
 		},
-		requiresModelAttribute: policyRequiresRls
+		requiresModelAttribute: policyRequiresRls,
+		attributes: policyBlockAttributes
 	},
 	policy_delete: {
 		kind: "pslBlock",
@@ -72717,7 +73793,8 @@ const postgresAuthoringPslBlockDescriptors = {
 			using: policyPredicateParam,
 			permissive: policyPermissiveParam
 		},
-		requiresModelAttribute: policyRequiresRls
+		requiresModelAttribute: policyRequiresRls,
+		attributes: policyBlockAttributes
 	},
 	policy_insert: {
 		kind: "pslBlock",
@@ -72730,7 +73807,8 @@ const postgresAuthoringPslBlockDescriptors = {
 			withCheck: policyPredicateParam,
 			permissive: policyPermissiveParam
 		},
-		requiresModelAttribute: policyRequiresRls
+		requiresModelAttribute: policyRequiresRls,
+		attributes: policyBlockAttributes
 	},
 	policy_update: {
 		kind: "pslBlock",
@@ -72744,7 +73822,8 @@ const postgresAuthoringPslBlockDescriptors = {
 			withCheck: policyPredicateParam,
 			permissive: policyPermissiveParam
 		},
-		requiresModelAttribute: policyRequiresRls
+		requiresModelAttribute: policyRequiresRls,
+		attributes: policyBlockAttributes
 	},
 	policy_all: {
 		kind: "pslBlock",
@@ -72758,7 +73837,8 @@ const postgresAuthoringPslBlockDescriptors = {
 			withCheck: policyPredicateParam,
 			permissive: policyPermissiveParam
 		},
-		requiresModelAttribute: policyRequiresRls
+		requiresModelAttribute: policyRequiresRls,
+		attributes: policyBlockAttributes
 	},
 	/**
 	* PSL block descriptor for `native_enum`.
@@ -72776,7 +73856,8 @@ const postgresAuthoringPslBlockDescriptors = {
 		discriminator: "native_enum",
 		name: { required: true },
 		parameters: {},
-		variadicParameters: true
+		variadicParameters: true,
+		attributes: { map: () => nativeEnumMapAttribute }
 	},
 	/**
 	* PSL block descriptor for `role` (e.g. `role anon {}`). Name-only, no
@@ -72792,6 +73873,8 @@ const postgresAuthoringPslBlockDescriptors = {
 		parameters: {}
 	}
 };
+const postgresRlsSpec = modelAttribute("rls", {});
+const postgresRlsSpecFactory = () => postgresRlsSpec;
 /**
 * `@@` model attributes contributed by the Postgres target pack.
 *
@@ -72804,7 +73887,7 @@ const postgresAuthoringPslBlockDescriptors = {
 const postgresAuthoringModelAttributes = { rls: {
 	kind: "modelAttribute",
 	attribute: "rls",
-	spec: modelAttribute("rls", {}),
+	spec: postgresRlsSpecFactory,
 	lower: (_parsed, ctx) => ({
 		key: ctx.storageName,
 		entity: new PostgresRlsEnablement({
@@ -76216,103 +77299,6 @@ var PostgresRoleSchemaNode = class PostgresRoleSchemaNode extends SqlSchemaIRNod
 		assertNode(node, "PostgresRoleSchemaNode", PostgresRoleSchemaNode.is);
 	}
 };
-/**
-* Stable code emitted by the runtime when an in-flight `execute()`
-* is cancelled via the per-query `AbortSignal`. The envelope's
-* `details.phase` distinguishes where the abort was observed:
-*
-* - `'encode'` — abort fired during `encodeParams` (SQL) or
-*   `resolveValue` (Mongo).
-* - `'decode'` — abort fired during `decodeRow` / `decodeField`.
-* - `'stream'` — abort fired between rows or before any codec call
-*   (already-aborted at entry).
-* - `'beforeQuery'` / `'beforeExecute'` / `'afterQuery'` /
-*   `'afterExecute'` / `'onRow'` — abort fired on entry to or during
-*   the corresponding middleware phase
-*   (cooperative cancellation per the param-transform seam).
-*/
-const RUNTIME_ABORTED = "RUNTIME.ABORTED";
-/**
-* Construct a `RUNTIME.ABORTED` envelope. Phase distinguishes where the
-* abort was observed — codec call sites (`encode` / `decode` / `stream`)
-* or operation-specific middleware seams, as
-* enumerated on {@link RuntimeAbortedPhase}. Cause carries
-* `signal.reason` verbatim from the platform — native abort produces a
-* `DOMException`, explicit `controller.abort(reason)` produces whatever
-* the caller passed. No synthesis happens here.
-*/
-function runtimeAborted(phase, cause) {
-	const envelope = runtimeError(RUNTIME_ABORTED, `Operation aborted during ${phase}`, { phase });
-	return Object.assign(envelope, { cause });
-}
-/**
-* Throw a phase-tagged `RUNTIME.ABORTED` envelope if the supplied
-* context is already aborted at the precheck site. Centralises the
-* `if (ctx.signal?.aborted) throw runtimeAborted(...)` pattern that
-* every codec dispatch site (and the `beforeExecute` middleware phase)
-* repeats. Accepts both the framework `CodecCallContext` and the
-* `RuntimeMiddlewareContext`; both expose `signal?: AbortSignal`.
-*/
-function checkAborted(ctx, phase) {
-	if (ctx.signal?.aborted) throw runtimeAborted(phase, ctx.signal.reason);
-}
-/**
-* Race a per-cell `Promise.all` (or any other in-flight work promise) against
-* the supplied abort signal so the runtime returns `RUNTIME.ABORTED` promptly
-* even when codec bodies ignore the signal. In-flight bodies that ignore the
-* signal are abandoned and run to completion in the background — the
-* cooperative-cancellation contract documented in ADR 204.
-*
-* Call sites still SHOULD pre-check `signal.aborted` and short-circuit with
-* a phase-tagged `RUNTIME.ABORTED` envelope before invoking this helper —
-* that path is the canonical "aborted at entry" surface and avoids
-* scheduling the work promise. As a defensive belt-and-braces, this helper
-* also handles the already-aborted case internally: `AbortSignal` does not
-* replay past abort events to listeners registered after the abort, so we
-* inspect `signal.aborted` synchronously and reject with the sentinel
-* before installing the listener. The rejection is still attributed to the
-* abort path via the sentinel-identity check.
-*
-* Distinguishing the rejection source is load-bearing for AC-ERR4
-* (`RUNTIME.ENCODE_FAILED` / `RUNTIME.DECODE_FAILED` pass through unchanged).
-* The semantically equivalent `abortable(signal)` helper in
-* `@internal/utils` rejects with `signal.reason ?? new DOMException(...)`,
-* which is not stably distinguishable from a codec-thrown error by identity
-* alone (a fresh fallback DOMException is allocated per call). We instead
-* track abort attribution with a unique sentinel: only the `onAbort` listener
-* installed here ever rejects with the sentinel, so an `error === sentinel`
-* identity check after the race is unambiguous.
-*
-* Lives in `framework-components` (rather than the SQL family, where it
-* originated in m2) so every family runtime that needs cooperative
-* cancellation around a codec-dispatch `Promise.all` (SQL encode + decode
-* today, Mongo encode in m3) shares the same attribution logic.
-*/
-async function raceAgainstAbort(work, signal, phase) {
-	if (signal === void 0) return await work;
-	const sentinel = { reason: void 0 };
-	let onAbort;
-	const abortPromise = new Promise((_, reject) => {
-		if (signal.aborted) {
-			sentinel.reason = signal.reason;
-			reject(sentinel);
-			return;
-		}
-		onAbort = () => {
-			sentinel.reason = signal.reason;
-			reject(sentinel);
-		};
-		signal.addEventListener("abort", onAbort, { once: true });
-	});
-	try {
-		return await Promise.race([work, abortPromise]);
-	} catch (error) {
-		if (error === sentinel) throw runtimeAborted(phase, sentinel.reason);
-		throw error;
-	} finally {
-		if (onAbort) signal.removeEventListener("abort", onAbort);
-	}
-}
 function adapterError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -76417,87 +77403,20 @@ function renderLimitOffset(keyword, value, contract, pim) {
 	return `${keyword} ${renderExpr(value, contract, pim)}`;
 }
 function renderSelect(ast, contract, pim) {
-	const sourcesByRef = collectTableSources(ast);
 	return [
-		`SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, sourcesByRef, contract, pim)}${renderProjection(ast.projection, contract, pim)}`,
+		`SELECT ${renderDistinctPrefix(ast.distinct, ast.distinctOn, contract, pim)}${renderProjection(ast.projection, contract, pim)}`,
 		ast.from !== void 0 ? `FROM ${renderSource(ast.from, contract, pim)}` : "",
 		ast.joins?.length ? ast.joins.map((join) => renderJoin(join, contract, pim)).join(" ") : "",
 		ast.where ? `WHERE ${renderWhere(ast.where, contract, pim)}` : "",
 		ast.groupBy?.length ? `GROUP BY ${ast.groupBy.map((expr) => renderExpr(expr, contract, pim)).join(", ")}` : "",
 		ast.having ? `HAVING ${renderWhere(ast.having, contract, pim)}` : "",
 		ast.orderBy?.length ? `ORDER BY ${ast.orderBy.map((order) => {
-			return `${renderOrderByExpr(order.expr, sourcesByRef, contract, pim)} ${order.dir.toUpperCase()}`;
+			return `${renderExpr(order.expr, contract, pim)} ${order.dir.toUpperCase()}`;
 		}).join(", ")}` : "",
 		renderLimitOffset("LIMIT", ast.limit, contract, pim),
 		renderLimitOffset("OFFSET", ast.offset, contract, pim)
 	].filter((part) => part.length > 0).join(" ").trim();
 }
-/**
-* Map a SELECT's table references (the FROM source and any JOIN sources) to their storage coordinate, keyed by the name a `ColumnRef.table` would carry (the alias when present, otherwise the table name). Derived-table sources are skipped — their columns are projected through a sub-select, not a base storage column, so the enum hook does not apply.
-*/
-function collectTableSources(ast) {
-	const sources = /* @__PURE__ */ new Map();
-	const add = (source) => {
-		if (source.kind !== "table-source") return;
-		const ref = source.alias ?? source.name;
-		sources.set(ref, {
-			name: source.name,
-			namespaceId: source.namespaceId
-		});
-	};
-	if (ast.from !== void 0) add(ast.from);
-	for (const join of ast.joins ?? []) add(join.source);
-	return sources;
-}
-/**
-* Ordered, codec-encoded values of the value-set a storage column restricts to, or `undefined` when the referenced column carries no value-set (the common, non-enum case). Resolves the column's storage coordinate from the SELECT's table sources, then the column's `valueSet` ref to the value-set's `values`.
-*/
-function allStrings(values) {
-	return values.every((value) => typeof value === "string");
-}
-function resolveEnumOrderValues(ref, sourcesByRef, contract) {
-	const source = sourcesByRef.get(ref.table);
-	if (source === void 0 || source.namespaceId === void 0) return;
-	const sourceNs = contract.storage.namespaces[source.namespaceId];
-	const valueSet = (sourceNs !== void 0 ? sourceNs.entries.table?.[source.name]?.columns[ref.column] : void 0)?.valueSet;
-	if (valueSet === void 0) return;
-	const valueSetNs = contract.storage.namespaces[valueSet.namespaceId];
-	return valueSetNs !== void 0 ? valueSetNs.entries.valueSet?.[valueSet.entityName]?.values : void 0;
-}
-/**
-* Ordered values for an unqualified ORDER BY column (an `identifier-ref`, the shape the sql-builder emits for `.orderBy('col')`). Scans every FROM/JOIN source for a column of that name. Resolves only when exactly one source has a column of that name and it carries a value-set; if more than one source has such a column the bare identifier is ambiguous (regardless of which are enum-backed), so it falls through to the plain column rendering.
-*/
-function resolveEnumOrderValuesForIdentifier(name, sourcesByRef, contract) {
-	let matchedColumns = 0;
-	let resolved;
-	for (const source of sourcesByRef.values()) {
-		if (source.namespaceId === void 0) continue;
-		const identNs = contract.storage.namespaces[source.namespaceId];
-		const column = identNs !== void 0 ? identNs.entries.table?.[source.name]?.columns[name] : void 0;
-		if (column === void 0) continue;
-		matchedColumns += 1;
-		if (matchedColumns > 1) return;
-		const valueSet = column.valueSet;
-		if (valueSet === void 0) return;
-		const valueSetNs = contract.storage.namespaces[valueSet.namespaceId];
-		resolved = valueSetNs !== void 0 ? valueSetNs.entries.valueSet?.[valueSet.entityName]?.values : void 0;
-	}
-	return resolved;
-}
-/**
-* Render an ORDER BY expression. A column reference onto an enum-restricted column sorts by declaration order via `array_position(ARRAY[…]::text[], <col>)` over the value-set's ordered values (NULLs return `NULL` from `array_position`, sorting per the clause's default NULL handling). Both qualified `column-ref`s and the unqualified `identifier-ref`s the sql-builder emits for `.orderBy('col')` are intercepted. Every other expression renders unchanged.
-*/
-function renderOrderByExpr(expr, sourcesByRef, contract, pim) {
-	if (expr.kind === "column-ref") {
-		const orderValues = resolveEnumOrderValues(expr, sourcesByRef, contract);
-		if (orderValues !== void 0 && allStrings(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${renderColumn(expr)})`;
-	}
-	if (expr.kind === "identifier-ref") {
-		const orderValues = resolveEnumOrderValuesForIdentifier(expr.name, sourcesByRef, contract);
-		if (orderValues !== void 0 && allStrings(orderValues)) return `array_position(ARRAY[${orderValues.map((value) => `'${escapeLiteral(value)}'`).join(", ")}]::text[], ${quoteIdentifier(expr.name)})`;
-	}
-	return renderExpr(expr, contract, pim);
-}
 function renderProjection(projection, contract, pim) {
 	return projection.map((item) => {
 		const alias = quoteIdentifier(item.alias);
@@ -76515,8 +77434,8 @@ function renderReturning(items, contract, pim) {
 		return `${renderExpr(item.expr, contract, pim)} AS ${quoteIdentifier(item.alias)}`;
 	}).join(", ");
 }
-function renderDistinctPrefix(distinct, distinctOn, sourcesByRef, contract, pim) {
-	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderOrderByExpr(expr, sourcesByRef, contract, pim)).join(", ")}) `;
+function renderDistinctPrefix(distinct, distinctOn, contract, pim) {
+	if (distinctOn && distinctOn.length > 0) return `DISTINCT ON (${distinctOn.map((expr) => renderExpr(expr, contract, pim)).join(", ")}) `;
 	if (distinct) return "DISTINCT ";
 	return "";
 }
@@ -76920,7 +77839,7 @@ function isLegacyMarkerShapeReadError(message) {
 	return normalized.includes("column \"space\" does not exist") || normalized.includes("no such column: space");
 }
 function errorLegacyMarkerShape(options) {
-	return errorRunnerFailed(`Legacy marker-table shape detected on ${options.markerLocation} (no \`space\` column). Prisma Next is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop \`${options.markerLocation}\` and re-run \`{bin} db init\` to reinitialise from a clean baseline.`, {
+	return errorRunnerFailed(`Legacy marker-table shape detected on ${options.markerLocation} (no \`space\` column). Prisma 8 is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop \`${options.markerLocation}\` and re-run \`{bin} db init\` to reinitialise from a clean baseline.`, {
 		why: options.why,
 		fix: "Legacy marker-table shape detected. Drop `prisma_contract.marker` (Postgres) or `_prisma_marker` (SQLite) and re-run `{bin} db init` to recreate it with the current per-space schema.",
 		nextActions: [{
@@ -79586,28 +80505,31 @@ const postgresDriverDescriptor = {
 /**
 * Renders the checks a Postgres column needs, as opaque predicate text.
 *
-* A text-backed domain enum has no type-level enforcement, so membership is a
+* A domain enum has no type-level enforcement, so membership is a
 * predicate: `IN` for a scalar, and `<@` containment for an array — an array
 * column cannot use `IN` at all (`operator does not exist: text[] = text`),
 * and containment additionally rejects NULL elements. Every list column also
 * gets an element-non-null check, which no Postgres column type can express.
 *
-* The array side casts the COLUMN to `text[]` rather than assuming its element
-* type already is: `<@` needs both operands in one type, so a `varchar[]` or
-* `char[]` column meeting a bare `text[]` literal raises the same
-* `operator does not exist` this project exists to eliminate. The scalar `IN`
-* form needs no cast — `varchar = text` resolves on its own.
+* Array containment casts both operands to `numeric[]` for numeric members or
+* `text[]` for string members, so different storage types share an operator
+* without comparing numbers as text. The scalar `IN` form needs no cast.
 */
 function postgresRenderCheckExpressions(input) {
 	const candidates = [];
 	const column = quoteIdentifier(input.columnName);
 	if (input.memberValues !== void 0) {
 		invariant(input.memberValues.length > 0, `check for "${input.tableName}"."${input.columnName}": empty member set; both authoring surfaces reject a member-less enum before rendering`);
-		const members = input.memberValues.map((value) => `'${escapeLiteral(value)}'`).join(", ");
+		const members = input.memberValues.map((value) => {
+			if (typeof value === "string") return `'${escapeLiteral(value)}'`;
+			invariant(Number.isFinite(value), `check for "${input.tableName}"."${input.columnName}": non-finite numeric member`);
+			return String(value);
+		}).join(", ");
+		const arrayType = input.memberValues.every((value) => typeof value === "number") ? "numeric[]" : "text[]";
 		candidates.push({
 			kind: "membership",
 			columnName: input.columnName,
-			expression: input.many ? `${column}::text[] <@ ARRAY[${members}]::text[]` : `${column} IN (${members})`
+			expression: input.many ? `${column}::${arrayType} <@ ARRAY[${members}]::${arrayType}` : `${column} IN (${members})`
 		});
 	}
 	if (input.many) candidates.push({
@@ -79631,6 +80553,7 @@ const postgresIndexTypes = defineIndexTypes().add("btree", { options: type("obje
 const postgresTargetDescriptorMeta = {
 	...postgresTargetDescriptorMetaRuntime,
 	defaultNamespaceId: DEFAULT_NAMESPACE_ID,
+	supportsNamespaces: true,
 	indexTypes: postgresIndexTypes,
 	authoring: {
 		type: postgresAuthoringTypes$1,
@@ -82719,7 +83642,7 @@ function isNativeEnumSuffixAppend(actualMembers, expectedMembers) {
 }
 /** Operator-worded refusal for a native-enum member change beyond a suffix append (design ruling — tests match this verbatim). */
 function nativeEnumMemberChangeRefusal(options) {
-	return `Native enum type "${options.ddlSchemaName}"."${options.typeName}" changed beyond appending new values (contract declares [${options.expectedMembers.join(", ")}], database has [${options.actualMembers.join(", ")}]). Prisma Next does not modify a native enum's existing values (rename, removal, reorder) — see https://pris.ly/d/postgres-native-enums. Author the change manually with \`migration new\`.`;
+	return `Native enum type "${options.ddlSchemaName}"."${options.typeName}" changed beyond appending new values (contract declares [${options.expectedMembers.join(", ")}], database has [${options.actualMembers.join(", ")}]). Prisma 8 does not modify a native enum's existing values (rename, removal, reorder) — see https://pris.ly/d/postgres-native-enums. Author the change manually with \`migration new\`.`;
 }
 /**
 * Managed native-enum issue -> op lowering. A missing declared type creates
@@ -216768,7 +217691,7 @@ function addRelationField(map, tableName, field) {
 	if (existing) existing.push(field);
 	else map.set(tableName, [field]);
 }
-const LOCK_DOMAIN = "prisma_next.contract.marker";
+const LOCK_DOMAIN = "prisma_8.contract.marker";
 /**
 * Deep clones and freezes a record object to prevent mutation.
 * Recursively clones nested objects and arrays to ensure complete isolation.
@@ -216945,7 +217868,7 @@ var PostgresMigrationRunner = class {
 		if (result.rows.length === 0) return okVoid();
 		const columns = new Set(result.rows.map((row) => row.column_name));
 		if (columns.has("space")) return okVoid();
-		return runnerFailure("MIGRATION.LEGACY_MARKER_SHAPE", "Legacy marker-table shape detected on prisma_contract.marker (no `space` column). Prisma Next is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop `prisma_contract.marker` and re-run `dbInit` to reinitialise from a clean baseline.", { meta: {
+		return runnerFailure("MIGRATION.LEGACY_MARKER_SHAPE", "Legacy marker-table shape detected on prisma_contract.marker (no `space` column). Prisma 8 is in pre-1.0; the previous transitional auto-migration to the per-space-row schema has been removed. Drop `prisma_contract.marker` and re-run `dbInit` to reinitialise from a clean baseline.", { meta: {
 			table: "prisma_contract.marker",
 			columns: [...columns].sort()
 		} });
@@ -217394,6 +218317,10 @@ function buildNativeEnumBlock(name, typeName, values) {
 			}],
 			span: SYNTHETIC_SPAN
 		}],
+		attributes: name === typeName ? {} : { map: {
+			args: { name: typeName },
+			span: SYNTHETIC_SPAN
+		} },
 		span: SYNTHETIC_SPAN
 	};
 }
@@ -217799,7 +218726,7 @@ function buildPolicyBlocks(policiesByTable, modelNameMap, reservedHeads = /* @__
 		const badRole = policy.roles.find((role) => !PSL_IDENTIFIER.test(role));
 		if (badRole !== void 0) {
 			const notes = skipNotesByTable.get(tableName) ?? [];
-			notes.push(`// prisma-next: skipped policy "${policy.name}": role "${badRole}" is not a valid PSL identifier and role references cannot be escaped`);
+			notes.push(`// prisma: skipped policy "${policy.name}": role "${badRole}" is not a valid PSL identifier and role references cannot be escaped`);
 			skipNotesByTable.set(tableName, notes);
 			continue;
 		}
@@ -217854,6 +218781,10 @@ function buildPolicyBlocks(policiesByTable, modelNameMap, reservedHeads = /* @__
 				}],
 				span: SYNTHETIC_SPAN
 			}],
+			attributes: { map: {
+				args: { name: policy.name },
+				span: SYNTHETIC_SPAN
+			} },
 			span: SYNTHETIC_SPAN
 		});
 	}
@@ -218208,6 +219139,214 @@ function getEmittedArtifactPaths(outputJsonPath) {
 		dtsPath: `${outputJsonPath.slice(0, -5)}.d.ts`
 	};
 }
+const TYPESCRIPT_IDENTIFIER = /^[$A-Z_a-z][$\w]*$/;
+function namespacedMemberName(namespaceId, modelName) {
+	return `${namespaceId === "__unbound__" ? "unbound" : namespaceId}_${modelName}`;
+}
+function bareMemberName(_namespaceId, modelName) {
+	return modelName;
+}
+function claimMemberName(claims, memberName, source) {
+	if (!TYPESCRIPT_IDENTIFIER.test(memberName)) throw emitterError("CONTRACT.MODEL_TYPE_NAME_INVALID", `Emitted model type name "${memberName}" (from ${source}) is not a TypeScript identifier`, {
+		why: "Every entry in the emitted Models namespace is declared as `export type <name>`, so the name must be a TypeScript identifier.",
+		fix: "Rename the namespace or model so that <namespace>_<Model> contains only letters, digits, `$`, and `_`, and does not start with a digit.",
+		meta: {
+			memberName,
+			source
+		}
+	});
+	const existing = claims.get(memberName);
+	if (existing !== void 0) throw emitterError("CONTRACT.MODEL_TYPE_NAME_COLLISION", `Emitted model type name "${memberName}" is produced by both ${existing} and ${source}`, {
+		why: "Every entry in the emitted Models namespace needs a distinct name, formed as <namespace>_<Model>.",
+		fix: "Rename one of the models or namespaces so the two names differ.",
+		meta: {
+			memberName,
+			sources: [existing, source]
+		}
+	});
+	claims.set(memberName, source);
+}
+function isPolymorphicBase(model) {
+	return model.discriminator !== void 0 && model.variants !== void 0;
+}
+function findModelByName(namespaces, namespaceId, modelName) {
+	return namespaces.find((ns) => ns.namespaceId === namespaceId)?.models.find((m) => m.modelName === modelName);
+}
+function findModel(namespaces, ref) {
+	return findModelByName(namespaces, ref.namespace, ref.model);
+}
+function requireRelationTarget(namespaces, owner, relationName, ref) {
+	const target = findModel(namespaces, ref);
+	if (target !== void 0) return target;
+	const ownerSource = `${owner.namespaceId}.${owner.modelName}`;
+	throw emitterError("CONTRACT.MODEL_RELATION_TARGET_MISSING", `Relation "${relationName}" on ${ownerSource} targets ${ref.namespace}.${ref.model}, which is not in the contract`, {
+		why: "A same-space relation must point at a model the contract declares; only cross-space relations may reference models outside it.",
+		fix: "Declare the target model in the contract, or mark the relation as cross-space by giving its target a `space`.",
+		meta: {
+			owner: ownerSource,
+			relationName,
+			target: {
+				namespaceId: ref.namespace,
+				modelName: ref.model
+			}
+		}
+	});
+}
+function requireBase(namespaces, variant, base) {
+	const found = findModel(namespaces, base);
+	if (found !== void 0) return found;
+	const variantSource = `${variant.namespaceId}.${variant.modelName}`;
+	const baseSource = `${base.namespace}.${base.model}`;
+	throw emitterError("CONTRACT.MODEL_BASE_MISSING", `Model ${variantSource} names base ${baseSource}, which is not in the contract`, {
+		why: "A variant's type is its base's fields plus its own, so the base must be a model the contract declares.",
+		fix: "Declare the base model in the contract, or remove `base` from the variant.",
+		meta: {
+			variant: variantSource,
+			base: baseSource
+		}
+	});
+}
+function requireVariant(namespaces, base, variantName) {
+	const variant = findModelByName(namespaces, base.namespaceId, variantName);
+	if (variant !== void 0) return variant;
+	const baseSource = `${base.namespaceId}.${base.modelName}`;
+	throw emitterError("CONTRACT.MODEL_VARIANT_MISSING", `Polymorphic base ${baseSource} names variant "${variantName}", which is not in the contract`, {
+		why: "The Any<Base> union is the union of the variant model types, so every variant a base declares must be a model in the same namespace.",
+		fix: "Declare the variant model in the same namespace as the base, or remove it from the base's variants.",
+		meta: {
+			base: baseSource,
+			variantName
+		}
+	});
+}
+function collectFieldLines(ref, resolvers, discriminatorType) {
+	const lines = /* @__PURE__ */ new Map();
+	for (const [fieldName, field] of Object.entries(ref.model.fields)) {
+		const type = discriminatorType !== void 0 && fieldName === discriminatorType.field ? discriminatorType.type : resolveModelFieldType(ref.modelName, fieldName, field, ref.model, resolvers).output;
+		lines.set(fieldName, `${serializeObjectKey(fieldName)}: ${type};`);
+	}
+	return lines;
+}
+function hasJoin(relation) {
+	return "on" in relation && relation.on !== void 0;
+}
+function relationLine(owner, relationName, relation, index) {
+	if (relation.to.space !== void 0) return void 0;
+	const target = requireRelationTarget(index.namespaces, owner, relationName, relation.to);
+	const targetMember = index.memberNameOf(target.namespaceId, isPolymorphicBase(target.model) ? `Any${target.modelName}` : target.modelName);
+	const key = serializeObjectKey(relationName);
+	if (!hasJoin(relation)) return {
+		line: `${key}: ${relation.cardinality === "1:N" ? `${targetMember}[]` : targetMember};`,
+		hasJoin: false
+	};
+	if (relation.cardinality === "1:N" || relation.cardinality === "N:M") return {
+		line: `${key}: ${targetMember}[];`,
+		hasJoin: true
+	};
+	return {
+		line: `${key}: ${relation.nullable ? `${targetMember} | null` : targetMember};`,
+		hasJoin: true
+	};
+}
+function collectRelationLines(ref, index) {
+	const lines = /* @__PURE__ */ new Map();
+	for (const [relationName, relation] of Object.entries(ref.model.relations)) {
+		const rendered = relationLine(ref, relationName, relation, index);
+		if (rendered !== void 0) lines.set(relationName, rendered);
+	}
+	return lines;
+}
+function discriminatorUnion(base) {
+	const values = Object.values(base.variants ?? {}).map((v) => serializeValue(v.value));
+	return values.length > 0 ? values.join(" | ") : "never";
+}
+function memberLines(ref, index, resolvers) {
+	const base = ref.model.base !== void 0 ? requireBase(index.namespaces, ref, ref.model.base) : void 0;
+	if (base !== void 0 && isPolymorphicBase(base.model)) {
+		const discriminatorField = base.model.discriminator?.field ?? "";
+		const variantValue = base.model.variants?.[ref.modelName]?.value;
+		const discriminatorType = {
+			field: discriminatorField,
+			type: variantValue !== void 0 ? serializeValue(variantValue) : discriminatorUnion(base.model)
+		};
+		return {
+			fieldsByName: new Map([...collectFieldLines(base, resolvers, discriminatorType), ...collectFieldLines(ref, resolvers, void 0)]),
+			relationsByName: new Map([...collectRelationLines(base, index), ...collectRelationLines(ref, index)])
+		};
+	}
+	return {
+		fieldsByName: collectFieldLines(ref, resolvers, isPolymorphicBase(ref.model) ? {
+			field: ref.model.discriminator?.field ?? "",
+			type: discriminatorUnion(ref.model)
+		} : void 0),
+		relationsByName: collectRelationLines(ref, index)
+	};
+}
+function renderMember(memberName, lines, hasOwner) {
+	const entries = [...lines.relationsByName];
+	const joinlessLines = entries.filter(([, r]) => !r.hasJoin).map(([, r]) => r.line);
+	const joinedLines = entries.filter(([, r]) => r.hasJoin).map(([, r]) => r.line);
+	const relationNames = entries.filter(([, r]) => r.hasJoin).map(([name]) => name);
+	const phantom = relationNames.length > 0 ? relationNames.map((name) => serializeValue(name)).join(" | ") : "never";
+	return `  export type ${memberName} = {\n${[
+		...lines.fieldsByName.values(),
+		...joinlessLines,
+		...joinedLines,
+		...hasOwner ? [] : [`readonly [RelationKeys]?: ${phantom};`]
+	].map((line) => `    ${line}`).join("\n")}\n  };`;
+}
+function namespaceModelsOf(contract) {
+	return Object.entries(contract.domain.namespaces).map(([namespaceId, ns]) => ({
+		namespaceId,
+		models: Object.entries(ns.models).map(([modelName, model]) => ({
+			namespaceId,
+			modelName,
+			model
+		}))
+	}));
+}
+function generateModelTypesBlock(contract, resolvers, supportsNamespaces) {
+	const memberNameOf = supportsNamespaces ? namespacedMemberName : bareMemberName;
+	const namespaces = namespaceModelsOf(contract);
+	const index = {
+		namespaces,
+		memberNameOf
+	};
+	const claims = /* @__PURE__ */ new Map();
+	for (const ns of namespaces) for (const ref of ns.models) claimMemberName(claims, memberNameOf(ns.namespaceId, ref.modelName), `${ns.namespaceId}.${ref.modelName}`);
+	for (const ns of namespaces) for (const ref of ns.models) {
+		if (!isPolymorphicBase(ref.model)) continue;
+		claimMemberName(claims, memberNameOf(ns.namespaceId, `Any${ref.modelName}`), `${ns.namespaceId}.Any<${ref.modelName}>`);
+	}
+	const members = [];
+	const constantEntries = [];
+	for (const ns of namespaces) {
+		const keys = [];
+		for (const ref of ns.models) {
+			const memberName = memberNameOf(ns.namespaceId, ref.modelName);
+			members.push(renderMember(memberName, memberLines(ref, index, resolvers), ref.model.owner !== void 0));
+			keys.push(`${serializeObjectKey(ref.modelName)}: Models.${memberName};`);
+		}
+		for (const ref of ns.models) {
+			if (!isPolymorphicBase(ref.model)) continue;
+			const unionName = memberNameOf(ns.namespaceId, `Any${ref.modelName}`);
+			const variantMembers = Object.keys(ref.model.variants ?? {}).map((variantName) => {
+				const variant = requireVariant(namespaces, ref, variantName);
+				return memberNameOf(variant.namespaceId, variant.modelName);
+			});
+			members.push(`  export type ${unionName} = ${variantMembers.length > 0 ? variantMembers.join(" | ") : "never"};`);
+			keys.push(`${serializeObjectKey(`Any${ref.modelName}`)}: Models.${unionName};`);
+		}
+		if (!supportsNamespaces) {
+			constantEntries.push(...keys.map((key) => `  ${key}`));
+			continue;
+		}
+		const nsKey = serializeObjectKey(ns.namespaceId);
+		const nested = keys.map((key) => `    ${key}`).join("\n");
+		constantEntries.push(keys.length > 0 ? `  ${nsKey}: {\n${nested}\n  };` : `  ${nsKey}: {};`);
+	}
+	return `${members.length > 0 ? `export namespace Models {\n${members.join("\n")}\n}` : "export namespace Models {}"}\n\n${`export declare const models: {\n${constantEntries.join("\n")}\n};`}`;
+}
 function generateEnumBlockType(enums) {
 	return `{ ${Object.entries(enums).map(([name, entry]) => {
 		const membersType = `readonly [${entry.members.map((m) => `{ readonly name: ${serializeValue(m.name)}; readonly value: ${serializeValue(m.value)} }`).join(", ")}]`;
@@ -218256,6 +219395,11 @@ function generateContractDts(contract, emitter, codecTypeImports, hashes, option
 	const fieldTypesMaps = generateFieldTypesMapsByNamespace(namespaceEntries.map(([nsId, ns]) => [nsId, ns.models]), codecLookup, resolveFieldTypeParams, resolveFieldValueSet);
 	const extraTypeExports = emitter.getStorageTypeExports?.(contract, codecLookup);
 	const contractWrapper = emitter.getContractWrapper("ContractBase", "TypeMaps");
+	const modelTypesBlock = generateModelTypesBlock(contract, {
+		codecLookup,
+		resolveFieldTypeParams,
+		resolveFieldValueSet
+	}, options?.supportsNamespaces ?? true);
 	return `// ⚠️  GENERATED FILE - DO NOT EDIT
 // This file is automatically generated by 'prisma contract emit'.
 // To regenerate, run: prisma contract emit
@@ -218277,7 +219421,10 @@ ${familyTypeAliases}
 ${valueObjectTypeAliases}
 export type FieldOutputTypes = ${fieldTypesMaps.output};
 export type FieldInputTypes = ${fieldTypesMaps.input};
-${extraTypeExports ? `${extraTypeExports}\n` : ""}export type TypeMaps = ${typeMapsExpr};
+${extraTypeExports ? `${extraTypeExports}\n` : ""}
+${modelTypesBlock}
+
+export type TypeMaps = ${typeMapsExpr};
 
 type ContractBase = Omit<
   ContractType<${storageType}>,
@@ -218301,9 +219448,29 @@ ${domainNamespacesType};
 ${contractWrapper}
 `;
 }
+/**
+* The emitter only ever consumes a freshly authored contract, so every same-space to-one relation
+* must already state whether it is nullable. Hydration of an on-disk contract derives a missing
+* flag instead; that path never reaches here.
+*/
+function requireToOneRelationNullability(contract) {
+	for (const [namespaceId, namespace] of Object.entries(contract.domain.namespaces)) for (const [modelName, model] of Object.entries(namespace.models)) for (const [relationName, relation] of Object.entries(model.relations ?? {})) {
+		if (!("on" in relation && (relation.cardinality === "1:1" || relation.cardinality === "N:1") && relation.to.space === void 0) || typeof relation.nullable === "boolean") continue;
+		throw emitterError("CONTRACT.RELATION_INVALID", `Relation "${relationName}" on model "${namespaceId}:${modelName}" is a ${relation.cardinality} relation and must carry a boolean "nullable"`, {
+			why: "contract.d.ts types a to-one relation as nullable or required from this flag, and the authoring surfaces always set it.",
+			fix: "Author the contract through PSL or the contract builder, which derive the flag from the local fields the relation joins on.",
+			meta: {
+				modelName,
+				relationName,
+				reason: "to-one-nullability-missing"
+			}
+		});
+	}
+}
 const SCHEMA_VERSION = "1";
 async function emit(contract, stack, targetFamily, options) {
 	if (options.outputJsonPath !== void 0) getEmittedArtifactPaths(options.outputJsonPath);
+	requireToOneRelationNullability(contract);
 	const { codecTypeImports, queryOperationTypeImports, aggregateDescriptors, codecDescriptors } = stack;
 	const { storageHash } = contract.storage;
 	const executionHash = contract.execution?.executionHash;
@@ -218325,7 +219492,8 @@ async function emit(contract, stack, targetFamily, options) {
 	const generateOptions = {
 		...ifDefined("queryOperationTypeImports", queryOperationTypeImports),
 		...ifDefined("aggregateDescriptors", aggregateDescriptors),
-		...ifDefined("codecDescriptors", codecDescriptors)
+		...ifDefined("codecDescriptors", codecDescriptors),
+		...ifDefined("supportsNamespaces", options.supportsNamespaces)
 	};
 	const contractTypeHashes = {
 		storageHash,
@@ -218689,7 +219857,7 @@ function isControlPolicy(value) {
 * This is the precondition for advancing a contract space's marker without
 * any migrations (the declared-state resolution the db-init aggregate
 * planner and `migrate` share): only when nothing in the space is
-* Prisma-Next-managed can the storage structure be correct without a
+* Prisma 8-managed can the storage structure be correct without a
 * migration having produced it. Any space that declares a managed element
 * but ships no migration graph is an authoring bug and must fail loudly.
 */
@@ -220867,7 +222035,7 @@ function buildPathNotFoundFailure(spaceId, marker, targetHash) {
 	};
 }
 /**
-* Creates a programmatic control client for Prisma Next operations.
+* Creates a programmatic control client for Prisma ORM operations.
 *
 * The client accepts framework component descriptors at creation time,
 * manages driver lifecycle via connect()/close(), and exposes domain
@@ -221355,7 +222523,10 @@ var ControlClientImpl = class {
 					meta: void 0
 				});
 			}
-			const result = await emit(deserializedContract, this.stack, this.options.family.emission, { serializeContract: (contract) => this.options.target.contractSerializer.serializeContract(contract) });
+			const result = await emit(deserializedContract, this.stack, this.options.family.emission, {
+				serializeContract: (contract) => this.options.target.contractSerializer.serializeContract(contract),
+				...ifDefined("supportsNamespaces", this.options.target.supportsNamespaces)
+			});
 			onProgress?.({
 				action: "emit",
 				kind: "spanEnd",
@@ -221403,7 +222574,7 @@ function createPostgresControlClient(options = {}) {
 		...ifDefined("extensions", options.extensions)
 	});
 }
-var version = "0.18.0-dev.1";
+var version = "0.18.0-dev.2";
 var migration_default = {
 	from: null,
 	to: "9e4dbceec6522a4ffb997dfe82c437de70264962803f6a2c63eb196281232b32",