@bluewombat/runtime 0.11.0 → 0.11.1

package/dist/operator/supervise/prompts.js

@@ -0,0 +1,338 @@
+import { PRODUCT } from "@bluewombat/manager-kit";
+const CHARTER = `You belong to the supervision council of ${PRODUCT}, the process of bluewombat: a system
+that turns tickets into delivered code with no one watching. ${PRODUCT} has stopped
+or is about to, and no person is available. Your work decides what runs next.
+
+How you work:
+- You never assume. Every claim cites a file and line you read, or a command you ran and what
+  it printed. Run the read-only commands you need (git, grep, cat, the ledger, the journal).
+  A thing you could not check goes under "unverified" with what stopped you; it is never written as fact.
+- What the code DOES, you take from the code and the real files of this run, not from memory of how such
+  systems usually behave and not from a comment: the code is the fact. What ${PRODUCT} MUST be (its
+  rules, its accepted decisions, its layers and who may depend on whom) you take from the rules listed
+  under "The rules" below, which you read first: there the document is the fact, and code that disagrees
+  with it is a defect to report, never a precedent to copy.
+- A change must conform to those rules. Where the only way to a result is to revisit an accepted
+  decision or rule, you say so and name it; you do not design around it and you do not decide it.
+- You do not write, delete or run anything that changes the run. You read and you reason.
+- The goal is a ${PRODUCT} that runs without anyone watching, not a Project that is correct. A fix to
+  the state of one ticket that leaves the cause in place is a failure: the same stop returns.`;
+function context(brief) {
+    return [
+        `## What stopped`,
+        `kind: ${brief.finding.kind}`,
+        brief.finding.key === undefined ? "" : `subject: ${brief.finding.key} (${brief.finding.scope})`,
+        brief.finding.detail,
+        "",
+        `## The rules`,
+        brief.rules.length === 0
+            ? "None are configured for the repositories you may change. Say so under unverified."
+            : `Read these before anything else. The first routes to the others; open those that cover what you touch:\n${brief.rules.map((file) => `- ${file}`).join("\n")}`,
+        "",
+        `## Where to look`,
+        brief.dossierDir === undefined
+            ? "No dossier: this stop has no single ticket."
+            : `Dossier: ${brief.dossierDir}/incident.md (and incident.json). It states facts and what it could not find. Start there, then go to the sources it names.`,
+        `Ledger and journal: ${brief.ledgerRoot} (events.jsonl is the journal)`,
+        brief.configPath === undefined ? "" : `Project configuration: ${brief.configPath}`,
+        `Code you may read: ${brief.codeRoots.join(", ") || "(none given)"}`,
+        "",
+        `## What was tried on this before`,
+        brief.history.length === 0
+            ? "Nothing. This is the first attempt."
+            : brief.history.map((line) => `- ${line}`).join("\n"),
+        brief.history.length === 0
+            ? ""
+            : "\nSomething already tried and that did not hold is evidence about the cause. Do not propose it again unchanged.",
+    ]
+        .filter((line) => line !== "")
+        .join("\n");
+}
+export function rootcausePrompt(brief) {
+    return `${CHARTER}
+
+# Your role: root cause
+
+Reconstruct, from the origin, why this stopped. Not the last error: the chain.
+
+1. Read the dossier, then the sources: the ledger aggregate, the journal around the stop, the
+   Gate reports, the agent transcripts, the git state of the branches involved.
+2. Write the chain as numbered links, each backed by evidence. For each link say which layer is
+   responsible: "plan" (how the work was cut or ordered), "config" (the Project's ${PRODUCT}
+   configuration, prompts, Gates), "${PRODUCT}" (the code of ${PRODUCT} or of one of its packages), or
+   "project" (the Project's own code or environment).
+3. Find the first link that could have been prevented. That is the origin; the rest are consequences.
+4. For a "${PRODUCT}" link, read the code that did it. Name file and line. Say what the code does, which
+   is not always what its comment says.
+5. Say whether the stop will come back by itself after a plain resume. Prove it by reading what a
+   resume resets and what it keeps (counters, budgets, workspace), with file and line.
+
+${context(brief)}
+
+Answer in prose, then end with one \`\`\`json block:
+{"chain":[{"claim":"…","evidence":"file:line or command","layer":"plan|config|${PRODUCT}|project"}],
+ "origin":"…","returnsAfterPlainResume":true,"unverified":["…"]}`;
+}
+export function remedyPrompt(brief) {
+    return `${CHARTER}
+
+# Your role: remedies
+
+List every way to get this running again AND to stop it happening again. You do not judge them
+against each other: another member does.
+
+Sort them into:
+- "unblock": what puts the run back in motion. The only moves available are: resume a ticket or
+  feature by key; restart a feature from its line; cancel a ticket (loses its work); start the worker;
+  restart the worker (a hung process); free disk. Check by reading the code that the move actually clears what stopped it. A resume that
+  hands the work back with no budget left stops at once, again: count the budget the way the code does.
+- "fix": a change to a repository so that this cannot recur. Repositories you may name:
+  ${brief.targets.join(", ") || "(none configured: there are no fixes to propose)"}.
+  A fix is for the cause, in the layer responsible: the plan's ordering, the Project's configuration
+  or prompts, or ${PRODUCT}'s code. Say the area, the result to reach and what proves it. Say which
+  rules and accepted decisions it touches (from the rules above) and whether it conforms or would
+  revise one. Do not write the design: whoever makes the change designs it inside the rules.
+- "order": whether the unblock must wait for the fixes (the same stop would come straight back)
+  or can run first.
+
+For each remedy: what it does, what proves it worked (a command and the output to expect), and
+what it costs. Prefer a remedy that makes the class of stop impossible over one that handles a case.
+
+${context(brief)}
+
+Answer in prose, then end with one \`\`\`json block:
+{"unblock":[{"do":"resume|restart|cancel|start-worker|restart-worker|cleanup-disk","key":"…","why":"…","proof":"…"}],
+ "fixes":[{"target":"…","title":"…","change":"…","proof":"…","rules":"…","revises":""}],"unblockAfterFixes":false,"unverified":["…"]}`;
+}
+export function skepticPrompt(brief) {
+    return `${CHARTER}
+
+# Your role: skeptic
+
+You are the one who finds how the obvious answer fails. Assume the first idea anyone has is
+"resume it" or "raise the limit", and find out whether that holds.
+
+- Read the code that a resume goes through and say what it resets and what it keeps. Does the
+  ticket escalate again at once? Does it loop? Does it cost an attempt, a budget, a workspace?
+- Which proposed move weakens a bound (attempts, refusals, timeouts, a Gate) to get past a stop?
+  That trades the stop for a worse failure later; name it.
+- What could a fix to ${PRODUCT}'s code break elsewhere? Read the callers. What test would catch it?
+- What could happen to work already folded into the line? Is the move reversible, and how?
+- What would make this supervision attempt itself loop, or hide a bug in ${PRODUCT} instead of
+  fixing it?
+- What did the earlier attempts on this subject (below) get wrong?
+
+Be concrete: a scenario, with the lines of code that make it happen. A worry without a path is noise.
+
+${context(brief)}
+
+Answer in prose, then end with one \`\`\`json block:
+{"risks":[{"move":"…","scenario":"…","evidence":"file:line","severity":"blocking|serious|minor"}],
+ "mustBeTrue":["conditions the arbiter should require"],"unverified":["…"]}`;
+}
+/** The shape of the arbiter's answer, as `parseDecision` reads it. */
+const DECISION_FORM = `{"summary":"one line","cause":"…","evidence":["file:line or command → output"],
+ "confidence":"high|medium|low","unblockAfterFixes":false,
+ "unblock":[{"do":"resume|restart|cancel|start-worker|restart-worker|cleanup-disk","key":"exact key","reason":"…"}],
+ "fixes":[{"target":"…","title":"…","instruction":"result, constraints, proof","conformity":"rule or decision → why it conforms","revises":""}],
+ "needsHuman":""}`;
+/**
+ * The cheap second ask of an arbiter whose answer was refused for its shape:
+ * the first answer and the reason, no reports, no code to reread.
+ */
+export function formPrompt(answer, reason) {
+    return `You correct the form of an answer. You add no finding, read no code, and change no fact.
+
+The answer below was refused: ${reason}
+
+Rewrite it so that it ends with exactly one \`\`\`json block of this form, drawing every value from the
+answer itself:
+${DECISION_FORM}
+
+## The answer
+
+${answer}`;
+}
+export function arbiterPrompt(brief, reports) {
+    const body = Object.entries(reports)
+        .map(([role, text]) => `### ${role}\n\n${text}`)
+        .join("\n\n");
+    return `${CHARTER}
+
+# Your role: arbiter
+
+Three members reported on this stop. You decide. You may read the code yourself to settle a
+disagreement, and you must when two reports contradict each other: do not pick by tone.
+
+Decide:
+1. The cause, in one paragraph, with the evidence that makes it so.
+2. What puts the run back in motion ("unblock"), using keys exactly as the dossier writes them.
+3. The fixes that make this class of stop impossible ("fixes"), one per repository change. Each states
+   the RESULT to reach (what must be true afterwards, observable), the constraints the rules put on it,
+   and the test that proves it. It does not state the design: no function to edit, no algorithm. The
+   fixer reads the code and designs inside the rules; an instruction that dictates the design makes
+   you responsible for any rule it breaks.
+   Each fix also carries "conformity": the rules and accepted decisions (cite document and entry) it
+   touches and why it conforms. If no change can reach the result without revisiting an accepted
+   decision or rule, set "revises" to which one: the fix is then not made and a person decides.
+4. Whether the unblock has to wait for the fixes ("unblockAfterFixes": true when the same stop would
+   come straight back without them).
+
+Rules that bind you:
+- Prefer the fix of the cause over the patch of the state. If the cause is in ${PRODUCT}, ${PRODUCT} is fixed.
+- Never raise a bound (attempts, refusals, timeouts, budgets) or turn off a Gate to get past a stop.
+  A bound that is too tight is a finding to fix on its merits, with evidence, not a lever for today.
+- A move the skeptic showed to fail is not chosen. Anything marked "blocking" is answered or avoided.
+- Say "low" confidence when you could not verify the cause. The supervisor then does nothing and asks
+  again with more history, which is better than acting on a guess.
+- "needsHuman" only for what no agent can decide: a credential, a product choice, work already folded
+  into the line. Say precisely what the person must decide and what you recommend.
+- Read the rules above before you write a fix. A fix that adds a dependency across layers, makes one
+  part read another's internals, loosens a bound a decision froze, or inherits behaviour silently where
+  a decision says it must be explicit, is not a fix: it is a "revises".
+- A fix changes files that exist in the checkout of its repository. The Project's own configuration,
+  prompts and code are not in it: what must change there is for a person, so it goes in "needsHuman"
+  and is not a fix. A fix never names a file you did not find in that repository.
+- Fixes only name these repositories: ${brief.targets.join(", ") || "(none)"}.
+
+${context(brief)}
+
+## The reports
+
+${body}
+
+Answer with a short explanation, then end with exactly one \`\`\`json block:
+${DECISION_FORM}`;
+}
+export function fixerPrompt(input) {
+    return `You change one repository so that a stop of ${PRODUCT} cannot happen again. You work alone, in a
+worktree made for this change. No one will answer a question.
+
+Read the repository's AGENTS.md (or CLAUDE.md) first and follow it: its layout, its checks, what it
+asks you to update in the same change (documents, decisions).
+
+## Why
+${input.cause}
+
+Evidence the council gathered:
+${input.evidence.map((line) => `- ${line}`).join("\n")}
+
+## What to change: ${input.title}
+${input.instruction}
+
+The council says it conforms to the rules like this (check it, do not trust it):
+${input.conformity}
+
+${input.deferred === undefined || input.deferred.length === 0
+        ? ""
+        : `The guard approved the proposal but could not check these until the change exists; check them yourself and say what you saw:\n${input.deferred.map((line) => `- ${line}`).join("\n")}\n\n`}The result is what is asked; how to reach it is yours. Design it inside the repository's own rules,
+which win over this instruction: if the instruction as written would break one (a layer, a
+dependency direction, a frozen bound, an accepted decision), do not follow it; reach the result
+another way, or change nothing and say which rule stops you.
+
+## Rules
+- Fix the cause, not the symptom. Verify the cause yourself in the code before you change anything;
+  if what is written above is wrong, change what is actually wrong and say so in your last message.
+- Smallest change that makes the class of stop impossible. Add a test that fails before and passes after.
+- Never raise a bound, loosen a check, or skip a Gate to make something pass.
+- Do not commit, push or open anything. The supervisor does, once the checks pass.
+${input.deny.length === 0 ? "" : `- You may not touch: ${input.deny.join(", ")}.\n`}- The change must pass: ${input.checks.join(" ; ") || "(no check configured)"}. Run them.
+${input.failure === undefined ? "" : `\n## The previous attempt failed its checks\nFix this, do not start over:\n${input.failure}\n`}
+Finish with a short summary: what was wrong, what you changed, what you ran and what it printed.`;
+}
+/**
+ * The guard. It is given a change and the repository, never the stop that
+ * caused it: it judges the change against the product, not against the problem.
+ */
+export function reviewerPrompt(input) {
+    return `You are the guard of ${PRODUCT}. A change to ${input.target} is about to be offered. You do not know
+what prompted it and you must not try to find out: you do not judge whether it solves anything. You judge
+whether it belongs in ${PRODUCT}: its features, its goals, the choices already made, the code that exists.
+Your working directory is a checkout of the repository with the change applied. Nothing may be changed.
+
+How you work:
+- You never assume. Every claim cites a file and line you read, or a command you ran and what it printed.
+  What you could not check is listed under "unverified" and counts against approval; it is never written as fact.
+- Read the repository's AGENTS.md first, then the documents it routes you to: the product rules, the
+  accepted decisions, the architecture and the specification of every area the change touches.
+  The documents can be wrong and the code is the fact: when they disagree, say so.
+- Do not trust the change's own words, its tests or its comments. Read the code it touches and the code that
+  calls it.
+
+The change is titled "${input.title}". Files:
+${input.files.map((file) => `- ${file}`).join("\n")}
+
+\`\`\`diff
+${input.diff}
+\`\`\`
+
+Establish, with evidence, each of these:
+1. behaviour: what the change makes the code do that it did not, and what it no longer does.
+2. callers: every caller and every consumer of what changes (other packages, other Transformers, the Host,
+   the CLI, configuration files, documents); for each, whether it still holds.
+3. decisions: every accepted decision, invariant or product rule the change touches or contradicts. A change
+   that revisits one is acceptable only if it records the new decision in the same change (and says what it
+   replaces); otherwise reject.
+4. coherence: whether it fits the code around it (names, layers, who may import whom, the words of the
+   product's glossary) or adds a second way of doing what exists.
+5. proof: whether the tests cover the new behaviour and the behaviour next to it, and whether they would
+   fail without the change. Run what the repository's checks run (${input.checks.join(" ; ") || "none configured"}) if you doubt them.
+6. record: whether the documents that cover the touched files are updated in the same change, and whether
+   anything left unsure is written down as the repository asks.
+
+Reject if any point lacks evidence, shows an interference, a contradicted decision, a missing record or a
+loosened bound. Approve if you found no problem in everything that can be checked now. What can only be checked once
+the change is written (running its proof, the repository's checks) goes under "unverified": it does not
+stop the proposal, it is handed to whoever writes it and to the guard of the diff. A problem you found
+is a finding, never an "unverified". An approval lists what you checked.
+
+Finish with one JSON object in a \`\`\`json fence:
+{"verdict":"approve"|"reject",
+ "checked":["file:line or command → what it showed", "..."],
+ "findings":[{"point":1-6,"problem":"...","evidence":"file:line","required":"what the change must do"}],
+ "unverified":["..."]}`;
+}
+/**
+ * The guard, before anything is written: it reads the proposal against the rules.
+ * The cheapest place to refuse a change that cannot conform is before it is coded.
+ */
+export function proposalReviewerPrompt(input) {
+    return `You are the guard of ${PRODUCT}. A change to ${input.target} is PROPOSED, not yet written. You do not
+know what prompted it and you must not try to find out: you judge whether it can belong in ${PRODUCT}, not
+whether it solves anything. Your working directory is a checkout of the repository. Nothing may be changed.
+
+How you work:
+- You never assume. Every claim cites a file and line you read, or a command you ran and what it printed.
+  What you could not check is listed under "unverified" and counts against approval.
+- Read the rules first: ${input.rules.join(", ") || "the repository's AGENTS.md"}, then the documents they
+  route you to for the area the proposal touches (decisions, product rules, architecture, specifications).
+  Then the code the proposal would touch and the code that calls it.
+
+The proposal is titled "${input.title}".
+
+Instruction:
+${input.instruction}
+
+Its own claim of conformity (do not trust it; check it):
+${input.conformity}
+
+Establish, with evidence:
+1. behaviour: what it would make the code do, and what it would stop doing. Every file it names must
+   exist in this checkout; a proposal that changes anything outside this repository is rejected.
+2. callers: what depends on what changes, and whether it still holds.
+3. decisions: every accepted decision, invariant, layer rule or frozen bound it touches or contradicts.
+   If it cannot reach its result without contradicting one, reject: this is a decision for a person.
+4. coherence: whether it fits the code around it or adds a second way of doing what exists.
+5. instruction: whether it dictates a design that breaks a rule. Say which rule, and what result could be
+   reached instead, in the rules' terms.
+6. record: the documents a change of this kind must update in the same change.
+
+Approve only if you found nothing and could check everything. An approval lists what you checked.
+
+Finish with one JSON object in a \`\`\`json fence:
+{"verdict":"approve"|"reject",
+ "checked":["file:line or command → what it showed", "..."],
+ "findings":[{"point":1-6,"problem":"...","evidence":"file:line","required":"what the change must do instead"}],
+ "unverified":["..."]}`;
+}
+//# sourceMappingURL=prompts.js.map

package/dist/operator/supervise/prompts.js.map

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

package/dist/operator/supervise/review.d.ts

@@ -0,0 +1,24 @@
+export type Verdict = {
+    ok: true;
+    approve: true;
+    checked: string[];
+    deferred: string[];
+} | {
+    ok: true;
+    approve: false;
+    reasons: string[];
+    points: number[];
+} | {
+    ok: false;
+    reason: string;
+};
+/**
+ * The guard's answer. An approval has to show what was checked, and has nothing
+ * left unverified: a guard that says yes without evidence has said nothing.
+ * A proposal is not written yet: what can only be checked once it is stays with the
+ * fixer and the guard of the diff (`deferred`) and does not stop it.
+ */
+export declare function parseVerdict(output: string, options?: {
+    proposal?: boolean;
+}): Verdict;
+//# sourceMappingURL=review.d.ts.map

package/dist/operator/supervise/review.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"review.d.ts","sourceRoot":"","sources":["../../../src/operator/supervise/review.ts"],"names":[],"mappings":"AAEA,MAAM,MAAM,OAAO,GACf;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,CAAA;CAAE,GAClE;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,OAAO,EAAE,KAAK,CAAC;IAAC,OAAO,EAAE,MAAM,EAAE,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAA;CAAE,GACjE;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAC;AAElC;;;;;GAKG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,GAAE;IAAE,QAAQ,CAAC,EAAE,OAAO,CAAA;CAAO,GAAG,OAAO,CA4C1F"}

package/dist/operator/supervise/review.js

@@ -0,0 +1,51 @@
+import { lastJson } from "./decision.js";
+/**
+ * The guard's answer. An approval has to show what was checked, and has nothing
+ * left unverified: a guard that says yes without evidence has said nothing.
+ * A proposal is not written yet: what can only be checked once it is stays with the
+ * fixer and the guard of the diff (`deferred`) and does not stop it.
+ */
+export function parseVerdict(output, options = {}) {
+    const value = lastJson(output);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return { ok: false, reason: "no JSON object in the guard's answer" };
+    }
+    const o = value;
+    const strings = (v) => (Array.isArray(v) ? v.map(String) : []);
+    const checked = strings(o.checked);
+    const unverified = strings(o.unverified);
+    const raw = (Array.isArray(o.findings) ? o.findings : []).map((item) => (item ?? {}));
+    const points = raw.flatMap((f) => (typeof f.point === "number" ? [f.point] : []));
+    const findings = raw.map((f) => {
+        return `point ${String(f.point ?? "?")}: ${String(f.problem ?? "")} (${String(f.evidence ?? "no evidence")}) — required: ${String(f.required ?? "")}`;
+    });
+    if (o.verdict === "reject") {
+        return {
+            ok: true,
+            approve: false,
+            reasons: findings.length > 0 ? findings : ["rejected without a finding"],
+            points,
+        };
+    }
+    if (o.verdict !== "approve") {
+        return { ok: false, reason: 'verdict must be "approve" or "reject"' };
+    }
+    if (checked.length === 0) {
+        return { ok: false, reason: "an approval must list what was checked" };
+    }
+    if (findings.length > 0 || (unverified.length > 0 && options.proposal !== true)) {
+        return {
+            ok: true,
+            approve: false,
+            reasons: [...findings, ...unverified.map((u) => `unverified: ${u}`)],
+            points,
+        };
+    }
+    return {
+        ok: true,
+        approve: true,
+        checked,
+        deferred: options.proposal === true ? unverified : [],
+    };
+}
+//# sourceMappingURL=review.js.map

package/dist/operator/supervise/review.js.map

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

package/dist/operator/supervise/supervise.d.ts

@@ -0,0 +1,26 @@
+import { type Exec } from "./exec.js";
+export type SuperviseInput = {
+    cwd: string;
+    argv: string[];
+    write: (text: string) => void;
+    interruptFlag?: {
+        interrupted: boolean;
+    };
+    exec?: Exec;
+    now?: () => Date;
+    sleep?: (ms: number) => Promise<void>;
+};
+/**
+ * Watch a mason run, and do what a person would do by hand when it stops.
+ *
+ * It is another process than `run`, on the same ledger. It reads (the ledger,
+ * the journal, the lock, the disk), decides what is wrong, has a council of
+ * agents find the cause, and carries out the arbiter's decision: the move
+ * that puts the run back in motion, and the changes to the repositories it
+ * was given so that the stop does not come back. Those changes are offered as
+ * pull requests and folded by the repository's own rules, so they can be undone.
+ *
+ * With `--dry-run` it deliberates and writes what it would do, and does none of it.
+ */
+export declare function runSupervise(input: SuperviseInput): Promise<number>;
+//# sourceMappingURL=supervise.d.ts.map

package/dist/operator/supervise/supervise.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervise.d.ts","sourceRoot":"","sources":["../../../src/operator/supervise/supervise.ts"],"names":[],"mappings":"AA+BA,OAAO,EAAE,KAAK,IAAI,EAA0B,MAAM,WAAW,CAAC;AAc9D,MAAM,MAAM,cAAc,GAAG;IAC3B,GAAG,EAAE,MAAM,CAAC;IACZ,IAAI,EAAE,MAAM,EAAE,CAAC;IACf,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9B,aAAa,CAAC,EAAE;QAAE,WAAW,EAAE,OAAO,CAAA;KAAE,CAAC;IACzC,IAAI,CAAC,EAAE,IAAI,CAAC;IACZ,GAAG,CAAC,EAAE,MAAM,IAAI,CAAC;IACjB,KAAK,CAAC,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAC;CACvC,CAAC;AAUF;;;;;;;;;;;GAWG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,cAAc,GAAG,OAAO,CAAC,MAAM,CAAC,CAgFzE"}