@jmanuelcorral/openteam 0.1.41 → 0.2.0

package/dist/context/redaction.d.ts

@@ -39,10 +39,33 @@ export declare function redactedRef(ref: ContextRef): {
     sha256: string;
     bytes: number;
 };
+/** Claves prohibidas por transportar potencialmente contenido crudo. */
+export declare const FORBIDDEN_RAW_KEYS: ReadonlySet<string>;
 /**
  * Recorre una estructura y lanza `RedactionError` si encuentra alguna clave de
  * contenido crudo. Guard barato para journal/snapshots/telemetría; no valida
  * esquema, solo ausencia de campos crudos.
  */
 export declare function assertReferenceOnly(value: unknown): void;
+/** Result of a counting privacy scan. */
+export type PrivacyScanResult = {
+    /** Number of top-level structures scanned (the denominator). */
+    readonly surfacesScanned: number;
+    /**
+     * Total forbidden-key occurrences across all surfaces. Zero means the
+     * scanner ran, examined the surfaces, and found nothing forbidden.
+     */
+    readonly rawFindings: number;
+};
+/**
+ * Counting privacy scanner. Walks one or more structures and returns both the
+ * number of surfaces examined and the total forbidden-key findings, without
+ * throwing.
+ *
+ * **Surface definition:** one surface = one top-level value passed in the
+ * `surfaces` array. In soak context, this is the trace being scanned — one
+ * trace per observation. The definition is deliberately not inflatable: it
+ * counts logical units of work, not internal leaves.
+ */
+export declare function scanReferenceOnly(surfaces: readonly unknown[]): PrivacyScanResult;
 //# sourceMappingURL=redaction.d.ts.map

package/dist/context/redaction.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../../src/context/redaction.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE1D;;;;;;;;;GASG;AAEH,mEAAmE;AACnE,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;gBAET,GAAG,EAAE,MAAM;CAMxB;AAED,2DAA2D;AAC3D,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,qEAAqE;AACrE,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,2EAA2E;AAC3E,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,GAAG,CAAC,EAAE,UAAU,GACf,aAAa,CAKf;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,UAAU,GAAG;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAEA;AAgBD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAkBxD"}
+{"version":3,"file":"redaction.d.ts","sourceRoot":"","sources":["../../src/context/redaction.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,aAAa,EAAE,MAAM,UAAU,CAAC;AAE1D;;;;;;;;;GASG;AAEH,mEAAmE;AACnE,qBAAa,cAAe,SAAQ,KAAK;IACvC,QAAQ,CAAC,IAAI,EAAE,aAAa,CAAC;IAC7B,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB,YAAY,GAAG,EAAE,MAAM,EAKtB;CACF;AAED,2DAA2D;AAC3D,wBAAgB,SAAS,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,qEAAqE;AACrE,MAAM,MAAM,MAAM,GAAG;IACnB,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAAC;AAEF,2EAA2E;AAC3E,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAK/C;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,MAAM,EACb,IAAI,EAAE,MAAM,EACZ,GAAG,CAAC,EAAE,UAAU,GACf,aAAa,CAKf;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,GAAG,EAAE,UAAU,GAAG;IAC5C,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;CACf,CAEA;AAED,wEAAwE;AACxE,eAAO,MAAM,kBAAkB,EAAE,WAAW,CAAC,MAAM,CAWjD,CAAC;AA+BH;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,OAAO,GAAG,IAAI,CAIxD;AAED,yCAAyC;AACzC,MAAM,MAAM,iBAAiB,GAAG;IAC9B,gEAAgE;IAChE,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC;;;OAGG;IACH,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;CAC9B,CAAC;AAEF;;;;;;;;;GASG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,SAAS,OAAO,EAAE,GAC3B,iBAAiB,CASnB"}

package/dist/context/schema.d.ts

@@ -14,8 +14,8 @@ import { z } from "zod";
  */
 /** Clase de privacidad de un artefacto o contrato de contexto. */
 export declare const PrivacyClassSchema: z.ZodEnum<{
-    public: "public";
     internal: "internal";
+    public: "public";
     sensitive: "sensitive";
 }>;
 export type PrivacyClass = z.infer<typeof PrivacyClassSchema>;
@@ -74,8 +74,8 @@ export declare const ArtifactManifestSchema: z.ZodObject<{
     version: z.ZodLiteral<1>;
     taskID: z.ZodString;
     privacyClass: z.ZodEnum<{
-        public: "public";
         internal: "internal";
+        public: "public";
         sensitive: "sensitive";
     }>;
     entries: z.ZodArray<z.ZodObject<{
@@ -105,8 +105,8 @@ export declare const NodeContextContractSchema: z.ZodObject<{
         mediaType: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
     privacyClass: z.ZodEnum<{
-        public: "public";
         internal: "internal";
+        public: "public";
         sensitive: "sensitive";
     }>;
     maxInputTokens: z.ZodOptional<z.ZodNumber>;

package/dist/contract/opencode.d.ts

@@ -25,13 +25,13 @@ export declare const MIN_SUPPORTED_OPENCODE_VERSION = "1.17.13";
  * una versión nueva hay que añadirla aquí **después** de revisar los puntos de
  * integración documentados en {@link OPENCODE_CONTRACT_SURFACES}.
  */
-export declare const SUPPORTED_OPENCODE_VERSIONS: readonly ["1.17.13"];
+export declare const SUPPORTED_OPENCODE_VERSIONS: readonly ["1.17.13", "1.18.18"];
 export type SupportedOpencodeVersion = (typeof SUPPORTED_OPENCODE_VERSIONS)[number];
 /**
  * Puntos de integración concretos que openteam asume estables. Sirve como
  * checklist ejecutable/documental cuando se verifica una versión nueva.
  */
-export declare const OPENCODE_CONTRACT_SURFACES: readonly ["Hooks[\"chat.message\"] permite mutar output.message.model", "Hooks[\"chat.message\"] permite mutar output.parts[].text (inyección de contexto)", "tool() + tool.schema (zod) para custom tools", "PluginModule = { id?, server } con server: (input, options?) => Promise<Hooks>", "SDK session.create / session.prompt aceptan body.model = { providerID, modelID }", "Hooks[\"tool.execute.before\"] / Hooks[\"tool.execute.after\"] reciben { tool, sessionID, callID }", "Hooks[\"event\"] con message.updated trae properties.info (AssistantMessage) con cost:number y tokens{input,output,reasoning,cache{read,write}} y time{created,completed}", "El frontmatter `permission` de un agente (`.opencode/agent/*.md`) ANULA el `permission` global de `opencode.json`; el catch-all `\"*\": allow` concede todos los permisos (base del modo YOLO)"];
+export declare const OPENCODE_CONTRACT_SURFACES: readonly ['Hooks["chat.message"] permite mutar output.message.model', 'Hooks["chat.message"] permite mutar output.parts[].text (inyección de contexto)', "tool() + tool.schema (zod) para custom tools", "PluginModule = { id?, server } con server: (input, options?) => Promise<Hooks>", "SDK session.create / session.prompt aceptan body.model = { providerID, modelID }", 'Hooks["tool.execute.before"] / Hooks["tool.execute.after"] reciben { tool, sessionID, callID }', 'Hooks["event"] con message.updated trae properties.info (AssistantMessage) con cost:number y tokens{input,output,reasoning,cache{read,write}} y time{created,completed}', 'El frontmatter `permission` de un agente (`.opencode/agent/*.md`) ANULA el `permission` global de `opencode.json`; el catch-all `"*": allow` concede todos los permisos (base del modo YOLO)'];
 export type Semver = {
     readonly major: number;
     readonly minor: number;

package/dist/contract/opencode.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../src/contract/opencode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,sDAGpB,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,YAAY,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,sBAAuB,CAAC;AAEhE,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,0BAA0B,y0BAS7B,CAAC;AAEX,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAIF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAanD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAc9D;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,GACd,OAAO,IAAI,wBAAwB,CAErC;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOpE"}
+{"version":3,"file":"opencode.d.ts","sourceRoot":"","sources":["../../src/contract/opencode.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH;;GAEG;AACH,eAAO,MAAM,iBAAiB,YAC5B,qBAAqB,EACrB,kBAAkB,CACV,CAAC;AAEX,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAC;AAEjE;;;GAGG;AACH,eAAO,MAAM,8BAA8B,YAAY,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,2BAA2B,YAAI,SAAS,EAAE,SAAS,CAAU,CAAC;AAE3E,MAAM,MAAM,wBAAwB,GAClC,CAAC,OAAO,2BAA2B,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C;;;GAGG;AACH,eAAO,MAAM,0BAA0B,YACrC,0DAA0D,EAC1D,iFAAiF,EACjF,8CAA8C,EAC9C,gFAAgF,EAChF,kFAAkF,EAClF,gGAAgG,EAChG,yKAAyK,EACzK,8LAA8L,CACtL,CAAC;AAEX,MAAM,MAAM,MAAM,GAAG;IACnB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;CACxB,CAAC;AAIF;;;GAGG;AACH,wBAAgB,WAAW,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAanD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,CAAC,CAAC,GAAG,CAAC,GAAG,CAAC,CAc9D;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,GACd,OAAO,IAAI,wBAAwB,CAErC;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO,CAOpE"}

package/dist/graph/certificate.d.ts

@@ -0,0 +1,505 @@
+import { z } from "zod";
+import { type SoakObservation } from "./soakLedger";
+/**
+ * **Certificado de certificación shadow** `GraphShadowCertificateV1` (GE-046).
+ *
+ * Es el STOP duro que desbloquea R1 y lo consumen GE-050, GE-054 y GE-057, así
+ * que su propiedad central no es describir la evidencia sino **no poder mentir
+ * sobre ella**:
+ *
+ * - El veredicto se **deriva** de la evidencia; `buildShadowCertificate` no lo
+ *   acepta como entrada. No existe forma de pedir un certificado en verde.
+ * - `parseShadowCertificate` **recomputa** el veredicto y el digest antes de
+ *   aceptarlo, así que un `"pass"` escrito a mano o una evidencia editada
+ *   después de firmar fallan cerrado en vez de colarse en el arranque.
+ * - El certificado transporta la **procedencia** del espejo (GE-043), que acota
+ *   qué prueba realmente la paridad: certificar dimensiones que el espejo se
+ *   limita a copiar del trace no probaría nada.
+ *
+ * Módulo **puro y determinista**: sin I/O, reloj ni azar. La misma evidencia
+ * produce el mismo certificado, byte a byte.
+ */
+/** Tamaño mínimo de muestra: por debajo, no hay evidencia que certificar. */
+export declare const SHADOW_CERTIFICATE_MIN_RUNS = 1000;
+/** Puertas que el certificado evalúa, en orden determinista de reporte. */
+export type ShadowCertificateGate = "sample" | "parity" | "one-legacy-execution" | "privacy" | "overhead";
+/** Veredicto derivado del certificado. */
+export type ShadowCertificateVerdict = "pass" | "fail";
+declare const EvidenceSchema: z.ZodObject<{
+    opencodeVersion: z.ZodString;
+    parity: z.ZodObject<{
+        runs: z.ZodNumber;
+        match: z.ZodNumber;
+        divergent: z.ZodNumber;
+        inconclusive: z.ZodNumber;
+        divergences: z.ZodArray<z.ZodEnum<{
+            fixes: "fixes";
+            models: "models";
+            order: "order";
+            outcome: "outcome";
+            roles: "roles";
+            status: "status";
+        }>>;
+    }, z.core.$strict>;
+    legacy: z.ZodObject<{
+        observed: z.ZodNumber;
+        duplicated: z.ZodNumber;
+    }, z.core.$strict>;
+    privacy: z.ZodObject<{
+        surfacesScanned: z.ZodNumber;
+        rawFindings: z.ZodNumber;
+    }, z.core.$strict>;
+    overhead: z.ZodObject<{
+        p95Millis: z.ZodNumber;
+        budgetMillis: z.ZodNumber;
+        samples: z.ZodNumber;
+    }, z.core.$strict>;
+    provenance: z.ZodRecord<z.ZodEnum<{
+        fixes: "fixes";
+        models: "models";
+        order: "order";
+        outcome: "outcome";
+        roles: "roles";
+        status: "status";
+    }>, z.ZodEnum<{
+        carried: "carried";
+        compiled: "compiled";
+        recomputed: "recomputed";
+        validated: "validated";
+    }>>;
+}, z.core.$strict>;
+/** Evidencia bruta que alimenta el certificado. */
+export type ShadowCertificateEvidence = z.infer<typeof EvidenceSchema>;
+declare const CertificateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    certificate: z.ZodLiteral<"graph-shadow">;
+    opencodeVersion: z.ZodString;
+    evidence: z.ZodObject<{
+        opencodeVersion: z.ZodString;
+        parity: z.ZodObject<{
+            runs: z.ZodNumber;
+            match: z.ZodNumber;
+            divergent: z.ZodNumber;
+            inconclusive: z.ZodNumber;
+            divergences: z.ZodArray<z.ZodEnum<{
+                fixes: "fixes";
+                models: "models";
+                order: "order";
+                outcome: "outcome";
+                roles: "roles";
+                status: "status";
+            }>>;
+        }, z.core.$strict>;
+        legacy: z.ZodObject<{
+            observed: z.ZodNumber;
+            duplicated: z.ZodNumber;
+        }, z.core.$strict>;
+        privacy: z.ZodObject<{
+            surfacesScanned: z.ZodNumber;
+            rawFindings: z.ZodNumber;
+        }, z.core.$strict>;
+        overhead: z.ZodObject<{
+            p95Millis: z.ZodNumber;
+            budgetMillis: z.ZodNumber;
+            samples: z.ZodNumber;
+        }, z.core.$strict>;
+        provenance: z.ZodRecord<z.ZodEnum<{
+            fixes: "fixes";
+            models: "models";
+            order: "order";
+            outcome: "outcome";
+            roles: "roles";
+            status: "status";
+        }>, z.ZodEnum<{
+            carried: "carried";
+            compiled: "compiled";
+            recomputed: "recomputed";
+            validated: "validated";
+        }>>;
+    }, z.core.$strict>;
+    verdict: z.ZodEnum<{
+        fail: "fail";
+        pass: "pass";
+    }>;
+    failedGates: z.ZodArray<z.ZodEnum<{
+        "one-legacy-execution": "one-legacy-execution";
+        overhead: "overhead";
+        parity: "parity";
+        privacy: "privacy";
+        sample: "sample";
+    }>>;
+    digest: z.ZodString;
+}, z.core.$strict>;
+/** Certificado machine-readable de certificación shadow. */
+export type GraphShadowCertificateV1 = z.infer<typeof CertificateSchema>;
+/** Motivo tipado por el que un certificado no es aceptable. */
+export type ShadowCertificateErrorCode = "invalid-certificate" | "verdict-mismatch" | "digest-mismatch" | "opencode-mismatch";
+/** Error fail-closed del certificado. */
+export declare class ShadowCertificateError extends Error {
+    readonly code: ShadowCertificateErrorCode;
+    readonly detail: string;
+    constructor(code: ShadowCertificateErrorCode, detail: string);
+}
+/**
+ * Construye el certificado a partir de la evidencia. El veredicto **no es un
+ * parámetro**: se deriva de las puertas, de modo que no existe un camino para
+ * emitir un certificado en verde sin la evidencia que lo sostiene.
+ */
+export declare function buildShadowCertificate(evidence: ShadowCertificateEvidence): GraphShadowCertificateV1;
+/**
+ * Valida un certificado de procedencia no confiable contra el pin de opencode
+ * esperado. Fail-closed en todos los casos: esquema inválido, veredicto que no
+ * se corresponde con su evidencia, digest que no cubre la evidencia presentada,
+ * o pin distinto al certificado.
+ */
+export declare function parseShadowCertificate(value: unknown, opencodeVersion: string): GraphShadowCertificateV1;
+/**
+ * Puertas del certificado de release. Cada una es condición **necesaria**: una
+ * puerta que corrió cero casos falla por vacuidad, y la ausencia de evidencia
+ * es fracaso, no éxito.
+ */
+export type ReleaseCertificateGate = "shadow-valid" | "determinism" | "crash-recovery" | "replay-equivalence" | "privacy" | "contract" | "migration" | "health" | "performance";
+declare const ReleaseEvidenceSchema: z.ZodObject<{
+    opencodeVersion: z.ZodString;
+    platform: z.ZodEnum<{
+        linux: "linux";
+        win32: "win32";
+    }>;
+    shadowCertificateDigest: z.ZodString;
+    determinism: z.ZodObject<{
+        runs: z.ZodNumber;
+        allMatch: z.ZodBoolean;
+    }, z.core.$strict>;
+    crashRecovery: z.ZodObject<{
+        scenarios: z.ZodNumber;
+        allConverge: z.ZodBoolean;
+    }, z.core.$strict>;
+    replayEquivalence: z.ZodObject<{
+        checks: z.ZodNumber;
+        allEquivalent: z.ZodBoolean;
+    }, z.core.$strict>;
+    privacy: z.ZodObject<{
+        surfacesScanned: z.ZodNumber;
+        rawFindings: z.ZodNumber;
+    }, z.core.$strict>;
+    contract: z.ZodObject<{
+        roundTrips: z.ZodNumber;
+        allSettled: z.ZodBoolean;
+    }, z.core.$strict>;
+    migration: z.ZodObject<{
+        cases: z.ZodNumber;
+        allSucceeded: z.ZodBoolean;
+    }, z.core.$strict>;
+    health: z.ZodObject<{
+        samples: z.ZodNumber;
+        bounded: z.ZodBoolean;
+        idempotent: z.ZodBoolean;
+    }, z.core.$strict>;
+    performance: z.ZodObject<{
+        p95Millis: z.ZodNumber;
+        budgetMillis: z.ZodNumber;
+        samples: z.ZodNumber;
+    }, z.core.$strict>;
+}, z.core.$strict>;
+/** Evidencia bruta que alimenta el certificado de release. */
+export type ReleaseCertificateEvidence = z.infer<typeof ReleaseEvidenceSchema>;
+declare const ReleaseCertificateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    certificate: z.ZodLiteral<"graph-release">;
+    platform: z.ZodEnum<{
+        linux: "linux";
+        win32: "win32";
+    }>;
+    opencodeVersion: z.ZodString;
+    shadowCertificateDigest: z.ZodString;
+    evidence: z.ZodObject<{
+        opencodeVersion: z.ZodString;
+        platform: z.ZodEnum<{
+            linux: "linux";
+            win32: "win32";
+        }>;
+        shadowCertificateDigest: z.ZodString;
+        determinism: z.ZodObject<{
+            runs: z.ZodNumber;
+            allMatch: z.ZodBoolean;
+        }, z.core.$strict>;
+        crashRecovery: z.ZodObject<{
+            scenarios: z.ZodNumber;
+            allConverge: z.ZodBoolean;
+        }, z.core.$strict>;
+        replayEquivalence: z.ZodObject<{
+            checks: z.ZodNumber;
+            allEquivalent: z.ZodBoolean;
+        }, z.core.$strict>;
+        privacy: z.ZodObject<{
+            surfacesScanned: z.ZodNumber;
+            rawFindings: z.ZodNumber;
+        }, z.core.$strict>;
+        contract: z.ZodObject<{
+            roundTrips: z.ZodNumber;
+            allSettled: z.ZodBoolean;
+        }, z.core.$strict>;
+        migration: z.ZodObject<{
+            cases: z.ZodNumber;
+            allSucceeded: z.ZodBoolean;
+        }, z.core.$strict>;
+        health: z.ZodObject<{
+            samples: z.ZodNumber;
+            bounded: z.ZodBoolean;
+            idempotent: z.ZodBoolean;
+        }, z.core.$strict>;
+        performance: z.ZodObject<{
+            p95Millis: z.ZodNumber;
+            budgetMillis: z.ZodNumber;
+            samples: z.ZodNumber;
+        }, z.core.$strict>;
+    }, z.core.$strict>;
+    verdict: z.ZodEnum<{
+        fail: "fail";
+        pass: "pass";
+    }>;
+    failedGates: z.ZodArray<z.ZodEnum<{
+        contract: "contract";
+        "crash-recovery": "crash-recovery";
+        determinism: "determinism";
+        health: "health";
+        migration: "migration";
+        performance: "performance";
+        privacy: "privacy";
+        "replay-equivalence": "replay-equivalence";
+        "shadow-valid": "shadow-valid";
+    }>>;
+    digest: z.ZodString;
+}, z.core.$strict>;
+/** Certificado machine-readable de release del grafo. */
+export type GraphReleaseCertificateV1 = z.infer<typeof ReleaseCertificateSchema>;
+/** Motivo tipado por el que un certificado de release no es aceptable. */
+export type ReleaseCertificateErrorCode = "invalid-certificate" | "field-inconsistency" | "verdict-mismatch" | "digest-mismatch" | "opencode-mismatch";
+/** Error fail-closed del certificado de release. */
+export declare class ReleaseCertificateError extends Error {
+    readonly code: ReleaseCertificateErrorCode;
+    readonly detail: string;
+    constructor(code: ReleaseCertificateErrorCode, detail: string);
+}
+/**
+ * Construye el certificado de release a partir de la evidencia. El veredicto
+ * **no es un parámetro**: se deriva de las puertas.
+ *
+ * `expectedShadowDigest` es el digest del `GraphShadowCertificateV1` producido
+ * en la misma ejecución — vincula transitivamente la revisión. Si el digest no
+ * coincide, la puerta `shadow-valid` falla. Es obligatorio: un certificado
+ * nunca puede ser su propio testigo.
+ */
+export declare function buildReleaseCertificate(evidence: ReleaseCertificateEvidence, expectedShadowDigest: string): GraphReleaseCertificateV1;
+/**
+ * Valida un certificado de release de procedencia no confiable. Fail-closed:
+ * `invalid-certificate` → `field-inconsistency` → `verdict-mismatch` →
+ * `digest-mismatch` → `opencode-mismatch`.
+ *
+ * `expectedShadowDigest` es el digest del shadow certificate que el llamante
+ * espera — impide que un certificado forjado declare un digest falso y pase
+ * la puerta `shadow-valid` por autocomparación.
+ */
+export declare function parseReleaseCertificate(value: unknown, opencodeVersion: string, expectedShadowDigest: string): GraphReleaseCertificateV1;
+/**
+ * Puertas del certificado soak. Cada una es condición **necesaria**; cero
+ * observaciones fallan cerrado por la puerta `minimum-observations`, no por
+ * un error de schema. La ausencia de evidencia es fracaso, no éxito.
+ */
+export type SoakCertificateGate = "minimum-observations" | "minimum-duration" | "chain-integrity" | "zero-critical-divergence" | "zero-privacy-breach" | "zero-duplicate-effect" | "zero-model-mismatch" | "os-diversity" | "opencode-pin";
+/**
+ * Shadow divergence codes that the soak mechanism can classify as critical.
+ * Defined here (not imported from orchestrator) to keep the graph module pure.
+ */
+export declare const ShadowDivergenceCodeSchema: z.ZodEnum<{
+    fixes: "fixes";
+    models: "models";
+    order: "order";
+    outcome: "outcome";
+    roles: "roles";
+    status: "status";
+}>;
+export type ShadowDivergenceCode = z.infer<typeof ShadowDivergenceCodeSchema>;
+/**
+ * Códigos de divergencia cuya proyección shadow es recomputada de forma
+ * independiente por el espejo Y cuya divergencia es **demostrable** a través
+ * del pipeline completo (trace → mirrorLegacyTrace → proyecciones →
+ * compareShadowRun). Solo estos pueden producir una divergencia real y por
+ * tanto solo estos son aptos para el conjunto crítico de la política soak.
+ *
+ * `order` y `roles` fueron reclasificados de "recomputed" a "carried" (#55):
+ * `compileShadowSpec` preserva ids y roles del trace literalmente, así que
+ * ambos lados de la comparación ven las mismas secuencias. No se pudo
+ * construir ningún trace válido que los hiciera divergir por el pipeline.
+ *
+ * Un test de alcanzabilidad (`demonstrated-divergence-provenance.test.ts`)
+ * demuestra que cada código aquí listado PUEDE divergir por el pipeline real.
+ * Añadir un código sin su demostración es un test rojo.
+ */
+export declare const RECOMPUTED_DIVERGENCE_CODES: readonly ["fixes"];
+declare const RecomputedDivergenceCodeSchema: z.ZodEnum<{
+    fixes: "fixes";
+}>;
+export type RecomputedDivergenceCode = z.infer<typeof RecomputedDivergenceCodeSchema>;
+/**
+ * Política operativa del certificado soak. Los umbrales son configuración,
+ * no constantes — ajustables sin editar lógica de puertas. La política se
+ * embebe en el certificado y se cubre por el digest: un certificado que no
+ * registra contra qué estándar se juzgó es infalsificable.
+ *
+ * `criticalDivergenceCodes` classifies which shadow divergence codes count as
+ * critical for the `zero-critical-divergence` gate. Only codes with provenance
+ * "recomputed" are accepted: they are the only codes where the shadow mirror
+ * computes the value independently, making divergence structurally possible.
+ * Codes with provenance "carried" or "validated" copy the same trace field on
+ * both sides — including them would inflate declared coverage without
+ * measuring anything.
+ */
+export declare const SoakPolicySchema: z.ZodObject<{
+    minimumGenuineObservations: z.ZodNumber;
+    minimumDistinctDays: z.ZodNumber;
+    requireGenuineUsageOnAllPlatforms: z.ZodBoolean;
+    supportedOpencodeVersion: z.ZodString;
+    criticalDivergenceCodes: z.ZodArray<z.ZodEnum<{
+        fixes: "fixes";
+    }>>;
+}, z.core.$strict>;
+/** Política tipada del certificado soak. */
+export type SoakPolicy = z.infer<typeof SoakPolicySchema>;
+/** Política por defecto: solo el código cuya divergencia está demostrada. */
+export declare const DEFAULT_SOAK_POLICY: SoakPolicy;
+declare const SoakEvidenceSchema: z.ZodObject<{
+    totalObservations: z.ZodNumber;
+    genuineUsageObservations: z.ZodNumber;
+    ciSyntheticObservations: z.ZodNumber;
+    recorderCount: z.ZodNumber;
+    firstTimestamp: z.ZodNullable<z.ZodString>;
+    lastTimestamp: z.ZodNullable<z.ZodString>;
+    distinctDays: z.ZodNumber;
+    criticalDivergences: z.ZodNullable<z.ZodNumber>;
+    privacy: z.ZodNullable<z.ZodObject<{
+        surfacesScanned: z.ZodNumber;
+        rawFindings: z.ZodNumber;
+    }, z.core.$strict>>;
+    duplicateEffects: z.ZodNullable<z.ZodObject<{
+        effectsExamined: z.ZodNumber;
+        duplicatesFound: z.ZodNumber;
+    }, z.core.$strict>>;
+    modelVerification: z.ZodNullable<z.ZodObject<{
+        nodesChecked: z.ZodNumber;
+        unverified: z.ZodNumber;
+        mismatched: z.ZodNumber;
+    }, z.core.$strict>>;
+    platformsGenuine: z.ZodArray<z.ZodEnum<{
+        darwin: "darwin";
+        linux: "linux";
+        win32: "win32";
+    }>>;
+    platformsSynthetic: z.ZodArray<z.ZodEnum<{
+        darwin: "darwin";
+        linux: "linux";
+        win32: "win32";
+    }>>;
+    opencodeVersionsObserved: z.ZodArray<z.ZodString>;
+    invalidChains: z.ZodNumber;
+}, z.core.$strict>;
+/** Evidencia agregada del soak. */
+export type SoakCertificateEvidence = z.infer<typeof SoakEvidenceSchema>;
+declare const SoakCertificateSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    certificate: z.ZodLiteral<"graph-soak">;
+    trustBoundary: z.ZodLiteral<"contributors">;
+    policy: z.ZodObject<{
+        minimumGenuineObservations: z.ZodNumber;
+        minimumDistinctDays: z.ZodNumber;
+        requireGenuineUsageOnAllPlatforms: z.ZodBoolean;
+        supportedOpencodeVersion: z.ZodString;
+        criticalDivergenceCodes: z.ZodArray<z.ZodEnum<{
+            fixes: "fixes";
+        }>>;
+    }, z.core.$strict>;
+    evidence: z.ZodObject<{
+        totalObservations: z.ZodNumber;
+        genuineUsageObservations: z.ZodNumber;
+        ciSyntheticObservations: z.ZodNumber;
+        recorderCount: z.ZodNumber;
+        firstTimestamp: z.ZodNullable<z.ZodString>;
+        lastTimestamp: z.ZodNullable<z.ZodString>;
+        distinctDays: z.ZodNumber;
+        criticalDivergences: z.ZodNullable<z.ZodNumber>;
+        privacy: z.ZodNullable<z.ZodObject<{
+            surfacesScanned: z.ZodNumber;
+            rawFindings: z.ZodNumber;
+        }, z.core.$strict>>;
+        duplicateEffects: z.ZodNullable<z.ZodObject<{
+            effectsExamined: z.ZodNumber;
+            duplicatesFound: z.ZodNumber;
+        }, z.core.$strict>>;
+        modelVerification: z.ZodNullable<z.ZodObject<{
+            nodesChecked: z.ZodNumber;
+            unverified: z.ZodNumber;
+            mismatched: z.ZodNumber;
+        }, z.core.$strict>>;
+        platformsGenuine: z.ZodArray<z.ZodEnum<{
+            darwin: "darwin";
+            linux: "linux";
+            win32: "win32";
+        }>>;
+        platformsSynthetic: z.ZodArray<z.ZodEnum<{
+            darwin: "darwin";
+            linux: "linux";
+            win32: "win32";
+        }>>;
+        opencodeVersionsObserved: z.ZodArray<z.ZodString>;
+        invalidChains: z.ZodNumber;
+    }, z.core.$strict>;
+    verdict: z.ZodEnum<{
+        fail: "fail";
+        pass: "pass";
+    }>;
+    failedGates: z.ZodArray<z.ZodEnum<{
+        "chain-integrity": "chain-integrity";
+        "minimum-duration": "minimum-duration";
+        "minimum-observations": "minimum-observations";
+        "opencode-pin": "opencode-pin";
+        "os-diversity": "os-diversity";
+        "zero-critical-divergence": "zero-critical-divergence";
+        "zero-duplicate-effect": "zero-duplicate-effect";
+        "zero-model-mismatch": "zero-model-mismatch";
+        "zero-privacy-breach": "zero-privacy-breach";
+    }>>;
+    ledgerDigest: z.ZodString;
+    digest: z.ZodString;
+}, z.core.$strict>;
+/** Certificado machine-readable del soak del grafo. */
+export type GraphSoakCertificateV1 = z.infer<typeof SoakCertificateSchema>;
+/** Motivo tipado por el que un certificado soak no es aceptable. */
+export type SoakCertificateErrorCode = "invalid-certificate" | "policy-mismatch" | "verdict-mismatch" | "digest-mismatch" | "ledger-mismatch";
+/** Error fail-closed del certificado soak. */
+export declare class SoakCertificateError extends Error {
+    readonly code: SoakCertificateErrorCode;
+    readonly detail: string;
+    constructor(code: SoakCertificateErrorCode, detail: string);
+}
+/**
+ * Construye el certificado soak a partir de las cadenas de observación y la
+ * política operativa. El veredicto **no es un parámetro**: se deriva de las
+ * puertas evaluadas contra la política.
+ *
+ * La política se embebe en el certificado y se cubre por el digest — un
+ * certificado que no registra contra qué estándar se juzgó es infalsificable.
+ */
+export declare function buildSoakCertificate(chains: readonly (readonly SoakObservation[])[], policy: SoakPolicy): GraphSoakCertificateV1;
+/**
+ * Valida un certificado soak de procedencia no confiable. Fail-closed en
+ * todos los casos: esquema inválido → política divergente → veredicto
+ * incongruente → digest inválido → ledger incongruente.
+ *
+ * El llamante suministra la política que espera, exactamente como suministra
+ * `expectedLedgerDigest`. Si la política embebida diverge de la esperada, el
+ * certificado se rechaza con `policy-mismatch` — un veredicto `pass` bajo
+ * una política permisiva no satisface una política estricta.
+ */
+export declare function parseSoakCertificate(value: unknown, expectedPolicy: SoakPolicy, expectedLedgerDigest: string): GraphSoakCertificateV1;
+export {};
+//# sourceMappingURL=certificate.d.ts.map

package/dist/graph/certificate.d.ts.map

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

package/dist/graph/ids.d.ts

@@ -1,5 +1,14 @@
+import type { GraphSpecV1 } from "./schema";
 /** ID estable del efecto de un nodo, opcionalmente por revisión. */
 export declare function operationID(runID: string, nodeID: string, revision?: number): string;
 /** ID del intento `attempt` (>= 0) de una operación dada. */
 export declare function attemptID(operation: string, attempt: number): string;
+/**
+ * Digest SHA-256 estable del spec compilado (reproducible).
+ *
+ * Vive junto a los IDs del grafo, no en el compilador SDD: el espejo shadow lo
+ * necesita y alcanzar el compilador arrastraría el coordinador, las sesiones y
+ * la telemetría —es decir, superficie de ejecución— al grafo del espejo.
+ */
+export declare function graphSpecDigest(spec: GraphSpecV1): string;
 //# sourceMappingURL=ids.d.ts.map

package/dist/graph/ids.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/graph/ids.ts"],"names":[],"mappings":"AAYA,oEAAoE;AACpE,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,SAAI,GACX,MAAM,CAKR;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpE"}
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../../src/graph/ids.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAY5C,oEAAoE;AACpE,wBAAgB,WAAW,CACzB,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,QAAQ,SAAI,GACX,MAAM,CAKR;AAED,6DAA6D;AAC7D,wBAAgB,SAAS,CAAC,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAEpE;AAqBD;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,WAAW,GAAG,MAAM,CAEzD"}

package/dist/graph/privacyPolicy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"privacyPolicy.d.ts","sourceRoot":"","sources":["../../src/graph/privacyPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,uEAAuE;AACvE,MAAM,MAAM,WAAW,GACnB,uBAAuB,GACvB,uBAAuB,GACvB,KAAK,CAAC;AAEV,oCAAoC;AACpC,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;AAE7C,kEAAkE;AAClE,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;CAM3B;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,WAAW,GAChB,OAAO,CAET;AAED,uEAAuE;AACvE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,YAAY,EAAE,YAAY,CAAC;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;CACtB,GAAG,IAAI,CAOP"}
+{"version":3,"file":"privacyPolicy.d.ts","sourceRoot":"","sources":["../../src/graph/privacyPolicy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAC;AAEtD;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AAE3D,uEAAuE;AACvE,MAAM,MAAM,WAAW,GACnB,uBAAuB,GACvB,uBAAuB,GACvB,KAAK,CAAC;AAEV,oCAAoC;AACpC,MAAM,MAAM,SAAS,GAAG,OAAO,GAAG,UAAU,CAAC;AAE7C,kEAAkE;AAClE,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,QAAQ,CAAC,IAAI,EAAE,wBAAwB,CAAC;IACxC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YAAY,MAAM,EAAE,MAAM,EAKzB;CACF;AAED;;;GAGG;AACH,wBAAgB,eAAe,CAC7B,YAAY,EAAE,YAAY,EAC1B,IAAI,EAAE,WAAW,GAChB,OAAO,CAET;AAED,uEAAuE;AACvE,wBAAgB,qBAAqB,CAAC,KAAK,EAAE;IAC3C,YAAY,EAAE,YAAY,CAAC;IAC3B,IAAI,EAAE,WAAW,CAAC;IAClB,SAAS,EAAE,SAAS,CAAC;CACtB,GAAG,IAAI,CAOP"}

package/dist/graph/reducer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/graph/reducer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAa,WAAW,EAAE,MAAM,UAAU,CAAC;AACrE,OAAO,EACL,KAAK,UAAU,EAGhB,MAAM,SAAS,CAAC;AAEjB;;;;;;;GAOG;AAEH,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,eAAe,GACf,sBAAsB,GACtB,cAAc,GACd,0BAA0B,GAC1B,mBAAmB,GACnB,kBAAkB,GAClB,oBAAoB,GACpB,gBAAgB,CAAC;AAErB,2DAA2D;AAC3D,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM;CAMnD;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,CAM1D;AAoLD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,YAAY,GAClB,UAAU,CAkCZ;AAyBD,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEnD"}
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/graph/reducer.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAa,WAAW,EAAE,MAAM,UAAU,CAAC;AACrE,OAAO,EACL,KAAK,UAAU,EAGhB,MAAM,SAAS,CAAC;AAEjB;;;;;;;GAOG;AAEH,MAAM,MAAM,gBAAgB,GACxB,cAAc,GACd,eAAe,GACf,sBAAsB,GACtB,cAAc,GACd,0BAA0B,GAC1B,mBAAmB,GACnB,kBAAkB,GAClB,oBAAoB,GACpB,gBAAgB,CAAC;AAErB,2DAA2D;AAC3D,qBAAa,YAAa,SAAQ,KAAK;IACrC,QAAQ,CAAC,IAAI,EAAE,gBAAgB,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YAAY,IAAI,EAAE,gBAAgB,EAAE,MAAM,EAAE,MAAM,EAKjD;CACF;AAED,6EAA6E;AAC7E,wBAAgB,YAAY,CAAC,IAAI,EAAE,WAAW,GAAG,UAAU,CAM1D;AAoLD;;;GAGG;AACH,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,KAAK,EAAE,UAAU,EACjB,KAAK,EAAE,YAAY,GAClB,UAAU,CAkCZ;AAyBD,8EAA8E;AAC9E,wBAAgB,SAAS,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM,CAEnD"}

package/dist/graph/replay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../src/graph/replay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;GAMG;AAEH,yDAAyD;AACzD,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;gBAEZ,MAAM,EAAE,MAAM;CAM3B;AAED,gEAAgE;AAChE,wBAAgB,MAAM,CACpB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,SAAS,YAAY,EAAE,GAC9B,UAAU,CASZ;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,SAAS,YAAY,EAAE,GAC9B,MAAM,CAER"}
+{"version":3,"file":"replay.d.ts","sourceRoot":"","sources":["../../src/graph/replay.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AAC1D,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,SAAS,CAAC;AAE1C;;;;;;GAMG;AAEH,yDAAyD;AACzD,qBAAa,WAAY,SAAQ,KAAK;IACpC,QAAQ,CAAC,IAAI,EAAE,cAAc,CAAC;IAC9B,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,YAAY,MAAM,EAAE,MAAM,EAKzB;CACF;AAED,gEAAgE;AAChE,wBAAgB,MAAM,CACpB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,SAAS,YAAY,EAAE,GAC9B,UAAU,CASZ;AAED,0DAA0D;AAC1D,wBAAgB,UAAU,CACxB,IAAI,EAAE,WAAW,EACjB,MAAM,EAAE,SAAS,YAAY,EAAE,GAC9B,MAAM,CAER"}