@prisma-next/family-sql 0.14.0 → 0.15.0-dev.1

package/dist/diff.d.mts

@@ -0,0 +1,102 @@
+import { a as NativeTypeNormalizer, o as arraysEqual } from "./control-adapter-BQgad8Zc.mjs";
+import { n as CodecControlHooks } from "./types-BPv_y7iS.mjs";
+import { t as SqlSchemaDiffFn } from "./schema-differ-DnoopSXm.mjs";
+import { DiffSubjectGranularity, SchemaDiffIssue, VerifierIssueCategory, VerifyDatabaseSchemaResult } from "@prisma-next/framework-components/control";
+import { Contract, ControlPolicy } from "@prisma-next/contract/types";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
+import { SqlSchemaIRNode } from "@prisma-next/sql-schema-ir/types";
+import { TargetBoundComponentDescriptor } from "@prisma-next/framework-components/components";
+
+//#region src/core/diff/schema-verify.d.ts
+/**
+ * Resolves an issue's framework-neutral {@link DiffSubjectGranularity} on
+ * demand, from the issue's node's `nodeKind` via the target-provided
+ * `granularityOf` map. The node carries only its `nodeKind` identity, never a
+ * classification, and nothing is stamped onto the issue — every consumer
+ * (the family verdict below, the framework aggregate's unclaimed-elements
+ * sweep via {@link import('@prisma-next/framework-components/control').SchemaSubjectClassifierCapable})
+ * calls this the same way, resolved by the family/target that owns the node
+ * vocabulary. `undefined` for an issue with no node.
+ */
+declare function classifyDiffSubjectGranularity(issue: SchemaDiffIssue, granularityOf: (nodeKind: string) => DiffSubjectGranularity): DiffSubjectGranularity | undefined;
+/**
+ * Re-keys the legacy `classifySqlVerifierIssueKind` category mapping on the
+ * issue's {@link DiffSubjectGranularity} (resolved via `granularityOf`) + the
+ * issue reason. The vocabulary maps one-to-one: an undeclared live entity or
+ * namespace is `extraTopLevelObject`, an undeclared live field
+ * `extraNestedElement`, undeclared auxiliaries (constraints, indexes,
+ * defaults) and structural leaves (policies) `extraAuxiliary`; a value-set
+ * drift on a check node is `valueDrift`; every other paired divergence is
+ * `declaredIncompatible`; anything the database lacks is `declaredMissing`.
+ * `granularityOf` is the target's classifier, so target and extension node
+ * kinds classify without the family importing them.
+ */
+declare function classifySqlDiffIssue(issue: SchemaDiffIssue, granularityOf: (nodeKind: string) => DiffSubjectGranularity): VerifierIssueCategory;
+interface SqlDiffVerdictInput {
+  /** The full, ownership-scoped diff issue list from the target's differ. */
+  readonly issues: readonly SchemaDiffIssue[];
+  /** Resolves a diff issue's subject table's declared control policy directly from the contract. */
+  readonly resolveControlPolicy: (issue: SchemaDiffIssue) => ControlPolicy | undefined;
+  readonly strict: boolean;
+  readonly defaultControlPolicy: ControlPolicy | undefined;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+interface SqlDiffVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+/**
+ * Applies the two consumer filters to a diff issue list: strict gating
+ * (relational `not-expected` findings drop in lenient mode) and
+ * control-policy disposition (each surviving issue grades against its
+ * subject table's effective policy; suppressed issues drop, `observed`
+ * subjects warn). The verify verdict is `failures.length === 0`.
+ */
+declare function computeSqlDiffVerdict(input: SqlDiffVerdictInput): SqlDiffVerdict;
+interface StorageTypeVerdictInput {
+  readonly contract: Contract<SqlStorage>;
+  /**
+   * Expected/actual namespace-node pairs the target's differ input produced:
+   * for a namespaced tree, one entry per expected namespace with a
+   * non-empty table set, paired by DDL schema name (absent actual side for
+   * a schema the database lacks); a flat tree is the sole pair.
+   */
+  readonly namespacePairs: ReadonlyArray<{
+    readonly actual: SqlSchemaIRNode | undefined;
+  }>;
+  readonly codecHooks: ReadonlyMap<string, CodecControlHooks>;
+}
+/**
+ * Runs the codec `verifyType` hooks the way the legacy walk did: once per
+ * contract namespace with tables, against that namespace's paired actual
+ * node (the hook reads namespace-scoped state such as `enums` off it).
+ * Issue dispositions grade against the contract default policy, matching
+ * the legacy `pushTypeNode` semantics.
+ */
+interface StorageTypeVerdict {
+  readonly failures: readonly SchemaDiffIssue[];
+  readonly warnings: readonly SchemaDiffIssue[];
+}
+declare function computeStorageTypeVerdict(input: StorageTypeVerdictInput): StorageTypeVerdict;
+interface VerifySqlSchemaByDiffInput {
+  readonly contract: Contract<SqlStorage>;
+  readonly schema: SqlSchemaIRNode;
+  readonly strict: boolean;
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+  /** The target's full-tree node diff (`diffSchema` descriptor hook). */
+  readonly diffSchema: SqlSchemaDiffFn;
+  /** The target's classifier: a diff issue node's `nodeKind` → its subject granularity. */
+  readonly granularityOf: (nodeKind: string) => DiffSubjectGranularity;
+}
+/**
+ * THE SQL schema verify: runs the target's full-tree node diff, grades it
+ * through the family's post-diff filters (strict gating + control-policy
+ * disposition) plus the codec `verifyType` hook findings, and wraps the
+ * verdict in the issue-based result envelope. `ok` holds exactly when both
+ * issue lists are empty — the lists carry the verdict's failures.
+ */
+declare function verifySqlSchemaByDiff(input: VerifySqlSchemaByDiffInput): VerifyDatabaseSchemaResult;
+//#endregion
+export { type NativeTypeNormalizer, type SqlDiffVerdict, type SqlDiffVerdictInput, type StorageTypeVerdict, type StorageTypeVerdictInput, type VerifySqlSchemaByDiffInput, arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, verifySqlSchemaByDiff };
+//# sourceMappingURL=diff.d.mts.map

package/dist/diff.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.d.mts","names":[],"sources":["../src/core/diff/schema-verify.ts"],"mappings":";;;;;;;;;;;;;;AA6DyB;AAsCzB;;;;;iBAzCgB,8BAAA,CACd,KAAA,EAAO,eAAA,EACP,aAAA,GAAgB,QAAA,aAAqB,sBAAA,GACpC,sBAAA;AAqFH;;;;;;;;;;;;AAAA,iBA/CgB,oBAAA,CACd,KAAA,EAAO,eAAA,EACP,aAAA,GAAgB,QAAA,aAAqB,sBAAA,GACpC,qBAAA;AAAA,UA4Cc,mBAAA;EAIiB;EAAA,SAFvB,MAAA,WAAiB,eAAA;EAGjB;EAAA,SADA,oBAAA,GAAuB,KAAA,EAAO,eAAA,KAAoB,aAAA;EAAA,SAClD,MAAA;EAAA,SACA,oBAAA,EAAsB,aAAA;EAEN;EAAA,SAAhB,aAAA,GAAgB,QAAA,aAAqB,sBAAA;AAAA;AAAA,UAG/B,cAAA;EAAA,SACN,QAAA,WAAmB,eAAA;EAAA,SACnB,QAAA,WAAmB,eAAe;AAAA;;;;;;;AAAA;iBAU7B,qBAAA,CAAsB,KAAA,EAAO,mBAAA,GAAsB,cAAc;AAAA,UA+BhE,uBAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAhCmD;;;;;AAAA;EAAA,SAuCtE,cAAA,EAAgB,aAAA;IAAA,SACd,MAAA,EAAQ,eAAA;EAAA;EAAA,SAEV,UAAA,EAAY,WAAA,SAAoB,iBAAA;AAAA;;;;;;;;UAU1B,kBAAA;EAAA,SACN,QAAA,WAAmB,eAAA;EAAA,SACnB,QAAA,WAAmB,eAAe;AAAA;AAAA,iBAG7B,yBAAA,CAA0B,KAAA,EAAO,uBAAA,GAA0B,kBAAkB;AAAA,UA6B5E,0BAAA;EAAA,SACN,QAAA,EAAU,QAAA,CAAS,UAAA;EAAA,SACnB,MAAA,EAAQ,eAAA;EAAA,SACR,MAAA;EAAA,SACA,mBAAA,EAAqB,aAAA,CAAc,8BAAA;EAhDc;EAAA,SAkDjD,UAAA,EAAY,eAAA;EAxCY;EAAA,SA0CxB,aAAA,GAAgB,QAAA,aAAqB,sBAAA;AAAA;;;;;;AAxCH;AAG7C;iBA+CgB,qBAAA,CACd,KAAA,EAAO,0BAAA,GACN,0BAA0B"}

package/dist/diff.mjs

@@ -0,0 +1,14 @@
+import { a as computeStorageTypeVerdict, i as computeSqlDiffVerdict, n as classifyDiffSubjectGranularity, o as verifySqlSchemaByDiff, r as classifySqlDiffIssue } from "./schema-verify-W3r631Jh.mjs";
+//#region src/core/diff/sql-schema-diff.ts
+/**
+* Compares two arrays of strings for equality (order-sensitive).
+*/
+function arraysEqual(a, b) {
+	if (a.length !== b.length) return false;
+	for (let i = 0; i < a.length; i++) if (a[i] !== b[i]) return false;
+	return true;
+}
+//#endregion
+export { arraysEqual, classifyDiffSubjectGranularity, classifySqlDiffIssue, computeSqlDiffVerdict, computeStorageTypeVerdict, verifySqlSchemaByDiff };
+
+//# sourceMappingURL=diff.mjs.map

package/dist/diff.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"diff.mjs","names":[],"sources":["../src/core/diff/sql-schema-diff.ts"],"sourcesContent":["/**\n * Shared relational-diff types and helpers. The coordinate-based issue diff\n * this module used to house (`collectSqlSchemaIssues` /\n * `collectSqlSchemaIssuesPerNamespace`) retired once the migration planner\n * took `plan(start, end)` over the one differ (`buildPostgresPlanDiff` /\n * `buildSqlitePlanDiff`); what remains here is consumed by the surviving\n * verify verdict (`schema-verify.ts`) and the control adapters.\n */\n\nimport type { ColumnDefault } from '@prisma-next/contract/types';\n\n/**\n * Function type for normalizing raw database default expressions into ColumnDefault.\n * Target-specific implementations handle database dialect differences.\n */\nexport type DefaultNormalizer = (\n  rawDefault: string,\n  nativeType: string,\n) => ColumnDefault | undefined;\n\n/**\n * Function type for normalizing schema native types to canonical form for comparison.\n * Target-specific implementations handle dialect-specific type name variations\n * (e.g., Postgres 'varchar' → 'character varying', 'timestamptz' normalization).\n */\nexport type NativeTypeNormalizer = (nativeType: string) => string;\n\n/**\n * Compares two arrays of strings for equality (order-sensitive).\n */\nexport function arraysEqual(a: readonly string[], b: readonly string[]): boolean {\n  if (a.length !== b.length) {\n    return false;\n  }\n  for (let i = 0; i < a.length; i++) {\n    if (a[i] !== b[i]) {\n      return false;\n    }\n  }\n  return true;\n}\n"],"mappings":";;;;;AA8BA,SAAgB,YAAY,GAAsB,GAA+B;CAC/E,IAAI,EAAE,WAAW,EAAE,QACjB,OAAO;CAET,KAAK,IAAI,IAAI,GAAG,IAAI,EAAE,QAAQ,KAC5B,IAAI,EAAE,OAAO,EAAE,IACb,OAAO;CAGX,OAAO;AACT"}

package/dist/ir.d.mts

@@ -1,7 +1,7 @@
-import { ContractSerializer, SchemaIssue, SchemaVerifier, SchemaVerifyOptions, SchemaVerifyResult } from "@prisma-next/framework-components/control";
+import { ContractSerializer, SchemaDiffIssue, SchemaVerifier, SchemaVerifyOptions, SchemaVerifyResult } from "@prisma-next/framework-components/control";
 import { AnyEntityKindDescriptor, Namespace } from "@prisma-next/framework-components/ir";
-import { SqlNamespaceTablesInput, SqlStorage, SqlStorageTypeEntry } from "@prisma-next/sql-contract/types";
 import { Contract } from "@prisma-next/contract/types";
+import { SqlNamespaceInput, SqlStorage, SqlStorageTypeEntry } from "@prisma-next/sql-contract/types";
 import { JsonObject } from "@prisma-next/utils/json";
 
 //#region src/core/ir/sql-contract-serializer-base.d.ts
@@ -41,11 +41,24 @@ declare abstract class SqlContractSerializerBase<TContract extends Contract<SqlS
   sortStorage: import("@prisma-next/contract/hashing").StorageSort;
   protected parseSqlContractStructure(json: unknown): Contract<SqlStorage>;
   protected hydrateSqlStorage(validated: Contract<SqlStorage>): Contract<SqlStorage>;
-  protected abstract get defaultNamespaceId(): string;
-  protected hydrateSqlNamespaceMap(namespaces: Readonly<Record<string, Namespace | Record<string, unknown>>>): Readonly<Record<string, Namespace>>;
-  protected hydrateSqlNamespaceEntry(nsId: string, raw: Namespace | Record<string, unknown>): Namespace | SqlNamespaceTablesInput;
+  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
@@ -57,10 +70,14 @@ declare abstract class SqlContractSerializerBase<TContract extends Contract<SqlS
  * 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();
-  protected get defaultNamespaceId(): string;
 }
 //#endregion
 //#region src/core/ir/sql-schema-verifier-base.d.ts
@@ -68,7 +85,7 @@ declare class SqlContractSerializer extends SqlContractSerializerBase<Contract<S
  * 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
- * existing helpers in `verify-helpers.ts`) and exposes a protected hook
+ * shared satisfaction helpers in `sql-schema-diff.ts`) and exposes a protected hook
  * for target extensions (Postgres functions, RLS policies, future
  * target-only kinds).
  *
@@ -92,13 +109,13 @@ declare abstract class SqlSchemaVerifierBase<TContract, TSchema> implements Sche
    * family-shared implementation today; a future iteration will lift
    * the shared walk into this base.
    */
-  protected abstract verifyCommonSqlSchema(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaIssue[];
+  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 SchemaIssue[];
+  protected abstract verifyTargetExtensions(options: SchemaVerifyOptions<TContract, TSchema>): readonly SchemaDiffIssue[];
 }
 //#endregion
 export { SqlContractSerializer, SqlContractSerializerBase, type SqlEntityHydrationFactory, SqlSchemaVerifierBase };

package/dist/ir.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/core/ir/sql-contract-serializer-base.ts","../src/core/ir/sql-contract-serializer.ts","../src/core/ir/sql-schema-verifier-base.ts"],"mappings":";;;;;;;KAsCY,yBAAA,IAA6B,KAAc;;AAAvD;;;;AAAuD;AA0BvD;;;;;;;;;;;;;;;;;;uBAAsB,yBAAA,mBAA4C,QAAA,CAAS,UAAA,cAC9D,kBAAA,CAAmB,SAAA;EAAA,mBAMT,uBAAA,EAAyB,WAAA,SAE1C,yBAAA;EAAA,iBANa,cAAA;EAAA,iBACA,UAAA;cAGI,uBAAA,GAAyB,WAAA,SAE1C,yBAAA,GAEF,eAAA,YAA0B,uBAAA;EAO5B,mBAAA,WAA8B,SAAA,GAAY,SAAA,EAAW,IAAA,YAAgB,CAAA;EAMrE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;EAIxC,mBAAA,0CAAmB,sBAAA;EAEnB,WAAA,0CAAW,WAAA;EAAA,UAED,yBAAA,CAA0B,IAAA,YAAgB,QAAA,CAAS,UAAA;EAAA,UAOnD,iBAAA,CAAkB,SAAA,EAAW,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA;EAAA,uBAyDhD,kBAAA;EAAA,UAEb,sBAAA,CACR,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,SAAA,GAAY,MAAA,sBAC/C,QAAA,CAAS,MAAA,SAAe,SAAA;EAAA,UAmBjB,wBAAA,CACR,IAAA,UACA,GAAA,EAAK,SAAA,GAAY,MAAA,oBAChB,SAAA,GAAY,uBAAA;EAAA,UAmCL,uBAAA,CAAwB,KAAA,EAAO,mBAAA,GAAsB,mBAAA;EAAA,UAkBrD,uBAAA,CAAwB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,SAAA;AAAA;;;;;;;AAzMrE;;;;AAAuD;cCxB1C,qBAAA,SAA8B,yBAAA,CAA0B,QAAA,CAAS,UAAA;;gBAOrD,kBAAA;AAAA;;;;;;;;;ADiBzB;;;;AAAuD;AA0BvD;;;;;;;;;uBErCsB,qBAAA,gCACT,cAAA,CAAe,SAAA,EAAW,OAAA;EAErC,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;EFoDlC;;;;;;EAAA,mBEvCX,qBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;EF0DoC;;;;;EAAA,mBEnD7B,sBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,WAAA;AAAA"}
+{"version":3,"file":"ir.d.mts","names":[],"sources":["../src/core/ir/sql-contract-serializer-base.ts","../src/core/ir/sql-contract-serializer.ts","../src/core/ir/sql-schema-verifier-base.ts"],"mappings":";;;;;;;KAmCY,yBAAA,IAA6B,KAAc;;AAAvD;;;;AAAuD;AA0BvD;;;;;;;;;;;;;;;;;;uBAAsB,yBAAA,mBAA4C,QAAA,CAAS,UAAA,cAC9D,kBAAA,CAAmB,SAAA;EAAA,mBAMT,uBAAA,EAAyB,WAAA,SAE1C,yBAAA;EAAA,iBANa,cAAA;EAAA,iBACA,UAAA;cAGI,uBAAA,GAAyB,WAAA,SAE1C,yBAAA,GAEF,eAAA,YAA0B,uBAAA;EAO5B,mBAAA,WAA8B,SAAA,GAAY,SAAA,EAAW,IAAA,YAAgB,CAAA;EAMrE,iBAAA,CAAkB,QAAA,EAAU,SAAA,GAAY,UAAA;EAIxC,mBAAA,0CAAmB,sBAAA;EAEnB,WAAA,0CAAW,WAAA;EAAA,UAED,yBAAA,CAA0B,IAAA,YAAgB,QAAA,CAAS,UAAA;EAAA,UAOnD,iBAAA,CAAkB,SAAA,EAAW,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA;EAAA,UAuC7D,sBAAA,CACR,UAAA,EAAY,QAAA,CAAS,MAAA,SAAe,MAAA,sBACnC,QAAA,CAAS,MAAA,SAAe,SAAA;EAAA,UAcjB,wBAAA,CACR,IAAA,UACA,GAAA,EAAK,MAAA,oBACJ,SAAA,GAAY,iBAAA;EAAA,UA+BL,uBAAA,CAAwB,KAAA,EAAO,mBAAA,GAAsB,mBAAA;EAAA,UAkBrD,uBAAA,CAAwB,QAAA,EAAU,QAAA,CAAS,UAAA,IAAc,SAAA;EAAd;;;;;;;;;;EAAA,UAc3C,yBAAA,CACR,OAAA,EAAS,QAAA,CAAS,MAAA,SAAe,QAAA,CAAS,MAAA,uBACzC,MAAA,SAAe,MAAA,SAAe,UAAA;EAAA,QAazB,gBAAA;EAAA,UAQE,mBAAA,CAAoB,KAAA,YAAiB,UAAA;EAAA,QAOvC,kBAAA;AAAA;;;;;;;AAxNV;;;;AAAuD;AA0BvD;;;;;cC3Ca,qBAAA,SAA8B,yBAAA,CAA0B,QAAA,CAAS,UAAA;;;;;;;;;;;ADiB9E;;;;AAAuD;AA0BvD;;;;;;;;;uBElCsB,qBAAA,gCACT,cAAA,CAAe,SAAA,EAAW,OAAA;EAErC,YAAA,CAAa,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,IAAW,kBAAA;EFiDlC;;;;;;EAAA,mBEpCX,qBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,eAAA;EFuDoC;;;;;EAAA,mBEhD7B,sBAAA,CACjB,OAAA,EAAS,mBAAA,CAAoB,SAAA,EAAW,OAAA,aAC9B,eAAA;AAAA"}

package/dist/ir.mjs

@@ -1,10 +1,10 @@
-import { n as SqlContractSerializerBase, t as SqlContractSerializer } from "./sql-contract-serializer-BR2vC7Z-.mjs";
+import { n as SqlContractSerializerBase, t as SqlContractSerializer } from "./sql-contract-serializer-C75cfMSS.mjs";
 //#region src/core/ir/sql-schema-verifier-base.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
-* existing helpers in `verify-helpers.ts`) and exposes a protected hook
+* shared satisfaction helpers in `sql-schema-diff.ts`) and exposes a protected hook
 * for target extensions (Postgres functions, RLS policies, future
 * target-only kinds).
 *

package/dist/ir.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"ir.mjs","names":[],"sources":["../src/core/ir/sql-schema-verifier-base.ts"],"sourcesContent":["import type {\n  SchemaIssue,\n  SchemaVerifier,\n  SchemaVerifyOptions,\n  SchemaVerifyResult,\n} from '@prisma-next/framework-components/control';\n\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 * existing helpers in `verify-helpers.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 */\nexport abstract class SqlSchemaVerifierBase<TContract, TSchema>\n  implements SchemaVerifier<TContract, TSchema>\n{\n  verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult {\n    const issues: SchemaIssue[] = [];\n    issues.push(...this.verifyCommonSqlSchema(options));\n    issues.push(...this.verifyTargetExtensions(options));\n    return { ok: issues.length === 0, issues };\n  }\n\n  /**\n   * SQL-shared verification — table/column/FK/unique/index walks keyed\n   * by `(namespace.id, name)`. Concrete subclasses provide the\n   * family-shared implementation today; a future iteration will lift\n   * the shared walk into this base.\n   */\n  protected abstract verifyCommonSqlSchema(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaIssue[];\n\n  /**\n   * Target-specific extensions — e.g. Postgres functions, future RLS\n   * policies, namespace-mismatch issues. Returns the empty list when the\n   * target ships no extensions over the SQL family alphabet.\n   */\n  protected abstract verifyTargetExtensions(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaIssue[];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,wBAAtB,MAEA;CACE,aAAa,SAAsE;EACjF,MAAM,SAAwB,CAAC;EAC/B,OAAO,KAAK,GAAG,KAAK,sBAAsB,OAAO,CAAC;EAClD,OAAO,KAAK,GAAG,KAAK,uBAAuB,OAAO,CAAC;EACnD,OAAO;GAAE,IAAI,OAAO,WAAW;GAAG;EAAO;CAC3C;AAoBF"}
+{"version":3,"file":"ir.mjs","names":[],"sources":["../src/core/ir/sql-schema-verifier-base.ts"],"sourcesContent":["import type {\n  SchemaDiffIssue,\n  SchemaVerifier,\n  SchemaVerifyOptions,\n  SchemaVerifyResult,\n} from '@prisma-next/framework-components/control';\n\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 */\nexport abstract class SqlSchemaVerifierBase<TContract, TSchema>\n  implements SchemaVerifier<TContract, TSchema>\n{\n  verifySchema(options: SchemaVerifyOptions<TContract, TSchema>): SchemaVerifyResult {\n    const issues: SchemaDiffIssue[] = [];\n    issues.push(...this.verifyCommonSqlSchema(options));\n    issues.push(...this.verifyTargetExtensions(options));\n    return { ok: issues.length === 0, issues };\n  }\n\n  /**\n   * SQL-shared verification — table/column/FK/unique/index walks keyed\n   * by `(namespace.id, name)`. Concrete subclasses provide the\n   * family-shared implementation today; a future iteration will lift\n   * the shared walk into this base.\n   */\n  protected abstract verifyCommonSqlSchema(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaDiffIssue[];\n\n  /**\n   * Target-specific extensions — e.g. Postgres functions, future RLS\n   * policies, namespace-mismatch issues. Returns the empty list when the\n   * target ships no extensions over the SQL family alphabet.\n   */\n  protected abstract verifyTargetExtensions(\n    options: SchemaVerifyOptions<TContract, TSchema>,\n  ): readonly SchemaDiffIssue[];\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AA2BA,IAAsB,wBAAtB,MAEA;CACE,aAAa,SAAsE;EACjF,MAAM,SAA4B,CAAC;EACnC,OAAO,KAAK,GAAG,KAAK,sBAAsB,OAAO,CAAC;EAClD,OAAO,KAAK,GAAG,KAAK,uBAAuB,OAAO,CAAC;EACnD,OAAO;GAAE,IAAI,OAAO,WAAW;GAAG;EAAO;CAC3C;AAoBF"}

package/dist/migration.d.mts

@@ -1,4 +1,6 @@
-import { T as SqlPlanTargetDetails, p as SqlMigrationPlanOperation } from "./types-kgstZ_Zd.mjs";
+import { f as SqlMigrationPlanOperation, w as SqlPlanTargetDetails } from "./types-BPv_y7iS.mjs";
+import { Contract } from "@prisma-next/contract/types";
+import { SqlStorage } from "@prisma-next/sql-contract/types";
 import { Migration } from "@prisma-next/migration-tools/migration";
 
 //#region src/core/sql-migration.d.ts
@@ -13,10 +15,17 @@ import { Migration } from "@prisma-next/migration-tools/migration";
  * fully concrete operation shape. Target-free code in SQL family / tooling
  * parameterises over `TDetails` (and usually `TTargetId = string`).
  *
+ * The `Start` / `End` contract generics are forwarded to the framework
+ * `Migration` base so the derived `describe()` and the per-target view getters
+ * (`PostgresMigration` / `SqliteMigration`) carry each migration's precise
+ * contract types. The view getters themselves live on the per-target bases
+ * because the SQL ContractView shapes differ per target (SQLite unwraps its
+ * sole namespace to the root; Postgres is schema-qualified).
+ *
  * Keeps target-free contract/runtime features in the family layer while
  * letting adapters own target shape.
  */
-declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTargetId extends string = string> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId> {
+declare abstract class SqlMigration<TDetails extends SqlPlanTargetDetails, TTargetId extends string = string, Start extends Contract<SqlStorage> = Contract<SqlStorage>, End extends Contract<SqlStorage> = Contract<SqlStorage>> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId, Start, End> {
   /**
    * Sorted, deduplicated invariant ids declared by this migration's
    * data-transform ops. Derived from `this.operations` so the field remains

package/dist/migration.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"migration.d.mts","names":[],"sources":["../src/core/sql-migration.ts"],"mappings":";;;;;;AAmBA;;;;;;;;;;;;uBAAsB,YAAA,kBACH,oBAAA,6CAET,SAAA,CAAU,yBAAA,CAA0B,QAAA,UAAkB,SAAA;EAAtD;;;;;;AAWc;;;;EAXd,IAWJ,kBAAA;AAAA"}
+{"version":3,"file":"migration.d.mts","names":[],"sources":["../src/core/sql-migration.ts"],"mappings":";;;;;;;;AA4BA;;;;;;;;;;;;;;;;;;;uBAAsB,YAAA,kBACH,oBAAA,mDAEH,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,eAClC,QAAA,CAAS,UAAA,IAAc,QAAA,CAAS,UAAA,WACpC,SAAA,CAAU,yBAAA,CAA0B,QAAA,UAAkB,SAAA,EAAW,KAAA,EAAO,GAAA;EAJhF;;;;;;;;;;EAAA,IAeI,kBAAA;AAAA"}

package/dist/migration.mjs

@@ -13,6 +13,13 @@ import { isThenable } from "@prisma-next/utils/promise";
 * fully concrete operation shape. Target-free code in SQL family / tooling
 * parameterises over `TDetails` (and usually `TTargetId = string`).
 *
+* The `Start` / `End` contract generics are forwarded to the framework
+* `Migration` base so the derived `describe()` and the per-target view getters
+* (`PostgresMigration` / `SqliteMigration`) carry each migration's precise
+* contract types. The view getters themselves live on the per-target bases
+* because the SQL ContractView shapes differ per target (SQLite unwraps its
+* sole namespace to the root; Postgres is schema-qualified).
+*
 * Keeps target-free contract/runtime features in the family layer while
 * letting adapters own target shape.
 */

package/dist/migration.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"migration.mjs","names":[],"sources":["../src/core/sql-migration.ts"],"sourcesContent":["import { deriveProvidedInvariants } from '@prisma-next/migration-tools/invariants';\nimport { Migration } from '@prisma-next/migration-tools/migration';\nimport { isThenable } from '@prisma-next/utils/promise';\nimport type { SqlMigrationPlanOperation, SqlPlanTargetDetails } from './migrations/types';\n\n/**\n * Family-owned base class for SQL migrations.\n *\n * Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)\n * and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).\n *\n * Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and\n * a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the\n * fully concrete operation shape. Target-free code in SQL family / tooling\n * parameterises over `TDetails` (and usually `TTargetId = string`).\n *\n * Keeps target-free contract/runtime features in the family layer while\n * letting adapters own target shape.\n */\nexport abstract class SqlMigration<\n  TDetails extends SqlPlanTargetDetails,\n  TTargetId extends string = string,\n> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId> {\n  /**\n   * Sorted, deduplicated invariant ids declared by this migration's\n   * data-transform ops. Derived from `this.operations` so the field remains\n   * consistent with the operation list — planner-built plans (`db init`,\n   * `db update`) yield `[]` because they emit no data-transform ops.\n   *\n   * Required by `SqlMigrationPlan.providedInvariants` (tightened from\n   * optional at the SQL-family layer); the framework-level\n   * `MigrationPlan.providedInvariants?` stays optional.\n   */\n  get providedInvariants(): readonly string[] {\n    const ops = this.operations.filter(\n      (op): op is SqlMigrationPlanOperation<TDetails> => !isThenable(op),\n    );\n    return deriveProvidedInvariants(ops);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAmBA,IAAsB,eAAtB,cAGU,UAAiE;;;;;;;;;;;CAWzE,IAAI,qBAAwC;EAI1C,OAAO,yBAHK,KAAK,WAAW,QACzB,OAAkD,CAAC,WAAW,EAAE,CAEjC,CAAC;CACrC;AACF"}
+{"version":3,"file":"migration.mjs","names":[],"sources":["../src/core/sql-migration.ts"],"sourcesContent":["import type { Contract } from '@prisma-next/contract/types';\nimport { deriveProvidedInvariants } from '@prisma-next/migration-tools/invariants';\nimport { Migration } from '@prisma-next/migration-tools/migration';\nimport type { SqlStorage } from '@prisma-next/sql-contract/types';\nimport { isThenable } from '@prisma-next/utils/promise';\nimport type { SqlMigrationPlanOperation, SqlPlanTargetDetails } from './migrations/types';\n\n/**\n * Family-owned base class for SQL migrations.\n *\n * Generic in `TDetails` (family plan target details, e.g. Postgres vs SQLite)\n * and in `TTargetId` (the literal target identifier, e.g. `'postgres'`).\n *\n * Adapters (Postgres, SQLite, …) extend this with a concrete `TDetails` and\n * a fixed `TTargetId` literal, so the public `Migration<TOp>` base sees the\n * fully concrete operation shape. Target-free code in SQL family / tooling\n * parameterises over `TDetails` (and usually `TTargetId = string`).\n *\n * The `Start` / `End` contract generics are forwarded to the framework\n * `Migration` base so the derived `describe()` and the per-target view getters\n * (`PostgresMigration` / `SqliteMigration`) carry each migration's precise\n * contract types. The view getters themselves live on the per-target bases\n * because the SQL ContractView shapes differ per target (SQLite unwraps its\n * sole namespace to the root; Postgres is schema-qualified).\n *\n * Keeps target-free contract/runtime features in the family layer while\n * letting adapters own target shape.\n */\nexport abstract class SqlMigration<\n  TDetails extends SqlPlanTargetDetails,\n  TTargetId extends string = string,\n  Start extends Contract<SqlStorage> = Contract<SqlStorage>,\n  End extends Contract<SqlStorage> = Contract<SqlStorage>,\n> extends Migration<SqlMigrationPlanOperation<TDetails>, 'sql', TTargetId, Start, End> {\n  /**\n   * Sorted, deduplicated invariant ids declared by this migration's\n   * data-transform ops. Derived from `this.operations` so the field remains\n   * consistent with the operation list — planner-built plans (`db init`,\n   * `db update`) yield `[]` because they emit no data-transform ops.\n   *\n   * Required by `SqlMigrationPlan.providedInvariants` (tightened from\n   * optional at the SQL-family layer); the framework-level\n   * `MigrationPlan.providedInvariants?` stays optional.\n   */\n  get providedInvariants(): readonly string[] {\n    const ops = this.operations.filter(\n      (op): op is SqlMigrationPlanOperation<TDetails> => !isThenable(op),\n    );\n    return deriveProvidedInvariants(ops);\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AA4BA,IAAsB,eAAtB,cAKU,UAA6E;;;;;;;;;;;CAWrF,IAAI,qBAAwC;EAI1C,OAAO,yBAHK,KAAK,WAAW,QACzB,OAAkD,CAAC,WAAW,EAAE,CAEjC,CAAC;CACrC;AACF"}

package/dist/pack.mjs

@@ -1,4 +1,4 @@
-import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CjFfO6LM.mjs";
+import { i as sqlFamilyPslBlockDescriptors, n as sqlFamilyAuthoringFieldPresets, r as sqlFamilyEntityTypes, t as sqlFamilyAuthoringTypes } from "./authoring-type-constructors-CXd-8ydc.mjs";
 //#region src/exports/pack.ts
 const sqlFamilyPack = {
 	kind: "family",

package/dist/psl-infer.d.mts

@@ -0,0 +1,119 @@
+import { ColumnDefault } from "@prisma-next/contract/types";
+import { SqlForeignKeyIR, SqlTableIR } from "@prisma-next/sql-schema-ir/types";
+
+//#region src/core/psl-contract-infer/default-mapping.d.ts
+interface DefaultMappingOptions {
+  readonly functionAttributes?: Readonly<Record<string, string>>;
+  readonly fallbackFunctionAttribute?: ((expression: string) => string | undefined) | undefined;
+}
+type DefaultMappingResult = {
+  readonly attribute: string;
+} | {
+  readonly comment: string;
+};
+declare function mapDefault(columnDefault: ColumnDefault, options?: DefaultMappingOptions): DefaultMappingResult;
+//#endregion
+//#region src/core/psl-contract-infer/name-transforms.d.ts
+type NameResult = {
+  readonly name: string;
+  readonly map?: string;
+};
+declare function toModelName(tableName: string): NameResult;
+declare function toFieldName(columnName: string): NameResult;
+declare function toEnumName(pgTypeName: string): NameResult;
+/**
+ * PSL member name for a native-enum value. The value itself always prints
+ * explicitly (`member = "value"`), so the returned name never needs a map:
+ * a value that already is a valid, non-reserved identifier is kept verbatim
+ * (case included); anything else is camelCased/escaped like a field name.
+ */
+declare function toEnumMemberName(value: string): string;
+declare function pluralize(word: string): string;
+declare function deriveRelationFieldName(fkColumns: readonly string[], referencedTableName: string): string;
+declare function deriveBackRelationFieldName(childModelName: string, isOneToOne: boolean): string;
+declare function toNamedTypeName(columnName: string): string;
+//#endregion
+//#region src/core/psl-contract-infer/printer-config.d.ts
+type PslNativeTypeAttribute = {
+  readonly name: string;
+  readonly args?: readonly string[];
+};
+type PslTypeResolution = {
+  readonly pslType: string;
+  readonly nativeType: string;
+  readonly typeParams?: Record<string, unknown>;
+  readonly nativeTypeAttribute?: PslNativeTypeAttribute;
+} | {
+  readonly unsupported: true;
+  readonly nativeType: string;
+};
+interface PslTypeMap {
+  resolve(nativeType: string, annotations?: Record<string, unknown>): PslTypeResolution;
+}
+interface EnumInfo {
+  readonly typeNames: ReadonlySet<string>;
+  readonly definitions: ReadonlyMap<string, readonly string[]>;
+}
+interface PslPrinterOptions {
+  readonly typeMap: PslTypeMap;
+  readonly defaultMapping?: DefaultMappingOptions;
+  readonly enumInfo?: EnumInfo;
+  readonly parseRawDefault?: (rawDefault: string, nativeType?: string) => ColumnDefault | undefined;
+}
+type RelationField = {
+  readonly fieldName: string;
+  readonly typeName: string;
+  /**
+   * Namespace qualifier for a cross-space relation (e.g. `"auth"` for a
+   * relation into `supabase:auth.AuthUser`). Absent for a same-namespace
+   * relation.
+   */
+  readonly typeNamespaceId?: string | undefined;
+  /**
+   * Contract-space qualifier for a relation into another stack extension
+   * pack's contract space (e.g. `"supabase"`). Absent for a same-space
+   * relation.
+   */
+  readonly typeContractSpaceId?: string | undefined;
+  readonly referencedTableName?: string | undefined;
+  readonly optional: boolean;
+  readonly list: boolean;
+  readonly relationName?: string | undefined;
+  readonly fkName?: string | undefined;
+  readonly fields?: readonly string[] | undefined;
+  readonly references?: readonly string[] | undefined;
+  readonly onDelete?: string | undefined;
+  readonly onUpdate?: string | undefined; /** `false` when the FK's source columns have no live backing index; omitted (the default) otherwise. */
+  readonly index?: boolean | undefined;
+};
+//#endregion
+//#region src/core/psl-contract-infer/raw-default-parser.d.ts
+declare function parseRawDefault(rawDefault: string, nativeType?: string): ColumnDefault | undefined;
+//#endregion
+//#region src/core/psl-contract-infer/relation-inference.d.ts
+type InferredRelations = {
+  readonly relationsByTable: ReadonlyMap<string, readonly RelationField[]>;
+};
+declare function inferRelations(tables: Record<string, SqlTableIR>, modelNameMap: ReadonlyMap<string, string>): InferredRelations;
+/**
+ * Builds the child-side {@link RelationField} for a single foreign key:
+ * `typeName` is the parent model name, `fields`/`references` are the FK's raw
+ * columns, and `onDelete`/`onUpdate` are normalized to their PSL spelling.
+ * Exported so a caller resolving a foreign key against a model outside
+ * `tables` (e.g. a cross-space reference into another contract) can reuse the
+ * same normalization instead of duplicating it.
+ *
+ * `hostTable` is the table the FK is declared on (i.e. `table`, not the
+ * referenced parent) — its own indexes/uniques/primary key are what a
+ * backing index for this FK would be. When none of them exactly match the
+ * FK's source columns (in order), `index: false` is stamped so the emitted
+ * `@relation` opts out of the framework's default derived backing-index
+ * expectation, matching what `db verify` will find live. Passing the table
+ * is optional so existing single-FK callers (e.g. cross-space resolution
+ * before a host table reference is threaded through) can omit it and keep
+ * the framework default.
+ */
+declare function buildChildRelationField(fieldName: string, parentModelName: string, fk: SqlForeignKeyIR, optional: boolean, relationName?: string, hostTable?: SqlTableIR): RelationField;
+//#endregion
+export { type DefaultMappingOptions, type DefaultMappingResult, type EnumInfo, type InferredRelations, type PslNativeTypeAttribute, type PslPrinterOptions, type PslTypeMap, type PslTypeResolution, type RelationField, buildChildRelationField, deriveBackRelationFieldName, deriveRelationFieldName, inferRelations, mapDefault, parseRawDefault, pluralize, toEnumMemberName, toEnumName, toFieldName, toModelName, toNamedTypeName };
+//# sourceMappingURL=psl-infer.d.mts.map

package/dist/psl-infer.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"psl-infer.d.mts","names":[],"sources":["../src/core/psl-contract-infer/default-mapping.ts","../src/core/psl-contract-infer/name-transforms.ts","../src/core/psl-contract-infer/printer-config.ts","../src/core/psl-contract-infer/raw-default-parser.ts","../src/core/psl-contract-infer/relation-inference.ts"],"mappings":";;;;UAOiB,qBAAA;EAAA,SACN,kBAAA,GAAqB,QAAQ,CAAC,MAAA;EAAA,SAC9B,yBAAA,KAA8B,UAAA;AAAA;AAAA,KAG7B,oBAAA;EAAA,SAAkC,SAAA;AAAA;EAAA,SAAiC,OAAO;AAAA;AAAA,iBAEtE,UAAA,CACd,aAAA,EAAe,aAAA,EACf,OAAA,GAAU,qBAAA,GACT,oBAAA;;;KCbE,UAAA;EAAA,SACM,IAAA;EAAA,SACA,GAAG;AAAA;AAAA,iBA4DE,WAAA,CAAY,SAAA,WAAoB,UAAU;AAAA,iBAqB1C,WAAA,CAAY,UAAA,WAAqB,UAAU;AAAA,iBAqB3C,UAAA,CAAW,UAAA,WAAqB,UAAU;;;;;;;iBA6B1C,gBAAA,CAAiB,KAAa;AAAA,iBAO9B,SAAA,CAAU,IAAY;AAAA,iBAgBtB,uBAAA,CACd,SAAA,qBACA,mBAA2B;AAAA,iBAeb,2BAAA,CAA4B,cAAA,UAAwB,UAAmB;AAAA,iBAKvE,eAAA,CAAgB,UAAkB;;;KCnLtC,sBAAA;EAAA,SACD,IAAA;EAAA,SACA,IAAI;AAAA;AAAA,KAGH,iBAAA;EAAA,SAEG,OAAA;EAAA,SACA,UAAA;EAAA,SACA,UAAA,GAAa,MAAA;EAAA,SACb,mBAAA,GAAsB,sBAAsB;AAAA;EAAA,SAG5C,WAAA;EAAA,SACA,UAAA;AAAA;AAAA,UAGE,UAAA;EACf,OAAA,CAAQ,UAAA,UAAoB,WAAA,GAAc,MAAA,oBAA0B,iBAAiB;AAAA;AAAA,UAGtE,QAAA;EAAA,SACN,SAAA,EAAW,WAAA;EAAA,SACX,WAAA,EAAa,WAAW;AAAA;AAAA,UAGlB,iBAAA;EAAA,SACN,OAAA,EAAS,UAAA;EAAA,SACT,cAAA,GAAiB,qBAAA;EAAA,SACjB,QAAA,GAAW,QAAA;EAAA,SACX,eAAA,IAAmB,UAAA,UAAoB,UAAA,cAAwB,aAAA;AAAA;AAAA,KAG9D,aAAA;EAAA,SACD,SAAA;EAAA,SACA,QAAA;EFtBT;;;AACqB;;EADrB,SE4BS,eAAA;;;;;;WAMA,mBAAA;EAAA,SACA,mBAAA;EAAA,SACA,QAAA;EAAA,SACA,IAAA;EAAA,SACA,YAAA;EAAA,SACA,MAAA;EAAA,SACA,MAAA;EAAA,SACA,UAAA;EAAA,SACA,QAAA;EAAA,SACA,QAAA,uBD4BgD;EAAA,SC1BhD,KAAA;AAAA;;;iBCxBK,eAAA,CACd,UAAA,UACA,UAAA,YACC,aAAa;;;KCrBJ,iBAAA;EAAA,SACD,gBAAA,EAAkB,WAAW,kBAAkB,aAAA;AAAA;AAAA,iBAG1C,cAAA,CACd,MAAA,EAAQ,MAAA,SAAe,UAAA,GACvB,YAAA,EAAc,WAAA,mBACb,iBAAA;;;;;;;;;AJjBwD;AAG3D;;;;AAAsF;AAEtF;;;;iBImJgB,uBAAA,CACd,SAAA,UACA,eAAA,UACA,EAAA,EAAI,eAAA,EACJ,QAAA,WACA,YAAA,WACA,SAAA,GAAY,UAAA,GACX,aAAA"}