@prisma/orm-family-sql 0.16.0-dev.36

package/dist/ir-B3bKMnGQ.d.mts

@@ -0,0 +1,123 @@
+import { c as SqlStorage, s as SqlNamespaceInput, u as SqlStorageTypeEntry } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import "./types-BchwQpmO.mjs";
+import { AnyEntityKindDescriptor, Namespace } from "@prisma/orm-framework/components/ir";
+import { Contract } from "@prisma/orm-framework/contract/types";
+import { ContractSerializer, SchemaDiffIssue, SchemaVerifier, SchemaVerifyOptions, SchemaVerifyResult } from "@prisma/orm-framework/components/control";
+import { JsonObject } from "@prisma/orm-framework/utils/json";
+//#region ../../../2-sql/9-family/dist/ir.d.mts
+//#region src/core/ir/sql-contract-serializer-base.d.ts
+type SqlEntityHydrationFactory = (entry: unknown) => unknown;
+/**
+ * SQL family `ContractSerializer` abstract base. Carries the SQL-shared
+ * deserialization pipeline:
+ *
+ * 1. `parseSqlContractStructure` validates the on-disk JSON envelope
+ *    against the SQL contract arktype schema (`validateSqlContractFully`)
+ *    and returns the validated flat-data shape.
+ * 2. `hydrateSqlStorage` walks the validated `storage` subtree and
+ *    constructs the family-shared SQL Contract IR class hierarchy
+ *    (`SqlStorage` -> `StorageTable` -> `StorageColumn` / `PrimaryKey`
+ *    / …). The rest of the contract envelope is JSON-clean primitive
+ *    data and passes through unchanged.
+ * 3. `constructTargetContract` is the target-specific extension hook;
+ *    defaults to identity. Targets that need to attach target-only
+ *    fields (e.g. target-specific derived storage fields) override it.
+ *
+ * Default `serializeContract` is identity over the contract — concrete
+ * SQL targets ship JSON-clean class instances, so the contract value
+ * can be stringified directly. The non-enumerable family-level `kind`
+ * discriminator on `SqlNode` instances stays out of the persisted
+ * envelope automatically. Targets that need to canonicalize on the way
+ * out (key ordering, dropping computed-only fields) override
+ * `serializeContract` directly.
+ */
+declare abstract class SqlContractSerializerBase<TContract extends Contract<SqlStorage>> implements ContractSerializer<TContract> {
+  protected readonly entityHydrationRegistry: ReadonlyMap<string, SqlEntityHydrationFactory>;
+  private readonly contractSchema;
+  private readonly entryKinds;
+  constructor(entityHydrationRegistry?: ReadonlyMap<string, SqlEntityHydrationFactory>, packEntityKinds?: readonly AnyEntityKindDescriptor[]);
+  deserializeContract<T extends TContract = TContract>(json: unknown): T;
+  serializeContract(contract: TContract): JsonObject;
+  shouldPreserveEmpty: import("@prisma/orm-framework/contract/hashing").PreserveEmptyPredicate;
+  sortStorage: import("@prisma/orm-framework/contract/hashing").StorageSort;
+  protected parseSqlContractStructure(json: unknown): Contract<SqlStorage>;
+  protected hydrateSqlStorage(validated: Contract<SqlStorage>): Contract<SqlStorage>;
+  protected hydrateSqlNamespaceMap(namespaces: Readonly<Record<string, Record<string, unknown>>>): Readonly<Record<string, Namespace>>;
+  protected hydrateSqlNamespaceEntry(nsId: string, raw: Record<string, unknown>): Namespace | SqlNamespaceInput;
+  protected hydrateStorageTypeEntry(entry: SqlStorageTypeEntry): SqlStorageTypeEntry;
+  protected constructTargetContract(hydrated: Contract<SqlStorage>): TContract;
+  /**
+   * Serializes a namespace's `entries` dict by walking every enumerable
+   * kind — no kind is named here, mirroring the generic hydrate walk in
+   * `hydrateSqlNamespaceEntry` above. `table` is the SQL family's one
+   * universal base kind (every namespace carries it), so it is always
+   * emitted, even when empty; every other kind — target- or
+   * pack-contributed — is emitted only when it holds at least one entry.
+   * A kind carried non-enumerable on `entries` is excluded here for free,
+   * since `Object.entries` honors enumerability.
+   */
+  protected serializeNamespaceEntries(entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>): Record<string, Record<string, JsonObject>>;
+  private serializeEntries;
+  protected serializeJsonObject(value: unknown): JsonObject;
+  private serializeJsonValue;
+}
+//#endregion
+//#region src/core/ir/sql-contract-serializer.d.ts
+/**
+ * Default SQL family `ContractSerializer` concretion. Inherits the
+ * full SQL-shared deserialization pipeline (structural validation +
+ * IR-class hydration) without pack-registered `storage.types`
+ * hydration factories — targets that emit polymorphic JSON outside the
+ * codec-typed envelope wire a target-specific subclass with a populated
+ * registry (see Postgres). Family-level call sites instantiate this
+ * default directly when no target serializer is supplied.
+ *
+ * Because this serializer has no target concretion, deserialization of
+ * contracts that include namespace entries from JSON will throw unless
+ * the caller provides pre-hydrated `NamespaceBase` instances. Production
+ * paths always supply a target-specific serializer.
+ */
+declare class SqlContractSerializer extends SqlContractSerializerBase<Contract<SqlStorage>> {
+  constructor();
+}
+//#endregion
+//#region src/core/ir/sql-schema-verifier-base.d.ts
+/**
+ * SQL family `SchemaVerifier` abstract base. Centralises the SQL-shared
+ * walk (table-by-table + column-by-column matching keyed by
+ * `(namespace.id, name)`, FK / unique / index comparisons via the
+ * shared satisfaction helpers in `sql-schema-diff.ts`) and exposes a protected hook
+ * for target extensions (Postgres functions, RLS policies, future
+ * target-only kinds).
+ *
+ * The base accumulates issues in a single buffer and returns the
+ * combined result; the per-SPI family abstract handles the result
+ * envelope shape so concrete subclasses focus on target-specific
+ * verification logic.
+ *
+ * The protected hooks (`verifyCommonSqlSchema`,
+ * `verifyTargetExtensions`) carry the stable base API that target
+ * subclasses (`PostgresSchemaVerifier`, `SqliteSchemaVerifier`)
+ * compile against; the SQL-shared walk implementation will be lifted
+ * into this base when the verifier behaviour migrates off the
+ * legacy adapter shells.
+ */
+declare abstract class SqlSchemaVerifierBase<TContract, TSchema> implements SchemaVerifier<TContract, TSchema> {
+  verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult;
+  /**
+   * SQL-shared verification — table/column/FK/unique/index walks keyed
+   * by `(namespace.id, name)`. Concrete subclasses provide the
+   * family-shared implementation today; a future iteration will lift
+   * the shared walk into this base.
+   */
+  protected abstract verifyCommonSqlSchema(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaDiffIssue[];
+  /**
+   * Target-specific extensions — e.g. Postgres functions, future RLS
+   * policies, namespace-mismatch issues. Returns the empty list when the
+   * target ships no extensions over the SQL family alphabet.
+   */
+  protected abstract verifyTargetExtensions(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaDiffIssue[];
+}
+//#endregion
+export { SqlSchemaVerifierBase as i, SqlContractSerializerBase as n, SqlEntityHydrationFactory as r, SqlContractSerializer as t };
+//# sourceMappingURL=ir-B3bKMnGQ.d.mts.map

package/dist/ir-B3bKMnGQ.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-B3bKMnGQ.d.mts","names":[],"sources":["../../../../2-sql/9-family/dist/ir.d.mts"],"mappings":";;;;;;;;KAMK,6BAA6B;;;;;;;;;;;;;;;;;;;;;;;;;uBAyBX,0BAA0B,kBAAkB,SAAS,wBAAwB,mBAAmB;qBAClG,yBAAyB,oBAAoB;mBAC/C;mBACA;EACjB,YAAY,0BAA0B,oBAAoB,4BAA4B,2BAA2B;EACjH,oBAAoB,UAAU,YAAY,WAAW,gBAAgB;EACrE,kBAAkB,UAAU,YAAY;EACxC,0DAA0D;EAC1D,kDAAkD;YACxC,0BAA0B,gBAAgB,SAAS;YACnD,kBAAkB,WAAW,SAAS,cAAc,SAAS;YAC7D,uBAAuB,YAAY,SAAS,eAAe,4BAA4B,SAAS,eAAe;YAC/G,yBAAyB,cAAc,KAAK,0BAA0B,YAAY;YAClF,wBAAwB,OAAO,sBAAsB;YACrD,wBAAwB,UAAU,SAAS,cAAc;;;;;;;;;;;YAWzD,0BAA0B,SAAS,SAAS,eAAe,SAAS,6BAA6B,eAAe,eAAe;UACjI;YACE,oBAAoB,iBAAiB;UACvC;;;;;;;;;;;;;;;;;;cAkBI,8BAA8B,0BAA0B,SAAS;EAC7E;;;;;;;;;;;;;;;;;;;;;;;;uBAwBqB,sBAAsB,WAAW,oBAAoB,eAAe,WAAW;EACpG,aAAa,SAAS,oBAAoB,WAAW,WAAW;;;;;;;qBAO7C,sBAAsB,SAAS,oBAAoB,WAAW,oBAAoB;;;;;;qBAMlF,uBAAuB,SAAS,oBAAoB,WAAW,oBAAoB"}

package/dist/ir-I-xciGUH.mjs

@@ -0,0 +1,36 @@
+//#region ../../../2-sql/9-family/dist/ir.mjs
+/**
+* SQL family `SchemaVerifier` abstract base. Centralises the SQL-shared
+* walk (table-by-table + column-by-column matching keyed by
+* `(namespace.id, name)`, FK / unique / index comparisons via the
+* shared satisfaction helpers in `sql-schema-diff.ts`) and exposes a protected hook
+* for target extensions (Postgres functions, RLS policies, future
+* target-only kinds).
+*
+* The base accumulates issues in a single buffer and returns the
+* combined result; the per-SPI family abstract handles the result
+* envelope shape so concrete subclasses focus on target-specific
+* verification logic.
+*
+* The protected hooks (`verifyCommonSqlSchema`,
+* `verifyTargetExtensions`) carry the stable base API that target
+* subclasses (`PostgresSchemaVerifier`, `SqliteSchemaVerifier`)
+* compile against; the SQL-shared walk implementation will be lifted
+* into this base when the verifier behaviour migrates off the
+* legacy adapter shells.
+*/
+var SqlSchemaVerifierBase = class {
+	verifySchema(options) {
+		const issues = [];
+		issues.push(...this.verifyCommonSqlSchema(options));
+		issues.push(...this.verifyTargetExtensions(options));
+		return {
+			ok: issues.length === 0,
+			issues
+		};
+	}
+};
+//#endregion
+export { SqlSchemaVerifierBase as t };
+
+//# sourceMappingURL=ir-I-xciGUH.mjs.map

package/dist/ir-I-xciGUH.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"ir-I-xciGUH.mjs","names":[],"sources":["../../../../2-sql/9-family/dist/ir.mjs"],"sourcesContent":["import { n as SqlContractSerializerBase, t as SqlContractSerializer } from \"./sql-contract-serializer-2oBWuxTe.mjs\";\n//#region src/core/ir/sql-schema-verifier-base.ts\n/**\n* SQL family `SchemaVerifier` abstract base. Centralises the SQL-shared\n* walk (table-by-table + column-by-column matching keyed by\n* `(namespace.id, name)`, FK / unique / index comparisons via the\n* shared satisfaction helpers in `sql-schema-diff.ts`) and exposes a protected hook\n* for target extensions (Postgres functions, RLS policies, future\n* target-only kinds).\n*\n* The base accumulates issues in a single buffer and returns the\n* combined result; the per-SPI family abstract handles the result\n* envelope shape so concrete subclasses focus on target-specific\n* verification logic.\n*\n* The protected hooks (`verifyCommonSqlSchema`,\n* `verifyTargetExtensions`) carry the stable base API that target\n* subclasses (`PostgresSchemaVerifier`, `SqliteSchemaVerifier`)\n* compile against; the SQL-shared walk implementation will be lifted\n* into this base when the verifier behaviour migrates off the\n* legacy adapter shells.\n*/\nvar SqlSchemaVerifierBase = class {\n\tverifySchema(options) {\n\t\tconst issues = [];\n\t\tissues.push(...this.verifyCommonSqlSchema(options));\n\t\tissues.push(...this.verifyTargetExtensions(options));\n\t\treturn {\n\t\t\tok: issues.length === 0,\n\t\t\tissues\n\t\t};\n\t}\n};\n//#endregion\nexport { SqlContractSerializer, SqlContractSerializerBase, SqlSchemaVerifierBase };\n\n//# sourceMappingURL=ir.mjs.map"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAsBA,IAAI,wBAAwB,MAAM;CACjC,aAAa,SAAS;EACrB,MAAM,SAAS,CAAC;EAChB,OAAO,KAAK,GAAG,KAAK,sBAAsB,OAAO,CAAC;EAClD,OAAO,KAAK,GAAG,KAAK,uBAAuB,OAAO,CAAC;EACnD,OAAO;GACN,IAAI,OAAO,WAAW;GACtB;EACD;CACD;AACD"}

package/dist/lane-query-builder.d.mts

@@ -0,0 +1,236 @@
+import { a as StorageTable } from "./storage-table-BBaAmanc-BwR37LMA.mjs";
+import { c as SqlStorage } from "./sql-storage-B0QwiTg6-B8DVctJm.mjs";
+import { u as ExtractStorageColumnTypes } from "./types-CuDrWc5v-ISVXBmBs.mjs";
+import { n as StorageColumnTypeAcrossNamespaces } from "./types-BchwQpmO.mjs";
+import { Brand, Contract, StorageHashBase } from "@prisma/orm-framework/contract/types";
+import "@standard-schema/spec";
+//#region ../../../2-sql/4-lanes/query-builder/dist/index.d.mts
+//#region src/type-errors.d.ts
+/**
+ * An error message type, prefixed with `[error]`.
+ *
+ * @template TMessage The error message.
+ */
+type ErrorMessage = `[error] ${string}`;
+/**
+ * An error type indicating that the previous function call had bad input.
+ * To be used as a return type.
+ *
+ * @template TMessage The error message.
+ */
+type PreviousFunctionReceivedBadInputError<TMessage extends ErrorMessage> = Brand<TMessage>;
+//#endregion
+//#region src/column-reference.d.ts
+/**
+ * An object representing a reference to a column in a table in the database.
+ *
+ * @template TColumnName The name of the column.
+ * @template TTableName The name of the table this column belongs to.
+ * @template THash The contract storage hash belonging to the database this column is in.
+ */
+type ColumnReference<TColumnName extends string = string, TTableName extends string = string, THash extends StorageHashBase<string> = StorageHashBase<string>> = {
+  readonly '~name': TColumnName;
+  readonly '~table': TTableName;
+} & Brand<'[info] this column reference belongs to the following table reference:', `${TTableName}@${THash}`>;
+/**
+ * An error type indicating that the provided column reference is out of the contract's scope.
+ * To be used in reference creators, e.g. `createRef()`.
+ *
+ * @template TMessage The error message.
+ */
+type ColumnReferenceOutOfContractError<TMessage extends ErrorMessage> = Brand<TMessage>;
+/**
+ * A type representing a reference to all columns in the current query context.
+ */
+type Asterisk = {
+  readonly '~name': '*';
+  readonly '~table': null;
+} & Brand<'[info] referencing all columns in the current query context'>;
+/**
+ * A type representing a reference to all columns in a specific table.
+ *
+ * @template TTableName The name of the table whose columns are being referenced.
+ * @template THash The contract storage hash belonging to the database this column is in.
+ */
+type TableAsterisk<TTableName extends string = string, THash extends StorageHashBase<string> = StorageHashBase<string>> = {
+  readonly '~name': '*';
+  readonly '~table': TTableName;
+} & Brand<'[info] referencing all columns that belong to the following table reference:', `${TTableName}@${THash}`>;
+//#endregion
+//#region ../sql-builder/dist/db-DhMsmBS-.d.mts
+//#endregion
+//#region src/types/db.d.ts
+type CapabilitiesBase = Record<string, Record<string, boolean>>;
+type NamespaceEntries = Readonly<Record<string, Readonly<Record<string, unknown>>>>;
+type NamespaceDomain = Readonly<Record<string, {
+  readonly models: Readonly<Record<string, unknown>>;
+}>>;
+type TableProxyContract = {
+  readonly domain: {
+    readonly namespaces: NamespaceDomain;
+  };
+  readonly storage: {
+    readonly namespaces: Readonly<Record<string, {
+      readonly entries: NamespaceEntries;
+    }>>;
+  };
+  readonly capabilities: CapabilitiesBase;
+};
+type TablesInNamespace<NS extends {
+  readonly entries: NamespaceEntries;
+}> = NS['entries']['table'] extends Readonly<Record<string, StorageTable>> ? NS['entries']['table'] : Readonly<Record<string, StorageTable>>;
+type UnboundTables$1<C extends TableProxyContract> = { readonly [Name in TableNamesAcrossNamespaces<C>]: TableInAnyNamespace<C, Name>; };
+type TableNamesAcrossNamespaces<C extends TableProxyContract> = { [NSId in keyof C['storage']['namespaces']]: keyof TablesInNamespace<C['storage']['namespaces'][NSId]> & string; }[keyof C['storage']['namespaces']];
+type TableInAnyNamespace<C extends TableProxyContract, Name extends string> = { [NSId in keyof C['storage']['namespaces']]: Name extends keyof TablesInNamespace<C['storage']['namespaces'][NSId]> ? TablesInNamespace<C['storage']['namespaces'][NSId]>[Name] : never; }[keyof C['storage']['namespaces']];
+//#endregion
+//#region src/type-atoms.d.ts
+/**
+ * A utility type to drain outer generics from a type. A compiler micro-optimization.
+ *
+ * @template TThing The type to drain.
+ */
+type DrainOuterGeneric<TThing> = [TThing] extends [unknown] ? TThing : never;
+/**
+ * A utility type to ensure that exactly one property of an object type is present.
+ *
+ * @template TObject The object type to check.
+ */
+type ExactlyOneProperty<TObject extends object> = { [K in keyof TObject]-?: IsNever<Exclude<keyof TObject, K>>; }[keyof TObject];
+/**
+ * A utility type to merge two objects.
+ *
+ * @template TObject0 The first object.
+ * @template TObject1 The second object.
+ */
+type MergeObjects<TObject0 extends object, TObject1 extends object> = DrainOuterGeneric<IsNever<TObject0> extends true ? TObject1 : { readonly [K in keyof TObject0 | keyof TObject1]: K extends keyof TObject1 ? TObject1[K] : K extends keyof TObject0 ? TObject0[K] : never; }>;
+/**
+ * A utility type to determine if a type is `never`.
+ *
+ * @template TThing The type to check.
+ */
+type IsNever<TThing> = [TThing] extends [never] ? true : false;
+/**
+ * A utility type to simplify an object type for better readability.
+ *
+ * @template TObject The object type to simplify.
+ */
+type Simplify<TObject extends object> = DrainOuterGeneric<{ [K in keyof TObject]: TObject[K]; } & {}>;
+//#endregion
+//#region src/selection.d.ts
+type UnboundTables<TContract extends Contract<SqlStorage>> = UnboundTables$1<TContract & TableProxyContract>;
+type ExtractOutputType<TContract extends Contract<SqlStorage>, TTableName extends keyof UnboundTables<TContract> & string, TColumnName extends keyof UnboundTables<TContract>[TTableName]['columns'] & string> = StorageColumnTypeAcrossNamespaces<ExtractStorageColumnTypes<TContract>, TTableName, TColumnName>;
+/**
+ * A type representing a selection of columns in a SQL `select` query in the
+ * most generic form.
+ */
+type Selection = Record<string, SelectionValue<unknown, unknown>>;
+/**
+ * A type representing the value of a selected column in a SQL `select` query.
+ *
+ * @template TOutput The output type of the selected column.
+ * @template TDatatype The database-side datatype of the selected column.
+ */
+interface SelectionValue<TOutput, TDatatype extends string | unknown = unknown> {
+  readonly '~datatype': TDatatype;
+  readonly '~output': TOutput;
+}
+/**
+ * A utility type to convert a table's columns into a {@link Selection}.
+ *
+ * @template TContract The contract that describes the database.
+ * @template TTableName The name of the table whose columns will be included in the selection.
+ */
+type TableToSelection<TContract extends Contract<SqlStorage>, TTableName extends keyof UnboundTables<TContract> & string> = DrainOuterGeneric<{ readonly [ColumnName in keyof UnboundTables<TContract>[TTableName]['columns'] & string]: SelectionValue<ExtractOutputType<TContract, TTableName, ColumnName>, UnboundTables<TContract>[TTableName]['columns'][ColumnName]['nativeType']>; }>;
+//#endregion
+//#region src/table-reference.d.ts
+/**
+ * An object representing a reference to a table in the database.
+ *
+ * @template TName The name of the table. `string` is all tables, a union of string literals is a set of specific tables, a single string literal is a specific table.
+ * @template THash The contract storage hash belonging to the database this table is in.
+ */
+type TableReference<TName extends string = string, THash extends StorageHashBase<string> = StorageHashBase<string>> = {
+  readonly '~name': TName;
+} & Brand<'[info] this table reference belongs to the contract with the following storage hash:', THash>;
+/**
+ * An error type indicating that the provided table reference is out of the contract's scope.
+ * To be used in reference creators, e.g. `createRef()`.
+ *
+ * @template TMessage The error message.
+ */
+type TableReferenceOutOfContractError<TMessage extends ErrorMessage> = Brand<TMessage>;
+/**
+ * An error type indicating that the provided table reference is too wide.
+ * To be used as a `never` alternative in conditional types.
+ *
+ * @template TMessage The error message.
+ */
+type TableReferenceTooWideError<TMessage extends ErrorMessage> = Brand<TMessage>;
+//#endregion
+//#region src/ref.d.ts
+/**
+ * A fluent API representing references to tables and columns in a SQL contract.
+ *
+ * @template TContract The contract that describes the database.
+ */
+type Ref<TContract extends Contract<SqlStorage>> = { readonly [TableName in keyof UnboundTables<TContract> & string]: TableReference<TableName, TContract['storage']['storageHash']> & { readonly [ColumnName in Exclude<keyof UnboundTables<TContract>[TableName]['columns'], keyof TableReference> & string]: ColumnReference<ColumnName, TableName, TContract['storage']['storageHash']>; } & {
+  readonly ['*']: TableAsterisk<TableName, TContract['storage']['storageHash']>;
+} & Record<PropertyKey, ColumnReferenceOutOfContractError<`[error] reference to a non-existing column in the '${TableName}' table`>>; } & {
+  readonly ['*']: Asterisk;
+} & Record<PropertyKey, TableReferenceOutOfContractError<`[error] reference to a non-existing table in the contract`>>;
+/**
+ * Creates a reference object for the given SQL contract.
+ *
+ * @template TContract The contract that describes the database.
+ */
+declare function createRef<TContract extends Contract<SqlStorage>>(_contract: TContract): Ref<TContract>;
+//#endregion
+//#region src/select-builder.d.ts
+/**
+ * A builder for SQL `select` queries.
+ *
+ * @template TContract The contract that describes the database.
+ * @template TTables The tables involved in the current `select` query.
+ * @template TSelection The current selection of the `select` query.
+ */
+declare class SelectBuilder<TContract extends Contract<SqlStorage>, TTables extends UnboundTables<Contract<SqlStorage>>, TSelection extends Selection = never> {
+  #private;
+  constructor(contract: TContract);
+  select(asterisk: Asterisk): ExactlyOneProperty<TTables> extends true ? SelectBuilder<TContract, TTables, MergeObjects<TSelection, TableToSelection<TContract, keyof TTables & string>>> : PreviousFunctionReceivedBadInputError<'[error] selecting all columns via `*` results in ambiguity when multiple tables are involved in the query'>;
+  select<TTableName extends keyof TTables & string>(asterisk: TableAsterisk<TTableName, TContract['storage']['storageHash']>): SelectBuilder<TContract, TTables, MergeObjects<TSelection, TableToSelection<TContract, TTableName>>>;
+  select(arg: never): PreviousFunctionReceivedBadInputError<'[error] invalid input in previous `select()` call'>;
+  build(): IsNever<TSelection> extends true ? never : Simplify<TSelection>;
+}
+//#endregion
+//#region src/root.d.ts
+/**
+ * The root of all builder.
+ *
+ * @template TContract The contract that describes the database.
+ */
+declare class Root<TContract extends Contract<SqlStorage>> {
+  #private;
+  constructor(contract: TContract);
+  /**
+   * SQL's `from` clause, where all `select` queries actually start from.
+   *
+   * @param table The table to select from.
+   */
+  from(table: TableReference<never>): PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;
+  /**
+   * @template TName The name of the table to select from.
+   */
+  from<TName extends string>(table: string extends TName ? TableReferenceTooWideError<'[error] `root.from()` call received a table reference without a specific table name'> : TableReference<TName, TContract['storage']['storageHash']>): TName extends string ? SelectBuilder<TContract, Pick<UnboundTables<TContract>, TName>> : PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;
+  from(table: TableReferenceTooWideError<'[error] `root.from()` call received a table reference without a specific table name'>): PreviousFunctionReceivedBadInputError<'[error] invalid table reference in previous `root.from()` call will probably cause runtime errors'>;
+}
+/**
+ * Creates a new `Root` instance.
+ */
+declare function createRoot(contract: never): PreviousFunctionReceivedBadInputError<'[error] root creation will likely fail at runtime given the passed contract is not valid or verified'>;
+/**
+ * @template TContract The contract that describes the database.
+ */
+declare function createRoot<TContract extends Contract<SqlStorage>>(contract: TContract): Root<TContract>;
+//#endregion
+export { type Asterisk, type ColumnReference, type ColumnReferenceOutOfContractError, type DrainOuterGeneric, type ErrorMessage, type ExactlyOneProperty, type ExtractOutputType, type IsNever, type MergeObjects, type PreviousFunctionReceivedBadInputError, type Ref, type Root, type SelectBuilder, type Selection, type SelectionValue, type Simplify, type TableAsterisk, type TableReference, type TableReferenceOutOfContractError, type TableReferenceTooWideError, type TableToSelection, createRef, createRoot };
+//# sourceMappingURL=lane-query-builder.d.mts.map

package/dist/lane-query-builder.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane-query-builder.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/query-builder/dist/index.d.mts"],"mappings":"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"}

package/dist/lane-query-builder.mjs

@@ -0,0 +1,67 @@
+//#region ../../../2-sql/4-lanes/query-builder/dist/index.mjs
+/**
+* Creates a reference object for the given SQL contract.
+*
+* @template TContract The contract that describes the database.
+*/
+function createRef(_contract) {
+	return new Proxy({}, { get(_target, tableName) {
+		if (tableName === "*") return Object.freeze({
+			"~name": tableName,
+			"~table": null
+		});
+		return new Proxy({}, { get(_target, columnName) {
+			if (columnName === "~name") return tableName;
+			return Object.freeze({
+				"~name": columnName,
+				"~table": tableName
+			});
+		} });
+	} });
+}
+/**
+* A builder for SQL `select` queries.
+*
+* @template TContract The contract that describes the database.
+* @template TTables The tables involved in the current `select` query.
+* @template TSelection The current selection of the `select` query.
+*/
+var SelectBuilder = class {
+	#contract;
+	constructor(contract) {
+		this.#contract = contract;
+	}
+	select(..._args) {
+		return this;
+	}
+	build() {
+		return {};
+	}
+};
+/**
+* The root of all builder.
+*
+* @template TContract The contract that describes the database.
+*/
+var Root = class {
+	#contract;
+	constructor(contract) {
+		this.#contract = contract;
+	}
+	/**
+	* @internal
+	*/
+	from(_table) {
+		return new SelectBuilder(this.#contract);
+	}
+};
+/**
+* @internal
+*/
+function createRoot(contract) {
+	return new Root(contract);
+}
+//#endregion
+export { createRef, createRoot };
+
+//# sourceMappingURL=lane-query-builder.mjs.map

package/dist/lane-query-builder.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"lane-query-builder.mjs","names":["#contract"],"sources":["../../../../2-sql/4-lanes/query-builder/dist/index.mjs"],"sourcesContent":["//#region src/ref.ts\n/**\n* Creates a reference object for the given SQL contract.\n*\n* @template TContract The contract that describes the database.\n*/\nfunction createRef(_contract) {\n\treturn new Proxy({}, { get(_target, tableName) {\n\t\tif (tableName === \"*\") return Object.freeze({\n\t\t\t\"~name\": tableName,\n\t\t\t\"~table\": null\n\t\t});\n\t\treturn new Proxy({}, { get(_target, columnName) {\n\t\t\tif (columnName === \"~name\") return tableName;\n\t\t\treturn Object.freeze({\n\t\t\t\t\"~name\": columnName,\n\t\t\t\t\"~table\": tableName\n\t\t\t});\n\t\t} });\n\t} });\n}\n//#endregion\n//#region src/select-builder.ts\n/**\n* A builder for SQL `select` queries.\n*\n* @template TContract The contract that describes the database.\n* @template TTables The tables involved in the current `select` query.\n* @template TSelection The current selection of the `select` query.\n*/\nvar SelectBuilder = class {\n\t#contract;\n\tconstructor(contract) {\n\t\tthis.#contract = contract;\n\t}\n\tselect(..._args) {\n\t\treturn this;\n\t}\n\tbuild() {\n\t\treturn {};\n\t}\n};\n//#endregion\n//#region src/root.ts\n/**\n* The root of all builder.\n*\n* @template TContract The contract that describes the database.\n*/\nvar Root = class {\n\t#contract;\n\tconstructor(contract) {\n\t\tthis.#contract = contract;\n\t}\n\t/**\n\t* @internal\n\t*/\n\tfrom(_table) {\n\t\treturn new SelectBuilder(this.#contract);\n\t}\n};\n/**\n* @internal\n*/\nfunction createRoot(contract) {\n\treturn new Root(contract);\n}\n//#endregion\nexport { createRef, createRoot };\n\n//# sourceMappingURL=index.mjs.map"],"mappings":";;;;;;AAMA,SAAS,UAAU,WAAW;CAC7B,OAAO,IAAI,MAAM,CAAC,GAAG,EAAE,IAAI,SAAS,WAAW;EAC9C,IAAI,cAAc,KAAK,OAAO,OAAO,OAAO;GAC3C,SAAS;GACT,UAAU;EACX,CAAC;EACD,OAAO,IAAI,MAAM,CAAC,GAAG,EAAE,IAAI,SAAS,YAAY;GAC/C,IAAI,eAAe,SAAS,OAAO;GACnC,OAAO,OAAO,OAAO;IACpB,SAAS;IACT,UAAU;GACX,CAAC;EACF,EAAE,CAAC;CACJ,EAAE,CAAC;AACJ;;;;;;;;AAUA,IAAI,gBAAgB,MAAM;CACzB;CACA,YAAY,UAAU;EACrB,KAAKA,YAAY;CAClB;CACA,OAAO,GAAG,OAAO;EAChB,OAAO;CACR;CACA,QAAQ;EACP,OAAO,CAAC;CACT;AACD;;;;;;AAQA,IAAI,OAAO,MAAM;CAChB;CACA,YAAY,UAAU;EACrB,KAAKA,YAAY;CAClB;;;;CAIA,KAAK,QAAQ;EACZ,OAAO,IAAI,cAAc,KAAKA,SAAS;CACxC;AACD;;;;AAIA,SAAS,WAAW,UAAU;CAC7B,OAAO,IAAI,KAAK,QAAQ;AACzB"}

package/dist/middleware-B4XbF4d4-tfwBl6mX.d.mts

@@ -0,0 +1,119 @@
+import { t as SqlExecutionPlan } from "./sql-execution-plan-CJmsCP7n-DoEpNn7r.mjs";
+import { ParamRefMutator } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-sql/4-lanes/relational-core/dist/middleware-B4XbF4d4.d.mts
+//#region src/middleware/param-ref-mutator.d.ts
+/**
+ * Brand applied to {@link ParamRefHandle} so user-constructed handles
+ * are rejected by the type system. The mutator only accepts handles it
+ * produced from `entries()`.
+ *
+ * The brand is a phantom type — there is no runtime token. At runtime
+ * the handle is the underlying `ParamRef` instance from the plan's
+ * `ast`; the brand only narrows the type-level surface so callers
+ * cannot fabricate a handle from a fresh `ParamRef.of(...)`.
+ */
+declare const paramRefHandleBrand: unique symbol;
+/**
+ * Opaque token identifying a single `ParamRef` in the plan. Produced by
+ * {@link SqlParamRefMutator.entries}; consumed by `replaceValue` /
+ * `replaceValues`.
+ *
+ * The phantom `TCodecId` parameter records the codec id of the
+ * referenced `ParamRef` so type-level inference can route replacement
+ * values through `TCodecMap` to the codec's declared `TInput`.
+ */
+interface ParamRefHandle<TCodecId extends string | undefined = string | undefined> {
+  readonly [paramRefHandleBrand]: TCodecId;
+}
+/**
+ * One outbound `ParamRef` slot in the plan exposed to middleware.
+ * `value` is the current value (post any prior middleware mutations);
+ * `codecId` is the codec id declared on the underlying `ParamRef.codec`.
+ */
+interface ParamRefEntry<TCodecId extends string | undefined = string | undefined> {
+  readonly ref: ParamRefHandle<TCodecId>;
+  readonly value: unknown;
+  readonly codecId: TCodecId;
+}
+/**
+ * Discriminated entry union over a codec map. For each `K` in
+ * `TCodecMap`, `entries()` may yield a `ParamRefEntry<K>`; ParamRefs
+ * with no codec id (or a codec id outside the map) yield a
+ * `ParamRefEntry<undefined>`. Pattern-matching on `entry.codecId`
+ * narrows `entry.ref` to a `ParamRefHandle<K>`, which routes through
+ * the typed `replaceValue` overload.
+ */
+type ParamRefEntryUnion<TCodecMap extends Record<string, unknown>> = { [K in keyof TCodecMap & string]: ParamRefEntry<K>; }[keyof TCodecMap & string] | ParamRefEntry<undefined>;
+/**
+ * SQL-family mutator threaded into `SqlMiddleware.beforeExecute` as
+ * `params`. Scope is `ParamRef.value` slots only — middleware cannot
+ * insert / remove `ParamRef`s, rewrite SQL, or modify projection. The
+ * type-level `ParamRefHandle` brand and the `replaceValue(ref,
+ * newValue)` shape enforce this at compile time.
+ *
+ * `entries()` surfaces both literal call-site `ParamRef` slots and
+ * `prepare()`-time `PreparedParamRef` bind slots; the handle and codec
+ * id work the same for both.
+ *
+ * Allocation discipline: the mutator is constructed lazily from the
+ * plan. `entries()` walks the plan's existing AST without allocating
+ * an intermediate array; the working params buffer is only allocated
+ * on the first `replaceValue` / `replaceValues` call. If no middleware
+ * mutates, `currentParams()` returns the plan's original `params` by
+ * reference identity.
+ *
+ * The `TCodecMap` parameter is a record keyed by codec id; `replaceValue`
+ * infers `newValue` from `TCodecMap[H['codecId']]` for handles whose
+ * codec id is statically resolvable. For codec ids the type system
+ * cannot resolve, `newValue` falls back to `unknown` and the middleware
+ * is on the hook for runtime correctness.
+ */
+interface SqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends ParamRefMutator {
+  /** Iterate every outbound `ParamRef` the plan currently carries, in canonical order. */
+  entries(): IterableIterator<ParamRefEntryUnion<TCodecMap>>;
+  /**
+   * Replace one `ParamRef`'s value with the result of bulk processing.
+   * `newValue` is constrained to the codec's declared `TInput` for codec
+   * ids the type system can resolve via `TCodecMap`; for unresolvable
+   * codec ids `newValue` is `unknown` (the second overload).
+   */
+  replaceValue<TCodecId extends keyof TCodecMap & string>(ref: ParamRefHandle<TCodecId>, newValue: TCodecMap[TCodecId]): void;
+  replaceValue(ref: ParamRefHandle<undefined>, newValue: unknown): void;
+  /** Replace many at once (typical for bulk-pattern middleware). */
+  replaceValues(updates: Iterable<{
+    readonly ref: ParamRefHandle<(keyof TCodecMap & string) | undefined>;
+    readonly newValue: unknown;
+  }>): void;
+}
+/**
+ * Internal-only view of the mutator that exposes the post-mutation params
+ * array to the SQL runtime. The runtime calls `currentParams()` after the
+ * `beforeExecute` chain has run; the result is the plan's original
+ * `params` by reference identity if no middleware mutated, otherwise a
+ * frozen new array carrying the mutations applied in chain order.
+ *
+ * Family-internal contract — `SqlMiddleware` consumers never see this
+ * shape; they receive the public `SqlParamRefMutator` view above.
+ */
+interface SqlParamRefMutatorInternal<TCodecMap extends Record<string, unknown> = Record<string, unknown>> extends SqlParamRefMutator<TCodecMap> {
+  currentParams(): readonly unknown[];
+}
+/**
+ * Build a {@link SqlParamRefMutatorInternal} for the given lowered plan.
+ *
+ * The mutator captures `plan.params` by reference and walks
+ * `plan.ast` (via `collectOrderedParamRefs`) on demand to build
+ * entries. Mutations write to a lazily-allocated working copy so the
+ * fast path (no mutation) preserves bit-for-bit reference identity to
+ * the original `plan.params`.
+ *
+ * Threading: `plan.ast` carries the canonical `ParamRef` ordering used
+ * by every consumer (renderer's `$N` index map, encode-side metadata
+ * walk, etc.). The mutator's `entries()` yields the same order so
+ * middleware that filters by codec id sees ParamRefs in the order the
+ * runtime will encode them.
+ */
+declare function createSqlParamRefMutator<TCodecMap extends Record<string, unknown> = Record<string, unknown>>(plan: SqlExecutionPlan): SqlParamRefMutatorInternal<TCodecMap>;
+//#endregion
+export { SqlParamRefMutatorInternal as a, SqlParamRefMutator as i, ParamRefEntryUnion as n, createSqlParamRefMutator as o, ParamRefHandle as r, ParamRefEntry as t };
+//# sourceMappingURL=middleware-B4XbF4d4-tfwBl6mX.d.mts.map

package/dist/middleware-B4XbF4d4-tfwBl6mX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"middleware-B4XbF4d4-tfwBl6mX.d.mts","names":[],"sources":["../../../../2-sql/4-lanes/relational-core/dist/middleware-B4XbF4d4.d.mts"],"mappings":";;;;;;;;;;;;;;cAac;;;;;;;;;;UAUJ,eAAe;YACb,sBAAsB;;;;;;;UAOxB,cAAc;WACb,KAAK,eAAe;WACpB;WACA,SAAS;;;;;;;;;;KAUf,mBAAmB,kBAAkB,8BAA8B,WAAW,qBAAqB,cAAc,YAAY,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;UAyB9I,mBAAmB,kBAAkB,0BAA0B,iCAAiC;;EAExG,WAAW,iBAAiB,mBAAmB;;;;;;;EAO/C,aAAa,uBAAuB,oBAAoB,KAAK,eAAe,WAAW,UAAU,UAAU;EAC3G,aAAa,KAAK,2BAA2B;;EAE7C,cAAc,SAAS;aACZ,KAAK,sBAAsB;aAC3B;;;;;;;;;;;;;UAaH,2BAA2B,kBAAkB,0BAA0B,iCAAiC,mBAAmB;EACnI;;;;;;;;;;;;;;;;;iBAiBe,yBAAyB,kBAAkB,0BAA0B,yBAAyB,MAAM,mBAAmB,2BAA2B"}

package/dist/middleware-ByRsXxxq.d.mts

@@ -0,0 +1 @@
+import "./middleware-B4XbF4d4-tfwBl6mX.mjs";