harnery 0.32.0 → 0.34.0

package/dist/core/agents/session-events.js

@@ -1,35 +1,24 @@
 /**
  * Command/narration event emitter for the coordination layer.
  *
- * `writeSessionEvent` emits command and narration events straight to the
- * **canonical** `.harnery/events.ndjson` (alongside the hook events), which the
- * `/live` web viewer reads.
+ * `writeSessionEvent` records command spans in the canonical V3 ledger.
  */
 import { randomBytes } from "node:crypto";
 import { existsSync, readFileSync } from "node:fs";
-import { dirname, resolve } from "node:path";
+import { resolve } from "node:path";
 // Kept dependency-light: vendored verbatim into a downstream consumer, so no coordEnv import.
-import { normalizeAdapter, resolveEmitRoot } from "./canonical-emit.js";
-import { emit } from "./events/emit.js";
+import { LIVE_COMMAND_V3_PRODUCER_ID, liveInstanceIdV3, livePlatformV3, resolveLiveEventLedgerRouteV3, } from "../events/v3/live-routing.js";
+import { recordCommandSignalV3 } from "../events/v3/producers/command-recorder.js";
+import { writeProducerDiagnosticV3 } from "../events/v3/producers/intake.js";
+import { readHookProducerStateByInstanceV3 } from "../events/v3/producers/recorder.js";
+import { resolveEmitRoot } from "./canonical-emit.js";
 /**
  * Resolved path of the ndjson sidecar file. Lives inside `.harnery/` so a
  * containerized reader can pick it up through a single bind mount.
  */
-export function canonicalEventsPath() {
-    // Explicit override (tests + non-monorepo invocations).
-    const explicit = process.env.HARNERY_EVENTS_PATH;
-    if (explicit)
-        return explicit;
-    // Superproject-aware root resolution (git first, cwd walk fallback) via
-    // resolveEmitRoot. A plain cwd walk here mis-anchored to a NESTED
-    // `.harnery/` when the shell sat inside a submodule carrying its own
-    // (e.g. an embedded harnery checkout), silently splitting the event
-    // stream. Don't reintroduce CLAUDE.md / .git as anchors, which creates
-    // stray .harnery/ dirs under submodule subtrees.
+export function coordinationRootPath() {
     const root = resolveEmitRoot();
-    if (root)
-        return resolve(root, ".harnery", "session-events.ndjson");
-    return resolve(process.env.HOME || "/tmp", ".harnery", "session-events.ndjson");
+    return root ?? resolve(process.env.HOME || "/tmp");
 }
 /** Random 8-char hex id for grouping output lines under a single command. */
 export function newCmdId() {
@@ -46,7 +35,7 @@ export function newCmdId() {
 export function readLastIntent(instanceId) {
     if (!instanceId)
         return null;
-    // Same superproject-aware root resolution as canonicalEventsPath(): the
+    // Same superproject-aware root resolution as coordinationRootPath(): the
     // intent stamp is written by the PreToolUse hook into the SUPERPROJECT's
     // .harnery/, so a nested-`.harnery/` cwd must not redirect the read.
     const root = resolveEmitRoot();
@@ -66,95 +55,138 @@ export function readLastIntent(instanceId) {
         return null;
     }
 }
-const CANONICAL_TYPE = {
-    command_start: "command.start",
-    output: "command.output",
-    command_end: "command.end",
-    narration: "narration",
-};
-/** Cache heartbeat-derived envelope fields per instance_id so a burst of
- * `output` lines (one event per stdout line) doesn't re-read + re-parse the
- * heartbeat JSON each time. Short TTL: picks up platform/session changes
- * within a few seconds without hammering the disk on a chatty command. */
-const enrichCache = new Map();
-const ENRICH_TTL_MS = 5000;
-function enrichFromHeartbeat(coordRoot, instanceId) {
-    const now = Date.now();
-    const cached = enrichCache.get(instanceId);
-    if (cached && now - cached.at < ENRICH_TTL_MS)
-        return cached;
-    try {
-        const hbPath = resolve(coordRoot, ".harnery", "active", `${instanceId}.json`);
-        if (!existsSync(hbPath))
-            return null;
-        const hb = JSON.parse(readFileSync(hbPath, "utf8"));
-        const enrichment = {
-            session_id: hb.session_id || instanceId,
-            adapter: normalizeAdapter(hb.platform),
-            at: now,
-        };
-        enrichCache.set(instanceId, enrichment);
-        return enrichment;
-    }
-    catch {
-        return null;
-    }
-}
-/** Project the flat middleware `fields` into the canonical event's `data` shape.
- * Unknown types never reach here, guarded by CANONICAL_TYPE. */
-function canonicalData(type, fields) {
-    switch (type) {
-        case "command_start":
-            return { cmd_id: fields.cmd_id, intent: fields.intent, cmd: fields.cmd };
-        case "output":
-            return { cmd_id: fields.cmd_id, stream: fields.stream, line: fields.line };
-        case "command_end":
-            return {
-                cmd_id: fields.cmd_id,
-                exit: fields.exit,
-                duration_ms: fields.duration_ms,
-                ...(fields.signal ? { signal: fields.signal } : {}),
-            };
-        case "narration":
-            return { message: fields.message };
-        default:
-            return {};
-    }
-}
+const outputSequence = new Map();
 /** Emit a command/narration event to the canonical stream. Swallows every
  * error and skips when identity can't be resolved: telemetry must never break
  * or slow down a command. */
-function emitCanonicalCommand(type, fields) {
-    const eventType = CANONICAL_TYPE[type];
-    if (!eventType)
-        return;
+function recordCommandObservation(type, fields) {
     const instanceId = typeof fields.instance_id === "string" ? fields.instance_id : undefined;
     if (!instanceId)
         return;
     try {
-        // coordRoot = the dir containing `.harnery/`; canonicalEventsPath() anchors it.
-        const coordRoot = dirname(dirname(canonicalEventsPath()));
-        const enrich = enrichFromHeartbeat(coordRoot, instanceId);
-        if (!enrich)
+        const coordRoot = coordinationRootPath();
+        const route = resolveLiveEventLedgerRouteV3(coordRoot);
+        if (route.state === "blocked")
+            return;
+        const liveInstanceId = liveInstanceIdV3(instanceId);
+        const hook = readHookProducerStateByInstanceV3(coordRoot, liveInstanceId);
+        if (!hook) {
+            writeProducerDiagnosticV3(coordRoot, "command_emit_unjoinable", {
+                type,
+                instance_id: instanceId,
+                reason: "hook_generation_not_found",
+            });
+            return;
+        }
+        const command = commandSignalAndObservation(type, fields);
+        if (!command)
             return;
-        emit(coordRoot, {
-            event_type: eventType,
-            instance_id: instanceId,
-            session_id: enrich.session_id,
-            adapter: enrich.adapter,
-            data: canonicalData(type, fields),
+        const result = recordCommandSignalV3({
+            coordRoot,
+            mode: route.mode,
+            signal: command.signal,
+            observation: command.observation,
+            adapter: hook.adapter,
+            instance_id: liveInstanceId,
+            producer_id: LIVE_COMMAND_V3_PRODUCER_ID,
+            build_id: route.build_id,
+            platform: livePlatformV3(),
+            ...(fields.bridge === "codex-wsl" ? { bridge: "codex-wsl" } : {}),
+            monotonic_ns: process.hrtime.bigint().toString(),
         });
+        if (result.state === "generation_unavailable") {
+            writeProducerDiagnosticV3(coordRoot, "command_emit_unjoinable", {
+                type,
+                instance_id: instanceId,
+                signal: command.signal,
+                reason: result.reason,
+            });
+        }
+        else if (result.state !== "recorded" && result.state !== "already_recorded") {
+            writeProducerDiagnosticV3(coordRoot, "command_emit_rejected", {
+                type,
+                instance_id: instanceId,
+                signal: command.signal,
+                result_state: result.state,
+            });
+        }
     }
-    catch {
-        /* telemetry only, never break the command */
+    catch (error) {
+        // Telemetry must never break the command, but the loss is preserved.
+        try {
+            const coordRoot = coordinationRootPath();
+            writeProducerDiagnosticV3(coordRoot, "command_emit_failed", {
+                type,
+                instance_id: instanceId,
+                error: String(error),
+            });
+        }
+        catch {
+            /* diagnostics are best-effort */
+        }
+    }
+}
+function commandSignalAndObservation(type, fields) {
+    const commandId = typeof fields.cmd_id === "string" ? fields.cmd_id : undefined;
+    if (!commandId)
+        return undefined;
+    if (type === "command.started") {
+        outputSequence.set(commandId, 0);
+        const command = typeof fields.cmd === "string" ? fields.cmd : "";
+        const executable = command.trim().split(/\s+/, 1)[0] || "unknown";
+        return {
+            signal: "command.started",
+            observation: {
+                native_command_id: commandId,
+                executable,
+                executable_class: "cli",
+                // This module runs inside the command process, so preserve the actual
+                // argument boundaries for the HMAC instead of hashing a clamped line.
+                argv: process.argv.slice(2),
+                intent: typeof fields.intent === "string" ? fields.intent : undefined,
+                intent_kind: typeof fields.intent === "string" ? "declared" : "unknown",
+                sensitive_argument_count: 0,
+            },
+        };
+    }
+    if (type === "command.output_observed") {
+        const sequence = (outputSequence.get(commandId) ?? 0) + 1;
+        outputSequence.set(commandId, sequence);
+        const line = typeof fields.line === "string" ? fields.line : "";
+        const stream = fields.stream === "stdout" || fields.stream === "stderr" ? fields.stream : "combined";
+        return {
+            signal: "command.output_observed",
+            observation: {
+                native_command_id: commandId,
+                native_observation_id: `${commandId}:output:${sequence}`,
+                stream,
+                output: line,
+                output_bytes: Buffer.byteLength(line, "utf8"),
+                output_lines: line ? 1 : 0,
+            },
+        };
     }
+    outputSequence.delete(commandId);
+    const exitCode = typeof fields.exit === "number" && Number.isSafeInteger(fields.exit) ? fields.exit : undefined;
+    return {
+        signal: "command.completed",
+        observation: {
+            native_command_id: commandId,
+            ...(exitCode === undefined ? {} : { exit_code: exitCode }),
+            outcome: exitCode === undefined ? "unknown" : exitCode === 0 ? "succeeded" : "failed",
+            duration_ms: typeof fields.duration_ms === "number" && fields.duration_ms >= 0
+                ? fields.duration_ms
+                : undefined,
+            signal: typeof fields.signal === "string" ? fields.signal : undefined,
+        },
+    };
 }
 /**
- * Emit a command or narration event to `.harnery/events.ndjson`. Best-effort,
- * never throws into the caller; telemetry must not break or slow a command.
+ * Record a command event in V3. Best-effort, never throws into the caller;
+ * telemetry must not break or slow a command.
  */
 export function writeSessionEvent(type, fields = {}) {
-    emitCanonicalCommand(type, fields);
+    recordCommandObservation(type, fields);
 }
 /** Trim long values to keep individual events small. */
 export function clampField(v, max = 1024) {

package/dist/core/agents/session-finalization-state-v3.d.ts

@@ -0,0 +1,30 @@
+import type { ApprovedSessionEndReasonV3 } from "../events/v3/producers/recorder.js";
+export declare const SESSION_FINALIZATION_REQUEST_FORMAT_V3: "harnery-v3-session-finalization-request";
+export declare const SESSION_FINALIZATION_REQUEST_VERSION_V3: 1;
+export type SessionFinalizationTriggerV3 = "explicit_end" | "verified_archive" | "idle_timeout" | "parent_terminal" | "stale_sweep" | "agent_completed" | "run_completed" | "superseded" | "host_disappeared";
+export interface SessionFinalizationRequestV3 {
+    format: typeof SESSION_FINALIZATION_REQUEST_FORMAT_V3;
+    format_version: typeof SESSION_FINALIZATION_REQUEST_VERSION_V3;
+    request_id: `sfr_${string}`;
+    instance_id: `inst_${string}`;
+    generation_id: `gen_${string}`;
+    trigger: SessionFinalizationTriggerV3;
+    reason: ApprovedSessionEndReasonV3;
+    outcome: "succeeded" | "failed" | "cancelled" | "timed_out" | "denied" | "interrupted" | "unknown";
+    observed_at: string;
+    not_before: string;
+    last_event_id: `evt_${string}`;
+    observation_event_id?: `evt_${string}`;
+    requested_turn_id?: `tid_${string}`;
+    allowed_open_span_ids?: `span_${string}`[];
+    coordination_finalized: boolean;
+    status: "pending" | "cancelled" | "completed";
+    cancelled_at?: string;
+    completed_at?: string;
+    terminal_event_id?: `evt_${string}`;
+}
+export declare function sessionFinalizationRequestDirectoryV3(coordRoot: string): string;
+export declare function sessionFinalizationRequestPathV3(coordRoot: string, requestId: string): string;
+export declare function listSessionFinalizationRequestsV3(coordRoot: string): SessionFinalizationRequestV3[];
+export declare function readSessionFinalizationRequestV3(filePath: string): SessionFinalizationRequestV3;
+//# sourceMappingURL=session-finalization-state-v3.d.ts.map

package/dist/core/agents/session-finalization-state-v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-finalization-state-v3.d.ts","sourceRoot":"","sources":["../../../src/core/agents/session-finalization-state-v3.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,oCAAoC,CAAC;AAGrF,eAAO,MAAM,sCAAsC,EACjD,yCAAkD,CAAC;AACrD,eAAO,MAAM,uCAAuC,EAAG,CAAU,CAAC;AAElE,MAAM,MAAM,4BAA4B,GACpC,cAAc,GACd,kBAAkB,GAClB,cAAc,GACd,iBAAiB,GACjB,aAAa,GACb,iBAAiB,GACjB,eAAe,GACf,YAAY,GACZ,kBAAkB,CAAC;AAEvB,MAAM,WAAW,4BAA4B;IAC3C,MAAM,EAAE,OAAO,sCAAsC,CAAC;IACtD,cAAc,EAAE,OAAO,uCAAuC,CAAC;IAC/D,UAAU,EAAE,OAAO,MAAM,EAAE,CAAC;IAC5B,WAAW,EAAE,QAAQ,MAAM,EAAE,CAAC;IAC9B,aAAa,EAAE,OAAO,MAAM,EAAE,CAAC;IAC/B,OAAO,EAAE,4BAA4B,CAAC;IACtC,MAAM,EAAE,0BAA0B,CAAC;IACnC,OAAO,EACH,WAAW,GACX,QAAQ,GACR,WAAW,GACX,WAAW,GACX,QAAQ,GACR,aAAa,GACb,SAAS,CAAC;IACd,WAAW,EAAE,MAAM,CAAC;IACpB,UAAU,EAAE,MAAM,CAAC;IACnB,aAAa,EAAE,OAAO,MAAM,EAAE,CAAC;IAC/B,oBAAoB,CAAC,EAAE,OAAO,MAAM,EAAE,CAAC;IACvC,iBAAiB,CAAC,EAAE,OAAO,MAAM,EAAE,CAAC;IACpC,qBAAqB,CAAC,EAAE,QAAQ,MAAM,EAAE,EAAE,CAAC;IAC3C,sBAAsB,EAAE,OAAO,CAAC;IAChC,MAAM,EAAE,SAAS,GAAG,WAAW,GAAG,WAAW,CAAC;IAC9C,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,iBAAiB,CAAC,EAAE,OAAO,MAAM,EAAE,CAAC;CACrC;AAED,wBAAgB,qCAAqC,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE/E;AAED,wBAAgB,gCAAgC,CAAC,SAAS,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAE7F;AAED,wBAAgB,iCAAiC,CAC/C,SAAS,EAAE,MAAM,GAChB,4BAA4B,EAAE,CAWhC;AAED,wBAAgB,gCAAgC,CAAC,QAAQ,EAAE,MAAM,GAAG,4BAA4B,CAiB/F"}

package/dist/core/agents/session-finalization-state-v3.js

@@ -0,0 +1,40 @@
+import { existsSync, lstatSync, readdirSync, readFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { EVENT_V3_LEDGER_RELATIVE_ROOT } from "../events/v3/writer.js";
+export const SESSION_FINALIZATION_REQUEST_FORMAT_V3 = "harnery-v3-session-finalization-request";
+export const SESSION_FINALIZATION_REQUEST_VERSION_V3 = 1;
+export function sessionFinalizationRequestDirectoryV3(coordRoot) {
+    return join(resolve(coordRoot), EVENT_V3_LEDGER_RELATIVE_ROOT, "finalization", "requests");
+}
+export function sessionFinalizationRequestPathV3(coordRoot, requestId) {
+    return join(sessionFinalizationRequestDirectoryV3(coordRoot), `${requestId}.json`);
+}
+export function listSessionFinalizationRequestsV3(coordRoot) {
+    const directory = sessionFinalizationRequestDirectoryV3(coordRoot);
+    if (!existsSync(directory))
+        return [];
+    const metadata = lstatSync(directory);
+    if (!metadata.isDirectory() || metadata.isSymbolicLink()) {
+        throw new Error("V3 session finalization request directory is unsafe");
+    }
+    return readdirSync(directory)
+        .filter((name) => /^sfr_[0-9a-f-]+\.json$/.test(name))
+        .map((name) => readSessionFinalizationRequestV3(join(directory, name)))
+        .sort((left, right) => left.observed_at.localeCompare(right.observed_at));
+}
+export function readSessionFinalizationRequestV3(filePath) {
+    const metadata = lstatSync(filePath);
+    if (!metadata.isFile() || metadata.isSymbolicLink() || (metadata.mode & 0o077) !== 0) {
+        throw new Error("V3 session finalization request is unsafe");
+    }
+    const request = JSON.parse(readFileSync(filePath, "utf8"));
+    if (request.format !== SESSION_FINALIZATION_REQUEST_FORMAT_V3 ||
+        request.format_version !== SESSION_FINALIZATION_REQUEST_VERSION_V3 ||
+        !/^sfr_[0-9a-f-]+$/.test(request.request_id) ||
+        !/^inst_[a-zA-Z0-9._-]+$/.test(request.instance_id) ||
+        !/^gen_[0-9a-f-]+$/.test(request.generation_id) ||
+        !["pending", "cancelled", "completed"].includes(request.status)) {
+        throw new Error("V3 session finalization request is invalid");
+    }
+    return request;
+}

package/dist/core/agents/session-finalizer-v3.d.ts

@@ -0,0 +1,107 @@
+import type { Adapter } from "../adapter.js";
+import type { EventV3 } from "../events/v3/contract.js";
+import { type SessionFinalizationRequestV3 } from "./session-finalization-state-v3.js";
+export { listSessionFinalizationRequestsV3, type SessionFinalizationRequestV3, type SessionFinalizationTriggerV3, } from "./session-finalization-state-v3.js";
+export interface SessionArchiveObservationV3 {
+    adapter: Adapter;
+    native_session_id: string;
+    archived: boolean;
+    observed_at: string;
+}
+export interface ReconcileSessionFinalizationOptionsV3 {
+    now?: Date;
+    archive_observations?: readonly SessionArchiveObservationV3[];
+}
+export interface ReconcileSessionFinalizationResultV3 {
+    observed: number;
+    cancelled: number;
+    finalized: number;
+    already_terminal: number;
+    pending: number;
+    diagnostics: string[];
+}
+export interface EndSessionExplicitV3Input {
+    coordRoot: string;
+    instance_id: `inst_${string}`;
+    generation_id: `gen_${string}`;
+    outcome?: SessionFinalizationRequestV3["outcome"];
+    observed_at?: string;
+    coordination_finalized: boolean;
+}
+export interface RequestSessionEndExplicitV3Input extends EndSessionExplicitV3Input {
+}
+export type RequestSessionEndExplicitV3Result = ReturnType<typeof endSessionExplicitV3> | {
+    state: "busy";
+} | {
+    state: "generation_unavailable";
+} | {
+    state: "delegated_work_open";
+    count: number;
+} | {
+    state: "queued";
+    request: SessionFinalizationRequestV3;
+} | {
+    state: "already_requested";
+    request: SessionFinalizationRequestV3;
+    /** What the pending request is still waiting on, so a repeated explicit end reports its exact blocker instead of a bare refusal. */
+    blocker: {
+        open_span_ids: `span_${string}`[];
+        current_turn_open: boolean;
+        pending_age_ms: number;
+    };
+};
+export interface ObserveHostDisappearedV3Input {
+    coordRoot: string;
+    instance_id: `inst_${string}`;
+    generation_id: `gen_${string}`;
+    observed_at?: string;
+}
+export declare function endSessionExplicitV3(input: EndSessionExplicitV3Input): {
+    state: "gate_closed";
+    reason: string;
+} | {
+    state: "generation_unavailable";
+    reason: string;
+} | {
+    state: "already_ended";
+    event_id?: `evt_${string}`;
+} | {
+    state: "recorded";
+    event: EventV3;
+    durability: import("../events/v3/writer.js").WriteEventV3Result;
+    recovered: boolean;
+} | {
+    state: "unavailable";
+    reason: string;
+};
+/**
+ * Request an explicit end without weakening the terminal writer's open-work
+ * guard. When invoked from inside an adapter turn, the request is committed
+ * first and the stop hook reconciles it after that exact turn has closed.
+ */
+export declare function requestSessionEndExplicitV3(input: RequestSessionEndExplicitV3Input): RequestSessionEndExplicitV3Result;
+export declare function hasPendingExplicitSessionEndV3(coordRoot: string): boolean;
+/** Accept a host supervisor's observation without granting it terminal authority. */
+export declare function observeHostDisappearedV3(input: ObserveHostDisappearedV3Input): {
+    state: "unavailable";
+    reason: string;
+    request?: undefined;
+} | {
+    state: "busy";
+    readonly reason?: undefined;
+    request?: undefined;
+} | {
+    state: "generation_unavailable";
+    readonly reason?: undefined;
+    request?: undefined;
+} | {
+    state: "observed";
+    request: SessionFinalizationRequestV3;
+    readonly reason?: undefined;
+} | {
+    state: "already_observed";
+    readonly reason?: undefined;
+    request?: undefined;
+};
+export declare function reconcileSessionFinalizationV3(coordRoot: string, options?: ReconcileSessionFinalizationOptionsV3): ReconcileSessionFinalizationResultV3;
+//# sourceMappingURL=session-finalizer-v3.d.ts.map

package/dist/core/agents/session-finalizer-v3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"session-finalizer-v3.d.ts","sourceRoot":"","sources":["../../../src/core/agents/session-finalizer-v3.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAI7C,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAC;AAmBxD,OAAO,EAIL,KAAK,4BAA4B,EAIlC,MAAM,oCAAoC,CAAC;AAE5C,OAAO,EACL,iCAAiC,EACjC,KAAK,4BAA4B,EACjC,KAAK,4BAA4B,GAClC,MAAM,oCAAoC,CAAC;AAK5C,MAAM,WAAW,2BAA2B;IAC1C,OAAO,EAAE,OAAO,CAAC;IACjB,iBAAiB,EAAE,MAAM,CAAC;IAC1B,QAAQ,EAAE,OAAO,CAAC;IAClB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED,MAAM,WAAW,qCAAqC;IACpD,GAAG,CAAC,EAAE,IAAI,CAAC;IACX,oBAAoB,CAAC,EAAE,SAAS,2BAA2B,EAAE,CAAC;CAC/D;AAED,MAAM,WAAW,oCAAoC;IACnD,QAAQ,EAAE,MAAM,CAAC;IACjB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE,MAAM,CAAC;IACzB,OAAO,EAAE,MAAM,CAAC;IAChB,WAAW,EAAE,MAAM,EAAE,CAAC;CACvB;AAED,MAAM,WAAW,yBAAyB;IACxC,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,QAAQ,MAAM,EAAE,CAAC;IAC9B,aAAa,EAAE,OAAO,MAAM,EAAE,CAAC;IAC/B,OAAO,CAAC,EAAE,4BAA4B,CAAC,SAAS,CAAC,CAAC;IAClD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,sBAAsB,EAAE,OAAO,CAAC;CACjC;AAED,MAAM,WAAW,gCAAiC,SAAQ,yBAAyB;CAAG;AAEtF,MAAM,MAAM,iCAAiC,GACzC,UAAU,CAAC,OAAO,oBAAoB,CAAC,GACvC;IAAE,KAAK,EAAE,MAAM,CAAA;CAAE,GACjB;IAAE,KAAK,EAAE,wBAAwB,CAAA;CAAE,GACnC;IAAE,KAAK,EAAE,qBAAqB,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,GAC/C;IAAE,KAAK,EAAE,QAAQ,CAAC;IAAC,OAAO,EAAE,4BAA4B,CAAA;CAAE,GAC1D;IACE,KAAK,EAAE,mBAAmB,CAAC;IAC3B,OAAO,EAAE,4BAA4B,CAAC;IACtC,oIAAoI;IACpI,OAAO,EAAE;QACP,aAAa,EAAE,QAAQ,MAAM,EAAE,EAAE,CAAC;QAClC,iBAAiB,EAAE,OAAO,CAAC;QAC3B,cAAc,EAAE,MAAM,CAAC;KACxB,CAAC;CACH,CAAC;AAEN,MAAM,WAAW,6BAA6B;IAC5C,SAAS,EAAE,MAAM,CAAC;IAClB,WAAW,EAAE,QAAQ,MAAM,EAAE,CAAC;IAC9B,aAAa,EAAE,OAAO,MAAM,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,yBAAyB;;;;;;;;;;;;;;;;;EA6BpE;AAED;;;;GAIG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,gCAAgC,GACtC,iCAAiC,CA8DnC;AAED,wBAAgB,8BAA8B,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAIzE;AAED,qFAAqF;AACrF,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,6BAA6B;;;;;;;;;;;;;;;;;;;;EAiC5E;AAED,wBAAgB,8BAA8B,CAC5C,SAAS,EAAE,MAAM,EACjB,OAAO,GAAE,qCAA0C,GAClD,oCAAoC,CAmOtC"}