@happyvertical/smrt-core 0.43.9 → 0.44.0

package/dist/schema/uuid-convergence.d.ts

@@ -0,0 +1,142 @@
+import { SchemaDefinition } from './types.js';
+/** One physical column participating in a manifest UUID relationship. */
+export interface UuidConvergenceNode {
+    table: string;
+    column: string;
+}
+/** A planned, executable `text` → `uuid` conversion for one column. */
+export interface UuidConvergenceConversion extends UuidConvergenceNode {
+    /** The live PostgreSQL type the column has today (e.g. `text`). */
+    liveType: string;
+    /** Ordered statements: optional `DROP DEFAULT`, then the type change. */
+    statements: string[];
+}
+/**
+ * A relationship group that must converge but cannot be converged safely.
+ * Reported, never executed.
+ */
+export interface UuidConvergenceBlock {
+    /** Every column in the affected relationship component, sorted. */
+    nodes: UuidConvergenceNode[];
+    /** Which columns would have had to change, sorted. */
+    targets: UuidConvergenceNode[];
+    /** Why the automatic conversion is refused. */
+    reason: string;
+    /** Manual remediation the operator can inspect and run deliberately. */
+    suggestedSql: string[];
+}
+/** Result of {@link planUuidConvergence}. */
+export interface UuidConvergencePlan {
+    /** Executable conversions, ordered parent-first then by table/column. */
+    conversions: UuidConvergenceConversion[];
+    /** Components that need convergence but were refused. */
+    blocks: UuidConvergenceBlock[];
+    /**
+     * Type each column will have once this plan is applied: `UUID` for a
+     * converted or already-native column, the normalized live type otherwise.
+     * Callers use it to decide whether a foreign key is safe to emit in the
+     * same run.
+     */
+    effectiveType(table: string, column: string): string | undefined;
+}
+/** Live shape of one column, as the planner needs it. */
+export interface UuidConvergenceLiveColumn {
+    /** Normalized bucket — `UUID`, `TEXT`, or any other normalized type. */
+    normalizedType: string;
+    /** Raw live type as introspected, used verbatim in diagnostics. */
+    rawType: string;
+    /** True when the live column carries a DEFAULT that must be dropped first. */
+    hasDefault: boolean;
+    /** False when the table/column does not exist yet (it will be created). */
+    exists: boolean;
+}
+/** One live foreign key that already constrains a pair of columns. */
+export interface UuidConvergenceLiveForeignKey {
+    table: string;
+    column: string;
+    referencesTable: string;
+    referencesColumn: string;
+}
+/** Outcome of probing a column for values that are not uuid-shaped. */
+export type UuidShapeProbeResult = {
+    status: 'clean';
+} | {
+    status: 'dirty';
+    count: number;
+    sample?: string;
+} | {
+    status: 'unavailable';
+    reason: string;
+};
+/** One manifest-declared relationship considered for convergence. */
+export interface UuidConvergenceRelationship {
+    childTable: string;
+    childColumn: string;
+    parentTable: string;
+    parentColumn: string;
+}
+/** Inputs {@link planUuidConvergence} needs from the live database. */
+export interface UuidConvergenceInput {
+    manifestSchemas: Record<string, SchemaDefinition>;
+    /**
+     * Physical relationships declared by the manifest for this engine. The
+     * caller filters engine allowlists (`@foreignKey({ constraint: { engines }})`)
+     * before handing them over.
+     */
+    relationships: readonly UuidConvergenceRelationship[];
+    /** Live column shape, or `undefined` when the column does not exist yet. */
+    getLiveColumn(table: string, column: string): UuidConvergenceLiveColumn | undefined;
+    /** Every live foreign key across the schemas under comparison. */
+    liveForeignKeys: readonly UuidConvergenceLiveForeignKey[];
+    /** Probe run once per column that would be rewritten. */
+    probeUuidShape(table: string, column: string): Promise<UuidShapeProbeResult>;
+}
+/** Stable key for one `table.column` node. */
+export declare function uuidConvergenceNodeKey(table: string, column: string): string;
+/**
+ * SQL that counts, and samples, values a `text` column holds that could not
+ * be reinterpreted as `uuid`. `0` rows means the conversion is safe.
+ */
+export declare function renderUuidShapeProbe(tableName: string, columnName: string): string;
+/**
+ * Render the one-time PostgreSQL conversion of a legacy `text` identifier or
+ * reference column to native `uuid`.
+ *
+ * A live DEFAULT is dropped first: PostgreSQL refuses `ALTER COLUMN … TYPE`
+ * when the existing default cannot be cast automatically, and the differ's
+ * ordinary default comparison re-establishes the manifest default on the next
+ * run once the type is settled.
+ */
+export declare function renderUuidColumnConversion(tableName: string, columnName: string, options?: {
+    hasDefault?: boolean;
+}): string[];
+/**
+ * The `[SchemaManager]`/`[SchemaComparer]` sentence that describes one
+ * incompatible child/parent pair. Shared so the runtime guard and the status
+ * planner say exactly the same thing about the same drift.
+ */
+export declare function describeForeignKeyTypeConflict(input: {
+    childTable: string;
+    childColumn: string;
+    childType: string;
+    parentTable: string;
+    parentColumn: string;
+    parentType: string;
+}): string;
+/**
+ * Remediation text appended to every incompatible-type diagnostic: the
+ * planned convergence normally handles it, and this is the manual equivalent.
+ */
+export declare function renderUuidConvergenceRepairHint(nodes: readonly UuidConvergenceNode[]): string[];
+/**
+ * Group manifest UUID relationships into connected components and decide,
+ * per component, whether the live database must converge on native `uuid`.
+ *
+ * Components — not individual pairs — are the unit of decision because a
+ * single legacy `text` primary key can be referenced by several children:
+ * converting the parent for one child would break every other member that is
+ * still `text`. Self-referential tables fall out of the same grouping (both
+ * endpoints land in one component).
+ */
+export declare function planUuidConvergence(input: UuidConvergenceInput): Promise<UuidConvergencePlan>;
+//# sourceMappingURL=uuid-convergence.d.ts.map

package/dist/schema/uuid-convergence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid-convergence.d.ts","sourceRoot":"","sources":["../../src/schema/uuid-convergence.ts"],"names":[],"mappings":"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"}

package/dist/schema/uuid-convergence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"uuid-convergence.js","names":[],"sources":["../../src/schema/uuid-convergence.ts"],"sourcesContent":["/**\n * UUID convergence for pre-R11 PostgreSQL databases (#2608).\n *\n * R11 made SMRT identifiers and references native `uuid` on PostgreSQL.\n * Databases created before that change still carry `text` id columns, while\n * every column added afterwards materializes as `uuid`. PostgreSQL cannot\n * implement a `FOREIGN KEY` across those two physical types — there is no\n * cast inside FK DDL — so `ALTER TABLE … ADD CONSTRAINT … NOT VALID` fails\n * with SQLSTATE 42804 and takes the rest of the migration batch with it.\n *\n * This module owns the deterministic half of the repair:\n *\n * - {@link renderUuidColumnConversion} renders the one-time\n *   `ALTER COLUMN … TYPE uuid USING …::uuid` (plus the `DROP DEFAULT` a live\n *   text default would otherwise block), and\n * - {@link planUuidConvergence} decides *which* columns must convert, by\n *   grouping every manifest-declared UUID relationship into connected\n *   components and converging a component only when the live database already\n *   proves the target shape (at least one side is native `uuid`).\n *\n * The planner never coerces data: a component converges only when a caller\n * supplied probe confirms every non-null value is uuid-shaped, no live\n * foreign key depends on a column being rewritten, and no member carries some\n * third physical type. Anything else is returned as a *block* with an\n * operator-facing reason, so `db:status` can report \"blocked\" instead of\n * \"pending\" and `db:migrate` never attempts DDL PostgreSQL will reject.\n *\n * A database whose relationship is `text` on *both* sides is left alone: that\n * is the tolerated pre-R11 shape (see the R11 uuid/text equivalence in\n * `migrations/differ.ts`), and its foreign keys apply fine.\n */\n\nimport { CANONICAL_UUID_PATTERN } from './foreign-key-ddl.js';\nimport { quoteIdentifier } from './sql-identifiers.js';\nimport type { SchemaDefinition } from './types.js';\n\n/** One physical column participating in a manifest UUID relationship. */\nexport interface UuidConvergenceNode {\n  table: string;\n  column: string;\n}\n\n/** A planned, executable `text` → `uuid` conversion for one column. */\nexport interface UuidConvergenceConversion extends UuidConvergenceNode {\n  /** The live PostgreSQL type the column has today (e.g. `text`). */\n  liveType: string;\n  /** Ordered statements: optional `DROP DEFAULT`, then the type change. */\n  statements: string[];\n}\n\n/**\n * A relationship group that must converge but cannot be converged safely.\n * Reported, never executed.\n */\nexport interface UuidConvergenceBlock {\n  /** Every column in the affected relationship component, sorted. */\n  nodes: UuidConvergenceNode[];\n  /** Which columns would have had to change, sorted. */\n  targets: UuidConvergenceNode[];\n  /** Why the automatic conversion is refused. */\n  reason: string;\n  /** Manual remediation the operator can inspect and run deliberately. */\n  suggestedSql: string[];\n}\n\n/** Result of {@link planUuidConvergence}. */\nexport interface UuidConvergencePlan {\n  /** Executable conversions, ordered parent-first then by table/column. */\n  conversions: UuidConvergenceConversion[];\n  /** Components that need convergence but were refused. */\n  blocks: UuidConvergenceBlock[];\n  /**\n   * Type each column will have once this plan is applied: `UUID` for a\n   * converted or already-native column, the normalized live type otherwise.\n   * Callers use it to decide whether a foreign key is safe to emit in the\n   * same run.\n   */\n  effectiveType(table: string, column: string): string | undefined;\n}\n\n/** Live shape of one column, as the planner needs it. */\nexport interface UuidConvergenceLiveColumn {\n  /** Normalized bucket — `UUID`, `TEXT`, or any other normalized type. */\n  normalizedType: string;\n  /** Raw live type as introspected, used verbatim in diagnostics. */\n  rawType: string;\n  /** True when the live column carries a DEFAULT that must be dropped first. */\n  hasDefault: boolean;\n  /** False when the table/column does not exist yet (it will be created). */\n  exists: boolean;\n}\n\n/** One live foreign key that already constrains a pair of columns. */\nexport interface UuidConvergenceLiveForeignKey {\n  table: string;\n  column: string;\n  referencesTable: string;\n  referencesColumn: string;\n}\n\n/** Outcome of probing a column for values that are not uuid-shaped. */\nexport type UuidShapeProbeResult =\n  | { status: 'clean' }\n  | { status: 'dirty'; count: number; sample?: string }\n  | { status: 'unavailable'; reason: string };\n\n/** One manifest-declared relationship considered for convergence. */\nexport interface UuidConvergenceRelationship {\n  childTable: string;\n  childColumn: string;\n  parentTable: string;\n  parentColumn: string;\n}\n\n/** Inputs {@link planUuidConvergence} needs from the live database. */\nexport interface UuidConvergenceInput {\n  manifestSchemas: Record<string, SchemaDefinition>;\n  /**\n   * Physical relationships declared by the manifest for this engine. The\n   * caller filters engine allowlists (`@foreignKey({ constraint: { engines }})`)\n   * before handing them over.\n   */\n  relationships: readonly UuidConvergenceRelationship[];\n  /** Live column shape, or `undefined` when the column does not exist yet. */\n  getLiveColumn(\n    table: string,\n    column: string,\n  ): UuidConvergenceLiveColumn | undefined;\n  /** Every live foreign key across the schemas under comparison. */\n  liveForeignKeys: readonly UuidConvergenceLiveForeignKey[];\n  /** Probe run once per column that would be rewritten. */\n  probeUuidShape(table: string, column: string): Promise<UuidShapeProbeResult>;\n}\n\n/** Stable key for one `table.column` node. */\nexport function uuidConvergenceNodeKey(table: string, column: string): string {\n  return `${table}\u0000${column}`;\n}\n\nfunction describeNode(node: UuidConvergenceNode): string {\n  return `${node.table}.${node.column}`;\n}\n\n/**\n * SQL that counts, and samples, values a `text` column holds that could not\n * be reinterpreted as `uuid`. `0` rows means the conversion is safe.\n */\nexport function renderUuidShapeProbe(\n  tableName: string,\n  columnName: string,\n): string {\n  const column = quoteIdentifier(columnName);\n  return (\n    `SELECT count(*) AS invalid_count, min(${column}::text) AS sample_value ` +\n    `FROM ${quoteIdentifier(tableName)} ` +\n    `WHERE ${column} IS NOT NULL AND ${column}::text !~* '${CANONICAL_UUID_PATTERN}'`\n  );\n}\n\n/**\n * Render the one-time PostgreSQL conversion of a legacy `text` identifier or\n * reference column to native `uuid`.\n *\n * A live DEFAULT is dropped first: PostgreSQL refuses `ALTER COLUMN … TYPE`\n * when the existing default cannot be cast automatically, and the differ's\n * ordinary default comparison re-establishes the manifest default on the next\n * run once the type is settled.\n */\nexport function renderUuidColumnConversion(\n  tableName: string,\n  columnName: string,\n  options: { hasDefault?: boolean } = {},\n): string[] {\n  const table = quoteIdentifier(tableName);\n  const column = quoteIdentifier(columnName);\n  const statements: string[] = [];\n  if (options.hasDefault) {\n    statements.push(`ALTER TABLE ${table} ALTER COLUMN ${column} DROP DEFAULT`);\n  }\n  statements.push(\n    `ALTER TABLE ${table} ALTER COLUMN ${column} TYPE uuid USING ${column}::uuid`,\n  );\n  return statements;\n}\n\n/**\n * The `[SchemaManager]`/`[SchemaComparer]` sentence that describes one\n * incompatible child/parent pair. Shared so the runtime guard and the status\n * planner say exactly the same thing about the same drift.\n */\nexport function describeForeignKeyTypeConflict(input: {\n  childTable: string;\n  childColumn: string;\n  childType: string;\n  parentTable: string;\n  parentColumn: string;\n  parentType: string;\n}): string {\n  return (\n    `${input.childTable}.${input.childColumn} is ${input.childType} but ` +\n    `${input.parentTable}.${input.parentColumn} is ${input.parentType}; ` +\n    'PostgreSQL cannot cast inside FOREIGN KEY DDL (SQLSTATE 42804)'\n  );\n}\n\n/**\n * Remediation text appended to every incompatible-type diagnostic: the\n * planned convergence normally handles it, and this is the manual equivalent.\n */\nexport function renderUuidConvergenceRepairHint(\n  nodes: readonly UuidConvergenceNode[],\n): string[] {\n  return nodes.flatMap((node) => [\n    renderUuidShapeProbe(node.table, node.column),\n    ...renderUuidColumnConversion(node.table, node.column),\n  ]);\n}\n\ninterface ComponentNode extends UuidConvergenceNode {\n  key: string;\n  live: UuidConvergenceLiveColumn;\n}\n\n/**\n * Group manifest UUID relationships into connected components and decide,\n * per component, whether the live database must converge on native `uuid`.\n *\n * Components — not individual pairs — are the unit of decision because a\n * single legacy `text` primary key can be referenced by several children:\n * converting the parent for one child would break every other member that is\n * still `text`. Self-referential tables fall out of the same grouping (both\n * endpoints land in one component).\n */\nexport async function planUuidConvergence(\n  input: UuidConvergenceInput,\n): Promise<UuidConvergencePlan> {\n  const nodes = new Map<string, ComponentNode>();\n  const parents = new Map<string, string>();\n\n  const find = (key: string): string => {\n    let root = key;\n    while (parents.get(root) !== root) {\n      const next = parents.get(root);\n      if (next === undefined) break;\n      root = next;\n    }\n    let cursor = key;\n    while (parents.get(cursor) !== root) {\n      const next = parents.get(cursor);\n      if (next === undefined) break;\n      parents.set(cursor, root);\n      cursor = next;\n    }\n    return root;\n  };\n  const union = (a: string, b: string) => {\n    const rootA = find(a);\n    const rootB = find(b);\n    if (rootA !== rootB) parents.set(rootB, rootA);\n  };\n\n  const addNode = (\n    table: string,\n    column: string,\n    manifestType: string,\n  ): string | undefined => {\n    const key = uuidConvergenceNodeKey(table, column);\n    const existing = nodes.get(key);\n    if (existing) return key;\n    const live = input.getLiveColumn(table, column) ?? {\n      // A table or column the migration is about to create materializes with\n      // the manifest type, so it is authoritative evidence for the component.\n      normalizedType: manifestType,\n      rawType: manifestType.toLowerCase(),\n      hasDefault: false,\n      exists: false,\n    };\n    nodes.set(key, { key, table, column, live });\n    parents.set(key, key);\n    return key;\n  };\n\n  for (const relationship of input.relationships) {\n    const childColumn =\n      input.manifestSchemas[relationship.childTable]?.columns[\n        relationship.childColumn\n      ];\n    const parentColumn =\n      input.manifestSchemas[relationship.parentTable]?.columns[\n        relationship.parentColumn\n      ];\n    // Only relationships the manifest declares UUID on both sides can\n    // converge on uuid; anything else is an ordinary type question the\n    // column differ already owns.\n    if (childColumn?.type !== 'UUID' || parentColumn?.type !== 'UUID') continue;\n    const childKey = addNode(\n      relationship.childTable,\n      relationship.childColumn,\n      'UUID',\n    );\n    const parentKey = addNode(\n      relationship.parentTable,\n      relationship.parentColumn,\n      'UUID',\n    );\n    if (childKey && parentKey) union(childKey, parentKey);\n  }\n\n  const components = new Map<string, ComponentNode[]>();\n  for (const node of nodes.values()) {\n    const root = find(node.key);\n    const bucket = components.get(root);\n    if (bucket) bucket.push(node);\n    else components.set(root, [node]);\n  }\n\n  const conversions: UuidConvergenceConversion[] = [];\n  const blocks: UuidConvergenceBlock[] = [];\n  const converted = new Set<string>();\n\n  for (const members of components.values()) {\n    members.sort((a, b) => a.key.localeCompare(b.key));\n    const hasUuid = members.some((node) => node.live.normalizedType === 'UUID');\n    const targets = members.filter(\n      (node) => node.live.normalizedType === 'TEXT' && node.live.exists,\n    );\n    const foreign = members.filter(\n      (node) =>\n        node.live.normalizedType !== 'UUID' &&\n        node.live.normalizedType !== 'TEXT',\n    );\n\n    // All-`text` component: the tolerated pre-R11 shape. Its foreign keys are\n    // type-compatible today, so forcing native uuid here would be churn.\n    if (!hasUuid || targets.length === 0) {\n      if (hasUuid && foreign.length > 0) {\n        blocks.push(\n          buildBlock(\n            members,\n            [],\n            `column${foreign.length === 1 ? '' : 's'} ${foreign\n              .map(describeNode)\n              .join(', ')} hold${foreign.length === 1 ? 's' : ''} an ` +\n              `unexpected physical type (${foreign\n                .map((node) => node.live.rawType)\n                .join(', ')}) that SMRT will not rewrite automatically`,\n          ),\n        );\n      }\n      continue;\n    }\n\n    if (foreign.length > 0) {\n      blocks.push(\n        buildBlock(\n          members,\n          targets,\n          `column${foreign.length === 1 ? '' : 's'} ${foreign\n            .map(describeNode)\n            .join(', ')} hold${foreign.length === 1 ? 's' : ''} an ` +\n            `unexpected physical type (${foreign\n              .map((node) => node.live.rawType)\n              .join(', ')}) that SMRT will not rewrite automatically`,\n        ),\n      );\n      continue;\n    }\n\n    const targetKeys = new Set(targets.map((node) => node.key));\n    const dependents = input.liveForeignKeys.filter(\n      (live) =>\n        targetKeys.has(uuidConvergenceNodeKey(live.table, live.column)) ||\n        targetKeys.has(\n          uuidConvergenceNodeKey(live.referencesTable, live.referencesColumn),\n        ),\n    );\n    if (dependents.length > 0) {\n      blocks.push(\n        buildBlock(\n          members,\n          targets,\n          'live foreign keys still depend on the columns that must change (' +\n            dependents\n              .map(\n                (live) =>\n                  `${live.table}.${live.column} -> ${live.referencesTable}.${live.referencesColumn}`,\n              )\n              .join(', ') +\n            '). Drop those constraints deliberately, rerun the migration to ' +\n            'converge the columns, and let SMRT re-add the manifest constraints',\n        ),\n      );\n      continue;\n    }\n\n    let dirty: string | undefined;\n    for (const node of targets) {\n      const probe = await input.probeUuidShape(node.table, node.column);\n      if (probe.status === 'clean') continue;\n      dirty =\n        probe.status === 'dirty'\n          ? `${describeNode(node)} holds ${probe.count} value${\n              probe.count === 1 ? '' : 's'\n            } that ${probe.count === 1 ? 'is' : 'are'} not uuid-shaped` +\n            (probe.sample\n              ? ` (for example ${JSON.stringify(probe.sample)})`\n              : '')\n          : `${describeNode(node)} could not be probed for uuid-shaped values (${probe.reason})`;\n      break;\n    }\n    if (dirty) {\n      blocks.push(\n        buildBlock(\n          members,\n          targets,\n          `${dirty}. SMRT never coerces identifier values; repair or remove them, then rerun the migration`,\n        ),\n      );\n      continue;\n    }\n\n    for (const node of targets) {\n      converted.add(node.key);\n      conversions.push({\n        table: node.table,\n        column: node.column,\n        liveType: node.live.rawType,\n        statements: renderUuidColumnConversion(node.table, node.column, {\n          hasDefault: node.live.hasDefault,\n        }),\n      });\n    }\n  }\n\n  // Parents before children: converting a referenced primary key first keeps\n  // the statement stream valid even if an operator replays it by hand.\n  conversions.sort((left, right) => {\n    const leftIsId = left.column === 'id' ? 0 : 1;\n    const rightIsId = right.column === 'id' ? 0 : 1;\n    if (leftIsId !== rightIsId) return leftIsId - rightIsId;\n    return (\n      left.table.localeCompare(right.table) ||\n      left.column.localeCompare(right.column)\n    );\n  });\n\n  return {\n    conversions,\n    blocks,\n    effectiveType(table: string, column: string): string | undefined {\n      const key = uuidConvergenceNodeKey(table, column);\n      if (converted.has(key)) return 'UUID';\n      return nodes.get(key)?.live.normalizedType;\n    },\n  };\n}\n\nfunction buildBlock(\n  members: readonly ComponentNode[],\n  targets: readonly ComponentNode[],\n  reason: string,\n): UuidConvergenceBlock {\n  const plain = (node: UuidConvergenceNode) => ({\n    table: node.table,\n    column: node.column,\n  });\n  return {\n    nodes: members.map(plain),\n    targets: targets.map(plain),\n    reason,\n    suggestedSql: renderUuidConvergenceRepairHint(targets.map(plain)),\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAuIA,SAAgB,uBAAuB,OAAe,QAAwB;CAC5E,OAAO,GAAG,MAAM,GAAG;AACrB;AAEA,SAAS,aAAa,MAAmC;CACvD,OAAO,GAAG,KAAK,MAAM,GAAG,KAAK;AAC/B;;;;;AAMA,SAAgB,qBACd,WACA,YACQ;CACR,MAAM,SAAS,gBAAgB,UAAU;CACzC,OACE,yCAAyC,OAAO,+BACxC,gBAAgB,SAAS,EAAE,SAC1B,OAAO,mBAAmB,OAAO,cAAc,uBAAuB;AAEnF;;;;;;;;;;AAWA,SAAgB,2BACd,WACA,YACA,UAAoC,CAAC,GAC3B;CACV,MAAM,QAAQ,gBAAgB,SAAS;CACvC,MAAM,SAAS,gBAAgB,UAAU;CACzC,MAAM,aAAuB,CAAC;CAC9B,IAAI,QAAQ,YACV,WAAW,KAAK,eAAe,MAAM,gBAAgB,OAAO,cAAc;CAE5E,WAAW,KACT,eAAe,MAAM,gBAAgB,OAAO,mBAAmB,OAAO,OACxE;CACA,OAAO;AACT;;;;;;AAOA,SAAgB,+BAA+B,OAOpC;CACT,OACE,GAAG,MAAM,WAAW,GAAG,MAAM,YAAY,MAAM,MAAM,UAAU,OAC5D,MAAM,YAAY,GAAG,MAAM,aAAa,MAAM,MAAM,WAAW;AAGtE;;;;;AAMA,SAAgB,gCACd,OACU;CACV,OAAO,MAAM,SAAS,SAAS,CAC7B,qBAAqB,KAAK,OAAO,KAAK,MAAM,GAC5C,GAAG,2BAA2B,KAAK,OAAO,KAAK,MAAM,CACvD,CAAC;AACH;;;;;;;;;;;AAiBA,eAAsB,oBACpB,OAC8B;CAC9B,MAAM,wBAAQ,IAAI,IAA2B;CAC7C,MAAM,0BAAU,IAAI,IAAoB;CAExC,MAAM,QAAQ,QAAwB;EACpC,IAAI,OAAO;EACX,OAAO,QAAQ,IAAI,IAAI,MAAM,MAAM;GACjC,MAAM,OAAO,QAAQ,IAAI,IAAI;GAC7B,IAAI,SAAS,KAAA,GAAW;GACxB,OAAO;EACT;EACA,IAAI,SAAS;EACb,OAAO,QAAQ,IAAI,MAAM,MAAM,MAAM;GACnC,MAAM,OAAO,QAAQ,IAAI,MAAM;GAC/B,IAAI,SAAS,KAAA,GAAW;GACxB,QAAQ,IAAI,QAAQ,IAAI;GACxB,SAAS;EACX;EACA,OAAO;CACT;CACA,MAAM,SAAS,GAAW,MAAc;EACtC,MAAM,QAAQ,KAAK,CAAC;EACpB,MAAM,QAAQ,KAAK,CAAC;EACpB,IAAI,UAAU,OAAO,QAAQ,IAAI,OAAO,KAAK;CAC/C;CAEA,MAAM,WACJ,OACA,QACA,iBACuB;EACvB,MAAM,MAAM,uBAAuB,OAAO,MAAM;EAEhD,IADiB,MAAM,IAAI,GACvB,GAAU,OAAO;EACrB,MAAM,OAAO,MAAM,cAAc,OAAO,MAAM,KAAK;GAGjD,gBAAgB;GAChB,SAAS,aAAa,YAAY;GAClC,YAAY;GACZ,QAAQ;EACV;EACA,MAAM,IAAI,KAAK;GAAE;GAAK;GAAO;GAAQ;EAAK,CAAC;EAC3C,QAAQ,IAAI,KAAK,GAAG;EACpB,OAAO;CACT;CAEA,KAAK,MAAM,gBAAgB,MAAM,eAAe;EAC9C,MAAM,cACJ,MAAM,gBAAgB,aAAa,WAAW,EAAE,QAC9C,aAAa;EAEjB,MAAM,eACJ,MAAM,gBAAgB,aAAa,YAAY,EAAE,QAC/C,aAAa;EAKjB,IAAI,aAAa,SAAS,UAAU,cAAc,SAAS,QAAQ;EACnE,MAAM,WAAW,QACf,aAAa,YACb,aAAa,aACb,MACF;EACA,MAAM,YAAY,QAChB,aAAa,aACb,aAAa,cACb,MACF;EACA,IAAI,YAAY,WAAW,MAAM,UAAU,SAAS;CACtD;CAEA,MAAM,6BAAa,IAAI,IAA6B;CACpD,KAAK,MAAM,QAAQ,MAAM,OAAO,GAAG;EACjC,MAAM,OAAO,KAAK,KAAK,GAAG;EAC1B,MAAM,SAAS,WAAW,IAAI,IAAI;EAClC,IAAI,QAAQ,OAAO,KAAK,IAAI;OACvB,WAAW,IAAI,MAAM,CAAC,IAAI,CAAC;CAClC;CAEA,MAAM,cAA2C,CAAC;CAClD,MAAM,SAAiC,CAAC;CACxC,MAAM,4BAAY,IAAI,IAAY;CAElC,KAAK,MAAM,WAAW,WAAW,OAAO,GAAG;EACzC,QAAQ,MAAM,GAAG,MAAM,EAAE,IAAI,cAAc,EAAE,GAAG,CAAC;EACjD,MAAM,UAAU,QAAQ,MAAM,SAAS,KAAK,KAAK,mBAAmB,MAAM;EAC1E,MAAM,UAAU,QAAQ,QACrB,SAAS,KAAK,KAAK,mBAAmB,UAAU,KAAK,KAAK,MAC7D;EACA,MAAM,UAAU,QAAQ,QACrB,SACC,KAAK,KAAK,mBAAmB,UAC7B,KAAK,KAAK,mBAAmB,MACjC;EAIA,IAAI,CAAC,WAAW,QAAQ,WAAW,GAAG;GACpC,IAAI,WAAW,QAAQ,SAAS,GAC9B,OAAO,KACL,WACE,SACA,CAAC,GACD,SAAS,QAAQ,WAAW,IAAI,KAAK,IAAI,GAAG,QACzC,IAAI,YAAY,CAAC,CACjB,KAAK,IAAI,EAAE,OAAO,QAAQ,WAAW,IAAI,MAAM,GAAG,gCACtB,QAC1B,KAAK,SAAS,KAAK,KAAK,OAAO,CAAC,CAChC,KAAK,IAAI,EAAE,2CAClB,CACF;GAEF;EACF;EAEA,IAAI,QAAQ,SAAS,GAAG;GACtB,OAAO,KACL,WACE,SACA,SACA,SAAS,QAAQ,WAAW,IAAI,KAAK,IAAI,GAAG,QACzC,IAAI,YAAY,CAAC,CACjB,KAAK,IAAI,EAAE,OAAO,QAAQ,WAAW,IAAI,MAAM,GAAG,gCACtB,QAC1B,KAAK,SAAS,KAAK,KAAK,OAAO,CAAC,CAChC,KAAK,IAAI,EAAE,2CAClB,CACF;GACA;EACF;EAEA,MAAM,aAAa,IAAI,IAAI,QAAQ,KAAK,SAAS,KAAK,GAAG,CAAC;EAC1D,MAAM,aAAa,MAAM,gBAAgB,QACtC,SACC,WAAW,IAAI,uBAAuB,KAAK,OAAO,KAAK,MAAM,CAAC,KAC9D,WAAW,IACT,uBAAuB,KAAK,iBAAiB,KAAK,gBAAgB,CACpE,CACJ;EACA,IAAI,WAAW,SAAS,GAAG;GACzB,OAAO,KACL,WACE,SACA,SACA,qEACE,WACG,KACE,SACC,GAAG,KAAK,MAAM,GAAG,KAAK,OAAO,MAAM,KAAK,gBAAgB,GAAG,KAAK,kBACpE,CAAC,CACA,KAAK,IAAI,IACZ,mIAEJ,CACF;GACA;EACF;EAEA,IAAI;EACJ,KAAK,MAAM,QAAQ,SAAS;GAC1B,MAAM,QAAQ,MAAM,MAAM,eAAe,KAAK,OAAO,KAAK,MAAM;GAChE,IAAI,MAAM,WAAW,SAAS;GAC9B,QACE,MAAM,WAAW,UACb,GAAG,aAAa,IAAI,EAAE,SAAS,MAAM,MAAM,QACzC,MAAM,UAAU,IAAI,KAAK,IAC1B,QAAQ,MAAM,UAAU,IAAI,OAAO,MAAM,qBACzC,MAAM,SACH,iBAAiB,KAAK,UAAU,MAAM,MAAM,EAAE,KAC9C,MACJ,GAAG,aAAa,IAAI,EAAE,+CAA+C,MAAM,OAAO;GACxF;EACF;EACA,IAAI,OAAO;GACT,OAAO,KACL,WACE,SACA,SACA,GAAG,MAAM,wFACX,CACF;GACA;EACF;EAEA,KAAK,MAAM,QAAQ,SAAS;GAC1B,UAAU,IAAI,KAAK,GAAG;GACtB,YAAY,KAAK;IACf,OAAO,KAAK;IACZ,QAAQ,KAAK;IACb,UAAU,KAAK,KAAK;IACpB,YAAY,2BAA2B,KAAK,OAAO,KAAK,QAAQ,EAC9D,YAAY,KAAK,KAAK,WACxB,CAAC;GACH,CAAC;EACH;CACF;CAIA,YAAY,MAAM,MAAM,UAAU;EAChC,MAAM,WAAW,KAAK,WAAW,OAAO,IAAI;EAC5C,MAAM,YAAY,MAAM,WAAW,OAAO,IAAI;EAC9C,IAAI,aAAa,WAAW,OAAO,WAAW;EAC9C,OACE,KAAK,MAAM,cAAc,MAAM,KAAK,KACpC,KAAK,OAAO,cAAc,MAAM,MAAM;CAE1C,CAAC;CAED,OAAO;EACL;EACA;EACA,cAAc,OAAe,QAAoC;GAC/D,MAAM,MAAM,uBAAuB,OAAO,MAAM;GAChD,IAAI,UAAU,IAAI,GAAG,GAAG,OAAO;GAC/B,OAAO,MAAM,IAAI,GAAG,CAAC,EAAE,KAAK;EAC9B;CACF;AACF;AAEA,SAAS,WACP,SACA,SACA,QACsB;CACtB,MAAM,SAAS,UAA+B;EAC5C,OAAO,KAAK;EACZ,QAAQ,KAAK;CACf;CACA,OAAO;EACL,OAAO,QAAQ,IAAI,KAAK;EACxB,SAAS,QAAQ,IAAI,KAAK;EAC1B;EACA,cAAc,gCAAgC,QAAQ,IAAI,KAAK,CAAC;CAClE;AACF"}