@cotal-ai/runtime 0.0.1 → 0.25.0

package/dist/mesh-handler.d.ts

@@ -0,0 +1,310 @@
+import { type CheckpointRef, type CheckpointSettleFact } from "@cotal-ai/core";
+import type { JetStreamClient, JetStreamManager } from "@nats-io/jetstream";
+import type { KV } from "@nats-io/kv";
+import { type WaitRequest, type CheckpointRaw, type CheckpointRequest, type EffectContext, type JournalEntry, type NotifyRequest, type SleepRequest } from "@cotal-ai/lang";
+/** Who this handler acts as, and where. All of it is the DRIVER's identity, not the program's. */
+export interface MeshHandlerBinding {
+    readonly space: string;
+    /** The endpoint hosting the driver — the manager daemon. */
+    readonly endpoint: string;
+    /**
+     * WHICH RUN this handler performs for.
+     *
+     * It is here rather than on `EffectContext` because the effect context deliberately
+     * carries the step's identity and nothing about the run: `requestId` already folds the run
+     * in, and a handler that needed to name the run for recovery would be recovering by something
+     * other than the recorded identity. A NOTICE is keyed by its run, though — it is filed onto the
+     * run — so the run is part of what this handler is bound to. A drive is already shaped that way:
+     * the caller hands `drive()` a run id and a handler together.
+     */
+    readonly runId: string;
+    readonly instanceId: string;
+    readonly epoch: number;
+    /**
+     * MANDATORY, and the reason is worth keeping next to it: a checkpoint's resume is holder-bound,
+     * so an omitted holder would make the token a BEARER credential resumable by anyone who learns
+     * it (SPEC 13.6/13.10).
+     */
+    readonly holder: {
+        readonly id: string;
+        readonly lifecycleUid: string;
+    };
+    /**
+     * The deadline a `checkpoint` gets when the program names no `timeout`.
+     *
+     * MANDATORY, because `mintCheckpoint` requires a future deadline and there is no such thing as a
+     * checkpoint that waits forever on this plane: an unbounded pause is a run that can never be
+     * reconciled, and picking a silent constant here would be this file deciding a pin. It is read
+     * ONLY at the first mint — a resume finds the checkpoint already minted, and the recorded
+     * deadline is the authority from then on, so changing this never moves a pause already taken.
+     */
+    readonly defaultCheckpointTimeout: string;
+}
+/**
+ * A checkpoint resumed with no answer to read.
+ *
+ * The settle fact is the arbiter and it NAMES the answer it accepted, so a `resumed` settlement
+ * with no id — or with an id no record answers to — means the token was presented by something
+ * other than the run driver's own `resolveCheckpoint`. There is no honest value to return for it:
+ * the program asked a question, something released the pause, and what was answered is not
+ * recoverable. Returning `resolved` with an empty value would invent one.
+ */
+export declare class CheckpointAnswerMissing extends Error {
+    readonly token: string;
+    readonly answerId: string | undefined;
+    constructor(token: string, answerId: string | undefined);
+}
+/** How the handler learns that a checkpoint settled. Injected so a test can drive it directly. */
+export interface SettleWatcher {
+    /**
+     * Resolve when this ref's one-use settle fact exists. Called AFTER the mint, so a fact that
+     * already landed — the ordinary case for a run resuming across a crash — must resolve at once
+     * rather than wait for an event that has already happened.
+     */
+    awaitSettle(ref: CheckpointRef): Promise<CheckpointSettleFact>;
+}
+export declare class MeshHandler {
+    private readonly kv;
+    private readonly js;
+    private readonly jsm;
+    private readonly binding;
+    private readonly watcher;
+    private readonly clock;
+    constructor(kv: KV, js: JetStreamClient, jsm: JetStreamManager, binding: MeshHandlerBinding, watcher: SettleWatcher, clock?: () => number);
+    now(): number;
+    /**
+     * WHAT to repair when this process takes a run over. The driver decides WHEN and calls this.
+     *
+     * It is a method rather than an optional hook the host wires: an adopted run whose timers stay
+     * armed at the predecessor's coordinates fires where nobody listens, and the object that knows how
+     * to re-arm is the one the driver already holds.
+     *
+     * Failures are raised, not swallowed: a driver holding a run whose pauses it could not re-arm
+     * cannot advance it.
+     */
+    adopted(entries: readonly JournalEntry[]): Promise<string[]>;
+    /**
+     * `sleep` is a checkpoint nobody answers.
+     *
+     * There is no separate timer plane and there should not be one: a durable pause with a deadline,
+     * a token that survives a crash, and a one-use settle is exactly what the checkpoint plane is,
+     * and a second mechanism would be a second thing to get wrong. The difference is only that no
+     * `resolveCheckpoint` will ever arrive for this token, so the timer's expiry is the whole story
+     * and `null` is the whole answer.
+     */
+    sleep(req: SleepRequest, ctx: EffectContext): Promise<null>;
+    /**
+     * `checkpoint` is the same durable pause with somebody expected to answer it.
+     *
+     * The mint is identical to `sleep`'s — one token, one deadline, one settle fact — and everything
+     * that differs is on the ANSWER side, which is deliberately not this handler's to arrange: the
+     * run driver's `resolveCheckpoint` writes the answer record and presents the token, because the
+     * checkpoint's holder is the driver and a resume is holder-bound. So this waits, and then reads
+     * what the arbiter says was accepted.
+     *
+     * It returns the RAW outcome and never the program's result. Whether an expiry throws or returns
+     * is `onExpiry`, which is computed from today's source on the live path and the replay path
+     * alike; deciding it here would bake one answer into the journal.
+     */
+    checkpoint(req: CheckpointRequest, ctx: EffectContext): Promise<CheckpointRaw>;
+    /**
+     * `wait` — an event await that survives the process waiting for it.
+     *
+     * A DURABLE consumer named from `ctx.requestId` holds the run's position on the channel, so an
+     * event published while the host was down is still there when the run re-attaches under the same
+     * derived name. An ephemeral consumer, or one created on resume, starts from "now" and the event
+     * never happened.
+     *
+     * The TIMEOUT rides the checkpoint plane and is minted once with an absolute deadline, so a
+     * resumed 20-minute wait with 30 seconds left has 30 seconds left. A timeout resolves `null` and
+     * never throws: `??` is `otherwise`.
+     *
+     * `replied(agent)` and `down(agent)` are not here. They address an agent handle, which only
+     * `spawn` produces, so they refuse through the same named seam as the durable actions.
+     */
+    wait(req: WaitRequest, ctx: EffectContext): Promise<unknown | null>;
+    /**
+     * `notify` writes one bounded decision record per addressee, onto the run.
+     *
+     * NOT a channel post, and that is the whole point of the primitive: a post would put the program
+     * into the conversation as a participant, where conversation is the data plane and
+     * the program is the control plane. A notice is data filed on the run and rendered ahead of the
+     * addressee's next turn.
+     *
+     * **One call to N agents is N records, and a retry lands on its own.** The id is derived from the
+     * step's request id and the addressee, so a crash between the second and third write is repaired
+     * by re-running the call: the first two creates find their own bytes and return, the third
+     * happens. Nothing is written twice and nothing needs a memo of how far it got.
+     *
+     * The fact's bound is the language's and is enforced BEFORE this is reached (L3043 at the effect
+     * boundary), so a fact that could not be rendered as one table row cannot arrive here.
+     */
+    notify(req: NotifyRequest, ctx: EffectContext): Promise<null>;
+    spawn(_req: unknown, _ctx: EffectContext): Promise<never>;
+    turn(_req: unknown, _ctx: EffectContext): Promise<never>;
+    ask(_req: unknown, _ctx: EffectContext): Promise<never>;
+    monitor(_req: unknown, _ctx: EffectContext): Promise<never>;
+    /**
+     * A conclave, refused with the rest — and this one is an OVER-refusal, stated rather than hidden.
+     *
+     * A conclave's members are agent handles, so the ordinary case is gated exactly like the others.
+     * `conclave([], …)` is not: a sub-team with nobody in it is a channel, and the channel plane is
+     * here. It is refused anyway, because shipping the empty case alone would put half a primitive on
+     * the durable plane — a program that works with no members and refuses with one is a worse thing
+     * to explain than a primitive that is not here yet.
+     */
+    openConclave(_req: unknown, _ctx: EffectContext): Promise<never>;
+    closeConclave(_req: unknown, _ctx: EffectContext): Promise<never>;
+    /**
+     * Arm this pause, or ATTACH to the one already recorded under the same token.
+     *
+     * A mint is idempotent only if the whole spec is identical, so the recorded deadline is the
+     * authority and a resume may not recompute one: `now() + duration` is a different deadline a
+     * second later, and the plane reads a different deadline as a different intent. The pause holds
+     * it; a second copy anywhere else is a second thing to disagree.
+     *
+     * An already-passed deadline cannot be minted at all, correctly, because a due pause is not being
+     * armed. It needs its schedule re-emitted at the status's current generation, which is the
+     * reconciler's job. A spec with no status and an elapsed deadline is unrepairable from here, so it
+     * is raised rather than waited on.
+     */
+    private arm;
+    /** Push a live deadline out — the idle window restarting. The heartbeat CAS-advances the
+     *  generation before replacing the timer, so a fire from the old one no-ops rather than racing. */
+    private push;
+    /**
+     * Take the broker's `.fire` for this deadline, if it has published one, and let the checkpoint
+     * plane judge it. Answers whether the fire SETTLED the pause.
+     *
+     * A fire is a MESSAGE and a settlement is a FACT; `handleCheckpointFire` is what turns one into
+     * the other, and a pause nobody answers ends no other way.
+     *
+     * READ BY SUBJECT rather than by a subscription, because the fire is a record of a deadline
+     * passing and callers here are already polling: `last_by_subj` gives the current one whether it
+     * arrived a moment ago or while this host was down, and a resume lands in the second case.
+     *
+     * IDEMPOTENT BY THE PLANE rather than by bookkeeping here: a fire handed over twice finds the
+     * pause settled and declines. The one repeated verdict with a side effect is `re-armed` under
+     * owner-behind clock skew, and over-emission is idempotent at the timer writer.
+     */
+    private takeFire;
+    /** Has this deadline settled? `undefined` for "no deadline" and for "not yet".
+     *
+     *  A `wait` observes its deadlines by polling this, so the fire is taken on the same poll: the
+     *  settle fact a `wait` is reading for is one this process has to produce, and reading for it
+     *  without ever producing it is how a `wait` with a timeout waited past its timeout forever. */
+    private expired;
+    /** End a deadline that is no longer waited on, by claiming its one-use settlement with no answer.
+     *  A timer left armed would fire into a run that has moved on; claiming it is how the plane says
+     *  "this pause is over" without a second mechanism for cancellation. */
+    private cancelTimer;
+    /** The message at a recorded stream sequence — the re-bind path after a crash. */
+    private messageAt;
+    /**
+     * Wait for this token's one-use settlement.
+     *
+     * A settle that ALREADY landed is the ordinary case on a resume: the run crashed while paused and
+     * the timer fired, or somebody answered, without it. Reading before waiting is not an
+     * optimization, it is the difference between resuming and waiting forever for an event that is
+     * already in the past.
+     */
+    private settle;
+    /** Take this deadline's fire for as long as somebody is waiting on it. */
+    private pumpFires;
+}
+/** The durable that holds one wait's position on a channel. Derived from the step's own request id,
+ *  which is why a resumed run finds the consumer its earlier attempt created rather than starting
+ *  again from "now" — and why nothing about the wait has to be remembered across a crash. */
+export declare function waitConsumerName(requestId: string): string;
+/**
+ * The one definition of a wait's consumer, shared by the handler and by anything that has to
+ * recreate it — so the name a resume looks for and the name a wait creates cannot drift apart.
+ *
+ * `deliver_policy: "new"` applies only to the FIRST create: an existing durable keeps its own
+ * position, which is exactly what a resume needs, and events from before the program asked are not
+ * this wait's to see.
+ */
+export declare function waitConsumerConfig(space: string, requestId: string, channel: string): Record<string, unknown>;
+/**
+ * An effect whose durable substrate has not landed on this host.
+ *
+ * An honest two-exit, and deliberately not a fake success: the simulator implements these, so a
+ * program that uses them can be written, validated and dry-run today — but a DURABLE run refuses
+ * rather than performing them on a plane that could not recover them. A run that "succeeded" at an
+ * effect nothing can replay would be a lie the journal then carries forever.
+ */
+export declare class NotYetDurable extends Error {
+    readonly effect: string;
+    readonly needs: string;
+    /**
+     * L5016, and it is load-bearing rather than decorative.
+     *
+     * The interpreter wraps a handler's fault into an `EffectError` and SETTLES the entry with it, so
+     * the class does not survive the boundary — a caller of `run()` sees an `EffectError`, and the
+     * journal keeps whatever code was on it. Without this the entry would read `L4000 handler-fault`:
+     * "the handler broke", written durably about a step nothing ever attempted. The interpreter
+     * honours an L-code a handler raises, so the recorded fact says what actually happened.
+     */
+    readonly code = "L5016";
+    constructor(effect: string, needs: string);
+}
+/**
+ * RE-ARM the timers of every pause this run is still holding, under THIS driver's coordinates.
+ *
+ * A checkpoint's armed schedule fires onto `ept.<space>.<e>.<instanceId>.<epoch>.<token>.fire`,
+ * derived from the coordinates of the instance that armed it. A run adopted by another host — or by
+ * the same host at a new epoch — therefore has live timers firing at a subject nobody is reading,
+ * and its pauses would sit until something else swept them. Nothing about that is repaired by
+ * resuming the program: the effect is a replayed pending step that goes straight back to waiting.
+ *
+ * So the driver re-emits a schedule request for each outstanding token at the CURRENT generation,
+ * which the timer writer arms onto this instance's own fire subject. Over-emission is harmless by
+ * construction (same `(timerId, generation)` re-derives the same `.armed`, a no-op replacement), so
+ * this is safe to run on every takeover and needs no record of what it did last time.
+ *
+ * Called AFTER the barrier activated, never before: arming timers for a run this process turned out
+ * not to hold would point another driver's fires at this one.
+ */
+export declare function rearmOutstandingPauses(deps: {
+    kv: KV;
+    js: JetStreamClient;
+    jsm: JetStreamManager;
+}, binding: Pick<MeshHandlerBinding, "space" | "endpoint" | "instanceId" | "epoch">, entries: readonly JournalEntry[]): Promise<string[]>;
+/**
+ * The checkpoint tokens a replayed prefix leaves open.
+ *
+ * An entry is open when its LAST record is `pending`, so the map is built in append order and the
+ * later record wins — a step that settled has a settled entry after its pending one, and reading
+ * only the first would re-arm timers for pauses that are already over.
+ *
+ * THE KINDS ARE THE THREE THAT ARM A TIMER, and `wait` is one of them. It mints no pause of its own
+ * so it does not look like one, but its idle window and its timeout are mediated deadlines exactly
+ * as `sleep`'s is, and a `wait` adopted at a new epoch would otherwise wait on a deadline no live
+ * epoch fires.
+ *
+ * An idle wait with a timeout arms TWO, and the second is DERIVED rather than recorded, so it is
+ * re-derived here for the same reason the live path derives it: a resume that had to remember it
+ * would be carrying state the key already determines. Emitting it for a wait that never minted one
+ * is harmless by construction — the reconciler reads the checkpoint's status first and re-emits
+ * nothing when there is none — and the alternative, reading the request shape back out of the
+ * entry to decide, would make the repair depend on a field a replay is not guaranteed to carry.
+ */
+export declare function outstandingPauseTokens(entries: readonly JournalEntry[]): string[];
+/**
+ * The settle watcher over EPF, which is where the one-use settle fact lives.
+ *
+ * An EPHEMERAL consumer filtered to this token's settle subject, created for one wait and removed
+ * after it: the fact is written once and read once, so a durable would be a name to collide on and
+ * a thing to clean up, for a subscription that outlives nothing. `deliver_policy: all` because the
+ * fact may already be there — a settle is a record, not a notification, and a watcher that only saw
+ * new messages would wait forever for one that already happened.
+ */
+export declare class EpfSettleWatcher implements SettleWatcher {
+    private readonly js;
+    private readonly jsm;
+    private readonly space;
+    private readonly pollMs;
+    constructor(js: JetStreamClient, jsm: JetStreamManager, space: string, pollMs?: number);
+    awaitSettle(ref: CheckpointRef): Promise<CheckpointSettleFact>;
+}
+//# sourceMappingURL=mesh-handler.d.ts.map

package/dist/mesh-handler.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mesh-handler.d.ts","sourceRoot":"","sources":["../src/mesh-handler.ts"],"names":[],"mappings":"AAmBA,OAAO,EAoBL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EAE1B,MAAM,gBAAgB,CAAC;AACxB,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAC5E,OAAO,KAAK,EAAE,EAAE,EAAE,MAAM,aAAa,CAAC;AACtC,OAAO,EAEL,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,KAAK,YAAY,EACjB,KAAK,aAAa,EAClB,KAAK,YAAY,EAGlB,MAAM,gBAAgB,CAAC;AAExB,kGAAkG;AAClG,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,4DAA4D;IAC5D,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;;;;;;OASG;IACH,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE;QAAE,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;QAAC,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAA;KAAE,CAAC;IACxE;;;;;;;;OAQG;IACH,QAAQ,CAAC,wBAAwB,EAAE,MAAM,CAAC;CAC3C;AAED;;;;;;;;GAQG;AACH,qBAAa,uBAAwB,SAAQ,KAAK;IACpC,QAAQ,CAAC,KAAK,EAAE,MAAM;IAAE,QAAQ,CAAC,QAAQ,EAAE,MAAM,GAAG,SAAS;gBAApD,KAAK,EAAE,MAAM,EAAW,QAAQ,EAAE,MAAM,GAAG,SAAS;CAS1E;AAED,kGAAkG;AAClG,MAAM,WAAW,aAAa;IAC5B;;;;OAIG;IACH,WAAW,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,oBAAoB,CAAC,CAAC;CAChE;AAQD,qBAAa,WAAW;IAEpB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,KAAK;gBALL,EAAE,EAAE,EAAE,EACN,EAAE,EAAE,eAAe,EACnB,GAAG,EAAE,gBAAgB,EACrB,OAAO,EAAE,kBAAkB,EAC3B,OAAO,EAAE,aAAa,EACtB,KAAK,GAAE,MAAM,MAAyB;IAGzD,GAAG,IAAI,MAAM;IAIb;;;;;;;;;OASG;IACG,OAAO,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC;IAQlE;;;;;;;;OAQG;IACG,KAAK,CAAC,GAAG,EAAE,YAAY,EAAE,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAiBjE;;;;;;;;;;;;OAYG;IACG,UAAU,CAAC,GAAG,EAAE,iBAAiB,EAAE,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,aAAa,CAAC;IA0BpF;;;;;;;;;;;;;;OAcG;IACG,IAAI,CAAC,GAAG,EAAE,WAAW,EAAE,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,OAAO,GAAG,IAAI,CAAC;IAwFzE;;;;;;;;;;;;;;;OAeG;IACG,MAAM,CAAC,GAAG,EAAE,aAAa,EAAE,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAyC7D,KAAK,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC;IAIzD,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC;IAIxD,GAAG,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC;IAIvD,OAAO,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC;IAIjE;;;;;;;;OAQG;IACG,YAAY,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC;IAIhE,aAAa,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,aAAa,GAAG,OAAO,CAAC,KAAK,CAAC;IAIvE;;;;;;;;;;;;OAYG;YACW,GAAG;IAiCjB;uGACmG;YACrF,IAAI;IAUlB;;;;;;;;;;;;;;OAcG;YACW,QAAQ;IAmBtB;;;;oGAIgG;YAClF,OAAO;IAQrB;;4EAEwE;YAC1D,WAAW;IAezB,kFAAkF;YACpE,SAAS;IAUvB;;;;;;;OAOG;YACW,MAAM;IAqBpB,0EAA0E;YAC5D,SAAS;CAQxB;AAED;;6FAE6F;AAC7F,wBAAgB,gBAAgB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE1D;AAED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAO7G;AA0DD;;;;;;;GAOG;AACH,qBAAa,aAAc,SAAQ,KAAK;IAY1B,QAAQ,CAAC,MAAM,EAAE,MAAM;IAAE,QAAQ,CAAC,KAAK,EAAE,MAAM;IAX3D;;;;;;;;OAQG;IACH,QAAQ,CAAC,IAAI,WAAW;gBAEH,MAAM,EAAE,MAAM,EAAW,KAAK,EAAE,MAAM;CAQ5D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,sBAAsB,CAC1C,IAAI,EAAE;IAAE,EAAE,EAAE,EAAE,CAAC;IAAC,EAAE,EAAE,eAAe,CAAC;IAAC,GAAG,EAAE,gBAAgB,CAAA;CAAE,EAC5D,OAAO,EAAE,IAAI,CAAC,kBAAkB,EAAE,OAAO,GAAG,UAAU,GAAG,YAAY,GAAG,OAAO,CAAC,EAChF,OAAO,EAAE,SAAS,YAAY,EAAE,GAC/B,OAAO,CAAC,MAAM,EAAE,CAAC,CAWnB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,SAAS,YAAY,EAAE,GAAG,MAAM,EAAE,CAUjF;AAED;;;;;;;;GAQG;AACH,qBAAa,gBAAiB,YAAW,aAAa;IAElD,OAAO,CAAC,QAAQ,CAAC,EAAE;IACnB,OAAO,CAAC,QAAQ,CAAC,GAAG;IACpB,OAAO,CAAC,QAAQ,CAAC,KAAK;IACtB,OAAO,CAAC,QAAQ,CAAC,MAAM;gBAHN,EAAE,EAAE,eAAe,EACnB,GAAG,EAAE,gBAAgB,EACrB,KAAK,EAAE,MAAM,EACb,MAAM,SAAS;IAG5B,WAAW,CAAC,GAAG,EAAE,aAAa,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAgCrE"}