@prisma-next/family-sql 0.3.0-pr.93.5 → 0.3.0-pr.94.2

package/dist/types-D5CPT9N4.d.mts

@@ -0,0 +1,270 @@
+import { n as SqlControlFamilyInstance } from "./instance-wm4TrZN0.mjs";
+import { Result } from "@prisma-next/utils/result";
+import { ControlDriverInstance, ControlExtensionDescriptor, ControlTargetDescriptor, ControlTargetInstance, MigrationOperationPolicy, MigrationPlan, MigrationPlanOperation, MigrationPlannerConflict, MigrationPlannerFailureResult, MigrationPlannerSuccessResult, MigrationRunnerExecutionChecks, MigrationRunnerFailure, MigrationRunnerSuccessValue, OperationContext, SchemaIssue } from "@prisma-next/core-control-plane/types";
+import { SqlSchemaIR } from "@prisma-next/sql-schema-ir/types";
+import { SqlContract, SqlStorage } from "@prisma-next/sql-contract/types";
+import { TargetBoundComponentDescriptor } from "@prisma-next/contract/framework-components";
+
+//#region src/core/migrations/types.d.ts
+
+type AnyRecord = Readonly<Record<string, unknown>>;
+/**
+ * A single database dependency declared by a framework component.
+ * Uses SqlMigrationPlanOperation so we inherit the existing precheck/execute/postcheck contract.
+ *
+ * Database dependencies allow components (extensions, adapters) to declare what database-side
+ * persistence structures they require (e.g., Postgres extensions, schemas, functions).
+ * The planner emits these as migration operations, and the verifier uses the pure verification
+ * hook to check satisfaction against the schema IR.
+ */
+interface ComponentDatabaseDependency<TTargetDetails> {
+  /** Stable identifier for the dependency (e.g. 'postgres.extension.vector') */
+  readonly id: string;
+  /** Human label for output (e.g. 'Enable vector extension') */
+  readonly label: string;
+  /**
+   * Operations that install/ensure the dependency.
+   * Use SqlMigrationPlanOperation so we inherit the existing precheck/execute/postcheck contract.
+   */
+  readonly install: readonly SqlMigrationPlanOperation<TTargetDetails>[];
+  /**
+   * Pure verification hook: checks whether this dependency is already installed
+   * based on the in-memory schema IR (no DB I/O).
+   *
+   * This must return structured issues suitable for CLI and tree output, not just a boolean.
+   */
+  readonly verifyDatabaseDependencyInstalled: (schema: SqlSchemaIR) => readonly SchemaIssue[];
+}
+/**
+ * Database dependencies declared by a framework component.
+ */
+interface ComponentDatabaseDependencies<TTargetDetails> {
+  /**
+   * Dependencies required for db init.
+   * Future: update dependencies can be added later (e.g. widening/destructive).
+   */
+  readonly init?: readonly ComponentDatabaseDependency<TTargetDetails>[];
+}
+/**
+ * SQL-specific extension descriptor with optional database dependencies.
+ * Extends the core ControlExtensionDescriptor with SQL-specific metadata.
+ *
+ * Database dependencies are attached to the descriptor (not the instance) because
+ * they are declarative metadata that planner/verifier need without constructing instances.
+ */
+interface SqlControlExtensionDescriptor<TTargetId extends string> extends ControlExtensionDescriptor<'sql', TTargetId> {
+  /** Optional database dependencies this extension requires. */
+  readonly databaseDependencies?: ComponentDatabaseDependencies<unknown>;
+}
+/**
+ * A single step in a SQL migration operation (precheck, execute, or postcheck).
+ */
+interface SqlMigrationPlanOperationStep {
+  readonly description: string;
+  readonly sql: string;
+  readonly meta?: AnyRecord;
+}
+/**
+ * Target details for a SQL migration operation (table, column, index, etc.).
+ */
+interface SqlMigrationPlanOperationTarget<TTargetDetails> {
+  readonly id: string;
+  readonly details?: TTargetDetails;
+}
+/**
+ * A single SQL migration operation with SQL-specific fields.
+ * Extends the core MigrationPlanOperation with SQL execution details.
+ */
+interface SqlMigrationPlanOperation<TTargetDetails> extends MigrationPlanOperation {
+  /** Optional detailed explanation of what this operation does and why. */
+  readonly summary?: string;
+  readonly target: SqlMigrationPlanOperationTarget<TTargetDetails>;
+  readonly precheck: readonly SqlMigrationPlanOperationStep[];
+  readonly execute: readonly SqlMigrationPlanOperationStep[];
+  readonly postcheck: readonly SqlMigrationPlanOperationStep[];
+  readonly meta?: AnyRecord;
+}
+/**
+ * Contract identity information for SQL migrations.
+ */
+interface SqlMigrationPlanContractInfo {
+  readonly coreHash: string;
+  readonly profileHash?: string;
+}
+/**
+ * A SQL migration plan with SQL-specific fields.
+ * Extends the core MigrationPlan with origin tracking and metadata.
+ */
+interface SqlMigrationPlan<TTargetDetails> extends MigrationPlan {
+  /**
+   * Origin contract identity that the plan expects the database to currently be at.
+   * If omitted, the runner treats the origin as "no marker present" (empty database),
+   * and will only proceed if no marker exists (or if the marker already matches destination).
+   */
+  readonly origin?: SqlMigrationPlanContractInfo | null;
+  /**
+   * Destination contract identity that the plan intends to reach.
+   */
+  readonly destination: SqlMigrationPlanContractInfo;
+  readonly operations: readonly SqlMigrationPlanOperation<TTargetDetails>[];
+  readonly meta?: AnyRecord;
+}
+/**
+ * Specific conflict kinds for SQL migrations.
+ */
+type SqlPlannerConflictKind = 'typeMismatch' | 'nullabilityConflict' | 'indexIncompatible' | 'foreignKeyConflict' | 'missingButNonAdditive' | 'unsupportedExtension' | 'extensionMissing' | 'unsupportedOperation';
+/**
+ * Location information for SQL planner conflicts.
+ */
+interface SqlPlannerConflictLocation {
+  readonly table?: string;
+  readonly column?: string;
+  readonly index?: string;
+  readonly constraint?: string;
+  readonly extension?: string;
+}
+/**
+ * A SQL-specific planner conflict with additional location information.
+ * Extends the core MigrationPlannerConflict.
+ */
+interface SqlPlannerConflict extends MigrationPlannerConflict {
+  readonly kind: SqlPlannerConflictKind;
+  readonly location?: SqlPlannerConflictLocation;
+  readonly meta?: AnyRecord;
+}
+/**
+ * Successful SQL planner result with the migration plan.
+ */
+interface SqlPlannerSuccessResult<TTargetDetails> extends Omit<MigrationPlannerSuccessResult, 'plan'> {
+  readonly kind: 'success';
+  readonly plan: SqlMigrationPlan<TTargetDetails>;
+}
+/**
+ * Failed SQL planner result with the list of conflicts.
+ */
+interface SqlPlannerFailureResult extends Omit<MigrationPlannerFailureResult, 'conflicts'> {
+  readonly kind: 'failure';
+  readonly conflicts: readonly SqlPlannerConflict[];
+}
+/**
+ * Union type for SQL planner results.
+ */
+type SqlPlannerResult<TTargetDetails> = SqlPlannerSuccessResult<TTargetDetails> | SqlPlannerFailureResult;
+/**
+ * Options for SQL migration planner.
+ */
+interface SqlMigrationPlannerPlanOptions {
+  readonly contract: SqlContract<SqlStorage>;
+  readonly schema: SqlSchemaIR;
+  readonly policy: MigrationOperationPolicy;
+  readonly schemaName?: string;
+  /**
+   * Active framework components participating in this composition.
+   * SQL targets can interpret this list to derive database dependencies.
+   * All components must have matching familyId ('sql') and targetId.
+   */
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}
+/**
+ * SQL migration planner interface.
+ * Extends the core MigrationPlanner with SQL-specific types.
+ */
+interface SqlMigrationPlanner<TTargetDetails> {
+  plan(options: SqlMigrationPlannerPlanOptions): SqlPlannerResult<TTargetDetails>;
+}
+/**
+ * Callbacks for SQL migration runner execution.
+ */
+interface SqlMigrationRunnerExecuteCallbacks<TTargetDetails> {
+  onOperationStart?(operation: SqlMigrationPlanOperation<TTargetDetails>): void;
+  onOperationComplete?(operation: SqlMigrationPlanOperation<TTargetDetails>): void;
+}
+/**
+ * Options for SQL migration runner execution.
+ */
+interface SqlMigrationRunnerExecuteOptions<TTargetDetails> {
+  readonly plan: SqlMigrationPlan<TTargetDetails>;
+  readonly driver: ControlDriverInstance<'sql', string>;
+  /**
+   * Destination contract IR.
+   * Must correspond to `plan.destination` and is used for schema verification and marker/ledger writes.
+   */
+  readonly destinationContract: SqlContract<SqlStorage>;
+  /**
+   * Execution-time policy that defines which operation classes are allowed.
+   * The runner validates each operation against this policy before execution.
+   */
+  readonly policy: MigrationOperationPolicy;
+  readonly schemaName?: string;
+  readonly strictVerification?: boolean;
+  readonly callbacks?: SqlMigrationRunnerExecuteCallbacks<TTargetDetails>;
+  readonly context?: OperationContext;
+  /**
+   * Execution-time checks configuration.
+   * All checks default to `true` (enabled) when omitted.
+   */
+  readonly executionChecks?: MigrationRunnerExecutionChecks;
+  /**
+   * Active framework components participating in this composition.
+   * SQL targets can interpret this list to derive database dependencies.
+   * All components must have matching familyId ('sql') and targetId.
+   */
+  readonly frameworkComponents: ReadonlyArray<TargetBoundComponentDescriptor<'sql', string>>;
+}
+/**
+ * Error codes for SQL migration runner failures.
+ */
+type SqlMigrationRunnerErrorCode = 'DESTINATION_CONTRACT_MISMATCH' | 'MARKER_ORIGIN_MISMATCH' | 'POLICY_VIOLATION' | 'PRECHECK_FAILED' | 'POSTCHECK_FAILED' | 'SCHEMA_VERIFY_FAILED' | 'EXECUTION_FAILED';
+/**
+ * Detailed information about a SQL migration runner failure.
+ * Extends the core MigrationRunnerFailure with SQL-specific error codes.
+ */
+interface SqlMigrationRunnerFailure extends MigrationRunnerFailure {
+  readonly code: SqlMigrationRunnerErrorCode;
+  readonly meta?: AnyRecord;
+}
+/**
+ * Success value for SQL migration runner execution.
+ * Extends core type for type branding and potential SQL-specific extensions.
+ */
+interface SqlMigrationRunnerSuccessValue extends MigrationRunnerSuccessValue {}
+/**
+ * Result type for SQL migration runner execution.
+ */
+type SqlMigrationRunnerResult = Result<SqlMigrationRunnerSuccessValue, SqlMigrationRunnerFailure>;
+/**
+ * SQL migration runner interface.
+ * Extends the core MigrationRunner with SQL-specific types.
+ */
+interface SqlMigrationRunner<TTargetDetails> {
+  execute(options: SqlMigrationRunnerExecuteOptions<TTargetDetails>): Promise<SqlMigrationRunnerResult>;
+}
+/**
+ * SQL control target descriptor with migration support.
+ * Extends the core ControlTargetDescriptor with SQL-specific migration methods.
+ */
+interface SqlControlTargetDescriptor<TTargetId extends string, TTargetDetails> extends ControlTargetDescriptor<'sql', TTargetId, ControlTargetInstance<'sql', TTargetId>, SqlControlFamilyInstance> {
+  /**
+   * Creates a SQL migration planner for this target.
+   * Direct method for SQL-specific usage.
+   */
+  createPlanner(family: SqlControlFamilyInstance): SqlMigrationPlanner<TTargetDetails>;
+  /**
+   * Creates a SQL migration runner for this target.
+   * Direct method for SQL-specific usage.
+   */
+  createRunner(family: SqlControlFamilyInstance): SqlMigrationRunner<TTargetDetails>;
+}
+/**
+ * Options for creating a SQL migration plan.
+ */
+interface CreateSqlMigrationPlanOptions<TTargetDetails> {
+  readonly targetId: string;
+  readonly origin?: SqlMigrationPlanContractInfo | null;
+  readonly destination: SqlMigrationPlanContractInfo;
+  readonly operations: readonly SqlMigrationPlanOperation<TTargetDetails>[];
+  readonly meta?: AnyRecord;
+}
+//#endregion
+export { SqlPlannerConflictLocation as C, SqlPlannerSuccessResult as E, SqlPlannerConflictKind as S, SqlPlannerResult as T, SqlMigrationRunnerExecuteOptions as _, SqlControlExtensionDescriptor as a, SqlMigrationRunnerSuccessValue as b, SqlMigrationPlanContractInfo as c, SqlMigrationPlanOperationTarget as d, SqlMigrationPlanner as f, SqlMigrationRunnerExecuteCallbacks as g, SqlMigrationRunnerErrorCode as h, CreateSqlMigrationPlanOptions as i, SqlMigrationPlanOperation as l, SqlMigrationRunner as m, ComponentDatabaseDependencies as n, SqlControlTargetDescriptor as o, SqlMigrationPlannerPlanOptions as p, ComponentDatabaseDependency as r, SqlMigrationPlan as s, AnyRecord as t, SqlMigrationPlanOperationStep as u, SqlMigrationRunnerFailure as v, SqlPlannerFailureResult as w, SqlPlannerConflict as x, SqlMigrationRunnerResult as y };
+//# sourceMappingURL=types-D5CPT9N4.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types-D5CPT9N4.d.mts","names":[],"sources":["../src/core/migrations/types.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/verify-DhFytkFC.mjs

@@ -0,0 +1,108 @@
+import { type } from "arktype";
+
+//#region src/core/verify.ts
+const MetaSchema = type({ "[string]": "unknown" });
+function parseMeta(meta) {
+	if (meta === null || meta === void 0) return {};
+	let parsed;
+	if (typeof meta === "string") try {
+		parsed = JSON.parse(meta);
+	} catch {
+		return {};
+	}
+	else parsed = meta;
+	const result = MetaSchema(parsed);
+	if (result instanceof type.errors) return {};
+	return result;
+}
+const ContractMarkerRowSchema = type({
+	core_hash: "string",
+	profile_hash: "string",
+	"contract_json?": "unknown | null",
+	"canonical_version?": "number | null",
+	"updated_at?": "Date | string",
+	"app_tag?": "string | null",
+	"meta?": "unknown | null"
+});
+/**
+* Parses a contract marker row from database query result.
+* This is SQL-specific parsing logic (handles SQL row structure with snake_case columns).
+*/
+function parseContractMarkerRow(row) {
+	const result = ContractMarkerRowSchema(row);
+	if (result instanceof type.errors) {
+		const messages = result.map((p) => p.message).join("; ");
+		throw new Error(`Invalid contract marker row: ${messages}`);
+	}
+	const validatedRow = result;
+	const updatedAt = validatedRow.updated_at ? validatedRow.updated_at instanceof Date ? validatedRow.updated_at : new Date(validatedRow.updated_at) : /* @__PURE__ */ new Date();
+	return {
+		coreHash: validatedRow.core_hash,
+		profileHash: validatedRow.profile_hash,
+		contractJson: validatedRow.contract_json ?? null,
+		canonicalVersion: validatedRow.canonical_version ?? null,
+		updatedAt,
+		appTag: validatedRow.app_tag ?? null,
+		meta: parseMeta(validatedRow.meta)
+	};
+}
+/**
+* Returns the SQL statement to read the contract marker.
+* This is a migration-plane helper (no runtime imports).
+* @internal - Used internally by readMarker(). Prefer readMarker() for Control Plane usage.
+*/
+function readMarkerSql() {
+	return {
+		sql: `select
+      core_hash,
+      profile_hash,
+      contract_json,
+      canonical_version,
+      updated_at,
+      app_tag,
+      meta
+    from prisma_contract.marker
+    where id = $1`,
+		params: [1]
+	};
+}
+/**
+* Reads the contract marker from the database using the provided driver.
+* Returns the parsed marker record or null if no marker is found.
+* This abstracts SQL-specific details from the Control Plane.
+*
+* @param driver - ControlDriverInstance instance for executing queries
+* @returns Promise resolving to ContractMarkerRecord or null if marker not found
+*/
+async function readMarker(driver) {
+	const markerStatement = readMarkerSql();
+	try {
+		const queryResult = await driver.query(markerStatement.sql, markerStatement.params);
+		if (queryResult.rows.length === 0) return null;
+		const markerRow = queryResult.rows[0];
+		if (!markerRow) throw new Error("Database query returned unexpected result structure");
+		return parseContractMarkerRow(markerRow);
+	} catch (error) {
+		if (error instanceof Error && (error.message.includes("does not exist") || error.code === "42P01")) return null;
+		throw error;
+	}
+}
+/**
+* Collects supported codec type IDs from adapter and extension manifests.
+* Returns a sorted, unique array of type IDs that are declared in the manifests.
+* This enables coverage checks by comparing contract column types against supported types.
+*
+* Note: This extracts type IDs from manifest type imports, not from runtime codec registries.
+* The manifests declare which codec types are available, but the actual type IDs
+* are defined in the codec-types TypeScript modules that are imported.
+*
+* For MVP, we return an empty array since extracting type IDs from TypeScript modules
+* would require runtime evaluation or static analysis. This can be enhanced later.
+*/
+function collectSupportedCodecTypeIds(descriptors) {
+	return [];
+}
+
+//#endregion
+export { readMarkerSql as i, parseContractMarkerRow as n, readMarker as r, collectSupportedCodecTypeIds as t };
+//# sourceMappingURL=verify-DhFytkFC.mjs.map

package/dist/verify-DhFytkFC.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-DhFytkFC.mjs","names":["parsed: unknown"],"sources":["../src/core/verify.ts"],"sourcesContent":["import type { ContractMarkerRecord } from '@prisma-next/contract/types';\nimport type {\n  ControlAdapterDescriptor,\n  ControlDriverInstance,\n  ControlExtensionDescriptor,\n  ControlTargetDescriptor,\n} from '@prisma-next/core-control-plane/types';\nimport { type } from 'arktype';\n\nconst MetaSchema = type({ '[string]': 'unknown' });\n\nfunction parseMeta(meta: unknown): Record<string, unknown> {\n  if (meta === null || meta === undefined) {\n    return {};\n  }\n\n  let parsed: unknown;\n  if (typeof meta === 'string') {\n    try {\n      parsed = JSON.parse(meta);\n    } catch {\n      return {};\n    }\n  } else {\n    parsed = meta;\n  }\n\n  const result = MetaSchema(parsed);\n  if (result instanceof type.errors) {\n    return {};\n  }\n\n  return result as Record<string, unknown>;\n}\n\nconst ContractMarkerRowSchema = type({\n  core_hash: 'string',\n  profile_hash: 'string',\n  'contract_json?': 'unknown | null',\n  'canonical_version?': 'number | null',\n  'updated_at?': 'Date | string',\n  'app_tag?': 'string | null',\n  'meta?': 'unknown | null',\n});\n\n/**\n * Parses a contract marker row from database query result.\n * This is SQL-specific parsing logic (handles SQL row structure with snake_case columns).\n */\nexport function parseContractMarkerRow(row: unknown): ContractMarkerRecord {\n  const result = ContractMarkerRowSchema(row);\n  if (result instanceof type.errors) {\n    const messages = result.map((p: { message: string }) => p.message).join('; ');\n    throw new Error(`Invalid contract marker row: ${messages}`);\n  }\n\n  const validatedRow = result as {\n    core_hash: string;\n    profile_hash: string;\n    contract_json?: unknown | null;\n    canonical_version?: number | null;\n    updated_at?: Date | string;\n    app_tag?: string | null;\n    meta?: unknown | null;\n  };\n\n  const updatedAt = validatedRow.updated_at\n    ? validatedRow.updated_at instanceof Date\n      ? validatedRow.updated_at\n      : new Date(validatedRow.updated_at)\n    : new Date();\n\n  return {\n    coreHash: validatedRow.core_hash,\n    profileHash: validatedRow.profile_hash,\n    contractJson: validatedRow.contract_json ?? null,\n    canonicalVersion: validatedRow.canonical_version ?? null,\n    updatedAt,\n    appTag: validatedRow.app_tag ?? null,\n    meta: parseMeta(validatedRow.meta),\n  };\n}\n\n/**\n * Returns the SQL statement to read the contract marker.\n * This is a migration-plane helper (no runtime imports).\n * @internal - Used internally by readMarker(). Prefer readMarker() for Control Plane usage.\n */\nexport function readMarkerSql(): { readonly sql: string; readonly params: readonly unknown[] } {\n  return {\n    sql: `select\n      core_hash,\n      profile_hash,\n      contract_json,\n      canonical_version,\n      updated_at,\n      app_tag,\n      meta\n    from prisma_contract.marker\n    where id = $1`,\n    params: [1],\n  };\n}\n\n/**\n * Reads the contract marker from the database using the provided driver.\n * Returns the parsed marker record or null if no marker is found.\n * This abstracts SQL-specific details from the Control Plane.\n *\n * @param driver - ControlDriverInstance instance for executing queries\n * @returns Promise resolving to ContractMarkerRecord or null if marker not found\n */\nexport async function readMarker(\n  driver: ControlDriverInstance<'sql', string>,\n): Promise<ContractMarkerRecord | null> {\n  const markerStatement = readMarkerSql();\n\n  try {\n    const queryResult = await driver.query<{\n      core_hash: string;\n      profile_hash: string;\n      contract_json: unknown | null;\n      canonical_version: number | null;\n      updated_at: Date | string;\n      app_tag: string | null;\n      meta: unknown | null;\n    }>(markerStatement.sql, markerStatement.params);\n\n    if (queryResult.rows.length === 0) {\n      return null;\n    }\n\n    const markerRow = queryResult.rows[0];\n    if (!markerRow) {\n      // If rows array has length > 0 but first element is undefined, this is an unexpected result structure\n      throw new Error('Database query returned unexpected result structure');\n    }\n\n    return parseContractMarkerRow(markerRow);\n  } catch (error) {\n    // Handle case where marker table doesn't exist yet (empty database)\n    // PostgreSQL error code 42P01 = undefined_table\n    if (\n      error instanceof Error &&\n      (error.message.includes('does not exist') || (error as { code?: string }).code === '42P01')\n    ) {\n      return null;\n    }\n    throw error;\n  }\n}\n\n/**\n * Collects supported codec type IDs from adapter and extension manifests.\n * Returns a sorted, unique array of type IDs that are declared in the manifests.\n * This enables coverage checks by comparing contract column types against supported types.\n *\n * Note: This extracts type IDs from manifest type imports, not from runtime codec registries.\n * The manifests declare which codec types are available, but the actual type IDs\n * are defined in the codec-types TypeScript modules that are imported.\n *\n * For MVP, we return an empty array since extracting type IDs from TypeScript modules\n * would require runtime evaluation or static analysis. This can be enhanced later.\n */\nexport function collectSupportedCodecTypeIds<TFamilyId extends string, TTargetId extends string>(\n  descriptors: ReadonlyArray<\n    | ControlTargetDescriptor<TFamilyId, TTargetId>\n    | ControlAdapterDescriptor<TFamilyId, TTargetId>\n    | ControlExtensionDescriptor<TFamilyId, TTargetId>\n  >,\n): readonly string[] {\n  // For MVP, return empty array\n  // Future enhancement: Extract type IDs from codec-types modules via static analysis\n  // or require manifests to explicitly list supported type IDs\n  void descriptors;\n  return [];\n}\n"],"mappings":";;;AASA,MAAM,aAAa,KAAK,EAAE,YAAY,WAAW,CAAC;AAElD,SAAS,UAAU,MAAwC;AACzD,KAAI,SAAS,QAAQ,SAAS,OAC5B,QAAO,EAAE;CAGX,IAAIA;AACJ,KAAI,OAAO,SAAS,SAClB,KAAI;AACF,WAAS,KAAK,MAAM,KAAK;SACnB;AACN,SAAO,EAAE;;KAGX,UAAS;CAGX,MAAM,SAAS,WAAW,OAAO;AACjC,KAAI,kBAAkB,KAAK,OACzB,QAAO,EAAE;AAGX,QAAO;;AAGT,MAAM,0BAA0B,KAAK;CACnC,WAAW;CACX,cAAc;CACd,kBAAkB;CAClB,sBAAsB;CACtB,eAAe;CACf,YAAY;CACZ,SAAS;CACV,CAAC;;;;;AAMF,SAAgB,uBAAuB,KAAoC;CACzE,MAAM,SAAS,wBAAwB,IAAI;AAC3C,KAAI,kBAAkB,KAAK,QAAQ;EACjC,MAAM,WAAW,OAAO,KAAK,MAA2B,EAAE,QAAQ,CAAC,KAAK,KAAK;AAC7E,QAAM,IAAI,MAAM,gCAAgC,WAAW;;CAG7D,MAAM,eAAe;CAUrB,MAAM,YAAY,aAAa,aAC3B,aAAa,sBAAsB,OACjC,aAAa,aACb,IAAI,KAAK,aAAa,WAAW,mBACnC,IAAI,MAAM;AAEd,QAAO;EACL,UAAU,aAAa;EACvB,aAAa,aAAa;EAC1B,cAAc,aAAa,iBAAiB;EAC5C,kBAAkB,aAAa,qBAAqB;EACpD;EACA,QAAQ,aAAa,WAAW;EAChC,MAAM,UAAU,aAAa,KAAK;EACnC;;;;;;;AAQH,SAAgB,gBAA+E;AAC7F,QAAO;EACL,KAAK;;;;;;;;;;EAUL,QAAQ,CAAC,EAAE;EACZ;;;;;;;;;;AAWH,eAAsB,WACpB,QACsC;CACtC,MAAM,kBAAkB,eAAe;AAEvC,KAAI;EACF,MAAM,cAAc,MAAM,OAAO,MAQ9B,gBAAgB,KAAK,gBAAgB,OAAO;AAE/C,MAAI,YAAY,KAAK,WAAW,EAC9B,QAAO;EAGT,MAAM,YAAY,YAAY,KAAK;AACnC,MAAI,CAAC,UAEH,OAAM,IAAI,MAAM,sDAAsD;AAGxE,SAAO,uBAAuB,UAAU;UACjC,OAAO;AAGd,MACE,iBAAiB,UAChB,MAAM,QAAQ,SAAS,iBAAiB,IAAK,MAA4B,SAAS,SAEnF,QAAO;AAET,QAAM;;;;;;;;;;;;;;;AAgBV,SAAgB,6BACd,aAKmB;AAKnB,QAAO,EAAE"}