trail-code 0.0.0-stage → 0.28.0-semantic.3

package/dist/graph/refresh.js

@@ -0,0 +1,430 @@
+/**
+ * `ensureFreshGraph` — the pre-query gate that keeps retrieval honest.
+ *
+ * A graph is a set of `file:line` spans for one working tree, so an answer drawn
+ * from it is only as honest as its freshness. That cannot be somebody else's job:
+ * an edit made outside the agent (your editor, a branch switch, a stash, a merge)
+ * sets no flag anywhere. So freshness lives in the query path: every retrieval
+ * call probes the working tree (`fingerprint.ts`, ~3ms) and, when something moved,
+ * repairs the structural graph. Properties worth keeping:
+ *
+ * - **$0 and offline.** Tier-1 only — never a summarizer, never `--deep`. Anything
+ *   that runs without being asked must not spend money.
+ * - **Never fatal.** A failed refresh degrades to answering from the graph on
+ *   disk. A query that works today must not start failing because a rebuild did.
+ * - **Never a stampede.** It takes the same `.cache/.sync.lock` a background build
+ *   takes, so concurrent MCP calls and the rebuild they trigger can't pile up.
+ * - **Bounded.** Up to `DRIFT_INLINE_MAX` changed files are re-extracted before
+ *   answering; more than that is handed to a background rebuild and the answer
+ *   carries `[stale: N files changed, rebuilding in background]`. A branch switch
+ *   never blocks a query.
+ * - **Writes only what a query reads** (`graphOnly`): the graph, the `ask` sidecar,
+ *   the freshness record. Not the markdown cards, not `INDEX.md`, not `.gitignore`.
+ *   Those belong to an explicit `trail build`, so retrieval stays cheap and a read
+ *   stays a read. `stats.json` is left alone too.
+ * - **Lexical here, semantic elsewhere.** The inline repair updates the graph only.
+ *   The vector index loads an ONNX model, so it refreshes in a detached process
+ *   (`build-run.ts`) and never on the path that answers.
+ *
+ * One case is not drift but absence: inside a git worktree there is no graph at all,
+ * because `.trail/`/`graft/` is gitignored and so was never checked out. The gate
+ * covers that too — it copies the parent checkout's graph in (`./seed.ts`) and then
+ * treats the difference between the two checkouts as ordinary drift, which is
+ * exactly what it is.
+ *
+ * The other absence is a repo this machine never built: `trail init` ran somewhere
+ * else, or the clone is new. Its queries find no code and the agent goes back to
+ * grep for the rest of the session. So the first query there starts a full build in
+ * the background and waits a while for it (`buildMissingMap`).
+ */
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { contextDirFor } from "../context/node-file.js";
+import { isTrailMapDir } from "../context/map-dir.js";
+import { homeFolderRefusal } from "../init-guard.js";
+import { acquireLockIn, lockHeldIn, releaseLockIn } from "../util/state.js";
+import { CACHE_DIR } from "../context/node-file.js";
+import { buildGraph } from "./build.js";
+import { BACKGROUND_TIMEOUT_MS, embeddingsDbPath } from "./build-run.js";
+import { driftCount, isClean, probeDrift, readFingerprint } from "./fingerprint.js";
+import { invalidateGraphCaches } from "./load.js";
+import { seedGraph } from "./seed.js";
+import { wiringPath } from "./write.js";
+import { cmd, tag } from "../brand.js";
+/**
+ * Most files a query will re-extract before answering, instead of handing the
+ * rebuild to a background process.
+ *
+ * A constant, not a flag: a merge or an ordinary edit of a handful of files stays
+ * well under it and gets answered from a current graph; a branch switch or a fresh
+ * clone blows past it, and blocking that query to re-parse hundreds of files is
+ * exactly the cost this gate exists to avoid. See design decision 5.
+ */
+export const DRIFT_INLINE_MAX = 50;
+/** How long to wait for another process's in-flight rebuild before giving up and
+ * answering from the current graph. Long enough to ride out a small repo's build,
+ * short enough that a tool call never feels hung. */
+const LOCK_WAIT_MS = 2000;
+const LOCK_POLL_MS = 50;
+/** How long a query waits for a repo's first build before answering without code.
+ * A big repo (8k files) builds in about 75s, and the agent's shell gives a command
+ * two minutes; a reply with code in it on the first try is worth the wait, once. */
+const FIRST_BUILD_WAIT_MS = 90_000;
+const FIRST_BUILD_POLL_MS = 250;
+/** The first build's own time limit, well past the end-of-turn rebuild's two minutes. */
+const FIRST_BUILD_TIMEOUT_MS = 10 * 60_000;
+const CLEAN = { refreshed: false };
+/** Env kill switch, for CI or anyone who wants queries to never write. */
+function envDisabled() {
+    const v = process.env.GRAFT_NO_REFRESH;
+    return v !== undefined && v !== "" && v !== "0" && v !== "false";
+}
+function sleep(ms) {
+    return new Promise((r) => setTimeout(r, ms));
+}
+/** The wait for a first build: the option, else `GRAFT_FIRST_BUILD_WAIT_MS` (the hooks
+ * set 0, since their own budget is seconds), else the default. */
+function firstBuildWait(opts) {
+    if (opts.firstBuildWaitMs !== undefined)
+        return opts.firstBuildWaitMs;
+    const v = process.env.GRAFT_FIRST_BUILD_WAIT_MS;
+    const ms = v === undefined || v === "" ? NaN : Number(v);
+    return Number.isFinite(ms) && ms >= 0 ? ms : FIRST_BUILD_WAIT_MS;
+}
+/**
+ * The detached rebuild runner: the compiled sibling this module ships with, or a
+ * test's stand-in. Null when neither is on disk — the caller then answers from
+ * whatever graph it has, which is the behaviour that predates all of this.
+ */
+function runnerPath() {
+    const overridden = process.env.GRAFT_TEST_BUILD_RUN;
+    if (overridden)
+        return existsSync(overridden) ? overridden : null;
+    const run = fileURLToPath(new URL("./build-run.js", import.meta.url));
+    return existsSync(run) ? run : null;
+}
+/** Start `build-run` detached. The caller owns the lock contract (see below). */
+function spawnJob(dir, outDir, mode, timeoutMs) {
+    const run = runnerPath();
+    if (!run)
+        return false;
+    const child = spawn(process.execPath, [run, mode, dir, outDir, String(timeoutMs)], {
+        detached: true,
+        stdio: "ignore",
+        windowsHide: true,
+    });
+    child.on("error", () => { });
+    child.unref();
+    return true;
+}
+/**
+ * Hand a rebuild to a background process, under the same lock every other rebuild
+ * takes. False when nothing was started (no runner on disk, someone else already
+ * rebuilding, or a `full` job whose lock we could not take).
+ *
+ * `graph` and `full` take the lock and the child releases it; `embed` takes none —
+ * it only reads the graph and writes the vector index, and a query that answered
+ * a moment ago is not going to race it for the graph.
+ *
+ * `embed` also refuses to create an index that isn't there: a repo that never ran
+ * a semantic build must not start downloading a 400 MB model because someone
+ * edited a file. It refreshes what exists, nothing more.
+ */
+function startBackgroundJob(dir, outDir, mode) {
+    if (mode === "embed") {
+        if (!existsSync(embeddingsDbPath(outDir)))
+            return false;
+        return spawnJob(dir, outDir, mode, BACKGROUND_TIMEOUT_MS);
+    }
+    const lockCache = join(outDir, CACHE_DIR);
+    if (lockHeldIn(lockCache))
+        return true; // someone is already rebuilding
+    if (!acquireLockIn(lockCache))
+        return false;
+    if (!spawnJob(dir, outDir, mode, mode === "full" ? FIRST_BUILD_TIMEOUT_MS : BACKGROUND_TIMEOUT_MS)) {
+        releaseLockIn(lockCache);
+        return false;
+    }
+    return true;
+}
+/**
+ * Start a full `full` build of `dir`, for a repo on trail that has no map yet. The
+ * caller holds the lock; the child releases it when the build ends, however it ends.
+ */
+function startFirstBuild(dir, outDir) {
+    if (lockHeldIn(join(outDir, CACHE_DIR)))
+        return true;
+    if (!acquireLockIn(join(outDir, CACHE_DIR)))
+        return false;
+    if (!spawnJob(dir, outDir, "full", FIRST_BUILD_TIMEOUT_MS)) {
+        releaseLockIn(join(outDir, CACHE_DIR));
+        return false;
+    }
+    return true;
+}
+/**
+ * No graph here and none to copy in. A repo on trail gets one built: its team
+ * committed `.trail/` and this person installed trail, so a build is what they
+ * asked for, and answering "no matching nodes" sends the agent back to grep for
+ * good. Anywhere else (a graft repo, a `--dir` map, the home folder) nothing is
+ * built behind the user's back, as before.
+ *
+ * The first query to get here starts the build and waits up to `firstBuildWait`;
+ * queries arriving meanwhile wait on the same lock. Returns a note when the map
+ * is now there and the query should go on, or what to answer with when it isn't.
+ */
+async function buildMissingMap(dir, outDir, opts, busy) {
+    const own = !opts.contextDir && !process.env.GRAFT_DIR && isTrailMapDir(dir, outDir) && homeFolderRefusal(dir) === null;
+    if (!own) {
+        return busy
+            ? { refreshed: false, note: "another process is still copying the graph into this worktree — retry the query in a moment" }
+            : CLEAN;
+    }
+    const lockCache = join(outDir, CACHE_DIR);
+    const started = Date.now();
+    // The lock free and still no map: nobody is building it, so this query starts it.
+    // Taken here, released by the child.
+    if (!startFirstBuild(dir, outDir)) {
+        // Nothing to start, and nothing running either: say so below rather than waiting.
+    }
+    const deadline = started + firstBuildWait(opts);
+    while (lockHeldIn(lockCache) && Date.now() < deadline)
+        await sleep(FIRST_BUILD_POLL_MS);
+    if (existsSync(wiringPath(outDir))) {
+        invalidateGraphCaches(outDir);
+        return `built this repo's code map for the first time (${Math.round((Date.now() - started) / 1000)}s)`;
+    }
+    if (lockHeldIn(lockCache)) {
+        return {
+            refreshed: false,
+            note: "no code map here yet: building one in the background (about a minute on a big repo). Until it's done the answer has no code in it — run the same command again in a minute instead of rewording it",
+        };
+    }
+    return { refreshed: false, note: `couldn't build this repo's code map — run \`${cmd("graft build")}\` to see why` };
+}
+/**
+ * Release the lock if this process is asked to die while holding it. Returns the
+ * un-hook.
+ *
+ * Not hypothetical: the Claude Code prompt hook runs `graft ask` with a timeout, and
+ * `execFileSync` enforces it with SIGTERM. Node's default disposition for SIGTERM is
+ * to exit without unwinding, so the `finally` below never runs and the lock outlives
+ * the process — after which the background sync is blocked and every query waits and
+ * then answers stale until the lock ages out. Ctrl-C on a CLI query is the same story
+ * with SIGINT.
+ *
+ * Adding a listener replaces that default disposition, so re-raise it explicitly
+ * afterwards: remove ourselves, then `process.kill(process.pid, sig)`, so the exit
+ * status still says "terminated by signal" for whoever is waiting on us.
+ */
+export function releaseOnSignal(cache) {
+    const signals = ["SIGTERM", "SIGINT"];
+    const onSignal = (sig) => {
+        releaseLockIn(cache);
+        for (const s of signals)
+            process.removeListener(s, onSignal);
+        process.kill(process.pid, sig);
+    };
+    for (const s of signals)
+        process.once(s, onSignal);
+    return () => {
+        for (const s of signals)
+            process.removeListener(s, onSignal);
+    };
+}
+/** Wait out someone else's rebuild, then take the lock. False when we couldn't. */
+async function waitForLock(cache) {
+    const deadline = Date.now() + LOCK_WAIT_MS;
+    for (;;) {
+        if (acquireLockIn(cache))
+            return true;
+        if (Date.now() >= deadline)
+            return false;
+        await sleep(LOCK_POLL_MS);
+    }
+}
+/**
+ * Copy a parent checkout's graph in, holding the same lock a rebuild would.
+ *
+ * Two MCP tool calls in a fresh worktree arrive here at the same moment, and an 8 MB
+ * copy is long enough for both to start one. The loser waits, then finds the graph
+ * already there and reports nothing — which is why the caller re-checks the file
+ * rather than trusting this return value.
+ */
+async function seedUnderLock(dir, outDir, contextDir) {
+    const lockCache = join(outDir, CACHE_DIR);
+    // `busy` matters: with no graph on disk there is nothing to fall back to, so a
+    // caller that stayed silent here would emit the bare "no matching nodes" this whole
+    // mechanism exists to remove. Say what happened instead.
+    if (!(await waitForLock(lockCache)))
+        return { seeded: false, busy: true };
+    const unhook = releaseOnSignal(lockCache);
+    try {
+        return seedGraph(dir, { contextDir });
+    }
+    finally {
+        unhook();
+        releaseLockIn(lockCache);
+    }
+}
+/**
+ * Rebuild `root`'s structural graph if the working tree has moved since the last
+ * build. Cheap and side-effect-free when nothing changed, which is the usual case.
+ *
+ * `root` is the repository root (the same value the query itself is given), not
+ * the context dir.
+ */
+export async function ensureFreshGraph(root, opts = {}) {
+    if (opts.disabled || envDisabled())
+        return CLEAN;
+    try {
+        const dir = resolve(root);
+        const outDir = contextDirFor(dir, opts.contextDir);
+        let seededFrom;
+        let builtNote;
+        if (!existsSync(wiringPath(outDir))) {
+            // One case has a graph to work with even though this checkout has none: a git
+            // worktree, whose parent checkout's `graft/` git could not check out. Copy it
+            // in and carry on — the drift below is then exactly the diff between the two
+            // checkouts, and repairing it is what makes the copied graph honest here.
+            const seed = await seedUnderLock(dir, outDir, opts.contextDir);
+            seededFrom = seed.from;
+            // Still nothing (not a worktree, parent never built, or a concurrent seed or
+            // first build we lost the race for): a repo on trail gets its map built; any
+            // other repo gets the caller's own "no graph — run graft build" message.
+            if (!existsSync(wiringPath(outDir))) {
+                const built = await buildMissingMap(dir, outDir, opts, seed.busy);
+                if (typeof built !== "string")
+                    return built;
+                builtNote = built;
+            }
+        }
+        const seedNote = seededFrom ? `copied the graph from the main checkout (${seededFrom})` : builtNote;
+        // null = no fingerprint at all: a graph built before this mechanism existed,
+        // or by a different extractor build. Rebuild once — that lays the fingerprint
+        // down, so it costs exactly one build, not one per query.
+        const drift = probeDrift(dir, outDir);
+        if (drift && isClean(drift))
+            return seedNote ? { refreshed: false, note: seedNote } : CLEAN;
+        // Too much to patch before answering: a branch switch, a fresh checkout, a
+        // merge of somebody else's work. Answer from the graph that is on disk, say it
+        // is stale, and let a background process repair it — blocking here is what made
+        // a query after `git switch` feel like a hang. The next query, once that build
+        // lands, answers fresh with no note at all.
+        //
+        // Only when the handoff actually happened: if no background runner is on disk
+        // (a half-installed CLI) the note would promise a rebuild that nobody is doing,
+        // so the slower inline repair below is the honest answer.
+        if (drift && driftCount(drift) > DRIFT_INLINE_MAX && startBackgroundJob(dir, outDir, "graph")) {
+            return { refreshed: false, drift, stale: driftCount(drift) };
+        }
+        // The lock every rebuild takes, so two queries and a background build can never
+        // rebuild the same graph at the same time.
+        const lockCache = join(outDir, CACHE_DIR);
+        if (!(await waitForLock(lockCache))) {
+            const busy = "a graph rebuild is already in flight — answering from the current graph";
+            return {
+                refreshed: false,
+                drift: drift ?? undefined,
+                note: seedNote ? `${seedNote}; ${busy}` : busy,
+            };
+        }
+        const unhook = releaseOnSignal(lockCache);
+        try {
+            // We may have queued behind another process's rebuild for up to LOCK_WAIT_MS,
+            // and that rebuild very likely fixed the same drift we saw. Re-probe rather
+            // than rebuild on the strength of a stale observation: without this, four
+            // parallel MCP tool calls on one edited file produce four full rebuilds, three
+            // of them pure waste, and the last tool call pays for all of it. A null drift
+            // means "no fingerprint" and still has to build.
+            const now = drift ? probeDrift(dir, outDir) : null;
+            if (now && isClean(now)) {
+                invalidateGraphCaches(outDir);
+                return seedNote ? { refreshed: false, note: seedNote } : CLEAN;
+            }
+            // Tier-1 only: no summarizer, so no LLM call and no network, ever. And
+            // `graphOnly`: write the graph, the ask sidecar and the fingerprint, nothing
+            // else. The markdown projections under `graft/` stay the `Stop` hook's job —
+            // a query has no business rewriting the repo's `.gitignore` or churning every
+            // card's mtime, and skipping them is most of what keeps this cheap.
+            // A `--only-dir` build recorded its whitelist in the fingerprint; re-apply it
+            // here so an auto-rebuild keeps the same limited file set instead of silently
+            // widening to the whole tree.
+            const onlyDirs = readFingerprint(outDir)?.onlyDirs;
+            await buildGraph(dir, { contextDir: opts.contextDir, graphOnly: true, onlyDirs });
+            invalidateGraphCaches(outDir);
+            // The vector index is the one thing that stays behind: loading the ONNX model
+            // costs seconds and this was a lexical query. It refreshes out of process —
+            // and only if the repo has an index to refresh (`startBackgroundJob`).
+            startBackgroundJob(dir, outDir, "embed");
+            return { refreshed: true, drift: drift ?? undefined, note: seedNote };
+        }
+        finally {
+            unhook();
+            releaseLockIn(lockCache);
+        }
+    }
+    catch (err) {
+        // Answering from a slightly stale graph beats failing the query.
+        return { refreshed: false, note: `graph refresh skipped: ${err instanceof Error ? err.message : String(err)}` };
+    }
+}
+/**
+ * Workspace variant: refresh each child repo's own graph (a workspace parent holds
+ * an index, never nodes). Children are independent, but they're refreshed in
+ * sequence — a fan-out of concurrent tree-sitter builds would spike CPU on the
+ * very path that's supposed to feel free.
+ */
+export async function ensureFreshChildren(root, children, opts = {}) {
+    if (opts.disabled || envDisabled())
+        return CLEAN;
+    const refreshedIn = [];
+    let files = 0;
+    let staleFiles = 0;
+    for (const child of children) {
+        // Deliberately NOT `opts`: `contextDirFor` returns an override verbatim and
+        // ignores the root it's handed, so forwarding the parent's `--dir` would point
+        // every child at the *parent's* context dir — which holds a workspace index and
+        // no wiring.json, so every child would silently be skipped. (And if it did hold
+        // one, each child would build into that single shared dir in turn, the last
+        // clobbering the rest.) A child's graph always lives in its own `<child>/graft`,
+        // which is exactly how `loadWorkspaceGraphs` reads them back.
+        const r = await ensureFreshGraph(resolve(root, child), { disabled: opts.disabled });
+        if (r.stale !== undefined)
+            staleFiles += r.stale;
+        if (!r.refreshed)
+            continue;
+        refreshedIn.push(child);
+        files += r.drift ? driftCount(r.drift) : 0;
+    }
+    // A workspace is as stale as its stalest child: the warning has to survive the
+    // ranking, or an answer that cites some other child's fresh graph looks sound
+    // while the one the user cares about is a branch behind.
+    if (staleFiles > 0)
+        return { refreshed: refreshedIn.length > 0, stale: staleFiles };
+    if (!refreshedIn.length)
+        return CLEAN;
+    return {
+        refreshed: true,
+        note: `refreshed ${refreshedIn.join(", ")} (${files || "?"} file${files === 1 ? "" : "s"} changed) before answering`,
+    };
+}
+/** The one-line note a CLI/MCP surface prints when a refresh actually happened.
+ * Null when there's nothing to say (the overwhelmingly common case). */
+export function refreshNote(r) {
+    // Stale first: it is a warning about the answer, not a report of work done.
+    if (r.stale !== undefined) {
+        return `[stale: ${r.stale} files changed, rebuilding in background]`;
+    }
+    if (!r.refreshed)
+        return r.note ? `${tag()} ${r.note}` : null;
+    const n = r.drift ? driftCount(r.drift) : 0;
+    const built = `refreshed the graph (${n || "?"} file${n === 1 ? "" : "s"} changed) before answering`;
+    // Both facts, when a worktree was seeded *and* the copy needed repairing: the
+    // count is the interesting half (it's the branch diff), the provenance explains
+    // where a graph came from in a directory the user knows they never built.
+    return r.note ? `${tag()} ${built} — ${r.note}` : `${tag()} ${built}`;
+}
+//# sourceMappingURL=refresh.js.map

package/dist/graph/refresh.js.map

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

package/dist/graph/relations.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Edges that carry dependency meaning for a graph walk/rank: `calls`,
+ * `references`, `imports`, `implements`, `extends`. `contains` is deliberately
+ * excluded — a file "contains" every symbol defined in it, so walking it
+ * would make every same-file symbol a neighbour and let a file act as a false
+ * hub, flooding a walk that must stay confined to genuine dependency wiring.
+ *
+ * Shared by `traverse.ts` (callers/callees/impact edge walks), `graphrank.ts`
+ * (personalized PageRank), and `search/grep.ts` (in-degree ranking) so every
+ * surface agrees on what counts as a dependency edge.
+ */
+import type { Relation } from "./types.js";
+export declare const WALK_RELATIONS: ReadonlySet<Relation>;
+//# sourceMappingURL=relations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"relations.d.ts","sourceRoot":"","sources":["../../src/graph/relations.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AACH,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE3C,eAAO,MAAM,cAAc,EAAE,WAAW,CAAC,QAAQ,CAM/C,CAAC"}

package/dist/graph/relations.js

@@ -0,0 +1,8 @@
+export const WALK_RELATIONS = new Set([
+    "calls",
+    "references",
+    "imports",
+    "implements",
+    "extends",
+]);
+//# sourceMappingURL=relations.js.map

package/dist/graph/relations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relations.js","sourceRoot":"","sources":["../../src/graph/relations.ts"],"names":[],"mappings":"AAaA,MAAM,CAAC,MAAM,cAAc,GAA0B,IAAI,GAAG,CAAW;IACrE,OAAO;IACP,YAAY;IACZ,SAAS;IACT,YAAY;IACZ,SAAS;CACV,CAAC,CAAC"}

package/dist/graph/resolve.d.ts

@@ -0,0 +1,17 @@
+import type { EdgeV1, NodeV1 } from "./types.js";
+import { type RawEdge } from "./extract.js";
+/** A Go module discovered in the repo: its `module` path from `go.mod` and the repo
+ * directory that `go.mod` lives in (posix, `.` for the repo root). A monorepo may hold
+ * several — e.g. `backend/go.mod`, `tools/go.mod`. */
+export interface GoModule {
+    module: string;
+    dir: string;
+}
+export interface ResolveOptions {
+    /** The Go modules found in the repo. Enables mapping Go import package paths
+     * (`example.com/app/pkg/util`) to the in-repo directory they name, relative to the
+     * owning module's `go.mod` location. Empty/absent → Go imports stay external strings. */
+    goModules?: GoModule[];
+}
+export declare function resolveEdges(nodes: NodeV1[], rawEdges: RawEdge[], opts?: ResolveOptions): EdgeV1[];
+//# sourceMappingURL=resolve.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"resolve.d.ts","sourceRoot":"","sources":["../../src/graph/resolve.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,MAAM,EAAQ,MAAM,EAAY,MAAM,YAAY,CAAC;AACjE,OAAO,EAAc,KAAK,OAAO,EAAE,MAAM,cAAc,CAAC;AAoExD;;sDAEsD;AACtD,MAAM,WAAW,QAAQ;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,GAAG,EAAE,MAAM,CAAC;CACb;AAED,MAAM,WAAW,cAAc;IAC7B;;6FAEyF;IACzF,SAAS,CAAC,EAAE,QAAQ,EAAE,CAAC;CACxB;AAED,wBAAgB,YAAY,CAC1B,KAAK,EAAE,MAAM,EAAE,EACf,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,GAAE,cAAmB,GACxB,MAAM,EAAE,CAiQV"}