@prisma/orm-family-sql 8.0.0-rc.1-dev.44 → 8.0.0-rc.1-dev.46

package/dist/{expression-Q_yaDQPb.d.mts → expression-FJK6Ar-d.d.mts}

@@ -1,7 +1,11 @@
+import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
 import { S as QueryOperationReturn } from "./types-BDUG29Df-LE85dIXP.mjs";
 import "./types-UcHa2cTe.mjs";
 import { t as SqlLoweringSpec } from "./index-C5I8D-MB.mjs";
-import { Ct as RawSqlLiteral, T as CodecRef$1, _t as ParamRef, s as AnyExpression } from "./types-DH6Sqzxu-DfzaLX0o.mjs";
+import { St as RawQueryAst, T as CodecRef$1, Tt as RawSqlLiteral, _t as ParamRef, s as AnyExpression } from "./types-v3qxLLxo-DCeKv7yY.mjs";
+import { l as SqlStatementStats } from "./driver-types-BQtRkOJ0-Bv2RPSfr.mjs";
+import { t as SqlQueryPlan } from "./plan-CDxduYaN-pLIyyJaB.mjs";
+import { Contract } from "@prisma/orm-framework/contract/types";
 import { ParamSpec } from "@prisma/orm-framework/operations";
 //#region ../../../2-sql/4-lanes/relational-core/dist/exports/expression.d.mts
 //#region src/expression.d.ts
@@ -152,15 +156,102 @@ interface RawSqlBuilder {
     nullable: N;
   }>;
 }
+/**
+ * One column of a raw query's declared result row, as authored: a codec id, or
+ * a codec id plus nullability. Mirrors the contract-free lane's
+ * `ColumnDescriptor`; contract-column references are sugar layered on top of
+ * this form by the contract-typed builder.
+ */
+type RawRowSpecEntry = string | {
+  readonly codecId: string;
+  readonly nullable?: boolean;
+};
+/**
+ * Declares the one column name a row spec cannot use. TypeScript types
+ * `{ __proto__: 'pg/int4@1' }` and `{ ['__proto__']: 'pg/int4@1' }` alike — as
+ * a spec with a `__proto__` column — while JavaScript keeps the key in neither
+ * object. Rejecting the name here is what makes the two agree; the AST refuses
+ * the computed form again at runtime, where it does arrive.
+ */
+type NoReservedRowColumn = {
+  readonly __proto__?: 'A raw row spec cannot declare a __proto__ column: alias the column in SQL and declare the alias instead';
+};
+/** The declared result row of a raw query: result-column name to codec. */
+type RawRowSpec = Readonly<Record<string, RawRowSpecEntry>> & NoReservedRowColumn;
+/**
+ * Row type minted for a {@link RawRowSpec}. Column names carry through; the
+ * per-column JS type is `unknown` here, where codec ids are opaque strings —
+ * the contract-typed builder resolves them against the contract's codec map.
+ */
+type RawRow<Spec extends RawRowSpec> = { readonly [K in keyof Spec]: unknown; };
+/**
+ * What a raw statement needs in order to mint a plan: the contract the plan's
+ * metadata is sourced from, and the lane the plan is tagged with.
+ */
+interface RawPlanContext {
+  readonly contract: Contract<SqlStorage>;
+  readonly laneId?: string;
+}
+/**
+ * A raw query that returns rows, terminated by `.returnsRow(spec)`.
+ *
+ * Row-returning raw queries are embeddable: interpolating one into another raw
+ * template splices its parts in, which is what makes derived tables and CTEs
+ * (including data-modifying CTEs, whose `RETURNING` is what earns them a row
+ * spec) expressible.
+ */
+interface RawRowQuery<Row = unknown> {
+  buildAst(): RawQueryAst;
+  build(): SqlQueryPlan<Row>;
+}
+declare const affectedCountResult: unique symbol;
+/**
+ * The row type of a plan that reports how many rows a statement affected.
+ *
+ * The brand is what a consumer keys on to tell such a plan from one that
+ * returns rows: the statistics shape alone cannot carry that meaning, because
+ * a row spec is free to declare a column named `affectedRows`. Nothing holds
+ * the brand at runtime — `_row` is phantom — so declaring it required costs
+ * nothing and makes the claim unforgeable by coincidence.
+ */
+interface AffectedCount extends SqlStatementStats {
+  readonly [affectedCountResult]: true;
+}
+/**
+ * A raw statement that reports how many rows it affected, terminated by
+ * `.affectedCount()`. It is not an expression and carries no row spec, so it
+ * is not embeddable — a mutation reaches expression position only through
+ * `RETURNING` and `.returnsRow()`.
+ */
+interface RawAffectedCountQuery {
+  build(): SqlQueryPlan<AffectedCount>;
+}
+/**
+ * The builder returned by a raw template that can also terminate in statement
+ * position. `returns*` terminators yield something usable where expressions
+ * go; `.affectedCount()` yields a plan handle only.
+ */
+interface RawSqlStatementBuilder extends RawSqlBuilder {
+  returnsRow<Spec extends RawRowSpec>(spec: Spec): RawRowQuery<RawRow<Spec>>;
+  affectedCount(): RawAffectedCountQuery;
+}
 /** Tagged-template function returned by {@link createRawSql}. */
 type RawSqlTag = (strings: TemplateStringsArray, ...values: RawSqlInterpolation[]) => RawSqlBuilder;
-type RawSqlInterpolation = Expression<ScopeField> | ParamRef | RawSqlLiteral;
+/** Tagged-template function returned by {@link createRawSql} when given a {@link RawPlanContext}. */
+type RawSqlStatementTag = (strings: TemplateStringsArray, ...values: RawSqlInterpolation[]) => RawSqlStatementBuilder;
+/** Interpolations that occupy a single position in the parts list. */
+type RawExprInterpolation = Expression<ScopeField> | ParamRef | RawSqlLiteral;
+/** Interpolations a raw template accepts; a {@link RawRowQuery} splices its own parts in. */
+type RawSqlInterpolation = RawExprInterpolation | RawRowQuery;
 /**
- * Create a tagged-template builder for raw SQL expressions. The returned tag accepts SQL string fragments interleaved with typed {@link Expression}, {@link ParamRef}, or bare {@link RawSqlLiteral} interpolations. Call `.returns(spec)` on the result to obtain a typed {@link Expression} whose AST is a {@link RawExpr}.
+ * Create a tagged-template builder for raw SQL. The returned tag accepts SQL string fragments interleaved with typed {@link Expression}, {@link ParamRef}, row-returning {@link RawRowQuery}, or bare {@link RawSqlLiteral} interpolations. Call `.returns(spec)` on the result to obtain a typed {@link Expression} whose AST is a {@link RawExpr}.
+ *
+ * Supplied with a {@link RawPlanContext}, the tag also terminates in statement position: `.returnsRow(spec)` and `.affectedCount()` mint a {@link SqlQueryPlan} whose AST is a {@link RawQueryAst}. The context is stated once, here, so authoring sites carry nothing but the template and its terminator.
  *
  * Bare {@link RawSqlLiteral} interpolations are wrapped as `ParamRef` nodes with the codec resolved via `adapter.inferCodec(value)`. Use {@link param} when the codec cannot be inferred from the value alone (e.g. `Date`).
  */
+declare function createRawSql(adapter: RawCodecInferer, planContext: RawPlanContext): RawSqlStatementTag;
 declare function createRawSql(adapter: RawCodecInferer): RawSqlTag;
 //#endregion
-export { Expression as a, RawSqlTag as c, TraitExpression as d, buildOperation as f, toExpr as g, param as h, CodecValue as i, ScalarListExpression as l, createRawSql as m, CodecExpression as n, RawCodecInferer as o, codecOf as p, CodecTypesBase as r, RawSqlBuilder as s, BuildOperationSpec as t, ScopeField as u };
-//# sourceMappingURL=expression-Q_yaDQPb.d.mts.map
+export { buildOperation as C, toExpr as D, param as E, TraitExpression as S, createRawSql as T, RawSqlStatementBuilder as _, CodecValue as a, ScalarListExpression as b, RawAffectedCountQuery as c, RawRow as d, RawRowQuery as f, RawSqlInterpolation as g, RawSqlBuilder as h, CodecTypesBase as i, RawCodecInferer as l, RawRowSpecEntry as m, BuildOperationSpec as n, Expression as o, RawRowSpec as p, CodecExpression as r, NoReservedRowColumn as s, AffectedCount as t, RawPlanContext as u, RawSqlStatementTag as v, codecOf as w, ScopeField as x, RawSqlTag as y };
+//# sourceMappingURL=expression-FJK6Ar-d.d.mts.map

package/dist/expression-FJK6Ar-d.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expression-FJK6Ar-d.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/exports/expression.d.mts"],"mappings":";;;;;;;;;;;KAQK;EACH;EACA;;;;;;;;EAQA;;;;EAIA,QAAQ;;KAEL,iBAAiB;WACX;WACA;;;;;KAKN,WAAW,UAAU,cAAc;WAC7B,YAAY;EACrB,YAAY;;KAET,kBAAkB,WAAW;WACvB;IACP,+CAA+C,WAAW,cAAc,GAAG;WACpE,cAAc;KACpB,iCAAiC,KAAK,2BAA2B;KACjE,WAAW,KAAK;;;;;KAKhB,WAAW,wBAAwB,0BAA0B,WAAW;WAClE;OACJ,sBAAsB,KAAK,GAAG,6BAA6B,WAAW;;;;;;;;;;;;;;;KAexE,gBAAgB,wBAAwB,0BAA0B,WAAW;WACvE;MACL;EACJ,SAAS;EACT,UAAU;EACV;KACG,WAAW,SAAS,UAAU;;;;;;;KAO9B,qBAAqB,wBAAwB,4BAA4B;EAC5E,SAAS;EACT,UAAU;EACV;;;;;;;KAOG,gBAAgB,kCAAkC,0BAA0B,WAAW;WACjF;MACL,gBAAgB,kBAAkB,IAAI,SAAS,UAAU;;;;;;;;iBAQ9C,OAAO,gBAAgB,QAAQ,aAAW;;;;iBAI1C,MAAM,GAAG,OAAO,GAAG;EAClC;IACE;;;;;;;;;;;iBAWa,QAAQ,iBAAiB;UAChC,mBAAmB,UAAU;WAC5B;;;;WAIA,gBAAgB,kBAAkB;WAClC,SAAS,IAAI;WACb,UAAU;;;;;iBAKJ,eAAe,UAAU,YAAY,MAAM,mBAAmB,KAAK,WAAW;;;;;;;;;;;;;UAarF;EACR,WAAW,OAAO;;;UAGV;EACR,QAAQ,kBAAkB,MAAM,IAAI;IAClC,SAAS;IACT;;EAEF,QAAQ,kBAAkB,2BAA2B;aAC1C,SAAS;aACT,WAAW;MAClB;IACF,SAAS;IACT,UAAU;;;;;;;;;KAST;WACM;WACA;;;;;;;;;KASN;WACM;;;KAGN,aAAa,SAAS,eAAe,oBAAoB;;;;;;KAMzD,OAAO,aAAa,0BAA0B,WAAW;;;;;UAKpD;WACC,UAAU,SAAS;WACnB;;;;;;;;;;UAUD,YAAY;EACpB,YAAY;EACZ,SAAS,aAAa;;cAEV;;;;;;;;;;UAUJ,sBAAsB;YACpB;;;;;;;;UAQF;EACR,SAAS,aAAa;;;;;;;UAOd,+BAA+B;EACvC,WAAW,aAAa,YAAY,MAAM,OAAO,YAAY,OAAO;EACpE,iBAAiB;;;KAGd,aAAa,SAAS,yBAAyB,QAAQ,0BAA0B;;KAEjF,sBAAsB,SAAS,yBAAyB,QAAQ,0BAA0B;;KAE1F,uBAAuB,WAAW,cAAc,WAAW;;KAE3D,sBAAsB,uBAAuB;;;;;;;;iBAQjC,aAAa,SAAS,iBAAiB,aAAa,iBAAiB;iBACrE,aAAa,SAAS,kBAAkB"}

package/dist/family.d.mts

@@ -1,13 +1,13 @@
 import { n as resolveStorageTable, t as ResolvedStorageTable } from "./resolve-storage-table-Nyrgk4h8.mjs";
-import { i as SqlControlAdapter, n as Lowerer, o as arraysEqual, r as NativeTypeNormalizer, t as ExecuteRequestLowerer } from "./control-adapter-C99J7aEF-Vx9xXYOy.mjs";
-import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, D as SqlPlannerConflictLocation, E as SqlPlannerConflictKind, O as SqlPlannerFailureResult, S as SqlMigrationRunnerResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, a as FieldEvent, b as SqlMigrationRunnerExecuteOptions, c as SqlControlAdapterDescriptor, d as SqlMigrationPlanContractInfo, f as SqlMigrationPlanOperation, g as SqlMigrationPlannerPlanOptions, h as SqlMigrationPlanner, i as ExpandNativeTypeInput, j as StorageTypePlanResult, k as SqlPlannerResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationTarget, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperationStep, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, w as SqlPlanTargetDetails, x as SqlMigrationRunnerFailure, y as SqlMigrationRunnerExecuteCallbacks } from "./types-IqZMLrFC-B0YziCVx.mjs";
+import { i as SqlControlAdapter, n as Lowerer, o as arraysEqual, r as NativeTypeNormalizer, t as ExecuteRequestLowerer } from "./control-adapter-C99J7aEF-B7eQd7vD.mjs";
+import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, D as SqlPlannerConflictLocation, E as SqlPlannerConflictKind, O as SqlPlannerFailureResult, S as SqlMigrationRunnerResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, a as FieldEvent, b as SqlMigrationRunnerExecuteOptions, c as SqlControlAdapterDescriptor, d as SqlMigrationPlanContractInfo, f as SqlMigrationPlanOperation, g as SqlMigrationPlannerPlanOptions, h as SqlMigrationPlanner, i as ExpandNativeTypeInput, j as StorageTypePlanResult, k as SqlPlannerResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationTarget, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperationStep, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, w as SqlPlanTargetDetails, x as SqlMigrationRunnerFailure, y as SqlMigrationRunnerExecuteCallbacks } from "./types-IqZMLrFC-DcH8v_u3.mjs";
 import { n as SqlSchemaDiffInput, r as SqlSchemaDiffResult, t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-DFAtGezx.mjs";
-import { A as partitionCallsByControlPolicy, B as timestampNowControlDescriptor, C as buildNativeTypeExpander, D as createMigrationPlan, E as controlPolicyForCall, F as runnerFailure, I as runnerSuccess, L as temporalAuthoringPresets, M as planFieldEventOperations, N as plannerFailure, O as detectDestructiveChanges, P as plannerSuccess, R as temporalCodecPreset, S as assembleAuthoringContributions, T as contractToSchemaIR, _ as SqlControlTargetDescriptor, a as EnumNamespaceSchemaResolver, b as TargetMigrationsCapability, c as MigrationOperationPolicy, d as MigrationPlanner, f as MigrationPlannerConflict, g as SqlControlFamilyInstance, h as PlanFieldEventOperationsOptions, i as DefaultResolver, j as partitionIssuesByControlPolicy, k as extractCodecControlHooks, l as MigrationPlan, m as NativeTypeExpander, n as ControlPolicySubject, o as INIT_ADDITIVE_POLICY, p as MigrationPlannerResult, r as DefaultRenderer, s as MigrationOperationClass, t as ContractToSchemaIROptions, u as MigrationPlanOperation, v as SqlDescribedContractSpace, w as contractNamespaceToSchemaIR, y as SuppressionRecord, z as temporalCodecPresetWithPrecision } from "./control-DssujEJW.mjs";
-import "./control-adapter-CLID4Q6Z.mjs";
-import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-pl1Xal4J.mjs";
+import { A as partitionCallsByControlPolicy, B as timestampNowControlDescriptor, C as buildNativeTypeExpander, D as createMigrationPlan, E as controlPolicyForCall, F as runnerFailure, I as runnerSuccess, L as temporalAuthoringPresets, M as planFieldEventOperations, N as plannerFailure, O as detectDestructiveChanges, P as plannerSuccess, R as temporalCodecPreset, S as assembleAuthoringContributions, T as contractToSchemaIR, _ as SqlControlTargetDescriptor, a as EnumNamespaceSchemaResolver, b as TargetMigrationsCapability, c as MigrationOperationPolicy, d as MigrationPlanner, f as MigrationPlannerConflict, g as SqlControlFamilyInstance, h as PlanFieldEventOperationsOptions, i as DefaultResolver, j as partitionIssuesByControlPolicy, k as extractCodecControlHooks, l as MigrationPlan, m as NativeTypeExpander, n as ControlPolicySubject, o as INIT_ADDITIVE_POLICY, p as MigrationPlannerResult, r as DefaultRenderer, s as MigrationOperationClass, t as ContractToSchemaIROptions, u as MigrationPlanOperation, v as SqlDescribedContractSpace, w as contractNamespaceToSchemaIR, y as SuppressionRecord, z as temporalCodecPresetWithPrecision } from "./control-DTLJ1WtZ.mjs";
+import "./control-adapter-MZJQiwcE.mjs";
+import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-DbTNVm2f.mjs";
 import { i as SqlSchemaVerifierBase, n as SqlContractSerializerBase, r as SqlEntityHydrationFactory, t as SqlContractSerializer } from "./ir-Bghjt-FG.mjs";
-import { t as SqlMigration } from "./migration-CGlaINey.mjs";
+import { t as SqlMigration } from "./migration-CjDRZNep.mjs";
 import { _ as toEnumMemberName, a as PslPrinterOptions, b as toModelName, c as PslTypeResolution, d as deriveBackRelationFieldName, f as deriveRelationFieldName, g as pluralize, h as parseRawDefault, i as InferredRelations, l as RelationField, m as mapDefault, n as DefaultMappingResult, o as PslTypeMap, p as inferRelations, r as EnumInfo, s as PslTypeReference, t as DefaultMappingOptions, u as buildChildRelationField, v as toEnumName, y as toFieldName } from "./psl-infer-CCAD6FWA.mjs";
-import { a as timestampNowRuntimeGenerator, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-cPrAp99G.mjs";
+import { a as timestampNowRuntimeGenerator, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-DpKF2Yu2.mjs";
 import { n as parseContractMarkerRow, t as ContractMarkerRow } from "./verify-zDRnw0Rn.mjs";
 export { type CodecControlHooks, type ContractMarkerRow, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultMappingOptions, type DefaultMappingResult, type DefaultRenderer, type DefaultResolver, type EnumInfo, type EnumNamespaceSchemaResolver, type ExecuteRequestLowerer, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type InferredRelations, type Lowerer, SqlMigration as Migration, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type NativeTypeExpander, type NativeTypeNormalizer, type PlanFieldEventOperationsOptions, type PslPrinterOptions, type PslTypeMap, type PslTypeReference, type PslTypeResolution, type RelationField, type ResolveIdentityValueInput, type ResolvedDomainModel, type ResolvedStorageTable, SqlContractSerializer, SqlContractSerializerBase, type SqlControlAdapter, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlDescribedContractSpace, type SqlDiffVerdict, type SqlDiffVerdictInput, type SqlEntityHydrationFactory, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type SqlSchemaDiffFn, type SqlSchemaDiffInput, type SqlSchemaDiffResult, SqlSchemaVerifierBase, type StorageTypePlanResult, type StorageTypeVerdict, type StorageTypeVerdictInput, type SuppressionRecord, type TargetMigrationsCapability, UNBOUND_DOMAIN_NAMESPACE_ID, type VerifySqlSchemaByDiffInput, arraysEqual, assembleAuthoringContributions, buildChildRelationField, buildNativeTypeExpander, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, deriveBackRelationFieldName, deriveRelationFieldName, detectDestructiveChanges, extractCodecControlHooks, inferRelations, mapDefault, parseContractMarkerRow, parseRawDefault, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, pluralize, resolveDomainModel, resolveStorageTable, runnerFailure, runnerSuccess, temporalAuthoringPresets, temporalCodecPreset, temporalCodecPresetWithPrecision, timestampNowControlDescriptor, timestampNowRuntimeGenerator, toEnumMemberName, toEnumName, toFieldName, toModelName, verifySqlSchemaByDiff };

package/dist/family.mjs

@@ -3,10 +3,10 @@ import { a as computeStorageTypeVerdict, i as computeSqlDiffVerdict, n as classi
 import { n as SqlContractSerializerBase, t as SqlContractSerializer } from "./sql-contract-serializer-2oBWuxTe-DKZTf2n8.mjs";
 import { n as parseContractMarkerRow } from "./verify-u0UTdZgD-DSAaz9rW.mjs";
 import { a as timestampNowControlDescriptor, i as temporalCodecPresetWithPrecision, n as temporalAuthoringPresets, r as temporalCodecPreset } from "./timestamp-now-generator-DRXygu32-DN9Qb1uI.mjs";
-import { a as contractToSchemaIR, c as createMigrationPlan, d as partitionIssuesByControlPolicy, f as planFieldEventOperations, g as runnerSuccess, h as runnerFailure, i as contractNamespaceToSchemaIR, l as detectDestructiveChanges, m as plannerSuccess, n as assembleAuthoringContributions, o as controlPolicyForCall, p as plannerFailure, r as buildNativeTypeExpander, t as INIT_ADDITIVE_POLICY, u as partitionCallsByControlPolicy } from "./control-DAkNosoF.mjs";
+import { a as contractToSchemaIR, c as createMigrationPlan, d as partitionIssuesByControlPolicy, f as planFieldEventOperations, g as runnerSuccess, h as runnerFailure, i as contractNamespaceToSchemaIR, l as detectDestructiveChanges, m as plannerSuccess, n as assembleAuthoringContributions, o as controlPolicyForCall, p as plannerFailure, r as buildNativeTypeExpander, t as INIT_ADDITIVE_POLICY, u as partitionCallsByControlPolicy } from "./control-D3cB5YQp.mjs";
 import { t as arraysEqual } from "./diff-B16bL_IR.mjs";
 import { t as SqlSchemaVerifierBase } from "./ir-I-xciGUH.mjs";
 import { t as SqlMigration } from "./migration-CK4oePIo.mjs";
-import { a as mapDefault, c as toEnumMemberName, d as toModelName, i as inferRelations, l as toEnumName, n as deriveBackRelationFieldName, o as parseRawDefault, r as deriveRelationFieldName, s as pluralize, t as buildChildRelationField, u as toFieldName } from "./psl-infer-YhbKkybN.mjs";
+import { a as mapDefault, c as toEnumMemberName, d as toModelName, i as inferRelations, l as toEnumName, n as deriveBackRelationFieldName, o as parseRawDefault, r as deriveRelationFieldName, s as pluralize, t as buildChildRelationField, u as toFieldName } from "./psl-infer-Dk5kgKre.mjs";
 import { i as timestampNowRuntimeGenerator, n as resolveDomainModel, t as UNBOUND_DOMAIN_NAMESPACE_ID } from "./runtime-tIHpGCcG.mjs";
 export { INIT_ADDITIVE_POLICY, SqlMigration as Migration, SqlContractSerializer, SqlContractSerializerBase, SqlSchemaVerifierBase, UNBOUND_DOMAIN_NAMESPACE_ID, arraysEqual, assembleAuthoringContributions, buildChildRelationField, buildNativeTypeExpander, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, deriveBackRelationFieldName, deriveRelationFieldName, detectDestructiveChanges, extractCodecControlHooks, inferRelations, mapDefault, parseContractMarkerRow, parseRawDefault, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, pluralize, resolveDomainModel, resolveStorageTable, runnerFailure, runnerSuccess, temporalAuthoringPresets, temporalCodecPreset, temporalCodecPresetWithPrecision, timestampNowControlDescriptor, timestampNowRuntimeGenerator, toEnumMemberName, toEnumName, toFieldName, toModelName, verifySqlSchemaByDiff };

package/dist/family__control-adapter.d.mts

@@ -1,3 +1,3 @@
-import { a as SqlControlAdapterDescriptor, i as SqlControlAdapter, n as Lowerer, t as ExecuteRequestLowerer } from "./control-adapter-C99J7aEF-Vx9xXYOy.mjs";
-import "./control-adapter-CLID4Q6Z.mjs";
+import { a as SqlControlAdapterDescriptor, i as SqlControlAdapter, n as Lowerer, t as ExecuteRequestLowerer } from "./control-adapter-C99J7aEF-B7eQd7vD.mjs";
+import "./control-adapter-MZJQiwcE.mjs";
 export type { ExecuteRequestLowerer, Lowerer, SqlControlAdapter, SqlControlAdapterDescriptor };

package/dist/family__control.d.mts

@@ -1,4 +1,4 @@
-import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, D as SqlPlannerConflictLocation, E as SqlPlannerConflictKind, O as SqlPlannerFailureResult, S as SqlMigrationRunnerResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, a as FieldEvent, b as SqlMigrationRunnerExecuteOptions, c as SqlControlAdapterDescriptor, d as SqlMigrationPlanContractInfo, f as SqlMigrationPlanOperation, g as SqlMigrationPlannerPlanOptions, h as SqlMigrationPlanner, i as ExpandNativeTypeInput, j as StorageTypePlanResult, k as SqlPlannerResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationTarget, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperationStep, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, w as SqlPlanTargetDetails, x as SqlMigrationRunnerFailure, y as SqlMigrationRunnerExecuteCallbacks } from "./types-IqZMLrFC-B0YziCVx.mjs";
+import { A as SqlPlannerSuccessResult, C as SqlMigrationRunnerSuccessValue, D as SqlPlannerConflictLocation, E as SqlPlannerConflictKind, O as SqlPlannerFailureResult, S as SqlMigrationRunnerResult, T as SqlPlannerConflict, _ as SqlMigrationRunner, a as FieldEvent, b as SqlMigrationRunnerExecuteOptions, c as SqlControlAdapterDescriptor, d as SqlMigrationPlanContractInfo, f as SqlMigrationPlanOperation, g as SqlMigrationPlannerPlanOptions, h as SqlMigrationPlanner, i as ExpandNativeTypeInput, j as StorageTypePlanResult, k as SqlPlannerResult, l as SqlControlExtensionDescriptor, m as SqlMigrationPlanOperationTarget, n as CodecControlHooks, o as FieldEventContext, p as SqlMigrationPlanOperationStep, r as CreateSqlMigrationPlanOptions, s as ResolveIdentityValueInput, u as SqlMigrationPlan, v as SqlMigrationRunnerErrorCode, w as SqlPlanTargetDetails, x as SqlMigrationRunnerFailure, y as SqlMigrationRunnerExecuteCallbacks } from "./types-IqZMLrFC-DcH8v_u3.mjs";
 import { n as SqlSchemaDiffInput, r as SqlSchemaDiffResult, t as SqlSchemaDiffFn } from "./schema-differ-DpG_gnur-DFAtGezx.mjs";
-import { A as partitionCallsByControlPolicy, B as timestampNowControlDescriptor, C as buildNativeTypeExpander, D as createMigrationPlan, E as controlPolicyForCall, F as runnerFailure, I as runnerSuccess, L as temporalAuthoringPresets, M as planFieldEventOperations, N as plannerFailure, O as detectDestructiveChanges, P as plannerSuccess, R as temporalCodecPreset, S as assembleAuthoringContributions, T as contractToSchemaIR, _ as SqlControlTargetDescriptor, a as EnumNamespaceSchemaResolver, b as TargetMigrationsCapability, c as MigrationOperationPolicy, d as MigrationPlanner, f as MigrationPlannerConflict, g as SqlControlFamilyInstance, h as PlanFieldEventOperationsOptions, i as DefaultResolver, j as partitionIssuesByControlPolicy, k as extractCodecControlHooks, l as MigrationPlan, m as NativeTypeExpander, n as ControlPolicySubject, o as INIT_ADDITIVE_POLICY, p as MigrationPlannerResult, r as DefaultRenderer, s as MigrationOperationClass, t as ContractToSchemaIROptions, u as MigrationPlanOperation, v as SqlDescribedContractSpace, w as contractNamespaceToSchemaIR, x as _default, y as SuppressionRecord, z as temporalCodecPresetWithPrecision } from "./control-DssujEJW.mjs";
+import { A as partitionCallsByControlPolicy, B as timestampNowControlDescriptor, C as buildNativeTypeExpander, D as createMigrationPlan, E as controlPolicyForCall, F as runnerFailure, I as runnerSuccess, L as temporalAuthoringPresets, M as planFieldEventOperations, N as plannerFailure, O as detectDestructiveChanges, P as plannerSuccess, R as temporalCodecPreset, S as assembleAuthoringContributions, T as contractToSchemaIR, _ as SqlControlTargetDescriptor, a as EnumNamespaceSchemaResolver, b as TargetMigrationsCapability, c as MigrationOperationPolicy, d as MigrationPlanner, f as MigrationPlannerConflict, g as SqlControlFamilyInstance, h as PlanFieldEventOperationsOptions, i as DefaultResolver, j as partitionIssuesByControlPolicy, k as extractCodecControlHooks, l as MigrationPlan, m as NativeTypeExpander, n as ControlPolicySubject, o as INIT_ADDITIVE_POLICY, p as MigrationPlannerResult, r as DefaultRenderer, s as MigrationOperationClass, t as ContractToSchemaIROptions, u as MigrationPlanOperation, v as SqlDescribedContractSpace, w as contractNamespaceToSchemaIR, x as _default, y as SuppressionRecord, z as temporalCodecPresetWithPrecision } from "./control-DTLJ1WtZ.mjs";
 export { type CodecControlHooks, type ContractToSchemaIROptions, type ControlPolicySubject, type CreateSqlMigrationPlanOptions, type DefaultRenderer, type DefaultResolver, type EnumNamespaceSchemaResolver, type ExpandNativeTypeInput, type FieldEvent, type FieldEventContext, INIT_ADDITIVE_POLICY, type MigrationOperationClass, type MigrationOperationPolicy, type MigrationPlan, type MigrationPlanOperation, type MigrationPlanner, type MigrationPlannerConflict, type MigrationPlannerResult, type NativeTypeExpander, type PlanFieldEventOperationsOptions, type ResolveIdentityValueInput, type SqlControlAdapterDescriptor, type SqlControlExtensionDescriptor, type SqlControlFamilyInstance, type SqlControlTargetDescriptor, type SqlDescribedContractSpace, type SqlMigrationPlan, type SqlMigrationPlanContractInfo, type SqlMigrationPlanOperation, type SqlMigrationPlanOperationStep, type SqlMigrationPlanOperationTarget, type SqlMigrationPlanner, type SqlMigrationPlannerPlanOptions, type SqlMigrationRunner, type SqlMigrationRunnerErrorCode, type SqlMigrationRunnerExecuteCallbacks, type SqlMigrationRunnerExecuteOptions, type SqlMigrationRunnerFailure, type SqlMigrationRunnerResult, type SqlMigrationRunnerSuccessValue, type SqlPlanTargetDetails, type SqlPlannerConflict, type SqlPlannerConflictKind, type SqlPlannerConflictLocation, type SqlPlannerFailureResult, type SqlPlannerResult, type SqlPlannerSuccessResult, type SqlSchemaDiffFn, type SqlSchemaDiffInput, type SqlSchemaDiffResult, type StorageTypePlanResult, type SuppressionRecord, type TargetMigrationsCapability, assembleAuthoringContributions, buildNativeTypeExpander, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, _default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, temporalCodecPreset, temporalCodecPresetWithPrecision, timestampNowControlDescriptor };

package/dist/family__control.mjs

@@ -1,4 +1,4 @@
 import { o as extractCodecControlHooks } from "./schema-verify-C_PEdlAr-Dxxjm6EM.mjs";
 import { a as timestampNowControlDescriptor, i as temporalCodecPresetWithPrecision, n as temporalAuthoringPresets, r as temporalCodecPreset } from "./timestamp-now-generator-DRXygu32-DN9Qb1uI.mjs";
-import { a as contractToSchemaIR, c as createMigrationPlan, d as partitionIssuesByControlPolicy, f as planFieldEventOperations, g as runnerSuccess, h as runnerFailure, i as contractNamespaceToSchemaIR, l as detectDestructiveChanges, m as plannerSuccess, n as assembleAuthoringContributions, o as controlPolicyForCall, p as plannerFailure, r as buildNativeTypeExpander, s as control_default, t as INIT_ADDITIVE_POLICY, u as partitionCallsByControlPolicy } from "./control-DAkNosoF.mjs";
+import { a as contractToSchemaIR, c as createMigrationPlan, d as partitionIssuesByControlPolicy, f as planFieldEventOperations, g as runnerSuccess, h as runnerFailure, i as contractNamespaceToSchemaIR, l as detectDestructiveChanges, m as plannerSuccess, n as assembleAuthoringContributions, o as controlPolicyForCall, p as plannerFailure, r as buildNativeTypeExpander, s as control_default, t as INIT_ADDITIVE_POLICY, u as partitionCallsByControlPolicy } from "./control-D3cB5YQp.mjs";
 export { INIT_ADDITIVE_POLICY, assembleAuthoringContributions, buildNativeTypeExpander, contractNamespaceToSchemaIR, contractToSchemaIR, controlPolicyForCall, createMigrationPlan, control_default as default, detectDestructiveChanges, extractCodecControlHooks, partitionCallsByControlPolicy, partitionIssuesByControlPolicy, planFieldEventOperations, plannerFailure, plannerSuccess, runnerFailure, runnerSuccess, temporalAuthoringPresets, temporalCodecPreset, temporalCodecPresetWithPrecision, timestampNowControlDescriptor };

package/dist/family__diff.d.mts

@@ -1,3 +1,3 @@
-import { o as arraysEqual, r as NativeTypeNormalizer } from "./control-adapter-C99J7aEF-Vx9xXYOy.mjs";
-import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-pl1Xal4J.mjs";
+import { o as arraysEqual, r as NativeTypeNormalizer } from "./control-adapter-C99J7aEF-B7eQd7vD.mjs";
+import { a as VerifySqlSchemaByDiffInput, c as computeSqlDiffVerdict, i as StorageTypeVerdictInput, l as computeStorageTypeVerdict, n as SqlDiffVerdictInput, o as classifyDiffSubjectGranularity, r as StorageTypeVerdict, s as classifySqlDiffIssue, t as SqlDiffVerdict, u as verifySqlSchemaByDiff } from "./diff-DbTNVm2f.mjs";
 export { type NativeTypeNormalizer, type SqlDiffVerdict, type SqlDiffVerdictInput, type StorageTypeVerdict, type StorageTypeVerdictInput, type VerifySqlSchemaByDiffInput, arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, verifySqlSchemaByDiff };

package/dist/family__migration.d.mts

@@ -1,2 +1,2 @@
-import { t as SqlMigration } from "./migration-CGlaINey.mjs";
+import { t as SqlMigration } from "./migration-CjDRZNep.mjs";
 export { SqlMigration as Migration };

package/dist/family__pack.mjs

@@ -1,4 +1,4 @@
-import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-Blqoa2Ua-CvHn00xx.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringTypes, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringFieldPresets } from "./authoring-type-constructors-Blqoa2Ua-DqvNCOb2.mjs";
 //#region ../../../2-sql/9-family/dist/pack.mjs
 const sqlFamilyPack = {
 	kind: "family",

package/dist/family__psl-infer.mjs

@@ -1,2 +1,2 @@
-import { a as mapDefault, c as toEnumMemberName, d as toModelName, i as inferRelations, l as toEnumName, n as deriveBackRelationFieldName, o as parseRawDefault, r as deriveRelationFieldName, s as pluralize, t as buildChildRelationField, u as toFieldName } from "./psl-infer-YhbKkybN.mjs";
+import { a as mapDefault, c as toEnumMemberName, d as toModelName, i as inferRelations, l as toEnumName, n as deriveBackRelationFieldName, o as parseRawDefault, r as deriveRelationFieldName, s as pluralize, t as buildChildRelationField, u as toFieldName } from "./psl-infer-Dk5kgKre.mjs";
 export { buildChildRelationField, deriveBackRelationFieldName, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, pluralize, toEnumMemberName, toEnumName, toFieldName, toModelName };

package/dist/family__runtime.d.mts

@@ -1,3 +1,3 @@
 import { n as resolveStorageTable, t as ResolvedStorageTable } from "./resolve-storage-table-Nyrgk4h8.mjs";
-import { a as timestampNowRuntimeGenerator, i as sqlRuntimeFamilyDescriptor, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-cPrAp99G.mjs";
+import { a as timestampNowRuntimeGenerator, i as sqlRuntimeFamilyDescriptor, n as UNBOUND_DOMAIN_NAMESPACE_ID, r as resolveDomainModel, t as ResolvedDomainModel } from "./runtime-DpKF2Yu2.mjs";
 export { type ResolvedDomainModel, type ResolvedStorageTable, UNBOUND_DOMAIN_NAMESPACE_ID, sqlRuntimeFamilyDescriptor as default, resolveDomainModel, resolveStorageTable, timestampNowRuntimeGenerator };

package/dist/{foreign-key-materialization-DO9dvG7v.d.mts → foreign-key-materialization-CkvOzJWy.d.mts}

@@ -55,11 +55,11 @@ interface MaterializedTableConstraints {
  * `contract.json` persists: a `constraint: false` FK contributes no
  * `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already
  * backed by a declared index/unique/primary-key contributes a wire-named
- * `indexes[]` entry (default prefix + content-hash wire name). Declared
- * indexes always survive unchanged; a second FK sharing already-synthesized
- * backing columns does not mint a duplicate index.
+ * `indexes[]` entry (byte-budgeted default prefix + content-hash wire name).
+ * Declared indexes always survive unchanged; a second FK sharing an already
+ * synthesized backing index does not mint a duplicate.
  */
 declare function materializeForeignKeysAndIndexes(tableName: string, foreignKeys: readonly ForeignKeyAuthoringInput[], declaredIndexes: readonly IndexInput[], uniques: readonly UniqueConstraintInput[], primaryKey: PrimaryKeyInput | undefined): MaterializedTableConstraints;
 //#endregion
 export { isBackedByColumnKeys as a, backingIndexColumnKeys as i, ForeignKeyAuthoringInput as n, materializeForeignKeysAndIndexes as o, MaterializedTableConstraints as r, BackingIndexCandidates as t };
-//# sourceMappingURL=foreign-key-materialization-DO9dvG7v.d.mts.map
+//# sourceMappingURL=foreign-key-materialization-CkvOzJWy.d.mts.map

package/dist/{foreign-key-materialization-DO9dvG7v.d.mts.map → foreign-key-materialization-CkvOzJWy.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"foreign-key-materialization-DO9dvG7v.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/foreign-key-materialization.d.mts"],"mappings":";;;;;KAIK;WACM;aACE;;WAEF;aACE;;WAEF;aACE;;;;;;;;;;;;;;iBAcI,uBAAuB,OAAO;;;;;;iBAM9B,qBAAqB,4BAA4B;;;;;;UAMxD;WACC,QAAQ;WACR,QAAQ;WACR;WACA,WAAW;WACX,WAAW;WACX;WACA;;UAED;WACC,sBAAsB;WACtB,kBAAkB;;;;;;;;;;;iBAWZ,iCAAiC,mBAAmB,sBAAsB,4BAA4B,0BAA0B,cAAc,kBAAkB,yBAAyB,YAAY,8BAA8B"}
+{"version":3,"file":"foreign-key-materialization-CkvOzJWy.d.mts","names":[],"sources":["../../../../2-sql/1-core/contract/dist/foreign-key-materialization.d.mts"],"mappings":";;;;;KAIK;WACM;aACE;;WAEF;aACE;;WAEF;aACE;;;;;;;;;;;;;;iBAcI,uBAAuB,OAAO;;;;;;iBAM9B,qBAAqB,4BAA4B;;;;;;UAMxD;WACC,QAAQ;WACR,QAAQ;WACR;WACA,WAAW;WACX,WAAW;WACX;WACA;;UAED;WACC,sBAAsB;WACtB,kBAAkB;;;;;;;;;;;iBAWZ,iCAAiC,mBAAmB,sBAAsB,4BAA4B,0BAA0B,cAAc,kBAAkB,yBAAyB,YAAY,8BAA8B"}

package/dist/{foreign-key-materialization-DLOi1Ps0.mjs → foreign-key-materialization-Cu7-7LHl.mjs}

@@ -1,3 +1,4 @@
+import { g as truncateToWireNamePrefixBytes, o as defaultIndexName } from "./naming-DKr4TJd7-Cszhq9RV.mjs";
 import { n as lowerAuthoredIndex } from "./index-naming-DREt6js7-CRH27yUv.mjs";
 //#region ../../../2-sql/1-core/contract/dist/foreign-key-materialization.mjs
 /**
@@ -31,9 +32,9 @@ function isBackedByColumnKeys(columns, backingKeys) {
 * `contract.json` persists: a `constraint: false` FK contributes no
 * `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already
 * backed by a declared index/unique/primary-key contributes a wire-named
-* `indexes[]` entry (default prefix + content-hash wire name). Declared
-* indexes always survive unchanged; a second FK sharing already-synthesized
-* backing columns does not mint a duplicate index.
+* `indexes[]` entry (byte-budgeted default prefix + content-hash wire name).
+* Declared indexes always survive unchanged; a second FK sharing an already
+* synthesized backing index does not mint a duplicate.
 */
 function materializeForeignKeysAndIndexes(tableName, foreignKeys, declaredIndexes, uniques, primaryKey) {
 	const satisfiedIndexColumns = new Set(backingIndexColumnKeys({
@@ -53,7 +54,7 @@ function materializeForeignKeysAndIndexes(tableName, foreignKeys, declaredIndexe
 					where: void 0,
 					unique: void 0,
 					map: void 0,
-					name: void 0,
+					name: truncateToWireNamePrefixBytes(defaultIndexName(tableName, reference.source.columns)),
 					type: void 0,
 					options: void 0
 				}));
@@ -69,4 +70,4 @@ function materializeForeignKeysAndIndexes(tableName, foreignKeys, declaredIndexe
 //#endregion
 export { isBackedByColumnKeys as n, materializeForeignKeysAndIndexes as r, backingIndexColumnKeys as t };
 
-//# sourceMappingURL=foreign-key-materialization-DLOi1Ps0.mjs.map
+//# sourceMappingURL=foreign-key-materialization-Cu7-7LHl.mjs.map

package/dist/foreign-key-materialization-Cu7-7LHl.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"foreign-key-materialization-Cu7-7LHl.mjs","names":[],"sources":["../../../../2-sql/1-core/contract/dist/foreign-key-materialization.mjs"],"sourcesContent":["import { n as lowerAuthoredIndex } from \"./index-naming-DREt6js7.mjs\";\nimport { defaultIndexName, truncateToWireNamePrefixBytes } from \"@internal/sql-schema-ir/naming\";\n//#region src/foreign-key-materialization.ts\n/**\n* The column-list keys (`\"colA,colB\"`, order preserved) a table's own\n* indexes, unique constraints, and primary key already back. A foreign key\n* whose source columns join to one of these keys needs no separately\n* derived backing index.\n*\n* Shared by {@link isBackedByColumnKeys}'s callers: `materializeForeignKeysAndIndexes`\n* (deriving the discrete backing-index entities persisted at `contract emit`)\n* and the postgres PSL inferrer (deciding whether an introspected relation\n* needs an explicit `index: false`).\n*/\nfunction backingIndexColumnKeys(table) {\n\treturn [\n\t\t...table.indexes.flatMap((index) => index.columns !== void 0 ? [index.columns.join(\",\")] : []),\n\t\t...table.uniques.map((unique) => unique.columns.join(\",\")),\n\t\t...table.primaryKey ? [table.primaryKey.columns.join(\",\")] : []\n\t];\n}\n/**\n* Whether `columns`, in order, matches one of `backingKeys` (see\n* {@link backingIndexColumnKeys}). Order-sensitive: `(a, b)` does not\n* satisfy a backing index declared as `(b, a)`.\n*/\nfunction isBackedByColumnKeys(columns, backingKeys) {\n\treturn backingKeys.includes(columns.join(\",\"));\n}\n/**\n* Lowers a table's authored foreign keys into the discrete entities\n* `contract.json` persists: a `constraint: false` FK contributes no\n* `foreignKeys[]` entry, and an `index: true` FK whose columns aren't already\n* backed by a declared index/unique/primary-key contributes a wire-named\n* `indexes[]` entry (byte-budgeted default prefix + content-hash wire name).\n* Declared indexes always survive unchanged; a second FK sharing an already\n* synthesized backing index does not mint a duplicate.\n*/\nfunction materializeForeignKeysAndIndexes(tableName, foreignKeys, declaredIndexes, uniques, primaryKey) {\n\tconst satisfiedIndexColumns = new Set(backingIndexColumnKeys({\n\t\tindexes: declaredIndexes,\n\t\tuniques,\n\t\tprimaryKey\n\t}));\n\tconst synthesizedIndexes = [];\n\tconst materializedForeignKeys = [];\n\tfor (const { constraint, index, ...reference } of foreignKeys) {\n\t\tif (constraint !== false) materializedForeignKeys.push(reference);\n\t\tif (index !== false) {\n\t\t\tconst key = reference.source.columns.join(\",\");\n\t\t\tif (!satisfiedIndexColumns.has(key)) {\n\t\t\t\tsynthesizedIndexes.push(lowerAuthoredIndex(tableName, {\n\t\t\t\t\tcolumns: reference.source.columns,\n\t\t\t\t\twhere: void 0,\n\t\t\t\t\tunique: void 0,\n\t\t\t\t\tmap: void 0,\n\t\t\t\t\tname: truncateToWireNamePrefixBytes(defaultIndexName(tableName, reference.source.columns)),\n\t\t\t\t\ttype: void 0,\n\t\t\t\t\toptions: void 0\n\t\t\t\t}));\n\t\t\t\tsatisfiedIndexColumns.add(key);\n\t\t\t}\n\t\t}\n\t}\n\treturn {\n\t\tforeignKeys: materializedForeignKeys,\n\t\tindexes: [...declaredIndexes, ...synthesizedIndexes]\n\t};\n}\n//#endregion\nexport { backingIndexColumnKeys, isBackedByColumnKeys, materializeForeignKeysAndIndexes };\n\n//# sourceMappingURL=foreign-key-materialization.mjs.map"],"mappings":";;;;;;;;;;;;;;AAcA,SAAS,uBAAuB,OAAO;CACtC,OAAO;EACN,GAAG,MAAM,QAAQ,SAAS,UAAU,MAAM,YAAY,KAAK,IAAI,CAAC,MAAM,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC,CAAC;EAC7F,GAAG,MAAM,QAAQ,KAAK,WAAW,OAAO,QAAQ,KAAK,GAAG,CAAC;EACzD,GAAG,MAAM,aAAa,CAAC,MAAM,WAAW,QAAQ,KAAK,GAAG,CAAC,IAAI,CAAC;CAC/D;AACD;;;;;;AAMA,SAAS,qBAAqB,SAAS,aAAa;CACnD,OAAO,YAAY,SAAS,QAAQ,KAAK,GAAG,CAAC;AAC9C;;;;;;;;;;AAUA,SAAS,iCAAiC,WAAW,aAAa,iBAAiB,SAAS,YAAY;CACvG,MAAM,wBAAwB,IAAI,IAAI,uBAAuB;EAC5D,SAAS;EACT;EACA;CACD,CAAC,CAAC;CACF,MAAM,qBAAqB,CAAC;CAC5B,MAAM,0BAA0B,CAAC;CACjC,KAAK,MAAM,EAAE,YAAY,OAAO,GAAG,eAAe,aAAa;EAC9D,IAAI,eAAe,OAAO,wBAAwB,KAAK,SAAS;EAChE,IAAI,UAAU,OAAO;GACpB,MAAM,MAAM,UAAU,OAAO,QAAQ,KAAK,GAAG;GAC7C,IAAI,CAAC,sBAAsB,IAAI,GAAG,GAAG;IACpC,mBAAmB,KAAK,mBAAmB,WAAW;KACrD,SAAS,UAAU,OAAO;KAC1B,OAAO,KAAK;KACZ,QAAQ,KAAK;KACb,KAAK,KAAK;KACV,MAAM,8BAA8B,iBAAiB,WAAW,UAAU,OAAO,OAAO,CAAC;KACzF,MAAM,KAAK;KACX,SAAS,KAAK;IACf,CAAC,CAAC;IACF,sBAAsB,IAAI,GAAG;GAC9B;EACD;CACD;CACA,OAAO;EACN,aAAa;EACb,SAAS,CAAC,GAAG,iBAAiB,GAAG,kBAAkB;CACpD;AACD"}

package/dist/{index-DIHXLCbY.d.mts → index-C-vQOMY_.d.mts}

@@ -1,13 +1,13 @@
 import { c as SqlStorage } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
 import "./types-UcHa2cTe.mjs";
-import { O as ContractCodecRegistry, m as AnyQueryAst, ut as LoweredStatement } from "./types-DH6Sqzxu-DfzaLX0o.mjs";
-import { t as Adapter } from "./ast-D8qqdDX_.mjs";
-import { t as SqlExecutionPlan } from "./sql-execution-plan-D0ZTnszb-DnCRtfQO.mjs";
-import { t as SqlQueryPlan } from "./plan-BC_trt1i-In5gOKCT.mjs";
-import "./plan-DrOMooQt.mjs";
-import { n as CodecDescriptorRegistry } from "./query-lane-context-gwWUcacE-DdWNrc8q.mjs";
-import "./query-lane-context-D62vkQhf.mjs";
-import { T as SqlMiddleware } from "./prepared-statement-z9bBbTph-BlzhaRTY.mjs";
+import { O as ContractCodecRegistry, m as AnyQueryAst, ut as LoweredStatement } from "./types-v3qxLLxo-DCeKv7yY.mjs";
+import { t as Adapter } from "./ast-HFcfQZr-.mjs";
+import { t as SqlQueryPlan } from "./plan-CDxduYaN-pLIyyJaB.mjs";
+import { t as SqlExecutionPlan } from "./sql-execution-plan--jKyLpe5-CMGhgO0M.mjs";
+import "./plan-BHLdb0Z7.mjs";
+import { n as CodecDescriptorRegistry } from "./query-lane-context-Qa-eddrE-kuZ8Z86-.mjs";
+import "./query-lane-context-XMvk7fmY.mjs";
+import { k as SqlMiddleware } from "./prepared-statement-9QpkE6JG-C430V3MO.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
 import { AfterExecuteResult as AfterExecuteResult$1, AfterQueryResult as AfterQueryResult$1, ExecuteInterceptResult as ExecuteInterceptResult$1, QueryInterceptResult as QueryInterceptResult$1, RuntimeLog as Log } from "@prisma/orm-framework/components/runtime";
 //#region ../../../2-sql/5-runtime/dist/index.d.mts
@@ -81,4 +81,4 @@ interface LintsOptions {
 declare function lints(options?: LintsOptions): SqlMiddleware;
 //#endregion
 export { LintsOptions as a, budgets as c, lints as d, lowerSqlPlan as f, ExecuteInterceptResult$1 as i, createAstCodecRegistry as l, validateContractCodecMappings as m, AfterQueryResult$1 as n, Log as o, validateCodecRegistryCompleteness as p, BudgetsOptions as r, QueryInterceptResult$1 as s, AfterExecuteResult$1 as t, extractCodecIds as u };
-//# sourceMappingURL=index-DIHXLCbY.d.mts.map
+//# sourceMappingURL=index-C-vQOMY_.d.mts.map

package/dist/{index-DIHXLCbY.d.mts.map → index-C-vQOMY_.d.mts.map}

@@ -1 +1 @@
-{"version":3,"file":"index-DIHXLCbY.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAiBiB,uBAAuB,aAAa,0BAA0B;;;iBAG9D,gBAAgB,UAAU,SAAS,cAAc;iBACjD,8BAA8B,UAAU,yBAAyB,UAAU,SAAS;iBACpF,kCAAkC,UAAU,yBAAyB,UAAU,SAAS;;;;;;;;;;;;iBAYxF,aAAa,KAAK,SAAS,QAAQ,aAAa,SAAS,aAAa,mBAAmB,UAAU,SAAS,aAAa,WAAW,aAAa,OAAO,iBAAiB;;;UAGhL;WACC;WACA;WACA,YAAY;WACZ;WACA;aACE;aACA;;;iBAGI,QAAQ,UAAU,iBAAiB;;;UAG1C;WACC;aACE;aACA;aACA;aACA;aACA;;WAEF;;;;;;;;;;;;;;;;iBAgBM,MAAM,UAAU,eAAe"}
+{"version":3,"file":"index-C-vQOMY_.d.mts","names":[],"sources":["../../../../2-sql/5-runtime/dist/index.d.mts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;iBAiBiB,uBAAuB,aAAa,0BAA0B;;;iBAG9D,gBAAgB,UAAU,SAAS,cAAc;iBACjD,8BAA8B,UAAU,yBAAyB,UAAU,SAAS;iBACpF,kCAAkC,UAAU,yBAAyB,UAAU,SAAS;;;;;;;;;;;;iBAYxF,aAAa,KAAK,SAAS,QAAQ,aAAa,SAAS,aAAa,mBAAmB,UAAU,SAAS,aAAa,WAAW,aAAa,OAAO,iBAAiB;;;UAGhL;WACC;WACA;WACA,YAAY;WACZ;WACA;aACE;aACA;;;iBAGI,QAAQ,UAAU,iBAAiB;;;UAG1C;WACC;aACE;aACA;aACA;aACA;aACA;;WAEF;;;;;;;;;;;;;;;;iBAgBM,MAAM,UAAU,eAAe"}

package/dist/{interpreter-DaBA2fm--FFkq_gGd.mjs → interpreter-DyiUUAWh-DYdjIpiE.mjs}

@@ -1,5 +1,5 @@
 import { t as deriveValueSetFromEntity } from "./value-set-derivation-hook-Di9JZ0X7.mjs";
-import { n as buildSqlContractFromDefinition } from "./derived-checks-DFMRmiAu-8jmha26I.mjs";
+import { n as buildSqlContractFromDefinition } from "./derived-checks-DFMRmiAu-DGfB8aS4.mjs";
 import { structuredError } from "@prisma/orm-framework/utils/structured-error";
 import { hasRegisteredFieldNamespace, instantiateAuthoringEntityType, instantiateAuthoringFieldPreset, instantiateAuthoringTypeConstructor, isAuthoringEntityTypeDescriptor, isAuthoringFieldPresetDescriptor, isAuthoringModelAttributeDescriptor, isAuthoringPslBlockDescriptor, isAuthoringTypeConstructorDescriptor, validateAuthoringHelperArguments } from "@prisma/orm-framework/components/authoring";
 import { UNBOUND_NAMESPACE_ID } from "@prisma/orm-framework/components/ir";
@@ -10,7 +10,7 @@ import { blindCast } from "@prisma/orm-framework/utils/casts";
 import { bool, entityRef, fieldAttribute, fieldRef, findBlockDescriptor, funcCall, identifier, interpretAttribute, keywordPslSpan, leafDiagnostic, list, modelAttribute, nodePslSpan, num, oneOf, optional, record, str } from "@prisma/orm-framework/psl-parser";
 import { assertDefined, invariant } from "@prisma/orm-framework/utils/assertions";
 import { notOk, ok } from "@prisma/orm-framework/utils/result";
-//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-DaBA2fm-.mjs
+//#region ../../../2-sql/2-authoring/contract-psl/dist/interpreter-DyiUUAWh.mjs
 function contractError(code, message, options) {
 	return structuredError(code, message, options);
 }
@@ -627,7 +627,7 @@ function checkUncomposedNamespace(attributeName, composedExtensions, context) {
 function reportUncomposedNamespace(input) {
 	input.diagnostics.push({
 		code: "PSL_EXTENSION_NAMESPACE_NOT_COMPOSED",
-		message: `${input.subjectLabel} uses unrecognized namespace "${input.namespace}". Add extension pack "${input.namespace}" to extensions in prisma-next.config.ts.`,
+		message: `${input.subjectLabel} uses unrecognized namespace "${input.namespace}". Add extension pack "${input.namespace}" to extensions in prisma.config.ts.`,
 		sourceId: input.sourceId,
 		span: input.span,
 		data: {
@@ -2659,7 +2659,7 @@ function buildModelNodeFromPsl(input) {
 			if (extContractForSpace === void 0) {
 				diagnostics.push({
 					code: "PSL_UNKNOWN_CONTRACT_SPACE",
-					message: `Relation field "${model.name}.${relationAttribute.field.name}" references contract space "${fieldTypeContractSpaceId}" which is not declared in extensions. Add "${fieldTypeContractSpaceId}" to extensions in prisma-next.config.ts.`,
+					message: `Relation field "${model.name}.${relationAttribute.field.name}" references contract space "${fieldTypeContractSpaceId}" which is not declared in extensions. Add "${fieldTypeContractSpaceId}" to extensions in prisma.config.ts.`,
 					sourceId,
 					span: relationAttribute.field.span,
 					data: {
@@ -3677,4 +3677,4 @@ function interpretPslDocumentToSqlContract(input) {
 //#endregion
 export { interpretPslDocumentToSqlContract as t };
 
-//# sourceMappingURL=interpreter-DaBA2fm--FFkq_gGd.mjs.map
+//# sourceMappingURL=interpreter-DyiUUAWh-DYdjIpiE.mjs.map