@prisma-next/target-postgres 0.14.0-dev.2 → 0.14.0-dev.20

package/src/core/postgres-schema.ts

@@ -17,8 +17,16 @@ import { blindCast } from '@prisma-next/utils/casts';
 import { ifDefined } from '@prisma-next/utils/defined';
 import { PostgresTableSource } from './ast/table-source';
 import { PG_TEXT_CODEC_ID } from './codec-ids';
+import { policyEntityKind, roleEntityKind } from './entity-kinds';
+import type { PostgresRlsPolicy } from './postgres-rls-policy';
+import type { PostgresRole } from './postgres-role';
 import { escapeLiteral } from './sql-utils';
 
+export type PostgresNamespaceEntries = SqlNamespaceEntries & {
+  readonly policy?: Readonly<Record<string, PostgresRlsPolicy>>;
+  readonly role?: Readonly<Record<string, PostgresRole>>;
+};
+
 export interface PostgresSchemaInput {
   readonly id: string;
   readonly entries: Readonly<Record<string, Readonly<Record<string, unknown>>>>;
@@ -50,13 +58,17 @@ export class PostgresSchema extends NamespaceBase {
 
   declare readonly kind: 'schema';
   readonly id: string;
-  readonly entries: SqlNamespaceEntries;
+  readonly entries: PostgresNamespaceEntries;
 
   constructor(input: PostgresSchemaInput) {
     super();
     this.id = input.id;
 
-    const dispatched = hydrateNamespaceEntities(input.entries, composeSqlEntityKinds(), 'carry');
+    const dispatched = hydrateNamespaceEntities(
+      input.entries,
+      composeSqlEntityKinds([policyEntityKind, roleEntityKind]),
+      'carry',
+    );
 
     // Drop an empty valueSet so presence signals non-emptiness.
     const valueSetRaw = dispatched['valueSet'];
@@ -67,8 +79,8 @@ export class PostgresSchema extends NamespaceBase {
 
     this.entries = Object.freeze(
       blindCast<
-        SqlNamespaceEntries,
-        'composeSqlEntityKinds() supplies table→StorageTable and valueSet→StorageValueSet descriptors, so this open-dict result holds exactly the typed members SqlNamespaceEntries declares; the descriptor Map erases those per-kind Node types from the return.'
+        PostgresNamespaceEntries,
+        'composeSqlEntityKinds([policyEntityKind, roleEntityKind]) supplies table→StorageTable, valueSet→StorageValueSet, policy→PostgresRlsPolicy, role→PostgresRole descriptors'
       >(withPresence),
     );
     Object.defineProperty(this, 'kind', {
@@ -88,6 +100,14 @@ export class PostgresSchema extends NamespaceBase {
     return this.entries.valueSet;
   }
 
+  get policy(): Readonly<Record<string, PostgresRlsPolicy>> {
+    return this.entries.policy ?? Object.freeze({});
+  }
+
+  get role(): Readonly<Record<string, PostgresRole>> {
+    return this.entries.role ?? Object.freeze({});
+  }
+
   /**
    * The bare schema qualifier as it would appear in a rendered SQL
    * fragment (already quoted). The unbound-schema singleton overrides

package/src/core/postgres-validators.ts

@@ -0,0 +1,20 @@
+import { type } from 'arktype';
+
+export const PostgresRoleSchema = type({
+  kind: "'role'",
+  name: 'string',
+  namespaceId: 'string',
+});
+
+export const PostgresRlsPolicySchema = type({
+  kind: "'policy'",
+  name: 'string',
+  prefix: 'string',
+  tableName: 'string',
+  namespaceId: 'string',
+  operation: "'select' | 'insert' | 'update' | 'delete' | 'all'",
+  roles: type.string.array().readonly(),
+  'using?': 'string',
+  'withCheck?': 'string',
+  permissive: 'boolean',
+});

package/src/core/rls/canonicalize.ts

@@ -0,0 +1,48 @@
+import { createHash } from 'node:crypto';
+
+export type RlsPolicyOperation = 'select' | 'insert' | 'update' | 'delete' | 'all';
+
+export interface ContentHashParts {
+  readonly using?: string;
+  readonly withCheck?: string;
+  readonly roles: readonly string[];
+  readonly operation: RlsPolicyOperation;
+  readonly permissive: boolean;
+}
+
+/**
+ * Stabilizes an authored predicate for hashing: trim, and collapse runs of
+ * internal whitespace to a single space.
+ *
+ * This is deliberately minimal. The content hash is the equivalence relation
+ * for a policy, and the wire name (prefix + hash) is the only thing ever
+ * compared — we never recompute the hash from an introspected policy body, so
+ * there is no need to match Postgres's reprinted form. Minimal normalization
+ * also protects the no-collision property: aggressive rewriting (lowercasing,
+ * paren-stripping, cast-alias folding) risks collapsing two distinct predicates
+ * onto one hash. Out-of-band alteration of a hashed policy is unsupported.
+ *
+ * The normalizer is a stability commitment: any change re-suffixes all wire names.
+ */
+export function normalizePredicate(sql: string): string {
+  return sql.replace(/\s+/g, ' ').trim();
+}
+
+/**
+ * Returns the first 8 lowercase hex characters of the SHA-256 digest over the
+ * canonical content tuple for an RLS policy:
+ *
+ *   [normalize(using), normalize(withCheck), sortedRoles, operation, permissive]
+ *
+ * Schema and table are excluded (they are orthogonal to policy equivalence).
+ * Uses `JSON.stringify` for a deterministic encoding.
+ */
+export function computeContentHash(parts: ContentHashParts): string {
+  const using = normalizePredicate(parts.using ?? '');
+  const withCheck = normalizePredicate(parts.withCheck ?? '');
+  const roles = [...new Set(parts.roles)].sort();
+  const permissive = parts.permissive ? 'permissive' : 'restrictive';
+
+  const tuple = JSON.stringify([using, withCheck, roles, parts.operation, permissive]);
+  return createHash('sha256').update(tuple).digest('hex').slice(0, 8);
+}

package/src/exports/contract-free.ts

@@ -24,5 +24,11 @@ export {
   buildControlTableBootstrapQueries,
   buildSignMarkerBootstrapQueries,
 } from '../contract-free/control-bootstrap';
-export { addColumnAction, alterTable, createSchema, createTable } from '../contract-free/ddl';
+export {
+  addColumnAction,
+  alterTable,
+  createSchema,
+  createTable,
+  dropDefaultAction,
+} from '../contract-free/ddl';
 export { PostgresTableSource } from '../core/ast/table-source';

package/src/exports/ddl.ts

@@ -3,9 +3,13 @@ export {
   type AlterTableActionVisitor,
   type AnyAlterTableAction,
   type AnyPostgresDdlNode,
+  DropDefaultAction,
   PostgresAlterTable,
+  PostgresCreatePolicy,
   PostgresCreateSchema,
   PostgresCreateTable,
   PostgresDdlNode,
   type PostgresDdlVisitor,
+  PostgresDropPolicy,
+  type RlsPolicyOperation,
 } from '../core/ddl/nodes';

package/src/exports/planner-ddl-builders.ts

@@ -1,7 +1,5 @@
 export {
-  buildAddColumnSql,
   buildColumnDefaultSql,
   buildColumnTypeSql,
-  buildCreateTableSql,
   renderDefaultLiteral,
 } from '../core/migrations/planner-ddl-builders';

package/src/exports/planner.ts

@@ -1 +1,2 @@
 export { createPostgresMigrationPlanner } from '../core/migrations/planner';
+export { diffPostgresRlsPolicies } from '../core/migrations/verify-postgres-rls-policies';

package/src/exports/rls-canonicalize.ts

@@ -0,0 +1,6 @@
+export {
+  type ContentHashParts,
+  computeContentHash,
+  normalizePredicate,
+  type RlsPolicyOperation,
+} from '../core/rls/canonicalize';

package/src/exports/schema-ir-annotations.ts

@@ -0,0 +1 @@
+export { resolveDdlSchemaForNamespaceStorage } from '../core/postgres-schema-ir-annotations';

package/src/exports/types.ts

@@ -1,6 +1,18 @@
 export {
+  PostgresRlsPolicy,
+  type PostgresRlsPolicyInput,
+  type RlsPolicyOperation,
+} from '../core/postgres-rls-policy';
+export { PostgresRole, type PostgresRoleInput } from '../core/postgres-role';
+export {
+  isPostgresSchema,
   PostgresSchema,
   PostgresUnboundSchema,
   postgresCreateNamespace,
 } from '../core/postgres-schema';
+export {
+  isPostgresSchemaIR,
+  PostgresSchemaIR,
+  type PostgresSchemaIRInput,
+} from '../core/postgres-schema-ir';
 export type { PostgresColumnDefault } from '../core/types';

package/dist/ddl-QDyOSeLc.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"ddl-QDyOSeLc.mjs","names":[],"sources":["../src/contract-free/checks.ts","../src/contract-free/ddl.ts"],"sourcesContent":["import type { SelectAst } from '@prisma-next/sql-relational-core/ast';\nimport {\n  type CfExpr,\n  type CfExprSelectQuery,\n  cfExpr,\n  cfTable,\n  exprSelect,\n} from '@prisma-next/sql-relational-core/contract-free';\nimport { PostgresTableSource } from '../core/ast/table-source';\nimport { PG_TEXT_CODEC_ID } from '../core/codec-ids';\nimport { postgresCreateNamespace } from '../core/postgres-schema';\n\n/**\n * `to_regclass($1)` with the qualified table name bound as a text parameter.\n * Thin vocabulary wrapper over the core `cfExpr.fn` helper — the target\n * supplies only the template and the codec'd operand.\n */\nexport function toRegclass(qualifiedName: string): CfExpr {\n  return cfExpr.fn({\n    method: 'to_regclass',\n    template: 'to_regclass({{self}})',\n    self: cfExpr.param(qualifiedName, PG_TEXT_CODEC_ID),\n    returns: { codecId: PG_TEXT_CODEC_ID, nullable: true },\n  });\n}\n\nexport interface TableExistsCheckBuilder {\n  tableAbsent(): SelectAst;\n  tablePresent(): SelectAst;\n}\n\n/**\n * Typed builder for the migration planner's table-existence checks. Produces\n * FROM-less `SELECT to_regclass($1) IS [NOT] NULL AS \"result\"` ASTs with the\n * qualified table name bound as a text parameter — never inlined into the SQL.\n *\n * `schema` is a namespace coordinate: the framework `__unbound__` sentinel\n * elides the qualifier (search_path decides at runtime); any other id\n * qualifies as `\"schema\".\"table\"`.\n */\nexport function tableExistsAst(schema: string, table: string): TableExistsCheckBuilder {\n  const qualified = postgresCreateNamespace({ id: schema, entries: { table: {} } }).qualifyTable(\n    table,\n  );\n  const regclass = toRegclass(qualified);\n  return {\n    tableAbsent: () => exprSelect().project('result', regclass.isNull()).build(),\n    tablePresent: () => exprSelect().project('result', regclass.isNotNull()).build(),\n  };\n}\n\nexport interface ConstraintExistsCheckBuilder {\n  constraintPresent(): SelectAst;\n  constraintAbsent(): SelectAst;\n}\n\n/**\n * Typed builder for the migration planner's constraint-existence checks.\n * Produces `SELECT [NOT ]EXISTS (SELECT 1 FROM pg_constraint c JOIN\n * pg_namespace n ON n.oid = c.connamespace WHERE c.conname = $1 AND\n * n.nspname = $2 [AND c.conrelid = to_regclass($3)]) AS \"result\"` with the\n * constraint name, schema name, and qualified table name bound as text\n * parameters.\n *\n * When `table` is omitted the check matches by name + schema across all\n * tables. Pass `table` to scope the check to a single table (prevents false\n * matches on identically-named constraints in different tables). `schema`\n * is a namespace coordinate: the `__unbound__` sentinel compares `nspname`\n * against `current_schema()` instead of a bound parameter.\n */\nexport function constraintExistsAst(options: {\n  readonly constraintName: string;\n  readonly schema: string;\n  readonly table?: string;\n}): ConstraintExistsCheckBuilder {\n  const namespace = postgresCreateNamespace({ id: options.schema, entries: { table: {} } });\n  const conditions = [\n    cfExpr.columnRef('c', 'conname').eqParam(options.constraintName, PG_TEXT_CODEC_ID),\n    cfExpr.columnRef('n', 'nspname').eqExpr(namespace.schemaFilterExpression()),\n  ];\n  if (options.table !== undefined) {\n    conditions.push(\n      cfExpr.columnRef('c', 'conrelid').eqExpr(toRegclass(namespace.qualifyTable(options.table))),\n    );\n  }\n  const inner = (): CfExprSelectQuery =>\n    exprSelect()\n      .from(cfTable('pg_constraint', 'c'))\n      .join(\n        cfTable('pg_namespace', 'n'),\n        cfExpr.columnRef('n', 'oid').eqExpr(cfExpr.columnRef('c', 'connamespace')),\n      )\n      .project('one', cfExpr.lit(1))\n      .where(cfExpr.allOf(conditions));\n  return {\n    constraintPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),\n    constraintAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),\n  };\n}\n\nfunction checkNamespace(schema: string) {\n  return postgresCreateNamespace({ id: schema, entries: { table: {} } });\n}\n\nfunction informationSchemaColumns(): PostgresTableSource {\n  return new PostgresTableSource({ schema: 'information_schema', name: 'columns' });\n}\n\nfunction infoSchemaColumnConditions(options: {\n  readonly schema: string;\n  readonly table: string;\n  readonly column: string;\n}): CfExpr[] {\n  return [\n    cfExpr\n      .identifierRef('table_schema')\n      .eqExpr(checkNamespace(options.schema).schemaFilterExpression()),\n    cfExpr.identifierRef('table_name').eqParam(options.table, PG_TEXT_CODEC_ID),\n    cfExpr.identifierRef('column_name').eqParam(options.column, PG_TEXT_CODEC_ID),\n  ];\n}\n\nfunction infoSchemaColumnQuery(conditions: ReadonlyArray<CfExpr>): CfExprSelectQuery {\n  return exprSelect()\n    .from(informationSchemaColumns())\n    .project('one', cfExpr.lit(1))\n    .where(cfExpr.allOf(conditions));\n}\n\nexport interface ColumnExistsCheckBuilder {\n  columnPresent(): SelectAst;\n  columnAbsent(): SelectAst;\n}\n\n/**\n * Typed builder for column-existence checks over\n * `information_schema.columns`, with schema, table, and column names bound\n * as text parameters.\n */\nexport function columnExistsAst(options: {\n  readonly schema: string;\n  readonly table: string;\n  readonly column: string;\n}): ColumnExistsCheckBuilder {\n  const inner = () => infoSchemaColumnQuery(infoSchemaColumnConditions(options));\n  return {\n    columnPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),\n    columnAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),\n  };\n}\n\n/**\n * Typed nullability check: EXISTS over `information_schema.columns` with\n * `is_nullable` compared against the bound `'YES'` / `'NO'` marker.\n */\nexport function columnNullabilityAst(options: {\n  readonly schema: string;\n  readonly table: string;\n  readonly column: string;\n  readonly nullable: boolean;\n}): SelectAst {\n  const conditions = [\n    ...infoSchemaColumnConditions(options),\n    cfExpr.identifierRef('is_nullable').eqParam(options.nullable ? 'YES' : 'NO', PG_TEXT_CODEC_ID),\n  ];\n  return exprSelect()\n    .project('result', cfExpr.exists(infoSchemaColumnQuery(conditions)))\n    .build();\n}\n\nexport interface ColumnDefaultCheckBuilder {\n  defaultPresent(): SelectAst;\n  defaultAbsent(): SelectAst;\n  noDefault(): SelectAst;\n}\n\n/**\n * Typed default-presence checks over `information_schema.columns`.\n * `defaultPresent` / `defaultAbsent` assert the column row exists with a\n * non-null / null `column_default`; `noDefault` is the NOT EXISTS variant\n * (also true when the column row is missing entirely).\n */\nexport function columnDefaultAst(options: {\n  readonly schema: string;\n  readonly table: string;\n  readonly column: string;\n}): ColumnDefaultCheckBuilder {\n  const withDefault = () =>\n    infoSchemaColumnQuery([\n      ...infoSchemaColumnConditions(options),\n      cfExpr.identifierRef('column_default').isNotNull(),\n    ]);\n  const withoutDefault = () =>\n    infoSchemaColumnQuery([\n      ...infoSchemaColumnConditions(options),\n      cfExpr.identifierRef('column_default').isNull(),\n    ]);\n  return {\n    defaultPresent: () => exprSelect().project('result', cfExpr.exists(withDefault())).build(),\n    defaultAbsent: () => exprSelect().project('result', cfExpr.exists(withoutDefault())).build(),\n    noDefault: () => exprSelect().project('result', cfExpr.notExists(withDefault())).build(),\n  };\n}\n\n/**\n * Typed column-type check: EXISTS over `pg_attribute` joined to `pg_class`\n * and `pg_namespace`, comparing `format_type(a.atttypid, a.atttypmod)`\n * against the bound expected display type and excluding dropped columns.\n */\nexport function columnTypeAst(options: {\n  readonly schema: string;\n  readonly table: string;\n  readonly column: string;\n  readonly expectedType: string;\n}): SelectAst {\n  const formatType = cfExpr.fn({\n    method: 'format_type',\n    template: 'format_type({{self}}, {{arg0}})',\n    self: cfExpr.columnRef('a', 'atttypid'),\n    args: [cfExpr.columnRef('a', 'atttypmod')],\n    returns: { codecId: PG_TEXT_CODEC_ID, nullable: false },\n  });\n  const inner = exprSelect()\n    .from(cfTable('pg_attribute', 'a'))\n    .join(\n      cfTable('pg_class', 'c'),\n      cfExpr.columnRef('c', 'oid').eqExpr(cfExpr.columnRef('a', 'attrelid')),\n    )\n    .join(\n      cfTable('pg_namespace', 'n'),\n      cfExpr.columnRef('n', 'oid').eqExpr(cfExpr.columnRef('c', 'relnamespace')),\n    )\n    .project('one', cfExpr.lit(1))\n    .where(\n      cfExpr.allOf([\n        cfExpr\n          .columnRef('n', 'nspname')\n          .eqExpr(checkNamespace(options.schema).schemaFilterExpression()),\n        cfExpr.columnRef('c', 'relname').eqParam(options.table, PG_TEXT_CODEC_ID),\n        cfExpr.columnRef('a', 'attname').eqParam(options.column, PG_TEXT_CODEC_ID),\n        formatType.eqParam(options.expectedType, PG_TEXT_CODEC_ID),\n        cfExpr.columnRef('a', 'attisdropped').not(),\n      ]),\n    );\n  return exprSelect().project('result', cfExpr.exists(inner)).build();\n}\n\nexport interface TablePrimaryKeyCheckBuilder {\n  pkPresent(): SelectAst;\n  pkAbsent(): SelectAst;\n}\n\n/**\n * Typed primary-key existence check over `pg_index` joined to `pg_class`\n * and `pg_namespace`, with a LEFT JOIN on the index relation so an\n * optional `constraintName` can scope the match to a named constraint.\n */\nexport function tablePrimaryKeyAst(options: {\n  readonly schema: string;\n  readonly table: string;\n  readonly constraintName?: string;\n}): TablePrimaryKeyCheckBuilder {\n  const conditions = [\n    cfExpr\n      .columnRef('n', 'nspname')\n      .eqExpr(checkNamespace(options.schema).schemaFilterExpression()),\n    cfExpr.columnRef('c', 'relname').eqParam(options.table, PG_TEXT_CODEC_ID),\n    cfExpr.columnRef('i', 'indisprimary'),\n  ];\n  if (options.constraintName !== undefined) {\n    conditions.push(\n      cfExpr.columnRef('c2', 'relname').eqParam(options.constraintName, PG_TEXT_CODEC_ID),\n    );\n  }\n  const inner = () =>\n    exprSelect()\n      .from(cfTable('pg_index', 'i'))\n      .join(\n        cfTable('pg_class', 'c'),\n        cfExpr.columnRef('c', 'oid').eqExpr(cfExpr.columnRef('i', 'indrelid')),\n      )\n      .join(\n        cfTable('pg_namespace', 'n'),\n        cfExpr.columnRef('n', 'oid').eqExpr(cfExpr.columnRef('c', 'relnamespace')),\n      )\n      .leftJoin(\n        cfTable('pg_class', 'c2'),\n        cfExpr.columnRef('c2', 'oid').eqExpr(cfExpr.columnRef('i', 'indexrelid')),\n      )\n      .project('one', cfExpr.lit(1))\n      .where(cfExpr.allOf(conditions));\n  return {\n    pkPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),\n    pkAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),\n  };\n}\n\n/**\n * Typed emptiness check: NOT EXISTS over the user table itself with\n * `LIMIT 1`. The table is addressed through the namespace's polymorphic\n * `tableSource` (qualified for named schemas, bare for the unbound slot).\n */\nexport function tableIsEmptyAst(schema: string, table: string): SelectAst {\n  const inner = exprSelect()\n    .from(checkNamespace(schema).tableSource(table))\n    .project('one', cfExpr.lit(1))\n    .limit(1);\n  return exprSelect().project('result', cfExpr.notExists(inner)).build();\n}\n\n/**\n * Typed no-NULL-values data check used by `SET NOT NULL` prechecks:\n * NOT EXISTS over the user table where the column IS NULL.\n */\nexport function noNullValuesAst(options: {\n  readonly schema: string;\n  readonly table: string;\n  readonly column: string;\n}): SelectAst {\n  const inner = exprSelect()\n    .from(checkNamespace(options.schema).tableSource(options.table))\n    .project('one', cfExpr.lit(1))\n    .where(cfExpr.identifierRef(options.column).isNull());\n  return exprSelect().project('result', cfExpr.notExists(inner)).build();\n}\n\nexport interface ExtensionExistsCheckBuilder {\n  extensionPresent(): SelectAst;\n  extensionAbsent(): SelectAst;\n}\n\n/**\n * Typed extension existence check over `pg_extension`, with the extension\n * name bound as a text parameter.\n */\nexport function extensionExistsAst(extensionName: string): ExtensionExistsCheckBuilder {\n  const inner = () =>\n    exprSelect()\n      .from(cfTable('pg_extension'))\n      .project('one', cfExpr.lit(1))\n      .where(cfExpr.identifierRef('extname').eqParam(extensionName, PG_TEXT_CODEC_ID));\n  return {\n    extensionPresent: () => exprSelect().project('result', cfExpr.exists(inner())).build(),\n    extensionAbsent: () => exprSelect().project('result', cfExpr.notExists(inner())).build(),\n  };\n}\n\nexport interface IndexExistsCheckBuilder {\n  indexPresent(): SelectAst;\n  indexAbsent(): SelectAst;\n}\n\n/**\n * Typed index existence check riding the same `to_regclass` vocabulary as\n * `tableExistsAst`, with the qualified index name bound as a text parameter.\n */\nexport function indexExistsAst(schema: string, indexName: string): IndexExistsCheckBuilder {\n  const regclass = toRegclass(checkNamespace(schema).qualifyTable(indexName));\n  return {\n    indexPresent: () => exprSelect().project('result', regclass.isNotNull()).build(),\n    indexAbsent: () => exprSelect().project('result', regclass.isNull()).build(),\n  };\n}\n","import type { DdlColumn, DdlTableConstraint } from '@prisma-next/sql-relational-core/ast';\nimport {\n  AddColumnAction,\n  type AnyAlterTableAction,\n  PostgresAlterTable,\n  PostgresCreateSchema,\n  PostgresCreateTable,\n} from '../core/ddl/nodes';\n\n/**\n * Build a Postgres `CREATE TABLE` query node.\n *\n * Pass `constraints` for table-level composite primary keys, foreign keys, and\n * unique constraints — use the {@link PrimaryKeyConstraint}, {@link ForeignKeyConstraint},\n * and {@link UniqueConstraint} classes from `@prisma-next/sql-relational-core/ast`.\n *\n * Precondition: identifiers (`table`, `schema`, column names/types) are\n * emitted to SQL verbatim — they are not quoted or escaped, so callers must\n * pass pre-trusted values (e.g. fixed control-plane identifiers). String-literal\n * default values, by contrast, are single-quote-escaped (embedded `'` doubled)\n * by the renderer. Identifier quoting for untrusted identifiers is added when\n * the migration planner adopts this lowering path.\n */\nexport function createTable(options: {\n  readonly table: string;\n  readonly schema?: string;\n  readonly ifNotExists?: boolean;\n  readonly columns: readonly DdlColumn[];\n  readonly constraints?: readonly DdlTableConstraint[];\n}): PostgresCreateTable {\n  return new PostgresCreateTable(options);\n}\n\n/**\n * Build a Postgres `CREATE SCHEMA` query node. See {@link createTable} for the\n * pre-trusted-identifier precondition.\n */\nexport function createSchema(options: {\n  readonly schema: string;\n  readonly ifNotExists?: boolean;\n}): PostgresCreateSchema {\n  return new PostgresCreateSchema(options);\n}\n\n/**\n * Build an `ADD COLUMN` action for use inside {@link alterTable}.\n * The column is a structured `DdlColumn` so codec-encoded defaults flow\n * through the adapter's `pgRenderDdlColumn` → `pgRenderDdlColumnDefault` path.\n */\nexport function addColumnAction(column: DdlColumn): AddColumnAction {\n  return new AddColumnAction(column);\n}\n\n/**\n * Build a Postgres `ALTER TABLE` query node carrying one or more actions.\n * See {@link addColumnAction} for building actions.\n */\nexport function alterTable(options: {\n  readonly table: string;\n  readonly schema?: string;\n  readonly actions: readonly AnyAlterTableAction[];\n}): PostgresAlterTable {\n  return new PostgresAlterTable(options);\n}\n"],"mappings":"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"}

package/dist/default-normalizer-DyyCHQWs.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"default-normalizer-DyyCHQWs.mjs","names":[],"sources":["../src/core/default-normalizer.ts"],"sourcesContent":["import type { ColumnDefault } from '@prisma-next/contract/types';\n\n/**\n * Pre-compiled regex patterns for performance.\n * These are compiled once at module load time rather than on each function call.\n */\nconst NEXTVAL_PATTERN = /^nextval\\s*\\(/i;\nconst NOW_FUNCTION_PATTERN = /^(now\\s*\\(\\s*\\)|CURRENT_TIMESTAMP)$/i;\nconst CLOCK_TIMESTAMP_PATTERN = /^clock_timestamp\\s*\\(\\s*\\)$/i;\nconst TIMESTAMP_CAST_SUFFIX = /::timestamp(?:tz|\\s+(?:with|without)\\s+time\\s+zone)?$/i;\nconst TEXT_CAST_SUFFIX = /::text$/i;\nconst NOW_LITERAL_PATTERN = /^'now'$/i;\nconst UUID_PATTERN = /^gen_random_uuid\\s*\\(\\s*\\)$/i;\nconst UUID_OSSP_PATTERN = /^uuid_generate_v4\\s*\\(\\s*\\)$/i;\nconst NULL_PATTERN = /^NULL(?:::.+)?$/i;\nconst TRUE_PATTERN = /^true$/i;\nconst FALSE_PATTERN = /^false$/i;\nconst NUMERIC_PATTERN = /^-?\\d+(\\.\\d+)?$/;\nconst STRING_LITERAL_PATTERN = /^'((?:[^']|'')*)'(?:::(?:\"[^\"]+\"|[\\w\\s]+)(?:\\(\\d+\\))?)?$/;\n\n/**\n * Returns the canonical expression for a timestamp default function, or undefined\n * if the expression is not a recognized timestamp default.\n *\n * Keeps now()/CURRENT_TIMESTAMP and clock_timestamp() distinct:\n * - now(), CURRENT_TIMESTAMP, ('now'::text)::timestamp... → 'now()'\n * - clock_timestamp(), clock_timestamp()::timestamptz → 'clock_timestamp()'\n *\n * These are semantically different in Postgres: now() returns the transaction\n * start time (constant within a transaction), while clock_timestamp() returns\n * the actual wall-clock time (can differ across rows in a single INSERT).\n */\nfunction canonicalizeTimestampDefault(expr: string): string | undefined {\n  if (NOW_FUNCTION_PATTERN.test(expr)) return 'now()';\n  if (CLOCK_TIMESTAMP_PATTERN.test(expr)) return 'clock_timestamp()';\n\n  if (!TIMESTAMP_CAST_SUFFIX.test(expr)) return undefined;\n\n  let inner = expr.replace(TIMESTAMP_CAST_SUFFIX, '').trim();\n\n  if (inner.startsWith('(') && inner.endsWith(')')) {\n    inner = inner.slice(1, -1).trim();\n  }\n\n  if (NOW_FUNCTION_PATTERN.test(inner)) return 'now()';\n  if (CLOCK_TIMESTAMP_PATTERN.test(inner)) return 'clock_timestamp()';\n\n  inner = inner.replace(TEXT_CAST_SUFFIX, '').trim();\n  if (NOW_LITERAL_PATTERN.test(inner)) return 'now()';\n\n  return undefined;\n}\n\n/**\n * Parses a raw Postgres column default expression into a normalized ColumnDefault.\n * This enables semantic comparison between contract defaults and introspected schema defaults.\n *\n * Used by the migration diff layer to normalize raw database defaults during comparison,\n * keeping the introspection layer focused on faithful data capture.\n *\n * @param rawDefault - Raw default expression from information_schema.columns.column_default\n * @param nativeType - Native column type, used for type-aware parsing (bigint tagging, JSON detection)\n * @returns Normalized ColumnDefault or undefined if the expression cannot be parsed\n */\nexport function parsePostgresDefault(\n  rawDefault: string,\n  nativeType?: string,\n): ColumnDefault | undefined {\n  const trimmed = rawDefault.trim();\n  const normalizedType = nativeType?.toLowerCase();\n  const isBigInt = normalizedType === 'bigint' || normalizedType === 'int8';\n\n  if (NEXTVAL_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'autoincrement()' };\n  }\n\n  const canonicalTimestamp = canonicalizeTimestampDefault(trimmed);\n  if (canonicalTimestamp) {\n    return { kind: 'function', expression: canonicalTimestamp };\n  }\n\n  if (UUID_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'gen_random_uuid()' };\n  }\n\n  if (UUID_OSSP_PATTERN.test(trimmed)) {\n    return { kind: 'function', expression: 'gen_random_uuid()' };\n  }\n\n  if (NULL_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: null };\n  }\n\n  if (TRUE_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: true };\n  }\n  if (FALSE_PATTERN.test(trimmed)) {\n    return { kind: 'literal', value: false };\n  }\n\n  if (NUMERIC_PATTERN.test(trimmed)) {\n    const num = Number(trimmed);\n    if (!Number.isFinite(num)) return undefined;\n    if (isBigInt && !Number.isSafeInteger(num)) {\n      return { kind: 'literal', value: trimmed };\n    }\n    return { kind: 'literal', value: num };\n  }\n\n  const stringMatch = trimmed.match(STRING_LITERAL_PATTERN);\n  if (stringMatch?.[1] !== undefined) {\n    const unescaped = stringMatch[1].replace(/''/g, \"'\");\n    if (normalizedType === 'json' || normalizedType === 'jsonb') {\n      try {\n        return { kind: 'literal', value: JSON.parse(unescaped) };\n      } catch {\n        // Keep legacy behavior for malformed/non-JSON string content.\n      }\n    }\n    if (isBigInt && NUMERIC_PATTERN.test(unescaped)) {\n      const num = Number(unescaped);\n      if (Number.isSafeInteger(num)) {\n        return { kind: 'literal', value: num };\n      }\n      return { kind: 'literal', value: unescaped };\n    }\n    return { kind: 'literal', value: unescaped };\n  }\n\n  return { kind: 'function', expression: trimmed };\n}\n"],"mappings":";;;;;AAMA,MAAM,kBAAkB;AACxB,MAAM,uBAAuB;AAC7B,MAAM,0BAA0B;AAChC,MAAM,wBAAwB;AAC9B,MAAM,mBAAmB;AACzB,MAAM,sBAAsB;AAC5B,MAAM,eAAe;AACrB,MAAM,oBAAoB;AAC1B,MAAM,eAAe;AACrB,MAAM,eAAe;AACrB,MAAM,gBAAgB;AACtB,MAAM,kBAAkB;AACxB,MAAM,yBAAyB;;;;;;;;;;;;;AAc/B,SAAS,6BAA6B,MAAkC;CACtE,IAAI,qBAAqB,KAAK,IAAI,GAAG,OAAO;CAC5C,IAAI,wBAAwB,KAAK,IAAI,GAAG,OAAO;CAE/C,IAAI,CAAC,sBAAsB,KAAK,IAAI,GAAG,OAAO,KAAA;CAE9C,IAAI,QAAQ,KAAK,QAAQ,uBAAuB,EAAE,CAAC,CAAC,KAAK;CAEzD,IAAI,MAAM,WAAW,GAAG,KAAK,MAAM,SAAS,GAAG,GAC7C,QAAQ,MAAM,MAAM,GAAG,EAAE,CAAC,CAAC,KAAK;CAGlC,IAAI,qBAAqB,KAAK,KAAK,GAAG,OAAO;CAC7C,IAAI,wBAAwB,KAAK,KAAK,GAAG,OAAO;CAEhD,QAAQ,MAAM,QAAQ,kBAAkB,EAAE,CAAC,CAAC,KAAK;CACjD,IAAI,oBAAoB,KAAK,KAAK,GAAG,OAAO;AAG9C;;;;;;;;;;;;AAaA,SAAgB,qBACd,YACA,YAC2B;CAC3B,MAAM,UAAU,WAAW,KAAK;CAChC,MAAM,iBAAiB,YAAY,YAAY;CAC/C,MAAM,WAAW,mBAAmB,YAAY,mBAAmB;CAEnE,IAAI,gBAAgB,KAAK,OAAO,GAC9B,OAAO;EAAE,MAAM;EAAY,YAAY;CAAkB;CAG3D,MAAM,qBAAqB,6BAA6B,OAAO;CAC/D,IAAI,oBACF,OAAO;EAAE,MAAM;EAAY,YAAY;CAAmB;CAG5D,IAAI,aAAa,KAAK,OAAO,GAC3B,OAAO;EAAE,MAAM;EAAY,YAAY;CAAoB;CAG7D,IAAI,kBAAkB,KAAK,OAAO,GAChC,OAAO;EAAE,MAAM;EAAY,YAAY;CAAoB;CAG7D,IAAI,aAAa,KAAK,OAAO,GAC3B,OAAO;EAAE,MAAM;EAAW,OAAO;CAAK;CAGxC,IAAI,aAAa,KAAK,OAAO,GAC3B,OAAO;EAAE,MAAM;EAAW,OAAO;CAAK;CAExC,IAAI,cAAc,KAAK,OAAO,GAC5B,OAAO;EAAE,MAAM;EAAW,OAAO;CAAM;CAGzC,IAAI,gBAAgB,KAAK,OAAO,GAAG;EACjC,MAAM,MAAM,OAAO,OAAO;EAC1B,IAAI,CAAC,OAAO,SAAS,GAAG,GAAG,OAAO,KAAA;EAClC,IAAI,YAAY,CAAC,OAAO,cAAc,GAAG,GACvC,OAAO;GAAE,MAAM;GAAW,OAAO;EAAQ;EAE3C,OAAO;GAAE,MAAM;GAAW,OAAO;EAAI;CACvC;CAEA,MAAM,cAAc,QAAQ,MAAM,sBAAsB;CACxD,IAAI,cAAc,OAAO,KAAA,GAAW;EAClC,MAAM,YAAY,YAAY,EAAE,CAAC,QAAQ,OAAO,GAAG;EACnD,IAAI,mBAAmB,UAAU,mBAAmB,SAClD,IAAI;GACF,OAAO;IAAE,MAAM;IAAW,OAAO,KAAK,MAAM,SAAS;GAAE;EACzD,QAAQ,CAER;EAEF,IAAI,YAAY,gBAAgB,KAAK,SAAS,GAAG;GAC/C,MAAM,MAAM,OAAO,SAAS;GAC5B,IAAI,OAAO,cAAc,GAAG,GAC1B,OAAO;IAAE,MAAM;IAAW,OAAO;GAAI;GAEvC,OAAO;IAAE,MAAM;IAAW,OAAO;GAAU;EAC7C;EACA,OAAO;GAAE,MAAM;GAAW,OAAO;EAAU;CAC7C;CAEA,OAAO;EAAE,MAAM;EAAY,YAAY;CAAQ;AACjD"}

package/dist/descriptor-meta-CpGygXpI.mjs

@@ -1,140 +0,0 @@
-import { temporalAuthoringPresets } from "@prisma-next/family-sql/control";
-//#region src/core/authoring.ts
-const postgresAuthoringTypes = {};
-const postgresAuthoringEntityTypes = {};
-/**
-* Field presets contributed by the Postgres target pack.
-*
-* These mirror the PSL scalar-to-codec mapping used by the Postgres adapter
-* (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field
-* via the TS callback surface (e.g. `field.int()`) and via the PSL scalar
-* surface (e.g. `Int`) lowers to byte-identical contracts.
-*
-* The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the
-* native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target
-* portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from
-* the family pack instead.
-*/
-const postgresAuthoringFieldPresets = {
-	text: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/text@1",
-			nativeType: "text"
-		}
-	},
-	int: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/int4@1",
-			nativeType: "int4"
-		}
-	},
-	bigint: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/int8@1",
-			nativeType: "int8"
-		}
-	},
-	float: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/float8@1",
-			nativeType: "float8"
-		}
-	},
-	decimal: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/numeric@1",
-			nativeType: "numeric"
-		}
-	},
-	boolean: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/bool@1",
-			nativeType: "bool"
-		}
-	},
-	json: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/jsonb@1",
-			nativeType: "jsonb"
-		}
-	},
-	bytes: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/bytea@1",
-			nativeType: "bytea"
-		}
-	},
-	dateTime: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/timestamptz@1",
-			nativeType: "timestamptz"
-		}
-	},
-	temporal: /* @__PURE__ */ temporalAuthoringPresets({
-		codecId: "pg/timestamptz@1",
-		nativeType: "timestamptz"
-	}),
-	uuidNative: {
-		kind: "fieldPreset",
-		output: {
-			codecId: "pg/uuid@1",
-			nativeType: "uuid"
-		}
-	},
-	id: {
-		uuidv4Native: {
-			kind: "fieldPreset",
-			output: {
-				codecId: "pg/uuid@1",
-				nativeType: "uuid",
-				executionDefaults: { onCreate: {
-					kind: "generator",
-					id: "uuidv4"
-				} },
-				id: true
-			}
-		},
-		uuidv7Native: {
-			kind: "fieldPreset",
-			output: {
-				codecId: "pg/uuid@1",
-				nativeType: "uuid",
-				executionDefaults: { onCreate: {
-					kind: "generator",
-					id: "uuidv7"
-				} },
-				id: true
-			}
-		}
-	}
-};
-const postgresTargetDescriptorMetaRuntime = {
-	kind: "target",
-	familyId: "sql",
-	targetId: "postgres",
-	id: "postgres",
-	version: "0.0.1",
-	capabilities: {}
-};
-const postgresTargetDescriptorMeta = {
-	...postgresTargetDescriptorMetaRuntime,
-	defaultNamespaceId: "public",
-	authoring: {
-		type: postgresAuthoringTypes,
-		field: postgresAuthoringFieldPresets,
-		entityTypes: postgresAuthoringEntityTypes
-	}
-};
-//#endregion
-export { postgresTargetDescriptorMetaRuntime as n, postgresAuthoringEntityTypes as r, postgresTargetDescriptorMeta as t };
-
-//# sourceMappingURL=descriptor-meta-CpGygXpI.mjs.map

package/dist/descriptor-meta-CpGygXpI.mjs.map

@@ -1 +0,0 @@
-{"version":3,"file":"descriptor-meta-CpGygXpI.mjs","names":[],"sources":["../src/core/authoring.ts","../src/core/descriptor-meta-runtime.ts","../src/core/descriptor-meta.ts"],"sourcesContent":["import { temporalAuthoringPresets } from '@prisma-next/family-sql/control';\nimport type {\n  AuthoringEntityTypeNamespace,\n  AuthoringFieldNamespace,\n  AuthoringTypeNamespace,\n} from '@prisma-next/framework-components/authoring';\n\nexport const postgresAuthoringTypes = {} as const satisfies AuthoringTypeNamespace;\n\nexport const postgresAuthoringEntityTypes = {} as const satisfies AuthoringEntityTypeNamespace;\n\n/**\n * Field presets contributed by the Postgres target pack.\n *\n * These mirror the PSL scalar-to-codec mapping used by the Postgres adapter\n * (see `createPostgresPslScalarTypeDescriptors`), so that authoring a field\n * via the TS callback surface (e.g. `field.int()`) and via the PSL scalar\n * surface (e.g. `Int`) lowers to byte-identical contracts.\n *\n * The `uuidNative` / `id.uuidv4Native` / `id.uuidv7Native` presets use the\n * native Postgres `uuid` type (codecId `pg/uuid@1`). For cross-target\n * portability use `uuidString` / `id.uuidv4String` / `id.uuidv7String` from\n * the family pack instead.\n */\nexport const postgresAuthoringFieldPresets = {\n  text: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/text@1',\n      nativeType: 'text',\n    },\n  },\n  int: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int4@1',\n      nativeType: 'int4',\n    },\n  },\n  bigint: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/int8@1',\n      nativeType: 'int8',\n    },\n  },\n  float: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/float8@1',\n      nativeType: 'float8',\n    },\n  },\n  decimal: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/numeric@1',\n      nativeType: 'numeric',\n    },\n  },\n  boolean: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bool@1',\n      nativeType: 'bool',\n    },\n  },\n  json: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/jsonb@1',\n      nativeType: 'jsonb',\n    },\n  },\n  bytes: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/bytea@1',\n      nativeType: 'bytea',\n    },\n  },\n  dateTime: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/timestamptz@1',\n      nativeType: 'timestamptz',\n    },\n  },\n  temporal: /* @__PURE__ */ temporalAuthoringPresets({\n    codecId: 'pg/timestamptz@1',\n    nativeType: 'timestamptz',\n  }),\n  uuidNative: {\n    kind: 'fieldPreset',\n    output: {\n      codecId: 'pg/uuid@1',\n      nativeType: 'uuid',\n    },\n  },\n  id: {\n    uuidv4Native: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: 'pg/uuid@1',\n        nativeType: 'uuid',\n        executionDefaults: {\n          onCreate: {\n            kind: 'generator',\n            id: 'uuidv4',\n          },\n        },\n        id: true,\n      },\n    },\n    uuidv7Native: {\n      kind: 'fieldPreset',\n      output: {\n        codecId: 'pg/uuid@1',\n        nativeType: 'uuid',\n        executionDefaults: {\n          onCreate: {\n            kind: 'generator',\n            id: 'uuidv7',\n          },\n        },\n        id: true,\n      },\n    },\n  },\n} as const satisfies AuthoringFieldNamespace;\n","// Runtime-safe slice of the postgres target descriptor metadata.\n//\n// This file exists separately from ./descriptor-meta on purpose: the runtime\n// plane reads only `kind/familyId/targetId/id/version/capabilities` (plus the\n// `__codecTypes` phantom). The `authoring` slot lives on the pack/control\n// descriptor only, because authoring contributions are consumed at\n// contract-construction time by `assembleAuthoringContributions` (control\n// plane) and the PSL interpreter — never at runtime.\n//\n// Keeping the runtime closure free of the `./authoring` import is what lets\n// the bundler tree-shake `@prisma-next/family-sql/control` (and its\n// transitive `verify-sql-schema` chunk) out of the runtime entry. Do not\n// add an `authoring` field here — if you need to, the pack/control meta in\n// `./descriptor-meta` is the right place. See TML-2766 for context.\nimport type { CodecTypes } from '../exports/codec-types';\n\nconst postgresTargetDescriptorMetaRuntimeBase = {\n  kind: 'target',\n  familyId: 'sql',\n  targetId: 'postgres',\n  id: 'postgres',\n  version: '0.0.1',\n  capabilities: {},\n} as const;\n\nexport const postgresTargetDescriptorMetaRuntime: typeof postgresTargetDescriptorMetaRuntimeBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaRuntimeBase;\n","import type { CodecTypes } from '../exports/codec-types';\nimport {\n  postgresAuthoringEntityTypes,\n  postgresAuthoringFieldPresets,\n  postgresAuthoringTypes,\n} from './authoring';\nimport { postgresTargetDescriptorMetaRuntime } from './descriptor-meta-runtime';\n\nconst postgresTargetDescriptorMetaBase = {\n  ...postgresTargetDescriptorMetaRuntime,\n  defaultNamespaceId: 'public',\n  authoring: {\n    type: postgresAuthoringTypes,\n    field: postgresAuthoringFieldPresets,\n    entityTypes: postgresAuthoringEntityTypes,\n  },\n} as const;\n\nexport const postgresTargetDescriptorMeta: typeof postgresTargetDescriptorMetaBase & {\n  readonly __codecTypes?: CodecTypes;\n} = postgresTargetDescriptorMetaBase;\n"],"mappings":";;AAOA,MAAa,yBAAyB,CAAC;AAEvC,MAAa,+BAA+B,CAAC;;;;;;;;;;;;;;AAe7C,MAAa,gCAAgC;CAC3C,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,KAAK;EACH,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,QAAQ;EACN,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,SAAS;EACP,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,MAAM;EACJ,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,OAAO;EACL,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,UAAU;EACR,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,UAA0B,yCAAyB;EACjD,SAAS;EACT,YAAY;CACd,CAAC;CACD,YAAY;EACV,MAAM;EACN,QAAQ;GACN,SAAS;GACT,YAAY;EACd;CACF;CACA,IAAI;EACF,cAAc;GACZ,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,mBAAmB,EACjB,UAAU;KACR,MAAM;KACN,IAAI;IACN,EACF;IACA,IAAI;GACN;EACF;EACA,cAAc;GACZ,MAAM;GACN,QAAQ;IACN,SAAS;IACT,YAAY;IACZ,mBAAmB,EACjB,UAAU;KACR,MAAM;KACN,IAAI;IACN,EACF;IACA,IAAI;GACN;EACF;CACF;AACF;ACxGA,MAAa,sCAET;CAVF,MAAM;CACN,UAAU;CACV,UAAU;CACV,IAAI;CACJ,SAAS;CACT,cAAc,CAAC;AAKb;ACTJ,MAAa,+BAET;CAXF,GAAG;CACH,oBAAoB;CACpB,WAAW;EACT,MAAM;EACN,OAAO;EACP,aAAa;CACf;AAKE"}