@opengeni/db 0.7.3 → 0.9.3

package/src/session-tool-call-settlement.ts

@@ -1,4 +1,5 @@
 import type { SessionEvent } from "@opengeni/contracts";
+import { boundModelToolOutputItem } from "@opengeni/codex";
 import { and, asc, eq, sql } from "drizzle-orm";
 import type { Database } from "./index";
 import { sanitizeEventPayload, sanitizeModelPayload } from "./event-payload-sanitizer";
@@ -129,14 +130,17 @@ export async function closePendingSessionToolCallsInTransaction(
   if (pending.length === 0) return { sequence: input.sequence, events: [], closed: 0 };
 
   const history = await tx
-    .select({ item: schema.sessionHistoryItems.item })
+    .select({
+      position: schema.sessionHistoryItems.position,
+      item: schema.sessionHistoryItems.item,
+      active: schema.sessionHistoryItems.active,
+    })
     .from(schema.sessionHistoryItems)
     .where(
       and(
         eq(schema.sessionHistoryItems.workspaceId, input.workspaceId),
         eq(schema.sessionHistoryItems.sessionId, input.sessionId),
         eq(schema.sessionHistoryItems.turnId, input.turnId),
-        eq(schema.sessionHistoryItems.active, true),
       ),
     )
     .orderBy(asc(schema.sessionHistoryItems.position));
@@ -149,6 +153,20 @@ export async function closePendingSessionToolCallsInTransaction(
         eq(schema.sessionHistoryItems.sessionId, input.sessionId),
       ),
     );
+  const existingOutputEvents = await tx
+    .select({ callId: sql<string | null>`${schema.sessionEvents.payload} ->> 'id'` })
+    .from(schema.sessionEvents)
+    .where(
+      and(
+        eq(schema.sessionEvents.workspaceId, input.workspaceId),
+        eq(schema.sessionEvents.sessionId, input.sessionId),
+        eq(schema.sessionEvents.turnId, input.turnId),
+        eq(schema.sessionEvents.type, "agent.toolCall.output"),
+      ),
+    );
+  const projectedCallIds = new Set(
+    existingOutputEvents.flatMap(({ callId }) => (callId ? [callId] : [])),
+  );
   let nextPosition = Math.floor(Number(maxPosition)) + 1;
   let sequence = input.sequence;
   const historyValues: Array<typeof schema.sessionHistoryItems.$inferInsert> = [];
@@ -160,7 +178,23 @@ export async function closePendingSessionToolCallsInTransaction(
     );
     const existingResult = resultType
       ? history.find(
-          ({ item }) => historyItemType(item) === resultType && historyCallId(item) === call.callId,
+          ({ item, position }) =>
+            position > (existingCall?.position ?? Number.MAX_SAFE_INTEGER) &&
+            historyItemType(item) === resultType &&
+            historyCallId(item) === call.callId,
+        )
+      : undefined;
+    const activeCall = history.find(
+      ({ item, active }) =>
+        active && historyItemType(item) === call.callType && historyCallId(item) === call.callId,
+    );
+    const activeResult = resultType
+      ? history.find(
+          ({ item, active, position }) =>
+            active &&
+            position > (activeCall?.position ?? Number.MAX_SAFE_INTEGER) &&
+            historyItemType(item) === resultType &&
+            historyCallId(item) === call.callId,
         )
       : undefined;
     const interruptedResult = interruptedToolCallResult({
@@ -173,6 +207,12 @@ export async function closePendingSessionToolCallsInTransaction(
       call,
       existingCall,
       existingResult,
+      activeCall,
+      activeResult,
+      completeDurablePair: Boolean(existingCall && existingResult),
+      supersededDurablePair: Boolean(
+        existingCall && existingResult && (!existingCall.active || !existingResult.active),
+      ),
       rawCallIsValid: historyItemType(call.callItem) === call.callType,
       result: existingResult?.item ?? call.resultItem ?? interruptedResult,
       interrupted: !existingResult && !call.resultItem,
@@ -181,8 +221,8 @@ export async function closePendingSessionToolCallsInTransaction(
 
   for (const resolution of resolutions) {
     if (
-      !resolution.existingResult &&
-      !resolution.existingCall &&
+      !resolution.completeDurablePair &&
+      !resolution.activeCall &&
       resolution.result &&
       resolution.rawCallIsValid
     ) {
@@ -203,17 +243,28 @@ export async function closePendingSessionToolCallsInTransaction(
       (right.call.resultRecordedAt?.getTime() ?? Number.MAX_SAFE_INTEGER),
   );
   for (const resolution of orderedResults) {
-    if (!resolution.existingResult && resolution.result && resolution.rawCallIsValid) {
+    if (
+      !resolution.completeDurablePair &&
+      !resolution.activeResult &&
+      resolution.result &&
+      resolution.rawCallIsValid
+    ) {
       historyValues.push({
         accountId: input.accountId,
         workspaceId: input.workspaceId,
         sessionId: input.sessionId,
         turnId: input.turnId,
         position: nextPosition++,
-        item: sanitizeModelPayload(resolution.result),
+        item: sanitizeModelPayload(boundModelToolOutputItem(resolution.result)),
         active: true,
       });
     }
+    // A pair superseded by compaction was already projected during its live
+    // response. Reactivating or re-emitting it would undo the checkpoint and
+    // duplicate the UI output. An active complete pair is different: it can be
+    // the crash point after model-memory persistence but before event publish,
+    // so it keeps the existing durable recovery projection below.
+    if (resolution.supersededDurablePair || projectedCallIds.has(resolution.call.callId)) continue;
     eventValues.push({
       accountId: input.accountId,
       workspaceId: input.workspaceId,

package/src/turn-initiator.ts

@@ -0,0 +1,155 @@
+import {
+  UNATTRIBUTED_LEGACY_INITIATOR_SUBJECT_ID,
+  type TurnInitiator,
+  type TurnInitiatorContext,
+} from "@opengeni/contracts";
+import { and, eq } from "drizzle-orm";
+import type { Database } from "./index";
+import type { SessionCommandActor } from "./session-control";
+import * as schema from "./schema";
+
+export const UNATTRIBUTED_LEGACY_INITIATOR: TurnInitiator = {
+  kind: "service",
+  subjectId: UNATTRIBUTED_LEGACY_INITIATOR_SUBJECT_ID,
+};
+
+export type FrozenTurnInitiator = {
+  initiator: TurnInitiator;
+  context: TurnInitiatorContext;
+};
+
+const MAX_AGENT_PROVENANCE_HOPS = 32;
+
+/**
+ * Bound agent provenance without discarding its causal authority. Once the
+ * chain exceeds the cap, retain the first hop and the newest hops in order;
+ * consumers can still identify the root attempt while recent diagnostics stay
+ * useful. The omitted middle is signalled separately by `viaTruncated`.
+ */
+export function clipAgentProvenanceHops(
+  hops: Array<Record<string, unknown>>,
+): Array<Record<string, unknown>> {
+  if (hops.length <= MAX_AGENT_PROVENANCE_HOPS) return hops;
+  return [hops[0]!, ...hops.slice(-(MAX_AGENT_PROVENANCE_HOPS - 1))];
+}
+
+export function initiatorContextForStorage(
+  initiator: TurnInitiator,
+  context: TurnInitiatorContext = {},
+): TurnInitiatorContext {
+  return initiator.label ? { ...context, label: initiator.label } : { ...context };
+}
+
+export function initiatorFromStorage(
+  kind: string,
+  subjectId: string,
+  context: TurnInitiatorContext,
+): TurnInitiator {
+  const label =
+    typeof context.label === "string" && context.label.length > 0 ? context.label : null;
+  return {
+    kind: kind === "subject" ? "subject" : "service",
+    subjectId,
+    ...(label ? { label } : {}),
+  };
+}
+
+export function initiatorColumns(value: FrozenTurnInitiator): {
+  initiatorKind: TurnInitiator["kind"];
+  initiatorSubjectId: string;
+  initiatorContext: TurnInitiatorContext;
+} {
+  return {
+    initiatorKind: value.initiator.kind,
+    initiatorSubjectId: value.initiator.subjectId,
+    initiatorContext: initiatorContextForStorage(value.initiator, value.context),
+  };
+}
+
+export function creatorColumns(value: FrozenTurnInitiator): {
+  createdByKind: TurnInitiator["kind"];
+  createdBySubjectId: string;
+  createdByContext: TurnInitiatorContext;
+} {
+  return {
+    createdByKind: value.initiator.kind,
+    createdBySubjectId: value.initiator.subjectId,
+    createdByContext: initiatorContextForStorage(value.initiator, value.context),
+  };
+}
+
+function validAgentHops(value: unknown): Array<Record<string, unknown>> {
+  if (!Array.isArray(value)) return [];
+  return value.filter(
+    (hop): hop is Record<string, unknown> =>
+      typeof hop === "object" && hop !== null && !Array.isArray(hop),
+  );
+}
+
+export async function frozenInitiatorForCommandActor(
+  db: Database,
+  workspaceId: string,
+  actor: SessionCommandActor,
+  subjectLabel?: string,
+): Promise<FrozenTurnInitiator> {
+  if (actor.type === "service") {
+    return {
+      initiator: {
+        kind: "service",
+        subjectId: actor.subjectId,
+        ...(actor.subjectLabel ? { label: actor.subjectLabel } : {}),
+      },
+      context: { ...(actor.context ?? {}) },
+    };
+  }
+  if (actor.type !== "agent_attempt") {
+    return {
+      initiator: {
+        kind: "subject",
+        subjectId: actor.subjectId,
+        ...(subjectLabel ? { label: subjectLabel } : {}),
+      },
+      context: {},
+    };
+  }
+
+  const [turn] = await db
+    .select({
+      initiatorKind: schema.sessionTurns.initiatorKind,
+      initiatorSubjectId: schema.sessionTurns.initiatorSubjectId,
+      initiatorContext: schema.sessionTurns.initiatorContext,
+    })
+    .from(schema.sessionTurns)
+    .where(
+      and(
+        eq(schema.sessionTurns.workspaceId, workspaceId),
+        eq(schema.sessionTurns.sessionId, actor.sessionId),
+        eq(schema.sessionTurns.id, actor.turnId),
+      ),
+    )
+    .limit(1);
+  if (!turn) {
+    throw new Error(`Agent initiator turn not found: ${actor.turnId}`);
+  }
+  const storedContext = turn.initiatorContext ?? {};
+  const inheritedHops = validAgentHops(storedContext.via);
+  const hops = [
+    ...inheritedHops,
+    {
+      kind: "agent",
+      sessionId: actor.sessionId,
+      turnId: actor.turnId,
+      attemptId: actor.attemptId,
+      executionGeneration: actor.executionGeneration,
+    },
+  ];
+  const clipped = clipAgentProvenanceHops(hops);
+  return {
+    initiator: initiatorFromStorage(turn.initiatorKind, turn.initiatorSubjectId, storedContext),
+    context: {
+      ...storedContext,
+      via: clipped,
+      ...(hops.length > clipped.length ? { viaTruncated: true } : {}),
+    },
+  };
+}

package/dist/chunk-7LDU7F5P.js

@@ -1,80 +0,0 @@
-// src/migrate.ts
-import { readdir, readFile } from "fs/promises";
-import { dirname, join } from "path";
-import { fileURLToPath } from "url";
-import postgres from "postgres";
-var DEFAULT_DATABASE_URL = "postgres://opengeni:opengeni@127.0.0.1:5432/opengeni";
-var concurrentIndexDirective = /^-- opengeni:concurrent-index lock-timeout=(\d+(?:ms|s|min))$/;
-function assertIdentifier(name, value) {
-  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
-    throw new Error(`${name} is not a valid Postgres identifier: ${value}`);
-  }
-  return value;
-}
-async function executeMigrationFile(sql, file, sqlText) {
-  const [firstLine = "", ...remainingLines] = sqlText.replaceAll("\r\n", "\n").split("\n");
-  const directive = concurrentIndexDirective.exec(firstLine.trim());
-  if (!directive) {
-    if (firstLine.trim().startsWith("-- opengeni:")) {
-      throw new Error(`Unsupported OpenGeni migration directive in ${file}`);
-    }
-    await sql.unsafe(sqlText);
-    return;
-  }
-  const lockTimeout = directive[1];
-  const statement = remainingLines.join("\n").trim();
-  const withoutTrailingSemicolon = statement.endsWith(";") ? statement.slice(0, -1).trimEnd() : statement;
-  if (!/^CREATE\s+(?:UNIQUE\s+)?INDEX\s+CONCURRENTLY\b/is.test(withoutTrailingSemicolon) || withoutTrailingSemicolon.includes(";")) {
-    throw new Error(
-      `${file}: opengeni:concurrent-index requires exactly one CREATE [UNIQUE] INDEX CONCURRENTLY statement`
-    );
-  }
-  await sql`select set_config('lock_timeout', ${lockTimeout}, false)`;
-  try {
-    await sql.unsafe(statement);
-  } finally {
-    await sql`select set_config('lock_timeout', '0', false)`;
-  }
-}
-async function migrate(databaseUrl = process.env.OPENGENI_MIGRATIONS_DATABASE_URL ?? process.env.OPENGENI_DATABASE_URL ?? DEFAULT_DATABASE_URL, schema = process.env.OPENGENI_DB_SCHEMA?.trim() || void 0) {
-  const migrationsDir = join(dirname(fileURLToPath(import.meta.url)), "../drizzle");
-  const files = (await readdir(migrationsDir)).filter((file) => file.endsWith(".sql")).sort();
-  const sql = postgres(databaseUrl, { max: 1 });
-  try {
-    await sql`SELECT pg_advisory_lock(727458)`;
-    if (schema) {
-      assertIdentifier("OPENGENI_DB_SCHEMA", schema);
-      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS "${schema}"`);
-      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS "opengeni_private"`);
-      await sql.unsafe(`SET search_path = "${schema}", "opengeni_private", "public"`);
-    }
-    await sql.unsafe(
-      `CREATE TABLE IF NOT EXISTS "schema_migrations" ("name" text PRIMARY KEY, "applied_at" timestamptz NOT NULL DEFAULT now())`
-    );
-    const appliedRows = await sql`SELECT "name" FROM "schema_migrations"`;
-    const applied = new Set(appliedRows.map((row) => row.name));
-    for (const file of files) {
-      if (applied.has(file)) {
-        continue;
-      }
-      const sqlText = await readFile(join(migrationsDir, file), "utf8");
-      await executeMigrationFile(sql, file, sqlText);
-      await sql`INSERT INTO "schema_migrations" ("name") VALUES (${file}) ON CONFLICT DO NOTHING`;
-    }
-  } finally {
-    await sql.end();
-  }
-}
-async function runMigrations(adminConnection, targetSchema) {
-  await migrate(adminConnection, targetSchema);
-}
-if (import.meta.main) {
-  await migrate();
-  console.log("Applied Drizzle SQL migrations.");
-}
-
-export {
-  migrate,
-  runMigrations
-};
-//# sourceMappingURL=chunk-7LDU7F5P.js.map

package/dist/chunk-7LDU7F5P.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/migrate.ts"],"sourcesContent":["import { readdir, readFile } from \"node:fs/promises\";\nimport { dirname, join } from \"node:path\";\nimport { fileURLToPath } from \"node:url\";\nimport postgres from \"postgres\";\n\nconst DEFAULT_DATABASE_URL = \"postgres://opengeni:opengeni@127.0.0.1:5432/opengeni\";\nconst concurrentIndexDirective = /^-- opengeni:concurrent-index lock-timeout=(\\d+(?:ms|s|min))$/;\n\n/** A bare Postgres identifier (schema/role name) safe to interpolate into DDL. */\nfunction assertIdentifier(name: string, value: string): string {\n  if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {\n    throw new Error(`${name} is not a valid Postgres identifier: ${value}`);\n  }\n  return value;\n}\n\n/**\n * Most migration files intentionally execute as one implicit transaction.\n * PostgreSQL forbids CREATE INDEX CONCURRENTLY there, so a migration may opt\n * into one narrowly validated transactionless statement with:\n *\n *   -- opengeni:concurrent-index lock-timeout=5s\n *   CREATE [UNIQUE] INDEX CONCURRENTLY ...;\n *\n * The directive is deliberately not a generic \"no transaction\" escape hatch:\n * only one concurrent-index statement is accepted, and lock acquisition is\n * always bounded. This keeps additive large-table indexes online without making\n * arbitrary partially-applied migration scripts possible.\n */\nasync function executeMigrationFile(\n  sql: postgres.Sql,\n  file: string,\n  sqlText: string,\n): Promise<void> {\n  const [firstLine = \"\", ...remainingLines] = sqlText.replaceAll(\"\\r\\n\", \"\\n\").split(\"\\n\");\n  const directive = concurrentIndexDirective.exec(firstLine.trim());\n  if (!directive) {\n    if (firstLine.trim().startsWith(\"-- opengeni:\")) {\n      throw new Error(`Unsupported OpenGeni migration directive in ${file}`);\n    }\n    await sql.unsafe(sqlText);\n    return;\n  }\n\n  const lockTimeout = directive[1]!;\n  const statement = remainingLines.join(\"\\n\").trim();\n  const withoutTrailingSemicolon = statement.endsWith(\";\")\n    ? statement.slice(0, -1).trimEnd()\n    : statement;\n  if (\n    !/^CREATE\\s+(?:UNIQUE\\s+)?INDEX\\s+CONCURRENTLY\\b/is.test(withoutTrailingSemicolon) ||\n    withoutTrailingSemicolon.includes(\";\")\n  ) {\n    throw new Error(\n      `${file}: opengeni:concurrent-index requires exactly one CREATE [UNIQUE] INDEX CONCURRENTLY statement`,\n    );\n  }\n\n  await sql`select set_config('lock_timeout', ${lockTimeout}, false)`;\n  try {\n    await sql.unsafe(statement);\n  } finally {\n    await sql`select set_config('lock_timeout', '0', false)`;\n  }\n}\n\n/**\n * Apply the OpenGeni SQL migration chain.\n *\n * STANDALONE (default, unchanged): `migrate()` / `migrate(databaseUrl)` runs the\n * whole chain with NO search_path manipulation, so every unqualified\n * table/index/policy lands in the server default schema (`public`). This is the\n * byte-for-byte historical behavior — the migration test suite calls\n * `migrate(DB_URL)` and is unaffected.\n *\n * EMBEDDED (Step I, §7.8 runtime/SDK half): pass a `schema` (or set\n * `OPENGENI_DB_SCHEMA`). The migrate session then `CREATE SCHEMA IF NOT EXISTS`\n * for both `<schema>` and `opengeni_private`, and sets\n * `search_path = \"<schema>\", \"opengeni_private\", \"public\"`, so EVERY unqualified\n * DDL statement lands in the dedicated schema with NO per-statement SQL rewrite\n * (the SPIKE-1 F1 result). Two things make this work and stay idempotent:\n *   1. The policy-existence guards in the migration SQL use `current_schema()`\n *      (not a hardcoded `'public'`) — so a re-run finds the policy it already\n *      created in `<schema>` and DROP/CREATEs idempotently instead of failing\n *      with \"policy already exists\". (This guard substitution is the migrate-\n *      time enabler for the runtime search_path approach; without it the SDK\n *      entry point silently fails on re-run — the Fork-6 hazard.)\n *   2. `public` stays LAST on the path so `gen_random_uuid()` (pgcrypto) and the\n *      `vector` type — both installed into `public` by 0000 — still resolve. The\n *      `opengeni_private.*` helpers are always called with an absolute prefix.\n *\n * `OPENGENI_DB_SCHEMA` defaults UNSET → `public` → standalone, so the default\n * binding never regresses.\n */\nexport async function migrate(\n  databaseUrl = process.env.OPENGENI_MIGRATIONS_DATABASE_URL ??\n    process.env.OPENGENI_DATABASE_URL ??\n    DEFAULT_DATABASE_URL,\n  schema: string | undefined = process.env.OPENGENI_DB_SCHEMA?.trim() || undefined,\n): Promise<void> {\n  const migrationsDir = join(dirname(fileURLToPath(import.meta.url)), \"../drizzle\");\n  const files = (await readdir(migrationsDir)).filter((file) => file.endsWith(\".sql\")).sort();\n  const sql = postgres(databaseUrl, { max: 1 });\n  try {\n    // Serialize concurrent migrate() runs; the session-level lock is released\n    // when the connection closes.\n    await sql`SELECT pg_advisory_lock(727458)`;\n    if (schema) {\n      assertIdentifier(\"OPENGENI_DB_SCHEMA\", schema);\n      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS \"${schema}\"`);\n      // opengeni_private is also created by 0001 with an absolute prefix, but the\n      // session search_path must already resolve it for the policy predicates\n      // and the SECURITY DEFINER functions that inherit the caller's path.\n      await sql.unsafe(`CREATE SCHEMA IF NOT EXISTS \"opengeni_private\"`);\n      await sql.unsafe(`SET search_path = \"${schema}\", \"opengeni_private\", \"public\"`);\n    }\n    await sql.unsafe(\n      `CREATE TABLE IF NOT EXISTS \"schema_migrations\" (\"name\" text PRIMARY KEY, \"applied_at\" timestamptz NOT NULL DEFAULT now())`,\n    );\n    const appliedRows = await sql`SELECT \"name\" FROM \"schema_migrations\"`;\n    const applied = new Set(appliedRows.map((row) => row.name as string));\n    for (const file of files) {\n      if (applied.has(file)) {\n        continue;\n      }\n      const sqlText = await readFile(join(migrationsDir, file), \"utf8\");\n      await executeMigrationFile(sql, file, sqlText);\n      await sql`INSERT INTO \"schema_migrations\" (\"name\") VALUES (${file}) ON CONFLICT DO NOTHING`;\n    }\n  } finally {\n    await sql.end();\n  }\n}\n\n/**\n * SDK entry point (Step I): run the migration chain over a host-supplied admin\n * connection string against an explicit target schema. This is the embedded\n * topology's named entry — a host calls `runMigrations(adminConnection,\n * targetSchema)` from its own provisioning code instead of relying on env vars.\n * `targetSchema` undefined → `public` → standalone behavior. Thin wrapper over\n * `migrate` so there is one migration engine.\n */\nexport async function runMigrations(adminConnection: string, targetSchema?: string): Promise<void> {\n  await migrate(adminConnection, targetSchema);\n}\n\nif (import.meta.main) {\n  await migrate();\n  console.log(\"Applied Drizzle SQL migrations.\");\n}\n"],"mappings":";AAAA,SAAS,SAAS,gBAAgB;AAClC,SAAS,SAAS,YAAY;AAC9B,SAAS,qBAAqB;AAC9B,OAAO,cAAc;AAErB,IAAM,uBAAuB;AAC7B,IAAM,2BAA2B;AAGjC,SAAS,iBAAiB,MAAc,OAAuB;AAC7D,MAAI,CAAC,2BAA2B,KAAK,KAAK,GAAG;AAC3C,UAAM,IAAI,MAAM,GAAG,IAAI,wCAAwC,KAAK,EAAE;AAAA,EACxE;AACA,SAAO;AACT;AAeA,eAAe,qBACb,KACA,MACA,SACe;AACf,QAAM,CAAC,YAAY,IAAI,GAAG,cAAc,IAAI,QAAQ,WAAW,QAAQ,IAAI,EAAE,MAAM,IAAI;AACvF,QAAM,YAAY,yBAAyB,KAAK,UAAU,KAAK,CAAC;AAChE,MAAI,CAAC,WAAW;AACd,QAAI,UAAU,KAAK,EAAE,WAAW,cAAc,GAAG;AAC/C,YAAM,IAAI,MAAM,+CAA+C,IAAI,EAAE;AAAA,IACvE;AACA,UAAM,IAAI,OAAO,OAAO;AACxB;AAAA,EACF;AAEA,QAAM,cAAc,UAAU,CAAC;AAC/B,QAAM,YAAY,eAAe,KAAK,IAAI,EAAE,KAAK;AACjD,QAAM,2BAA2B,UAAU,SAAS,GAAG,IACnD,UAAU,MAAM,GAAG,EAAE,EAAE,QAAQ,IAC/B;AACJ,MACE,CAAC,mDAAmD,KAAK,wBAAwB,KACjF,yBAAyB,SAAS,GAAG,GACrC;AACA,UAAM,IAAI;AAAA,MACR,GAAG,IAAI;AAAA,IACT;AAAA,EACF;AAEA,QAAM,wCAAwC,WAAW;AACzD,MAAI;AACF,UAAM,IAAI,OAAO,SAAS;AAAA,EAC5B,UAAE;AACA,UAAM;AAAA,EACR;AACF;AA8BA,eAAsB,QACpB,cAAc,QAAQ,IAAI,oCACxB,QAAQ,IAAI,yBACZ,sBACF,SAA6B,QAAQ,IAAI,oBAAoB,KAAK,KAAK,QACxD;AACf,QAAM,gBAAgB,KAAK,QAAQ,cAAc,YAAY,GAAG,CAAC,GAAG,YAAY;AAChF,QAAM,SAAS,MAAM,QAAQ,aAAa,GAAG,OAAO,CAAC,SAAS,KAAK,SAAS,MAAM,CAAC,EAAE,KAAK;AAC1F,QAAM,MAAM,SAAS,aAAa,EAAE,KAAK,EAAE,CAAC;AAC5C,MAAI;AAGF,UAAM;AACN,QAAI,QAAQ;AACV,uBAAiB,sBAAsB,MAAM;AAC7C,YAAM,IAAI,OAAO,gCAAgC,MAAM,GAAG;AAI1D,YAAM,IAAI,OAAO,gDAAgD;AACjE,YAAM,IAAI,OAAO,sBAAsB,MAAM,iCAAiC;AAAA,IAChF;AACA,UAAM,IAAI;AAAA,MACR;AAAA,IACF;AACA,UAAM,cAAc,MAAM;AAC1B,UAAM,UAAU,IAAI,IAAI,YAAY,IAAI,CAAC,QAAQ,IAAI,IAAc,CAAC;AACpE,eAAW,QAAQ,OAAO;AACxB,UAAI,QAAQ,IAAI,IAAI,GAAG;AACrB;AAAA,MACF;AACA,YAAM,UAAU,MAAM,SAAS,KAAK,eAAe,IAAI,GAAG,MAAM;AAChE,YAAM,qBAAqB,KAAK,MAAM,OAAO;AAC7C,YAAM,uDAAuD,IAAI;AAAA,IACnE;AAAA,EACF,UAAE;AACA,UAAM,IAAI,IAAI;AAAA,EAChB;AACF;AAUA,eAAsB,cAAc,iBAAyB,cAAsC;AACjG,QAAM,QAAQ,iBAAiB,YAAY;AAC7C;AAEA,IAAI,YAAY,MAAM;AACpB,QAAM,QAAQ;AACd,UAAQ,IAAI,iCAAiC;AAC/C;","names":[]}