@prisma/orm-family-sql 8.0.0-rc.2-dev.3 → 8.0.0-rc.20-dev.1

package/dist/transaction-state-DR3nKTmH-D29jmVE-.d.mts

@@ -0,0 +1,115 @@
+import { h as AnyQueryAst, ht as LoweredParam } from "./types-DriMIMNQ-BkbsW7w3.mjs";
+import { l as SqlStatementStats } from "./driver-types-DRsYeq3j-BimeCnUk.mjs";
+import { n as SqlQueryPlan } from "./plan-Cr4azjnG-CuL8FqXC.mjs";
+import { a as CodecValue, i as CodecTypesBase, o as Expression, t as AffectedCount } from "./expression-6ld_ZQL6-fOuazzzm.mjs";
+import "./expression-D8HstQiB.mjs";
+import "./ast-YEMe_B8z.mjs";
+import "./plan-Di6Gs2JD.mjs";
+import { h as RuntimeScope } from "./types-TXO7x1BA-CYYIY8NI.mjs";
+import "./types-B9wSEUsV.mjs";
+import { JsonValue, PlanMeta } from "@prisma/orm-framework/contract/types";
+import { AsyncIterableResult, RuntimeExecuteOptions } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-sql-family/5-runtime/dist/transaction-state-DR3nKTmH.d.mts
+//#region src/prepared/types.d.ts
+type ParamSpec<CT extends CodecTypesBase = CodecTypesBase> = (keyof CT & string) | {
+  readonly codecId: keyof CT & string;
+  readonly typeParams?: JsonValue;
+  readonly nullable?: boolean;
+};
+type Declaration<CT extends CodecTypesBase = CodecTypesBase> = Readonly<Record<string, ParamSpec<CT>>>;
+type DeclaredCodecId<S> = S extends string ? S : S extends {
+  readonly codecId: infer C extends string;
+} ? C : never;
+type DeclaredNullable<S> = S extends {
+  readonly nullable: true;
+} ? true : false;
+type BindSiteParams<D> = { readonly [K in keyof D]: Expression<{
+  codecId: DeclaredCodecId<D[K]>;
+  nullable: DeclaredNullable<D[K]>;
+}>; };
+type ParamsFromDeclaration<D, CT extends CodecTypesBase> = { readonly [K in keyof D]: CodecValue<DeclaredCodecId<D[K]>, DeclaredNullable<D[K]>, CT>; };
+type PrepareCallback<D, Row> = (params: BindSiteParams<D>) => SqlQueryPlan<Row>;
+interface PreparedStatement<Params, Row> {
+  readonly sql: string;
+  readonly ast: AnyQueryAst;
+  readonly meta: PlanMeta;
+  readonly slots: readonly LoweredParam[];
+  readonly _params?: Params;
+  readonly _row?: Row;
+  query(target: RuntimeScope, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+}
+/**
+ * A prepared statement whose plan declares statement statistics rather than
+ * rows. It carries the same lowered statement and bind slots as its
+ * row-streaming sibling and differs in one way: it is consumed by executing
+ * it, which resolves the statistics the statement reports.
+ */
+interface PreparedExecution<Params> {
+  readonly sql: string;
+  readonly ast: AnyQueryAst;
+  readonly meta: PlanMeta;
+  readonly slots: readonly LoweredParam[];
+  readonly _params?: Params;
+  execute(target: RuntimeScope, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
+}
+/**
+ * The prepared handle a plan earns, keyed on the result the plan declares:
+ * statistics prepare into a {@link PreparedExecution}, rows into a
+ * {@link PreparedStatement}. The two faces share no consumption method, so a
+ * handle cannot be read the wrong way round.
+ *
+ * The key is `AffectedCount`'s brand rather than the statistics shape, so a
+ * row spec free to declare a column named `affectedRows` cannot select the
+ * execution face by coincidence. This is the same fact `prepare()` reads at
+ * runtime from the AST's declared result — one decision, stated twice.
+ *
+ * `never` is answered first because it satisfies every `extends`: a builder
+ * state that projects nothing types its rows as `never`, and such a plan
+ * declares rows in its AST, so it earns the statement face the runtime builds
+ * for it.
+ */
+type PreparedFor<Params, Row> = [Row] extends [never] ? PreparedStatement<Params, Row> : [Row] extends [AffectedCount] ? PreparedExecution<Params> : PreparedStatement<Params, Row>;
+//#endregion
+//#region src/prepared/prepared-execute.d.ts
+declare const preparedStatementExecute: unique symbol;
+interface PreparedStatementExecuteTarget extends RuntimeScope {
+  [preparedStatementExecute]<Params>(statement: PreparedExecution<Params>, params: Params, options?: RuntimeExecuteOptions): Promise<SqlStatementStats>;
+}
+//#endregion
+//#region src/prepared/prepared-query.d.ts
+declare const preparedStatementQuery: unique symbol;
+interface PreparedStatementQueryTarget extends RuntimeScope {
+  [preparedStatementQuery]<Params, Row>(statement: PreparedStatement<Params, Row>, params: Params, options?: RuntimeExecuteOptions): AsyncIterableResult<Row>;
+}
+//#endregion
+//#region src/transaction-state.d.ts
+/**
+ * What the database did with a transaction the runtime wrapped. `withTransaction` and the ORM read it to tell a failed `COMMIT` or `ROLLBACK` from an `activityEnded` hook that threw after the database had already settled the transaction.
+ */
+declare const transactionSettlement: unique symbol;
+interface TransactionSettlementState {
+  /** The driver's `COMMIT` resolved. */
+  readonly committed: boolean;
+  /** The driver's `ROLLBACK` resolved. */
+  readonly rolledBack: boolean;
+  /** Passes an `activityEnded` error the caller does not receive to the transaction's log, so it is not lost. */
+  logDroppedError(error: unknown): void;
+}
+interface SettledTransactionTarget {
+  readonly [transactionSettlement]: TransactionSettlementState;
+}
+declare function settlementOf(transaction: object): TransactionSettlementState | undefined;
+/**
+ * How the last transaction start on a connection the runtime made went. `withTransaction` releases the connection after a start the `activityStarted` hooks refused before any `BEGIN` was sent, and destroys it after any other start failure.
+ */
+declare const transactionStart: unique symbol;
+interface TransactionStart {
+  refusedBeforeBegin: boolean;
+}
+interface TransactionStartTarget {
+  readonly [transactionStart]: TransactionStart;
+}
+declare function createTransactionStart(): TransactionStart;
+//#endregion
+export { transactionStart as S, createTransactionStart as _, ParamSpec as a, settlementOf as b, PreparedExecution as c, PreparedStatementExecuteTarget as d, PreparedStatementQueryTarget as f, TransactionStartTarget as g, TransactionStart as h, DeclaredNullable as i, PreparedFor as l, TransactionSettlementState as m, Declaration as n, ParamsFromDeclaration as o, SettledTransactionTarget as p, DeclaredCodecId as r, PrepareCallback as s, BindSiteParams as t, PreparedStatement as u, preparedStatementExecute as v, transactionSettlement as x, preparedStatementQuery as y };
+//# sourceMappingURL=transaction-state-DR3nKTmH-D29jmVE-.d.mts.map

package/dist/transaction-state-DR3nKTmH-D29jmVE-.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transaction-state-DR3nKTmH-D29jmVE-.d.mts","names":[],"sources":["../../../../2-sql-family/5-runtime/dist/transaction-state-DR3nKTmH.d.mts"],"mappings":";;;;;;;;;;;;;KAOK,UAAU,WAAW,iBAAiB,yBAAyB;WACzD,eAAe;WACf,aAAa;WACb;;KAEN,YAAY,WAAW,iBAAiB,kBAAkB,SAAS,eAAe,UAAU;KAC5F,gBAAgB,KAAK,mBAAmB,IAAI;WACtC,eAAe;IACtB;KACC,iBAAiB,KAAK;WAChB;;KAEN,eAAe,iBAAiB,WAAW,IAAI;EAClD,SAAS,gBAAgB,EAAE;EAC3B,UAAU,iBAAiB,EAAE;;KAE1B,sBAAsB,GAAG,WAAW,8BAA8B,WAAW,IAAI,WAAW,gBAAgB,EAAE,KAAK,iBAAiB,EAAE,KAAK;KAC3I,gBAAgB,GAAG,QAAQ,QAAQ,eAAe,OAAO,aAAa;UACjE,kBAAkB,QAAQ;WACzB;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,UAAU;WACV,OAAO;EAChB,MAAM,QAAQ,cAAc,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;;UAQ1F,kBAAkB;WACjB;WACA,KAAK;WACL,MAAM;WACN,gBAAgB;WAChB,UAAU;EACnB,QAAQ,QAAQ,cAAc,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ;;;;;;;;;;;;;;;;;;KAkBrF,YAAY,QAAQ,QAAQ,uBAAuB,kBAAkB,QAAQ,QAAQ,cAAc,iBAAiB,kBAAkB,UAAU,kBAAkB,QAAQ;;;cAGjK;UACJ,uCAAuC;GAC9C,0BAA0B,QAAQ,WAAW,kBAAkB,SAAS,QAAQ,QAAQ,UAAU,wBAAwB,QAAQ;;;;cAIvH;UACJ,qCAAqC;GAC5C,wBAAwB,QAAQ,KAAK,WAAW,kBAAkB,QAAQ,MAAM,QAAQ,QAAQ,UAAU,wBAAwB,oBAAoB;;;;;;;cAO3I;UACJ;;WAEC;;WAEA;;EAET,gBAAgB;;UAER;YACE,wBAAwB;;iBAEnB,aAAa,sBAAsB;;;;cAItC;UACJ;EACR;;UAEQ;YACE,mBAAmB;;iBAEd,0BAA0B"}

package/dist/types-B9wSEUsV.d.mts

@@ -0,0 +1 @@
+import "./types-TXO7x1BA-CYYIY8NI.mjs";

package/dist/{types-CUsJrvEl.mjs → types-CTdSkl0s.mjs}

@@ -1,7 +1,8 @@
-import { o as SqlNode } from "./storage-table-ZzbR-xzQ-BRoTQE_2.mjs";
+import { o as SqlNode } from "./storage-table-DDvN83mw-DkbBFmK9.mjs";
 import { NamespaceBase, freezeNode, isPlainRecord } from "@prisma/orm-framework/components/ir";
 import { InternalError } from "@prisma/orm-framework/utils/internal-error";
-//#region ../../../2-sql/1-core/contract/dist/types.mjs
+import { RelationKeys } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-sql-family/1-core/contract/dist/types.mjs
 /**
 * Sentinel kind for the legacy codec-triple shape persisted under
 * `SqlStorage.types`. Plain JSON-clean object literals carry this
@@ -19,11 +20,17 @@ function toStorageTypeInstance(input) {
 	return {
 		kind: CODEC_INSTANCE_KIND,
 		codecId: input.codecId,
-		nativeType: input.nativeType,
+		dataType: input.dataType,
 		typeParams: input.typeParams ?? {}
 	};
 }
 /**
+* A type's parameters, with empty parameters read as none, as a codec reads them; {@link toStorageTypeInstance} stores `{}` for a codec without parameters.
+*/
+function nonEmptyTypeParams(typeParams) {
+	return typeParams !== void 0 && Object.keys(typeParams).length > 0 ? typeParams : void 0;
+}
+/**
 * Type-guard for codec-typed entries on the polymorphic
 * `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from
 * any class-instance kinds a target pack contributes.
@@ -93,7 +100,7 @@ function normaliseTypeEntry(name, entry) {
 		if ("typeParams" in entry) return entry;
 		return toStorageTypeInstance(entry);
 	}
-	const rawKind = isPlainRecord(entry) ? entry["kind"] : void 0;
+	const rawKind = isPlainRecord(entry) && "kind" in entry ? entry.kind : void 0;
 	const kindDescription = rawKind === void 0 ? "missing `kind` discriminator" : `unrecognised \`kind\` discriminator ${JSON.stringify(rawKind)}`;
 	throw new InternalError(`storage.types[${JSON.stringify(name)}] has ${kindDescription}; expected ${JSON.stringify("codec-instance")}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`);
 }
@@ -106,6 +113,6 @@ function applyFkDefaults(fk, overrideDefaults) {
 	};
 }
 //#endregion
-export { SqlStorage as a, isSqlAuthoringContributions as c, SqlNamespaceBase as i, isStorageTypeInstance as l, DEFAULT_FK_CONSTRAINT as n, applyFkDefaults as o, DEFAULT_FK_INDEX as r, isMaterializedSqlNamespace as s, CODEC_INSTANCE_KIND as t, toStorageTypeInstance as u };
+export { SqlNamespaceBase as a, isMaterializedSqlNamespace as c, nonEmptyTypeParams as d, toStorageTypeInstance as f, RelationKeys as i, isSqlAuthoringContributions as l, DEFAULT_FK_CONSTRAINT as n, SqlStorage as o, DEFAULT_FK_INDEX as r, applyFkDefaults as s, CODEC_INSTANCE_KIND as t, isStorageTypeInstance as u };
 
-//# sourceMappingURL=types-CUsJrvEl.mjs.map
+//# sourceMappingURL=types-CTdSkl0s.mjs.map

package/dist/types-CTdSkl0s.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CTdSkl0s.mjs","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/types.mjs"],"sourcesContent":["import { a as ForeignKey, c as CheckConstraint, i as PrimaryKey, l as SqlNode, n as UniqueConstraint, o as ForeignKeyReference, r as StorageColumn, s as Index, t as StorageTable } from \"./storage-table-DDvN83mw.mjs\";\nimport { i as isStorageValueSet, n as checkConstraintInputFromSerialized, r as StorageValueSet, t as indexInputFromSerialized } from \"./serialized-index-DjCCnXB1.mjs\";\nimport { NamespaceBase, freezeNode, isPlainRecord } from \"@internal/framework-components/ir\";\nimport { InternalError } from \"@internal/utils/internal-error\";\nimport { RelationKeys } from \"@internal/framework-components/runtime\";\n//#region src/ir/storage-type-instance.ts\n/**\n* Sentinel kind for the legacy codec-triple shape persisted under\n* `SqlStorage.types`. Plain JSON-clean object literals carry this\n* discriminator so the polymorphic slot dispatch can route them down\n* the codec path while target-specific IR class instances (e.g. the\n* Postgres enum class) keep their own narrower `kind` literal.\n*/\nconst CODEC_INSTANCE_KIND = \"codec-instance\";\n/**\n* Stamp the codec-instance `kind` discriminator on a caller-supplied\n* codec triple. Idempotent: input that already carries the discriminator\n* passes through unchanged. Missing `typeParams` is normalised to `{}`.\n*/\nfunction toStorageTypeInstance(input) {\n\treturn {\n\t\tkind: CODEC_INSTANCE_KIND,\n\t\tcodecId: input.codecId,\n\t\tdataType: input.dataType,\n\t\ttypeParams: input.typeParams ?? {}\n\t};\n}\n/**\n* A type's parameters, with empty parameters read as none, as a codec reads them; {@link toStorageTypeInstance} stores `{}` for a codec without parameters.\n*/\nfunction nonEmptyTypeParams(typeParams) {\n\treturn typeParams !== void 0 && Object.keys(typeParams).length > 0 ? typeParams : void 0;\n}\n/**\n* Type-guard for codec-typed entries on the polymorphic\n* `SqlStorage.types` slot. Distinguishes `StorageTypeInstance` from\n* any class-instance kinds a target pack contributes.\n*/\nfunction isStorageTypeInstance(value) {\n\tif (typeof value !== \"object\" || value === null) return false;\n\treturn value.kind === CODEC_INSTANCE_KIND;\n}\n//#endregion\n//#region src/ir/sql-storage.ts\n/**\n* Narrows framework `AuthoringContributions` to the SQL-family shape by testing\n* for the SQL-specific `createNamespace` capability.\n*/\nfunction isSqlAuthoringContributions(authoring) {\n\tif (authoring === void 0 || !Object.hasOwn(authoring, \"createNamespace\")) return false;\n\treturn typeof Reflect.get(authoring, \"createNamespace\") === \"function\";\n}\n/**\n* Abstract SQL family namespace base class. Target concretions (`PostgresSchema`,\n* `SqliteDatabase`, …) extend this — it is never instantiated directly.\n* `entries` is the open ADR 224 dictionary: `entries[entityKind][entityName]`\n* addresses any entity.\n*/\nvar SqlNamespaceBase = class extends NamespaceBase {};\n/**\n* Realm-safe guard for hydrated `SqlNamespaceBase` concretions. Checks\n* `qualifyTable` structurally instead of `instanceof NamespaceBase`, so it\n* survives duplicate-module boundaries (e.g. dist e2e where the target and\n* the family carry separate copies of `@internal/framework-components`).\n*\n* Every concrete `SqlNamespaceBase` subclass (`PostgresSchema`, `SqliteDatabase`,\n* `TestSqlNamespace`, …) implements `qualifyTable`. Raw `SqlNamespaceInput`\n* objects (`{ id, entries }`) do not.\n*/\nfunction isMaterializedSqlNamespace(x) {\n\tif (typeof x !== \"object\" || x === null || !(\"qualifyTable\" in x)) return false;\n\treturn typeof x.qualifyTable === \"function\";\n}\nvar SqlStorage = class extends SqlNode {\n\tstorageHash;\n\tnamespaces;\n\tconstructor(input) {\n\t\tsuper();\n\t\tthis.storageHash = input.storageHash;\n\t\tthis.namespaces = Object.freeze(input.namespaces);\n\t\tif (input.types !== void 0) this.types = Object.freeze(Object.fromEntries(Object.entries(input.types).map(([name, ti]) => [name, normaliseTypeEntry(name, ti)])));\n\t\tfreezeNode(this);\n\t}\n};\n/**\n* Strict polymorphic-slot dispatch for `SqlStorage.types` entries.\n* Every entry must carry a `kind: 'codec-instance'` discriminator or\n* be an already-constructed `StorageTypeInstance`. Untagged or\n* unrecognised inputs throw a diagnostic naming the entry and its\n* `kind`, so format drift surfaces loudly at the deserializer\n* boundary instead of slipping past the seam and corrupting\n* downstream IR walks.\n*\n* Codec-triple authors that have an untagged shape on hand can call\n* `toStorageTypeInstance(...)` (which stamps the `'codec-instance'`\n* discriminator) before constructing `SqlStorage`. On-disk reads\n* cross `familyInstance.deserializeContract` first; the structural\n* arktype schema rejects untagged entries earlier, so this throw\n* only fires for in-memory authoring bugs.\n*/\nfunction normaliseTypeEntry(name, entry) {\n\tif (isStorageTypeInstance(entry)) {\n\t\tif (\"typeParams\" in entry) return entry;\n\t\treturn toStorageTypeInstance(entry);\n\t}\n\tconst rawKind = isPlainRecord(entry) && \"kind\" in entry ? entry.kind : void 0;\n\tconst kindDescription = rawKind === void 0 ? \"missing `kind` discriminator\" : `unrecognised \\`kind\\` discriminator ${JSON.stringify(rawKind)}`;\n\tthrow new InternalError(`storage.types[${JSON.stringify(name)}] has ${kindDescription}; expected ${JSON.stringify(\"codec-instance\")}. Untagged codec triples should be wrapped with toStorageTypeInstance(...) before construction.`);\n}\n//#endregion\n//#region src/types.ts\nconst DEFAULT_FK_CONSTRAINT = true;\nconst DEFAULT_FK_INDEX = true;\nfunction applyFkDefaults(fk, overrideDefaults) {\n\treturn {\n\t\tconstraint: fk.constraint ?? overrideDefaults?.constraint ?? true,\n\t\tindex: fk.index ?? overrideDefaults?.index ?? true\n\t};\n}\n//#endregion\nexport { CODEC_INSTANCE_KIND, CheckConstraint, DEFAULT_FK_CONSTRAINT, DEFAULT_FK_INDEX, ForeignKey, ForeignKeyReference, Index, PrimaryKey, RelationKeys, SqlNamespaceBase, SqlNode, SqlStorage, StorageColumn, StorageTable, StorageValueSet, UniqueConstraint, applyFkDefaults, checkConstraintInputFromSerialized, indexInputFromSerialized, isMaterializedSqlNamespace, isSqlAuthoringContributions, isStorageTypeInstance, isStorageValueSet, nonEmptyTypeParams, toStorageTypeInstance };\n\n//# sourceMappingURL=types.mjs.map"],"mappings":";;;;;;;;;;;;AAaA,MAAM,sBAAsB;;;;;;AAM5B,SAAS,sBAAsB,OAAO;CACrC,OAAO;EACN,MAAM;EACN,SAAS,MAAM;EACf,UAAU,MAAM;EAChB,YAAY,MAAM,cAAc,CAAC;CAClC;AACD;;;;AAIA,SAAS,mBAAmB,YAAY;CACvC,OAAO,eAAe,KAAK,KAAK,OAAO,KAAK,UAAU,CAAC,CAAC,SAAS,IAAI,aAAa,KAAK;AACxF;;;;;;AAMA,SAAS,sBAAsB,OAAO;CACrC,IAAI,OAAO,UAAU,YAAY,UAAU,MAAM,OAAO;CACxD,OAAO,MAAM,SAAS;AACvB;;;;;AAOA,SAAS,4BAA4B,WAAW;CAC/C,IAAI,cAAc,KAAK,KAAK,CAAC,OAAO,OAAO,WAAW,iBAAiB,GAAG,OAAO;CACjF,OAAO,OAAO,QAAQ,IAAI,WAAW,iBAAiB,MAAM;AAC7D;;;;;;;AAOA,IAAI,mBAAmB,cAAc,cAAc,CAAC;;;;;;;;;;;AAWpD,SAAS,2BAA2B,GAAG;CACtC,IAAI,OAAO,MAAM,YAAY,MAAM,QAAQ,EAAE,kBAAkB,IAAI,OAAO;CAC1E,OAAO,OAAO,EAAE,iBAAiB;AAClC;AACA,IAAI,aAAa,cAAc,QAAQ;CACtC;CACA;CACA,YAAY,OAAO;EAClB,MAAM;EACN,KAAK,cAAc,MAAM;EACzB,KAAK,aAAa,OAAO,OAAO,MAAM,UAAU;EAChD,IAAI,MAAM,UAAU,KAAK,GAAG,KAAK,QAAQ,OAAO,OAAO,OAAO,YAAY,OAAO,QAAQ,MAAM,KAAK,CAAC,CAAC,KAAK,CAAC,MAAM,QAAQ,CAAC,MAAM,mBAAmB,MAAM,EAAE,CAAC,CAAC,CAAC,CAAC;EAChK,WAAW,IAAI;CAChB;AACD;;;;;;;;;;;;;;;;;AAiBA,SAAS,mBAAmB,MAAM,OAAO;CACxC,IAAI,sBAAsB,KAAK,GAAG;EACjC,IAAI,gBAAgB,OAAO,OAAO;EAClC,OAAO,sBAAsB,KAAK;CACnC;CACA,MAAM,UAAU,cAAc,KAAK,KAAK,UAAU,QAAQ,MAAM,OAAO,KAAK;CAC5E,MAAM,kBAAkB,YAAY,KAAK,IAAI,iCAAiC,uCAAuC,KAAK,UAAU,OAAO;CAC3I,MAAM,IAAI,cAAc,iBAAiB,KAAK,UAAU,IAAI,EAAE,QAAQ,gBAAgB,aAAa,KAAK,UAAU,gBAAgB,EAAE,gGAAgG;AACrO;AAGA,MAAM,wBAAwB;AAC9B,MAAM,mBAAmB;AACzB,SAAS,gBAAgB,IAAI,kBAAkB;CAC9C,OAAO;EACN,YAAY,GAAG,cAAc,kBAAkB,cAAc;EAC7D,OAAO,GAAG,SAAS,kBAAkB,SAAS;CAC/C;AACD"}

package/dist/types-CkAd8SWm.d.mts

@@ -0,0 +1,57 @@
+import "./sql-node-kEz6YFZo-1ogT6Cxt.mjs";
+import "./check-constraint-B7qGu6rc-Bk2ezWXu.mjs";
+import "./foreign-key-qkDFfG8t-TaK_GYWR.mjs";
+import "./unique-constraint-M5TlQnJQ-qX-maNUV.mjs";
+import "./sql-index-ByAAE7K8-Dqtn_vUL.mjs";
+import "./storage-table-Bf1ZjnxO-pUj6pyP0.mjs";
+import "./storage-value-set-BGlj5Uus-ny2k-0PA.mjs";
+import "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import "./serialized-index-CrgG8ct1-DKVJ7TDX.mjs";
+import "./types-DfKvtJwS-CrpWTGBJ.mjs";
+import { ParameterizedOutputTypesFunction, StoredValueType, ValueTypeSide } from "@prisma/orm-framework/contract/types";
+import { RelationKeys, RelationNamesOf, Scalars, Shape, ShapeSpec } from "@prisma/orm-framework/components/runtime";
+//#region ../../../2-sql-family/1-core/contract/dist/types.d.mts
+//#region src/column-type-resolution.d.ts
+type StorageColumnMapAt<SCT, NsId extends string, TableName extends string> = string extends keyof SCT ? never : NsId extends keyof SCT ? string extends keyof SCT[NsId] ? never : TableName extends keyof SCT[NsId] ? SCT[NsId][TableName] : never : never;
+type StorageColumnTypeAcrossNamespaces<SCT, TableName extends string, ColumnName extends string> = { [Ns in keyof SCT]: TableName extends keyof SCT[Ns] ? ColumnName extends keyof SCT[Ns][TableName] ? SCT[Ns][TableName][ColumnName] : never : never; }[keyof SCT];
+type ExecutionDefaultEntryOf<C> = C extends {
+  readonly execution?: infer Execution;
+} ? Execution extends {
+  readonly mutations: {
+    readonly defaults: ReadonlyArray<infer Entry>;
+  };
+} ? Entry : never : never;
+/**
+ * Whether the contract's execution defaults generate a value for the column on create. An entry with only `onUpdate` does not. With `NsId` `never`, the entry may be in any namespace.
+ */
+type HasExecutionCreateDefault<C, NsId extends string, TableName extends string, ColumnName extends string> = [Extract<ExecutionDefaultEntryOf<C>, {
+  readonly ref: {
+    readonly entry: TableName;
+    readonly field: ColumnName;
+  } & ([NsId] extends [never] ? unknown : {
+    readonly namespace: NsId;
+  });
+  readonly onCreate: unknown;
+}>] extends [never] ? false : true;
+/**
+ * Whether a create or insert may leave out the column: it is nullable, has a storage default, or the contract generates its value on create. A column is required only when the contract proves none of these.
+ */
+type IsOptionalCreateColumn<C, Column, NsId extends string, TableName extends string, ColumnName extends string> = [Column] extends [{
+  readonly nullable: false;
+}] ? [Column] extends [{
+  readonly default: unknown;
+}] ? true : HasExecutionCreateDefault<C, NsId, TableName, ColumnName> : true;
+//#endregion
+//#region src/value-type-maps.d.ts
+type Lookup<T, Key> = Key extends keyof T ? T[Key] : never;
+type ColumnTypeParams<Column> = Column extends {
+  readonly typeParams: infer TypeParams;
+} ? TypeParams : undefined;
+type TablesOf<Namespace> = Lookup<Lookup<Namespace, 'entries'>, 'table'>;
+/**
+ * `StorageColumnTypes` (`Side` `'output'`) or `StorageColumnInputTypes` (`'input'`) of a contract whose storage is `Storage`, by the rules of `FieldTypesFromDomain` (`@internal/contract/types`), with `Overrides` keyed by namespace, table and column.
+ */
+type ColumnTypesFromStorage<Storage, CodecTypes, ParameterizedOutputs extends ParameterizedOutputTypesFunction, Overrides, Side extends ValueTypeSide> = { readonly [Ns in keyof Lookup<Storage, 'namespaces'>]: { readonly [T in keyof TablesOf<Lookup<Storage, 'namespaces'>[Ns]>]: { readonly [C in keyof Lookup<TablesOf<Lookup<Storage, 'namespaces'>[Ns]>[T], 'columns'>]: Lookup<TablesOf<Lookup<Storage, 'namespaces'>[Ns]>[T], 'columns'>[C] extends (infer Column) ? StoredValueType<Column, Lookup<Column, 'codecId'>, ColumnTypeParams<Column>, Lookup<Lookup<Lookup<Overrides, Ns>, T>, C>, CodecTypes, ParameterizedOutputs, Side> : never; }; }; };
+//#endregion
+export { RelationNamesOf as a, ShapeSpec as c, RelationKeys as i, StorageColumnMapAt as l, HasExecutionCreateDefault as n, Scalars as o, IsOptionalCreateColumn as r, Shape as s, ColumnTypesFromStorage as t, StorageColumnTypeAcrossNamespaces as u };
+//# sourceMappingURL=types-CkAd8SWm.d.mts.map

package/dist/types-CkAd8SWm.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-CkAd8SWm.d.mts","names":[],"sources":["../../../../2-sql-family/1-core/contract/dist/types.d.mts"],"mappings":";;;;;;;;;;;;;;KAaK,mBAAmB,KAAK,qBAAqB,iDAAiD,cAAc,mBAAmB,2BAA2B,IAAI,gBAAgB,wBAAwB,IAAI,QAAQ,IAAI,MAAM;KAC5N,kCAAkC,KAAK,0BAA0B,gCAAgC,YAAY,MAAM,wBAAwB,IAAI,MAAM,yBAAyB,IAAI,IAAI,aAAa,IAAI,IAAI,WAAW,qCAAqC;KAC3P,wBAAwB,KAAK;WACvB,kBAAkB;IACzB;WACO;aACE,UAAU,oBAAoB;;IAEvC;;;;KAIC,0BAA0B,GAAG,qBAAqB,0BAA0B,8BAA8B,QAAQ,wBAAwB;WACpI;aACE,OAAO;aACP,OAAO;QACZ;aACK,WAAW;;WAEb;;;;;KAKN,uBAAuB,GAAG,QAAQ,qBAAqB,0BAA0B,8BAA8B;WACzG;MACL;WACK;YACC,0BAA0B,GAAG,MAAM,WAAW;;;KAGrD,OAAO,GAAG,OAAO,kBAAkB,IAAI,EAAE;KACzC,iBAAiB,UAAU;WACrB,kBAAkB;IACzB;KACC,SAAS,aAAa,OAAO,OAAO;;;;KAIpC,uBAAuB,SAAS,YAAY,6BAA6B,kCAAkC,WAAW,aAAa,6BAA6B,YAAY,OAAO,qCAAqC,WAAW,SAAS,OAAO,uBAAuB,mBAAmB,WAAW,OAAO,SAAS,OAAO,uBAAuB,KAAK,iBAAiB,OAAO,SAAS,OAAO,uBAAuB,KAAK,eAAe,kBAAkB,UAAU,gBAAgB,QAAQ,OAAO,oBAAoB,iBAAiB,SAAS,OAAO,OAAO,OAAO,WAAW,KAAK,IAAI,IAAI,YAAY,sBAAsB"}

package/dist/{types-IqZMLrFC-DcH8v_u3.d.mts → types-Cq6ImLAB-RlU4jJAX.d.mts}

@@ -1,30 +1,22 @@
-import { r as StorageTable, t as StorageColumn } from "./storage-table-DSeWszOL-CI-cItEK.mjs";
-import { c as SqlStorage, d as StorageTypeInstance } from "./sql-storage-8LqxeLAY-DH4DdUXx.mjs";
-import { O as SqlControlDriverInstance } from "./types-BDUG29Df-LE85dIXP.mjs";
-import "./types-UcHa2cTe.mjs";
-import { r as SqlOperationDescriptors } from "./index-C5I8D-MB.mjs";
-import { v as SqlSchemaIRNode } from "./types-YStFFkKs-D9UAmnON.mjs";
-import "./types-Dwcw0F8X.mjs";
-import { i as SqlControlAdapter } from "./control-adapter-C99J7aEF-B7eQd7vD.mjs";
+import { r as StorageTable, t as StorageColumn } from "./storage-table-Bf1ZjnxO-pUj6pyP0.mjs";
+import { f as StorageTypeInstance, l as SqlStorage } from "./sql-storage-DeCAh5Hi-CEM-m8cs.mjs";
+import { j as SqlControlDriverInstance } from "./types-DfKvtJwS-CrpWTGBJ.mjs";
+import "./types-CkAd8SWm.mjs";
+import { r as SqlOperationDescriptors } from "./index-Nqc3OHR_.mjs";
+import { S as SqlSchemaIRNode } from "./types-CuCxAQat-Dz8P4xyt.mjs";
+import "./types-ljUNyiWe.mjs";
+import { r as SqlControlAdapter } from "./control-adapter-Bn0uhplA-BzP2uPqJ.mjs";
 import { Contract } from "@prisma/orm-framework/contract/types";
-import { Result } from "@prisma/orm-framework/utils/result";
 import { TargetBoundComponentDescriptor } from "@prisma/orm-framework/components/components";
-import { ContractSpace, ControlAdapterDescriptor, ControlExtensionDescriptor, MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlannerConflict, MigrationPlannerFailureResult, MigrationPlannerSuccessResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerPerSpaceSuccessValue, MigrationRunnerResult, OpFactoryCall, OperationContext, SchemaDiffIssue, SchemaOwnership } from "@prisma/orm-framework/components/control";
+import { Result } from "@prisma/orm-framework/utils/result";
+import { CheckExpectation, ContractSpace, ControlAdapterDescriptor, ControlExtensionDescriptor, MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlannerConflict, MigrationPlannerFailureResult, MigrationPlannerSuccessResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerPerSpaceSuccessValue, MigrationRunnerResult, OpFactoryCall, OperationContext, PlanOrigin, ResolvedMigrationStatement, SchemaDiffIssue, SchemaOwnership } from "@prisma/orm-framework/components/control";
 import { AggregateMigrationEdgeRef } from "@prisma/orm-toolchain/migration-tools/aggregate";
-//#region ../../../2-sql/9-family/dist/types-IqZMLrFC.d.mts
+//#region ../../../2-sql-family/9-family/dist/types-Cq6ImLAB.d.mts
 //#region src/core/migrations/types.d.ts
 type AnyRecord = Readonly<Record<string, unknown>>;
 interface StorageTypePlanResult<TTargetDetails> {
   readonly operations: readonly SqlMigrationPlanOperation<TTargetDetails>[];
 }
-/**
- * Input for expanding parameterized native types.
- */
-interface ExpandNativeTypeInput {
-  readonly nativeType: string;
-  readonly codecId?: string;
-  readonly typeParams?: Record<string, unknown>;
-}
 /**
  * Input for resolving an identity-value SQL literal used to backfill existing rows when
  * adding a NOT NULL column without an explicit default.
@@ -33,7 +25,8 @@ interface ExpandNativeTypeInput {
  * (0 for numbers, '' for strings, false for booleans, etc.).
  */
 interface ResolveIdentityValueInput {
-  readonly nativeType: string;
+  /** The id of the data type the column's codec represents. */
+  readonly dataType: string;
   readonly codecId?: string;
   readonly typeParams?: Record<string, unknown>;
 }
@@ -100,17 +93,6 @@ interface CodecControlHooks<TTargetDetails = unknown> {
     readonly driver: SqlControlDriverInstance<string>;
     readonly schemaName?: string;
   }) => Promise<Record<string, StorageTypeInstance>>;
-  /**
-   * Expands a parameterized native type to its full SQL representation.
-   * Used by schema verification to compare contract types against database types.
-   *
-   * For example, expands:
-   * - { nativeType: 'character varying', typeParams: { length: 255 } } -> 'character varying(255)'
-   * - { nativeType: 'numeric', typeParams: { precision: 10, scale: 2 } } -> 'numeric(10,2)'
-   *
-   * Returns the expanded type string, or the original nativeType if no expansion is needed.
-   */
-  expandNativeType?: (input: ExpandNativeTypeInput) => string;
   /**
    * Resolves the identity value (monoid neutral element) as a SQL literal for safely adding
    * a NOT NULL column without an explicit default to a non-empty table.
@@ -168,6 +150,8 @@ interface SqlMigrationPlanOperationStep {
    */
   readonly params?: readonly unknown[];
   readonly meta?: AnyRecord;
+  /** What the step, used as a check, states of the database, when it states an object's absence or presence. */
+  readonly expectation?: CheckExpectation;
 }
 /**
  * Minimal shape every SQL-family target must conform to for its per-operation
@@ -233,7 +217,7 @@ interface SqlMigrationPlan<TTargetDetails> extends MigrationPlan {
   readonly providedInvariants: readonly string[];
   readonly meta?: AnyRecord;
 }
-type SqlPlannerConflictKind = 'typeMismatch' | 'nullabilityConflict' | 'indexIncompatible' | 'rlsPolicyIncompatible' | 'foreignKeyConflict' | 'missingButNonAdditive' | 'unsupportedOperation' | 'controlPolicySuppressedCall';
+type SqlPlannerConflictKind = 'typeMismatch' | 'nullabilityConflict' | 'indexIncompatible' | 'rlsPolicyIncompatible' | 'foreignKeyConflict' | 'missingButNonAdditive' | 'unsupportedOperation' | 'controlPolicySuppressedCall' | 'tableNameCaseChanged' | 'statementRefused';
 interface SqlPlannerConflictLocation {
   readonly namespaceId?: string;
   readonly entityKind?: string;
@@ -287,11 +271,15 @@ interface SqlMigrationPlannerPlanOptions {
    * need from/to column-shape comparisons (unsafe type change, nullability
    * tightening) use this to decide whether to emit `dataTransform`
    * placeholders; they short-circuit when it is `null`.
-   *
-   * Planners also derive the "from" identity they stamp onto the produced
-   * plan's `describe()` as `fromContract?.storage.storageHash ?? null`.
    */
   readonly fromContract: Contract<SqlStorage> | null;
+  /** The origin the produced plan asserts; see the framework planner's `origin` option. */
+  readonly origin: PlanOrigin | null;
+  /**
+   * Statements the user gave, resolved against `fromContract` and `contract`, in the order
+   * given. Empty when the user gave none.
+   */
+  readonly statements: readonly ResolvedMigrationStatement[];
   /**
    * POSIX-relative path from the migration package dir to
    * `migrations/snapshots`, e.g. `'../../snapshots'`. Threaded straight
@@ -310,7 +298,7 @@ interface SqlMigrationPlannerPlanOptions {
    * Ownership oracle over the whole contract-space composition (the passive
    * aggregate). The planner asks it, per live extra node, whether any space
    * declares that entity: a sibling-owned node is left untouched, an unowned
-   * node is a genuine extra it may drop under a destructive policy. The
+   * node is a genuine extra it may drop under a policy that allows the drop's class. The
    * planner holds no list of other spaces' names — ownership lives in the
    * aggregate; it only asks. Absent for a single-space plan handed no
    * aggregate. See {@link SchemaOwnership}.
@@ -345,7 +333,6 @@ interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
    * The runner validates each operation against this policy before execution.
    */
   readonly policy: MigrationOperationPolicy;
-  readonly schemaName?: string;
   readonly strictVerification?: boolean;
   readonly callbacks?: SqlMigrationRunnerExecuteCallbacks<TTargetDetails>;
   readonly context?: OperationContext;
@@ -367,10 +354,9 @@ interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
    */
   readonly migrationEdges: readonly AggregateMigrationEdgeRef[];
 }
-type SqlMigrationRunnerErrorCode = 'MIGRATION.DESTINATION_CONTRACT_MISMATCH' | 'MIGRATION.LEGACY_MARKER_SHAPE' | 'MIGRATION.MARKER_ORIGIN_MISMATCH' | 'MIGRATION.MARKER_CAS_FAILURE' | 'MIGRATION.POLICY_VIOLATION' | 'MIGRATION.PRECHECK_FAILED' | 'MIGRATION.POSTCHECK_FAILED' | 'MIGRATION.SCHEMA_VERIFY_FAILED' | 'MIGRATION.FOREIGN_KEY_VIOLATION' | 'MIGRATION.EXECUTION_FAILED';
+type SqlMigrationRunnerErrorCode = 'MIGRATION.DESTINATION_CONTRACT_MISMATCH' | 'MIGRATION.MARKER_ORIGIN_MISMATCH' | 'MIGRATION.MARKER_CAS_FAILURE' | 'MIGRATION.POLICY_VIOLATION' | 'MIGRATION.PRECHECK_FAILED' | 'MIGRATION.POSTCHECK_FAILED' | 'MIGRATION.SCHEMA_VERIFY_FAILED' | 'MIGRATION.FOREIGN_KEY_VIOLATION' | 'MIGRATION.EXECUTION_FAILED';
 interface SqlMigrationRunnerFailure extends MigrationRunnerFailure {
   readonly code: SqlMigrationRunnerErrorCode;
-  readonly meta?: AnyRecord;
 }
 interface SqlMigrationRunnerSuccessValue extends MigrationRunnerPerSpaceSuccessValue {}
 type SqlMigrationRunnerResult = Result<SqlMigrationRunnerSuccessValue, SqlMigrationRunnerFailure>;
@@ -422,5 +408,5 @@ interface CreateSqlMigrationPlanOptions<TTargetDetails> {
   readonly meta?: AnyRecord;
 }
 //#endregion
-export { SqlPlannerSuccessResult as A, SqlMigrationRunnerSuccessValue as C, SqlPlannerConflictLocation as D, SqlPlannerConflictKind as E, SqlPlannerFailureResult as O, SqlMigrationRunnerResult as S, SqlPlannerConflict as T, SqlMigrationRunner as _, FieldEvent as a, SqlMigrationRunnerExecuteOptions as b, SqlControlAdapterDescriptor as c, SqlMigrationPlanContractInfo as d, SqlMigrationPlanOperation as f, SqlMigrationPlannerPlanOptions as g, SqlMigrationPlanner as h, ExpandNativeTypeInput as i, StorageTypePlanResult as j, SqlPlannerResult as k, SqlControlExtensionDescriptor as l, SqlMigrationPlanOperationTarget as m, CodecControlHooks as n, FieldEventContext as o, SqlMigrationPlanOperationStep as p, CreateSqlMigrationPlanOptions as r, ResolveIdentityValueInput as s, AnyRecord as t, SqlMigrationPlan as u, SqlMigrationRunnerErrorCode as v, SqlPlanTargetDetails as w, SqlMigrationRunnerFailure as x, SqlMigrationRunnerExecuteCallbacks as y };
-//# sourceMappingURL=types-IqZMLrFC-DcH8v_u3.d.mts.map
+export { SqlPlannerConflict as C, SqlPlannerResult as D, SqlPlannerFailureResult as E, SqlPlannerSuccessResult as O, SqlPlanTargetDetails as S, SqlPlannerConflictLocation as T, SqlMigrationRunnerExecuteCallbacks as _, ResolveIdentityValueInput as a, SqlMigrationRunnerResult as b, SqlMigrationPlan as c, SqlMigrationPlanOperationStep as d, SqlMigrationPlanOperationTarget as f, SqlMigrationRunnerErrorCode as g, SqlMigrationRunner as h, FieldEventContext as i, StorageTypePlanResult as k, SqlMigrationPlanContractInfo as l, SqlMigrationPlannerPlanOptions as m, CreateSqlMigrationPlanOptions as n, SqlControlAdapterDescriptor as o, SqlMigrationPlanner as p, FieldEvent as r, SqlControlExtensionDescriptor as s, CodecControlHooks as t, SqlMigrationPlanOperation as u, SqlMigrationRunnerExecuteOptions as v, SqlPlannerConflictKind as w, SqlMigrationRunnerSuccessValue as x, SqlMigrationRunnerFailure as y };
+//# sourceMappingURL=types-Cq6ImLAB-RlU4jJAX.d.mts.map

package/dist/types-Cq6ImLAB-RlU4jJAX.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types-Cq6ImLAB-RlU4jJAX.d.mts","names":[],"sources":["../../../../2-sql-family/9-family/dist/types-Cq6ImLAB.d.mts"],"mappings":";;;;;;;;;;;;;;;KAUK,YAAY,SAAS;UAChB,sBAAsB;WACrB,qBAAqB,0BAA0B;;;;;;;;;UAShD;;WAEC;WACA;WACA,aAAa;;;;;;;;;;;;;;;;KAgBnB;;;;;;;;;;;;;UAaK;WACC;WACA;WACA;WACA,aAAa;WACb,WAAW;WACX,aAAa;WACb,WAAW;;UAEZ,kBAAkB;;;;;;;;;EAS1B,sBAAsB;aACX;aACA,cAAc;aACd,UAAU,SAAS;aACnB,QAAQ;aACR;aACA,QAAQ;QACb,sBAAsB;EAC5B,cAAc;aACH;aACA,cAAc;aACd,QAAQ;aACR;iBACI;EACf,mBAAmB;aACR,QAAQ;aACR;QACL,QAAQ,eAAe;;;;;;;;;;EAU7B,wBAAwB,OAAO;;;;;;;;;;;;;;;EAe/B,gBAAgB,OAAO,YAAY,KAAK,+BAA+B;;UAE/D,8BAA8B,kCAAkC,kCAAkC;WACjG,wBAAwB;;;;;;;;;;;;WAYxB,gBAAgB,cAAc,SAAS;;UAExC,4BAA4B,kCAAkC,gCAAgC,WAAW,kBAAkB;WAC1H,wBAAwB;;UAEzB;WACC;WACA;;;;;;;;;WASA;WACA,OAAO;;WAEP,cAAc;;;;;;;;;UASf;WACC;WACA;;UAED,gCAAgC;WAC/B;WACA,UAAU;;UAEX,0BAA0B,wBAAwB;WACjD;WACA,QAAQ,gCAAgC;WACxC,mBAAmB;WACnB,kBAAkB;WAClB,oBAAoB;WACpB,OAAO;;UAER;WACC;WACA;;UAED,iBAAiB,wBAAwB;;;;;;;;;;;;;;;WAexC;;;;;WAKA,SAAS;;;;WAIT,aAAa;WACb,sBAAsB,0BAA0B,kBAAkB,QAAQ,0BAA0B;;;;;;;;;WASpG;WACA,OAAO;;KAEb;UACK;WACC;WACA;WACA;WACA;WACA;WACA;WACA;;UAED,2BAA2B;WAC1B,MAAM;WACN,WAAW;WACX,OAAO;;UAER,wBAAwB,wBAAwB,KAAK;WACpD;WACA,MAAM,iBAAiB;;UAExB,gCAAgC,KAAK;WACpC;WACA,oBAAoB;;KAE1B,iBAAiB,kBAAkB,wBAAwB,kBAAkB;UACxE;WACC,UAAU,SAAS;;;;;;WAMnB,QAAQ;WACR,QAAQ;WACR;;;;;;;;WAQA;;;;;;;;;;;;;;WAcA,cAAc,SAAS;;WAEvB,QAAQ;;;;;WAKR,qBAAqB;;;;;;;WAOrB;;;;;;;WAOA,qBAAqB,cAAc;;;;;;;;;;WAUnC,YAAY;;UAEb,oBAAoB;EAC5B,KAAK,SAAS,iCAAiC,iBAAiB;;UAExD,mCAAmC;EAC3C,kBAAkB,WAAW,0BAA0B;EACvD,qBAAqB,WAAW,0BAA0B;;UAElD,iCAAiC;WAChC,MAAM,iBAAiB;WACvB,QAAQ;;;;;;;;WAQR;;;;;WAKA,qBAAqB,SAAS;;;;;WAK9B,QAAQ;WACR;WACA,YAAY,mCAAmC;WAC/C,UAAU;;;;;WAKV,kBAAkB;;;;;;;WAOlB,qBAAqB,cAAc;;;;;WAKnC,yBAAyB;;KAE/B;UACK,kCAAkC;WACjC,MAAM;;UAEP,uCAAuC;KAC5C,2BAA2B,OAAO,gCAAgC;UAC7D,mBAAmB;;;;;;;;;;;;;;EAc3B,QAAQ;aACG,QAAQ;aACR,iBAAiB,cAAc,iCAAiC;MACvE,QAAQ;;;;;;;;;;;EAWZ,oBAAoB,SAAS,iCAAiC,kBAAkB,QAAQ;;UAEhF,8BAA8B;WAC7B;;;;WAIA;WACA,SAAS;WACT,aAAa;WACb,qBAAqB,0BAA0B;;;;;;WAM/C;WACA,OAAO"}