@ixo/decision-oracle 0.0.0-stage → 0.2.0

package/dist/lib/facts/expected.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The rubric as a WORK ORDER — and the work order is the ENGINE's manifest
+ * (`GET /v1/rubrics/manifest`, docs/ENGINE-CONTRACT.md "Manifest"): what its binder resolved the
+ * protocol's rubric to want, republished so the kit never parses a rubric itself and the two can
+ * never drift. The ONLY oracle-specific content of a FactSet is `ext.<name>` and `ai.<name>` —
+ * every other key (`answers`, `ctx`, `attachments`, `settings`, `frozenAt`) is deterministic
+ * plumbing the kit assembles (builder.ts) — so a producer reads `ext`/`ai` (which facts, of which
+ * type, with which fallback, and how the rubric's author expects them produced) and validate.ts
+ * holds it to exactly those names. The rest of the manifest (`fields`, `ctx`, `derived`, `usedBy`)
+ * is context a custom producer may use; the stock one ignores it. `sizeProbes` (bare root question
+ * names under a `maxSizeMB` rule) is the builder's: the only attachments it probes a byte size for.
+ *
+ * Type-only: the facts lane's names for the engine's shapes (lib/engine/types.ts is the Zod).
+ */
+import type { Manifest, ManifestAi, ManifestExt } from "../engine/types.js";
+export type ExpectedFacts = Manifest;
+/** One declared external source: the stock producer needs the call details, a custom one may read only `expect`/`onError`. */
+export type ExpectedExt = ManifestExt;
+/** One declared AI check — v1 checks are yes/no only. */
+export type ExpectedAi = ManifestAi;
+/** What a `send` map holds: `$path` / `~derived` / `ctx.*` ref strings, or literals. */
+export type SendMap = ManifestExt["send"];
+//# sourceMappingURL=expected.d.ts.map

package/dist/lib/facts/expected.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"expected.d.ts","sourceRoot":"","sources":["../../../src/lib/facts/expected.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAE,QAAQ,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,iBAAiB,CAAC;AAEzE,MAAM,MAAM,aAAa,GAAG,QAAQ,CAAC;AACrC,8HAA8H;AAC9H,MAAM,MAAM,WAAW,GAAG,WAAW,CAAC;AACtC,yDAAyD;AACzD,MAAM,MAAM,UAAU,GAAG,UAAU,CAAC;AACpC,wFAAwF;AACxF,MAAM,MAAM,OAAO,GAAG,WAAW,CAAC,MAAM,CAAC,CAAC"}

package/dist/lib/facts/expected.js

@@ -0,0 +1,16 @@
+/**
+ * The rubric as a WORK ORDER — and the work order is the ENGINE's manifest
+ * (`GET /v1/rubrics/manifest`, docs/ENGINE-CONTRACT.md "Manifest"): what its binder resolved the
+ * protocol's rubric to want, republished so the kit never parses a rubric itself and the two can
+ * never drift. The ONLY oracle-specific content of a FactSet is `ext.<name>` and `ai.<name>` —
+ * every other key (`answers`, `ctx`, `attachments`, `settings`, `frozenAt`) is deterministic
+ * plumbing the kit assembles (builder.ts) — so a producer reads `ext`/`ai` (which facts, of which
+ * type, with which fallback, and how the rubric's author expects them produced) and validate.ts
+ * holds it to exactly those names. The rest of the manifest (`fields`, `ctx`, `derived`, `usedBy`)
+ * is context a custom producer may use; the stock one ignores it. `sizeProbes` (bare root question
+ * names under a `maxSizeMB` rule) is the builder's: the only attachments it probes a byte size for.
+ *
+ * Type-only: the facts lane's names for the engine's shapes (lib/engine/types.ts is the Zod).
+ */
+export {};
+//# sourceMappingURL=expected.js.map

package/dist/lib/facts/expected.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"expected.js","sourceRoot":"","sources":["../../../src/lib/facts/expected.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG"}

package/dist/lib/facts/fact-cache.d.ts

@@ -0,0 +1,469 @@
+/**
+ * The connector-result cache (schema.ts `fact_cache`): resolved `ext`/`ai` facts persisted per
+ * claim WHILE its evaluate step is in flight, so a crash mid-produce — after some connectors
+ * answered, before the engine decided — never re-buys those calls on the step's retry. The other
+ * recovery lane, `GET /v1/decisions/:claimId` (workflows/claim-ingest.ts), only covers a crash
+ * AFTER the engine decided; this one covers the resolve phase before it.
+ *
+ * Fail-soft on BOTH sides (the `FactCache` contract, producer.ts): the cache is an optimization,
+ * so a D1 blip on read means "no cache" (connectors run) and on write means "not cached" (the
+ * fact still freezes) — never a failed fact, never a retry. Deletion is the workflows' job
+ * (`factCacheDelete`, batched with the claim's `decisions` row write): decided or dead, the cache
+ * is gone.
+ *
+ * Scoped to ONE work order (the manifest's `rubricId`): an attempt under a re-anchored `#rub`
+ * reads nothing the old rubric's connectors answered — its same-named facts are new questions.
+ */
+import type { Database } from "../../db/client.js";
+import type { Logger } from "../logger.js";
+import type { FactCache } from "./producer.js";
+export declare function dbFactCache(db: Database, logger: Logger, rubricId: string): FactCache;
+/** The claim's cache rows' deletion (every rubric's), as a statement the workflows batch beside the decision write. */
+export declare function factCacheDelete(db: Database, claimId: string): Omit<import("drizzle-orm/sqlite-core").SQLiteDeleteBase<import("drizzle-orm/sqlite-core").SQLiteTableWithColumns<{
+    name: "fact_cache";
+    schema: undefined;
+    columns: {
+        claimId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "claimId";
+            tableName: "fact_cache";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
+        rubricId: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "rubricId";
+            tableName: "fact_cache";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
+        kind: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "kind";
+            tableName: "fact_cache";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: "ai" | "ext" | "unique-judge";
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: ["ext", "ai", "unique-judge"];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: number | undefined;
+        }>;
+        name: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "name";
+            tableName: "fact_cache";
+            dataType: "string";
+            columnType: "SQLiteText";
+            data: string;
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: [string, ...string[]];
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            length: undefined;
+        }>;
+        fact: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "fact";
+            tableName: "fact_cache";
+            dataType: "json";
+            columnType: "SQLiteTextJson";
+            data: import("./stock/ai-unique.js").SameEventJudgement | {
+                status: "ok";
+                value: number | boolean;
+                reason: string | null;
+                confidence?: number | undefined;
+                transcript?: {
+                    request: {
+                        url: string;
+                        body: unknown;
+                        headers: Record<string, string>;
+                    };
+                    response: {
+                        status: number;
+                        body: unknown;
+                    } | null;
+                    attempts: number;
+                    elapsedMs: number;
+                    latencyMs?: number | undefined;
+                    genId?: string | null | undefined;
+                    usage?: {
+                        promptTokens: number;
+                        completionTokens: number;
+                        cachedTokens: number;
+                        costUsd: number;
+                    } | null | undefined;
+                    provenance?: {
+                        key: string;
+                        cid: string | null;
+                        result: {
+                            vendor: "google" | "openai" | "other" | "unknown";
+                            issuer?: string | undefined;
+                            model?: string | undefined;
+                            modelVersion?: string | undefined;
+                            aiGenerated: boolean;
+                            watermarked: boolean;
+                            signedAt?: string | undefined;
+                            trusted: boolean;
+                            failures: string[];
+                        } | null;
+                    }[] | undefined;
+                } | undefined;
+            } | {
+                status: "error";
+                onError: "reject" | "review";
+                detail: string;
+                transcript?: {
+                    request: {
+                        url: string;
+                        body: unknown;
+                        headers: Record<string, string>;
+                    };
+                    response: {
+                        status: number;
+                        body: unknown;
+                    } | null;
+                    attempts: number;
+                    elapsedMs: number;
+                    latencyMs?: number | undefined;
+                    genId?: string | null | undefined;
+                    usage?: {
+                        promptTokens: number;
+                        completionTokens: number;
+                        cachedTokens: number;
+                        costUsd: number;
+                    } | null | undefined;
+                    provenance?: {
+                        key: string;
+                        cid: string | null;
+                        result: {
+                            vendor: "google" | "openai" | "other" | "unknown";
+                            issuer?: string | undefined;
+                            model?: string | undefined;
+                            modelVersion?: string | undefined;
+                            aiGenerated: boolean;
+                            watermarked: boolean;
+                            signedAt?: string | undefined;
+                            trusted: boolean;
+                            failures: string[];
+                        } | null;
+                    }[] | undefined;
+                } | undefined;
+            } | {
+                status: "ok";
+                value: boolean;
+                reason: string | null;
+                failedRules: string[];
+                score: number;
+                confidence?: number | undefined;
+                transcript?: {
+                    request: {
+                        url: string;
+                        body: unknown;
+                        headers: Record<string, string>;
+                    };
+                    response: {
+                        status: number;
+                        body: unknown;
+                    } | null;
+                    attempts: number;
+                    elapsedMs: number;
+                    latencyMs?: number | undefined;
+                    genId?: string | null | undefined;
+                    usage?: {
+                        promptTokens: number;
+                        completionTokens: number;
+                        cachedTokens: number;
+                        costUsd: number;
+                    } | null | undefined;
+                    provenance?: {
+                        key: string;
+                        cid: string | null;
+                        result: {
+                            vendor: "google" | "openai" | "other" | "unknown";
+                            issuer?: string | undefined;
+                            model?: string | undefined;
+                            modelVersion?: string | undefined;
+                            aiGenerated: boolean;
+                            watermarked: boolean;
+                            signedAt?: string | undefined;
+                            trusted: boolean;
+                            failures: string[];
+                        } | null;
+                    }[] | undefined;
+                } | undefined;
+            } | {
+                status: "error";
+                onError: "reject" | "review";
+                detail: string;
+                transcript?: {
+                    request: {
+                        url: string;
+                        body: unknown;
+                        headers: Record<string, string>;
+                    };
+                    response: {
+                        status: number;
+                        body: unknown;
+                    } | null;
+                    attempts: number;
+                    elapsedMs: number;
+                    latencyMs?: number | undefined;
+                    genId?: string | null | undefined;
+                    usage?: {
+                        promptTokens: number;
+                        completionTokens: number;
+                        cachedTokens: number;
+                        costUsd: number;
+                    } | null | undefined;
+                    provenance?: {
+                        key: string;
+                        cid: string | null;
+                        result: {
+                            vendor: "google" | "openai" | "other" | "unknown";
+                            issuer?: string | undefined;
+                            model?: string | undefined;
+                            modelVersion?: string | undefined;
+                            aiGenerated: boolean;
+                            watermarked: boolean;
+                            signedAt?: string | undefined;
+                            trusted: boolean;
+                            failures: string[];
+                        } | null;
+                    }[] | undefined;
+                } | undefined;
+            };
+            driverParam: string;
+            notNull: true;
+            hasDefault: false;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: false;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {
+            $type: import("./stock/ai-unique.js").SameEventJudgement | {
+                status: "ok";
+                value: number | boolean;
+                reason: string | null;
+                confidence?: number | undefined;
+                transcript?: {
+                    request: {
+                        url: string;
+                        body: unknown;
+                        headers: Record<string, string>;
+                    };
+                    response: {
+                        status: number;
+                        body: unknown;
+                    } | null;
+                    attempts: number;
+                    elapsedMs: number;
+                    latencyMs?: number | undefined;
+                    genId?: string | null | undefined;
+                    usage?: {
+                        promptTokens: number;
+                        completionTokens: number;
+                        cachedTokens: number;
+                        costUsd: number;
+                    } | null | undefined;
+                    provenance?: {
+                        key: string;
+                        cid: string | null;
+                        result: {
+                            vendor: "google" | "openai" | "other" | "unknown";
+                            issuer?: string | undefined;
+                            model?: string | undefined;
+                            modelVersion?: string | undefined;
+                            aiGenerated: boolean;
+                            watermarked: boolean;
+                            signedAt?: string | undefined;
+                            trusted: boolean;
+                            failures: string[];
+                        } | null;
+                    }[] | undefined;
+                } | undefined;
+            } | {
+                status: "error";
+                onError: "reject" | "review";
+                detail: string;
+                transcript?: {
+                    request: {
+                        url: string;
+                        body: unknown;
+                        headers: Record<string, string>;
+                    };
+                    response: {
+                        status: number;
+                        body: unknown;
+                    } | null;
+                    attempts: number;
+                    elapsedMs: number;
+                    latencyMs?: number | undefined;
+                    genId?: string | null | undefined;
+                    usage?: {
+                        promptTokens: number;
+                        completionTokens: number;
+                        cachedTokens: number;
+                        costUsd: number;
+                    } | null | undefined;
+                    provenance?: {
+                        key: string;
+                        cid: string | null;
+                        result: {
+                            vendor: "google" | "openai" | "other" | "unknown";
+                            issuer?: string | undefined;
+                            model?: string | undefined;
+                            modelVersion?: string | undefined;
+                            aiGenerated: boolean;
+                            watermarked: boolean;
+                            signedAt?: string | undefined;
+                            trusted: boolean;
+                            failures: string[];
+                        } | null;
+                    }[] | undefined;
+                } | undefined;
+            } | {
+                status: "ok";
+                value: boolean;
+                reason: string | null;
+                failedRules: string[];
+                score: number;
+                confidence?: number | undefined;
+                transcript?: {
+                    request: {
+                        url: string;
+                        body: unknown;
+                        headers: Record<string, string>;
+                    };
+                    response: {
+                        status: number;
+                        body: unknown;
+                    } | null;
+                    attempts: number;
+                    elapsedMs: number;
+                    latencyMs?: number | undefined;
+                    genId?: string | null | undefined;
+                    usage?: {
+                        promptTokens: number;
+                        completionTokens: number;
+                        cachedTokens: number;
+                        costUsd: number;
+                    } | null | undefined;
+                    provenance?: {
+                        key: string;
+                        cid: string | null;
+                        result: {
+                            vendor: "google" | "openai" | "other" | "unknown";
+                            issuer?: string | undefined;
+                            model?: string | undefined;
+                            modelVersion?: string | undefined;
+                            aiGenerated: boolean;
+                            watermarked: boolean;
+                            signedAt?: string | undefined;
+                            trusted: boolean;
+                            failures: string[];
+                        } | null;
+                    }[] | undefined;
+                } | undefined;
+            } | {
+                status: "error";
+                onError: "reject" | "review";
+                detail: string;
+                transcript?: {
+                    request: {
+                        url: string;
+                        body: unknown;
+                        headers: Record<string, string>;
+                    };
+                    response: {
+                        status: number;
+                        body: unknown;
+                    } | null;
+                    attempts: number;
+                    elapsedMs: number;
+                    latencyMs?: number | undefined;
+                    genId?: string | null | undefined;
+                    usage?: {
+                        promptTokens: number;
+                        completionTokens: number;
+                        cachedTokens: number;
+                        costUsd: number;
+                    } | null | undefined;
+                    provenance?: {
+                        key: string;
+                        cid: string | null;
+                        result: {
+                            vendor: "google" | "openai" | "other" | "unknown";
+                            issuer?: string | undefined;
+                            model?: string | undefined;
+                            modelVersion?: string | undefined;
+                            aiGenerated: boolean;
+                            watermarked: boolean;
+                            signedAt?: string | undefined;
+                            trusted: boolean;
+                            failures: string[];
+                        } | null;
+                    }[] | undefined;
+                } | undefined;
+            };
+        }>;
+        createdAt: import("drizzle-orm/sqlite-core").SQLiteColumn<{
+            name: "createdAt";
+            tableName: "fact_cache";
+            dataType: "date";
+            columnType: "SQLiteTimestamp";
+            data: Date;
+            driverParam: number;
+            notNull: true;
+            hasDefault: true;
+            isPrimaryKey: false;
+            isAutoincrement: false;
+            hasRuntimeDefault: true;
+            enumValues: undefined;
+            baseColumn: never;
+            identity: undefined;
+            generated: undefined;
+        }, {}, {}>;
+    };
+    dialect: 'sqlite';
+}>, "async", D1Result<unknown>, undefined, false, "where">, "where">;
+//# sourceMappingURL=fact-cache.d.ts.map

package/dist/lib/facts/fact-cache.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fact-cache.d.ts","sourceRoot":"","sources":["../../../src/lib/facts/fact-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,iBAAiB,CAAC;AAEhD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,WAAW,CAAC;AACxC,OAAO,KAAK,EAAE,SAAS,EAAkB,MAAM,YAAY,CAAC;AAE5D,wBAAgB,WAAW,CAAC,EAAE,EAAE,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,CA4BrF;AAED,uHAAuH;AACvH,wBAAgB,eAAe,CAAC,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;qEAE5D"}

package/dist/lib/facts/fact-cache.js

@@ -0,0 +1,52 @@
+/**
+ * The connector-result cache (schema.ts `fact_cache`): resolved `ext`/`ai` facts persisted per
+ * claim WHILE its evaluate step is in flight, so a crash mid-produce — after some connectors
+ * answered, before the engine decided — never re-buys those calls on the step's retry. The other
+ * recovery lane, `GET /v1/decisions/:claimId` (workflows/claim-ingest.ts), only covers a crash
+ * AFTER the engine decided; this one covers the resolve phase before it.
+ *
+ * Fail-soft on BOTH sides (the `FactCache` contract, producer.ts): the cache is an optimization,
+ * so a D1 blip on read means "no cache" (connectors run) and on write means "not cached" (the
+ * fact still freezes) — never a failed fact, never a retry. Deletion is the workflows' job
+ * (`factCacheDelete`, batched with the claim's `decisions` row write): decided or dead, the cache
+ * is gone.
+ *
+ * Scoped to ONE work order (the manifest's `rubricId`): an attempt under a re-anchored `#rub`
+ * reads nothing the old rubric's connectors answered — its same-named facts are new questions.
+ */
+import { and, eq } from "drizzle-orm";
+import { factCache } from "../../db/schema.js";
+export function dbFactCache(db, logger, rubricId) {
+    return {
+        async read(claimId) {
+            try {
+                // The JSON column is typed as the union of every kind's shape; `kind` narrows it per row.
+                return (await db
+                    .select({ kind: factCache.kind, name: factCache.name, fact: factCache.fact })
+                    .from(factCache)
+                    .where(and(eq(factCache.claimId, claimId), eq(factCache.rubricId, rubricId))));
+            }
+            catch (err) {
+                logger.warn("fact-cache.read-failed", { claimId, error: String(err) });
+                return [];
+            }
+        },
+        async write(claimId, kind, name, fact) {
+            try {
+                // `onConflictDoNothing`: two racing writes of the same fact (a replayed task) keep the first.
+                await db
+                    .insert(factCache)
+                    .values({ claimId, rubricId, kind, name, fact })
+                    .onConflictDoNothing();
+            }
+            catch (err) {
+                logger.warn("fact-cache.write-failed", { claimId, kind, name, error: String(err) });
+            }
+        },
+    };
+}
+/** The claim's cache rows' deletion (every rubric's), as a statement the workflows batch beside the decision write. */
+export function factCacheDelete(db, claimId) {
+    return db.delete(factCache).where(eq(factCache.claimId, claimId));
+}
+//# sourceMappingURL=fact-cache.js.map

package/dist/lib/facts/fact-cache.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"fact-cache.js","sourceRoot":"","sources":["../../../src/lib/facts/fact-cache.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,GAAG,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AAEtC,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAI5C,MAAM,UAAU,WAAW,CAAC,EAAY,EAAE,MAAc,EAAE,QAAgB;IACxE,OAAO;QACL,KAAK,CAAC,IAAI,CAAC,OAAO;YAChB,IAAI,CAAC;gBACH,0FAA0F;gBAC1F,OAAO,CAAC,MAAM,EAAE;qBACb,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,IAAI,EAAE,SAAS,CAAC,IAAI,EAAE,CAAC;qBAC5E,IAAI,CAAC,SAAS,CAAC;qBACf,KAAK,CACJ,GAAG,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,EAAE,EAAE,CAAC,SAAS,CAAC,QAAQ,EAAE,QAAQ,CAAC,CAAC,CACtE,CAAqB,CAAC;YAC3B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,wBAAwB,EAAE,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;gBACvE,OAAO,EAAE,CAAC;YACZ,CAAC;QACH,CAAC;QACD,KAAK,CAAC,KAAK,CAAC,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI;YACnC,IAAI,CAAC;gBACH,8FAA8F;gBAC9F,MAAM,EAAE;qBACL,MAAM,CAAC,SAAS,CAAC;qBACjB,MAAM,CAAC,EAAE,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAC;qBAC/C,mBAAmB,EAAE,CAAC;YAC3B,CAAC;YAAC,OAAO,GAAG,EAAE,CAAC;gBACb,MAAM,CAAC,IAAI,CAAC,yBAAyB,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC,CAAC;YACtF,CAAC;QACH,CAAC;KACF,CAAC;AACJ,CAAC;AAED,uHAAuH;AACvH,MAAM,UAAU,eAAe,CAAC,EAAY,EAAE,OAAe;IAC3D,OAAO,EAAE,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,EAAE,CAAC,SAAS,CAAC,OAAO,EAAE,OAAO,CAAC,CAAC,CAAC;AACpE,CAAC"}