@vibe-agent-toolkit/cli 0.1.42 → 0.2.0-rc.10

package/dist/commands/cache/cache-control.js

@@ -0,0 +1,86 @@
+/**
+ * The root-level `--no-cache` control surface, kept apart from the `cache`
+ * command itself.
+ *
+ * `bin.ts` must call {@link registerCacheControl} on every single invocation,
+ * before parsing. Co-locating it with `createCacheCommand` in `index.ts` meant
+ * that unavoidable call dragged in `./clear.js` and, behind it, the whole
+ * resources package — measured at ~1.2s of module load on Windows, paid even by
+ * `vat --version`. This module imports nothing but commander, so the always-on
+ * path stays cheap — keep it that way: any import added here is paid by every
+ * `vat` invocation, and `index.ts` deliberately does not re-export it, so
+ * reaching these functions through the command group cannot happen by accident.
+ */
+/**
+ * Register the root-level `--no-cache` flag and the hook that gives it effect.
+ *
+ * ## Why this sets an environment variable instead of plumbing a flag
+ *
+ * ⚠️ The ORIGINAL reason has expired, and saying so is the point of this note.
+ * It was that `vat validate` / `vat verify` / `vat build` enumerated nothing in
+ * their own process — each `spawnSync`ed the vat binary once per phase, so a
+ * flag parsed in the parent never reached the process doing the parsing, while
+ * `process.env` crossed the boundary for free. Phases run in this process now,
+ * so that argument no longer holds.
+ *
+ * What still holds is narrower but sufficient: the flag has to reach code that
+ * no CLI option is threaded through. `ParseCache` is constructed deep inside
+ * `@vibe-agent-toolkit/resources`, by callers several layers below any command,
+ * and `bin.ts` leans on the same mechanism for `VAT_CONTEXT` /
+ * `VAT_CONTEXT_PATH`. Plumbing a `noCache` parameter down every one of those
+ * call chains is the alternative, and it is a real one — this is now a choice
+ * rather than a necessity, so treat it as revisitable rather than as settled.
+ *
+ * `VAT_CACHE=0` is read by `ParseCache` (packages/resources/src/parse-cache.ts)
+ * per construction, never at module load, so setting it from a `preAction` hook
+ * — after Commander has parsed, before any command body runs — is observed by
+ * every phase, all of which now start after that hook has run.
+ *
+ * ## The collision with `vat resources validate --no-cache`
+ *
+ * This root program does NOT use `enablePositionalOptions()`, so Commander scans
+ * the WHOLE argv for root options, including everything after the subcommand
+ * name. That is the same mechanism that let a root `-v` shadow the subcommands'
+ * own `-v, --verbose` (see the incident recorded in `bin.ts`). Measured against
+ * commander 12: `vat resources validate docs --no-cache` leaves the ROOT with
+ * `cache: false` and the SUBCOMMAND with `cache: true` — the subcommand's
+ * identically-named flag is swallowed before it ever sees it, which would have
+ * silently re-enabled the external-URL cache the flag exists to bypass.
+ *
+ * Rather than break a shipped flag, the hook hands the value back down to
+ * whichever action command declares a `cache` option of its own. `--no-cache` is
+ * a superset — every cache off — so the handoff is a strengthening, never a
+ * reversal.
+ *
+ * @param program - The root program to register the flag and hook on
+ */
+export function registerCacheControl(program) {
+    program.option('--no-cache', "Disable VAT's disk caches for this run (every phase included)");
+    program.hook('preAction', (_thisCommand, actionCommand) => {
+        applyCacheControl(program.opts(), actionCommand);
+    });
+}
+/**
+ * Apply the root `--no-cache` decision: export it to child processes, and hand
+ * it down to an action command that declares its own `cache` option.
+ *
+ * Exported so a test can drive it from real parsed options rather than from a
+ * hand-built bag. Deliberately does nothing when the flag was not passed — a
+ * toggle that writes `VAT_CACHE=1` by default would be indistinguishable from
+ * one that is always on.
+ *
+ * @param rootOptions - Options bag from the ROOT program
+ * @param actionCommand - The command whose action is about to run
+ */
+export function applyCacheControl(rootOptions, actionCommand) {
+    if (rootOptions.cache !== false)
+        return;
+    process.env['VAT_CACHE'] = '0';
+    // `attributeName()`, not `name()`: for `--no-cache` the latter returns
+    // 'no-cache', so a check written against it never matches and the handoff
+    // above becomes a no-op that looks like it works.
+    if (actionCommand.options.some((option) => option.attributeName() === 'cache')) {
+        actionCommand.setOptionValue('cache', false);
+    }
+}
+//# sourceMappingURL=cache-control.js.map

package/dist/commands/cache/cache-control.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cache-control.js","sourceRoot":"","sources":["../../../src/commands/cache/cache-control.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAeH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAgB;IACnD,OAAO,CAAC,MAAM,CAAC,YAAY,EAAE,+DAA+D,CAAC,CAAC;IAE9F,OAAO,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,YAAY,EAAE,aAAa,EAAE,EAAE;QACxD,iBAAiB,CAAC,OAAO,CAAC,IAAI,EAAuB,EAAE,aAAa,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;AACL,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,iBAAiB,CAAC,WAAgC,EAAE,aAAsB;IACxF,IAAI,WAAW,CAAC,KAAK,KAAK,KAAK;QAAE,OAAO;IAExC,OAAO,CAAC,GAAG,CAAC,WAAW,CAAC,GAAG,GAAG,CAAC;IAE/B,uEAAuE;IACvE,0EAA0E;IAC1E,kDAAkD;IAClD,IAAI,aAAa,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,MAAM,EAAE,EAAE,CAAC,MAAM,CAAC,aAAa,EAAE,KAAK,OAAO,CAAC,EAAE,CAAC;QAC/E,aAAa,CAAC,cAAc,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC;IAC/C,CAAC;AACH,CAAC"}

package/dist/commands/cache/clear.d.ts

@@ -0,0 +1,105 @@
+/**
+ * `vat cache clear` — delete VAT's shared temp-directory cache tree.
+ *
+ * "Recovery is rescan" was true but had no user-invocable form: a corrupt or
+ * merely stale cache could only be cleared by hand-deleting a path the docs
+ * described in prose. This is that path, named once.
+ *
+ * Scope is the WHOLE `<tmpdir>/.vat-cache/` tree, not just the parse tenant.
+ * That directory is shared — `external-links.json`, `auth-<user>/`, `parse/` and
+ * `<namespace>/projection-<shapeDigest>/projection.db` all live under it — and
+ * "clear the cache" cannot honestly mean "clear one of the four". All of them
+ * are disposable by construction.
+ *
+ * 🔑 **The projection store is the one that makes this command matter, and it is
+ * covered by SCOPE rather than by a clause about it.** `defaultStoreDirectory()`
+ * resolves through `vatCacheNamespaceRoot()`, so it is already inside the tree
+ * this removes; the tenant list above is the only thing that has to keep up. It
+ * is also by far the largest tenant (71 MB for one 12,602-file tree) and is on
+ * by DEFAULT, which is why reclaiming it had to be invocable before the flip.
+ *
+ * ⚠️ A store relocated with `VAT_PROJECTION_STORE_DIR` is outside this tree and
+ * is NOT removed — the variable names a directory this command was never told
+ * about, and a clear that hunted for stores by shape would delete directories
+ * the operator chose. Stated so nobody reads a clean `bytesRemoved` as "every
+ * store is gone".
+ */
+export interface CacheClearOptions {
+    debug?: boolean;
+}
+/**
+ * What a clear did, as published on stdout.
+ *
+ * `partial` is not a failure mode bolted on — it is the *common* outcome when
+ * something else on the machine is writing to the shared tree, and it has to be
+ * reportable. A recursive delete that gives up part-way has already removed most
+ * of the cache; surfacing that as a bare thrown error told the operator only
+ * that the command failed, while leaving them to guess how much of their cache
+ * still existed. An honest count of what went and what stayed is the whole
+ * point of a report.
+ */
+export interface CacheClearReport {
+    status: 'success' | 'partial';
+    cacheDir: string;
+    existed: boolean;
+    /** Top-level entries that are gone, sorted. Empty when nothing was there. */
+    removed: string[];
+    /** Top-level entries that survived a partial clear, sorted. Absent on success. */
+    remaining?: string[];
+    /** Why the delete stopped short. Absent on success. */
+    reason?: string;
+    entriesRemoved: number;
+    bytesRemoved: number;
+}
+/**
+ * The shared cache root, `<tmpdir>/.vat-cache`.
+ *
+ * Derived from `parseCacheDirectory()` rather than re-joining `normalizedTmpdir()`
+ * with a third copy of the `.vat-cache` literal — one authority for where the
+ * tree lives, and the CLI stays out of the path-resolution business.
+ *
+ * The name check is not decoration: this function's return value is handed
+ * straight to a recursive delete, so if `parseCacheDirectory()` ever stopped
+ * carrying a `parse/` leaf, the naive parent would be the system temp directory
+ * itself. Refusing an unexpected shape turns that into an error instead of an
+ * `rm -rf /tmp`.
+ *
+ * ⚠ `@vibe-agent-toolkit/resources` now also exports a `vatCacheRoot()`, and
+ * `parseCacheDirectory()` is built from it — so on paper this derivation is a
+ * round trip. It is kept deliberately: the guard's job is to notice if that
+ * relationship ever changes, and importing the root directly would retire the
+ * only check standing between a shape change and a recursive delete of
+ * `<tmpdir>` itself. Deriving-then-verifying is the point.
+ *
+ * ✅ **It has now earned that keep.** When the cache gained a per-build
+ * namespace, the layout went from `.vat-cache/parse` to
+ * `.vat-cache/<namespace>/parse` and the old single-`dirname` derivation
+ * started returning `.vat-cache/<namespace>`. The name check turned a silent
+ * change of delete target into a loud refusal. Anyone tempted to simplify this
+ * into an import should read that sentence twice.
+ *
+ * @returns Absolute path to the cache root
+ * @throws {Error} If the derived ancestor is not named `.vat-cache`
+ */
+export declare function vatCacheRoot(): string;
+/**
+ * Measure, then delete, an entire cache tree.
+ *
+ * Measured BEFORE the delete, because afterwards there is nothing left to count
+ * and a report of "removed: unknown" would make the command unverifiable.
+ *
+ * Deliberately reads no environment: `vat cache clear` runs whether or not
+ * caching is enabled for this process. A `VAT_CACHE=0` that also disarmed the
+ * cleanup would leave an operator with a cache they can neither use nor remove.
+ *
+ * @param cacheDir - Directory to remove, in full
+ * @returns What was removed
+ */
+export declare function clearCacheDirectory(cacheDir: string): Promise<CacheClearReport>;
+/**
+ * Command entry point: clear the real cache root and publish the report.
+ *
+ * @param options - Command options (only `--debug`, inherited from the root)
+ */
+export declare function cacheClearCommand(options?: CacheClearOptions): Promise<void>;
+//# sourceMappingURL=clear.d.ts.map

package/dist/commands/cache/clear.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear.d.ts","sourceRoot":"","sources":["../../../src/commands/cache/clear.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAgBH,MAAM,WAAW,iBAAiB;IAChC,KAAK,CAAC,EAAE,OAAO,CAAC;CACjB;AAED;;;;;;;;;;GAUG;AACH,MAAM,WAAW,gBAAgB;IAC/B,MAAM,EAAE,SAAS,GAAG,SAAS,CAAC;IAC9B,QAAQ,EAAE,MAAM,CAAC;IACjB,OAAO,EAAE,OAAO,CAAC;IACjB,6EAA6E;IAC7E,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,kFAAkF;IAClF,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,uDAAuD;IACvD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,cAAc,EAAE,MAAM,CAAC;IACvB,YAAY,EAAE,MAAM,CAAC;CACtB;AA4BD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,wBAAgB,YAAY,IAAI,MAAM,CAcrC;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAwBrF;AA+CD;;;;GAIG;AACH,wBAAsB,iBAAiB,CAAC,OAAO,GAAE,iBAAsB,GAAG,OAAO,CAAC,IAAI,CAAC,CAiBtF"}

package/dist/commands/cache/clear.js

@@ -0,0 +1,248 @@
+/**
+ * `vat cache clear` — delete VAT's shared temp-directory cache tree.
+ *
+ * "Recovery is rescan" was true but had no user-invocable form: a corrupt or
+ * merely stale cache could only be cleared by hand-deleting a path the docs
+ * described in prose. This is that path, named once.
+ *
+ * Scope is the WHOLE `<tmpdir>/.vat-cache/` tree, not just the parse tenant.
+ * That directory is shared — `external-links.json`, `auth-<user>/`, `parse/` and
+ * `<namespace>/projection-<shapeDigest>/projection.db` all live under it — and
+ * "clear the cache" cannot honestly mean "clear one of the four". All of them
+ * are disposable by construction.
+ *
+ * 🔑 **The projection store is the one that makes this command matter, and it is
+ * covered by SCOPE rather than by a clause about it.** `defaultStoreDirectory()`
+ * resolves through `vatCacheNamespaceRoot()`, so it is already inside the tree
+ * this removes; the tenant list above is the only thing that has to keep up. It
+ * is also by far the largest tenant (71 MB for one 12,602-file tree) and is on
+ * by DEFAULT, which is why reclaiming it had to be invocable before the flip.
+ *
+ * ⚠️ A store relocated with `VAT_PROJECTION_STORE_DIR` is outside this tree and
+ * is NOT removed — the variable names a directory this command was never told
+ * about, and a clear that hunted for stores by shape would delete directories
+ * the operator chose. Stated so nobody reads a clean `bytesRemoved` as "every
+ * store is gone".
+ */
+import { promises as fs } from 'node:fs';
+import { basename, dirname } from 'node:path';
+import { parseCacheDirectory } from '@vibe-agent-toolkit/resources';
+import { ExitCode } from '@vibe-agent-toolkit/schema';
+import { direntKind, isPathAbsentError, safePath } from '@vibe-agent-toolkit/utils';
+import { handleCommandError } from '../../utils/command-error.js';
+import { createLogger } from '../../utils/logger.js';
+import { writeYamlOutput } from '../../utils/output.js';
+/** The one name the shared cache root is allowed to have. See {@link vatCacheRoot}. */
+const VAT_CACHE_DIR_NAME = '.vat-cache';
+const EMPTY_USAGE = { entries: 0, bytes: 0 };
+/**
+ * Retry budget for the recursive delete.
+ *
+ * Not defensive padding — observed. `<tmpdir>/.vat-cache` is shared by every VAT
+ * on the machine: other worktrees, other sessions, and any adopter running an
+ * *installed* vat all write into it under their own namespace. A `vat cache
+ * clear` issued while one of them is mid-run walks a tree that is growing
+ * underneath it and `rmdir` fails `ENOTEMPTY` on a shard that gained a file
+ * between the listing and the removal. Reproduced twice against a concurrent
+ * `vat verify`; the same command succeeded immediately once that run finished.
+ *
+ * Node retries exactly this error class (`EBUSY`, `EMFILE`, `ENFILE`,
+ * `ENOTEMPTY`, `EPERM`) with a linear backoff, which clears a short overlap.
+ * It cannot win against a writer that keeps going for the whole window — that
+ * case still surfaces as an error, which is correct: "some of your cache is
+ * gone and something is still writing" must not be reported as success.
+ */
+const RM_RETRY = { maxRetries: 5, retryDelay: 100 };
+/**
+ * The shared cache root, `<tmpdir>/.vat-cache`.
+ *
+ * Derived from `parseCacheDirectory()` rather than re-joining `normalizedTmpdir()`
+ * with a third copy of the `.vat-cache` literal — one authority for where the
+ * tree lives, and the CLI stays out of the path-resolution business.
+ *
+ * The name check is not decoration: this function's return value is handed
+ * straight to a recursive delete, so if `parseCacheDirectory()` ever stopped
+ * carrying a `parse/` leaf, the naive parent would be the system temp directory
+ * itself. Refusing an unexpected shape turns that into an error instead of an
+ * `rm -rf /tmp`.
+ *
+ * ⚠ `@vibe-agent-toolkit/resources` now also exports a `vatCacheRoot()`, and
+ * `parseCacheDirectory()` is built from it — so on paper this derivation is a
+ * round trip. It is kept deliberately: the guard's job is to notice if that
+ * relationship ever changes, and importing the root directly would retire the
+ * only check standing between a shape change and a recursive delete of
+ * `<tmpdir>` itself. Deriving-then-verifying is the point.
+ *
+ * ✅ **It has now earned that keep.** When the cache gained a per-build
+ * namespace, the layout went from `.vat-cache/parse` to
+ * `.vat-cache/<namespace>/parse` and the old single-`dirname` derivation
+ * started returning `.vat-cache/<namespace>`. The name check turned a silent
+ * change of delete target into a loud refusal. Anyone tempted to simplify this
+ * into an import should read that sentence twice.
+ *
+ * @returns Absolute path to the cache root
+ * @throws {Error} If the derived ancestor is not named `.vat-cache`
+ */
+export function vatCacheRoot() {
+    const parseDir = parseCacheDirectory();
+    // Up two: `<root>/<namespace>/parse` → `<root>`. The namespace level is what
+    // makes this two rather than one; see the note above about why it is still
+    // derived and verified rather than imported.
+    const root = dirname(dirname(parseDir));
+    if (basename(root) !== VAT_CACHE_DIR_NAME) {
+        throw new Error(`Refusing to clear ${root}: expected a directory named ${VAT_CACHE_DIR_NAME} (derived from ${parseDir}).`);
+    }
+    return root;
+}
+/**
+ * Measure, then delete, an entire cache tree.
+ *
+ * Measured BEFORE the delete, because afterwards there is nothing left to count
+ * and a report of "removed: unknown" would make the command unverifiable.
+ *
+ * Deliberately reads no environment: `vat cache clear` runs whether or not
+ * caching is enabled for this process. A `VAT_CACHE=0` that also disarmed the
+ * cleanup would leave an operator with a cache they can neither use nor remove.
+ *
+ * @param cacheDir - Directory to remove, in full
+ * @returns What was removed
+ */
+export async function clearCacheDirectory(cacheDir) {
+    const entries = await readdirOrNull(cacheDir);
+    if (entries === null) {
+        return { status: 'success', cacheDir, existed: false, removed: [], entriesRemoved: 0, bytesRemoved: 0 };
+    }
+    const usage = await measureEntries(cacheDir, entries);
+    const names = entries.map((entry) => entry.name);
+    try {
+        await fs.rm(cacheDir, { recursive: true, force: true, ...RM_RETRY });
+    }
+    catch (error) {
+        return partialReport(cacheDir, names, usage, error);
+    }
+    return {
+        status: 'success',
+        cacheDir,
+        existed: true,
+        removed: sorted(names),
+        entriesRemoved: usage.entries,
+        bytesRemoved: usage.bytes,
+    };
+}
+/**
+ * Describe a delete that stopped part-way, by re-reading the tree.
+ *
+ * The survivors are read back off disk rather than inferred from the error,
+ * because the error names one path and says nothing about the other ninety-nine
+ * percent. Re-measuring what remains and subtracting is the only way the counts
+ * describe what actually happened rather than what was attempted.
+ *
+ * A concurrent writer can make the remainder *larger* than the original
+ * measurement, so the subtraction is floored at zero: reporting a negative
+ * number of removed bytes would be worse than reporting none.
+ *
+ * @param cacheDir - The tree that was being removed
+ * @param names - Top-level entry names as they were before the delete
+ * @param before - Usage measured before the delete
+ * @param error - Whatever `fs.rm` threw
+ * @returns A report naming what went, what stayed, and why
+ */
+async function partialReport(cacheDir, names, before, error) {
+    const survivors = (await readdirOrNull(cacheDir)) ?? [];
+    const remaining = new Set(survivors.map((entry) => entry.name));
+    const after = await measureEntries(cacheDir, survivors);
+    return {
+        status: 'partial',
+        cacheDir,
+        existed: true,
+        removed: sorted(names.filter((name) => !remaining.has(name))),
+        remaining: sorted([...remaining]),
+        reason: error instanceof Error ? error.message : String(error),
+        entriesRemoved: Math.max(0, before.entries - after.entries),
+        bytesRemoved: Math.max(0, before.bytes - after.bytes),
+    };
+}
+/** Stable ordering for the reported entry lists. */
+function sorted(names) {
+    return [...names].sort((left, right) => left.localeCompare(right));
+}
+/**
+ * Command entry point: clear the real cache root and publish the report.
+ *
+ * @param options - Command options (only `--debug`, inherited from the root)
+ */
+export async function cacheClearCommand(options = {}) {
+    const startTime = Date.now();
+    const logger = createLogger(options.debug ? { debug: true } : {});
+    try {
+        const report = await clearCacheDirectory(vatCacheRoot());
+        logger.debug(`Cleared ${String(report.entriesRemoved)} cache entries from ${report.cacheDir}`);
+        writeYamlOutput(report);
+        // A partial clear publishes its report and *then* fails. Exiting through
+        // `handleCommandError` instead would suppress the report entirely, which is
+        // the defect this branch exists to fix: the operator most needs to know how
+        // much of the cache survived precisely when the command did not finish.
+        // A partial clear is a run that did not finish, not a finding about the tree.
+        process.exit(report.status === 'partial' ? ExitCode.ERROR : ExitCode.OK);
+    }
+    catch (error) {
+        handleCommandError(error, logger, startTime, 'CacheClear');
+    }
+}
+/**
+ * `readdir` that reports a missing directory as `null` rather than throwing.
+ *
+ * Only ENOENT is absorbed. EACCES on a directory that exists is a genuine
+ * failure — reporting it as "nothing to clear" would tell the operator their
+ * cache is gone when it is still on disk.
+ */
+async function readdirOrNull(dir) {
+    try {
+        return await fs.readdir(dir, { withFileTypes: true });
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return null;
+        throw error;
+    }
+}
+/** Sum file count and bytes over already-listed directory entries. */
+async function measureEntries(dir, entries) {
+    const usages = await Promise.all(entries.map(async (entry) => {
+        const child = safePath.join(dir, entry.name);
+        // Not `isFile()`, and NOT followed: a symlink or socket is still an entry
+        // that is about to be removed, and counting only regular files would
+        // under-report it — while walking INTO a linked directory would count a
+        // tree `rm -rf` leaves untouched.
+        return direntKind(entry) === 'directory' ? measureTree(child) : { entries: 1, bytes: await sizeOf(child) };
+    }));
+    return usages.reduce((total, usage) => ({ entries: total.entries + usage.entries, bytes: total.bytes + usage.bytes }), EMPTY_USAGE);
+}
+/** Recursive measure. A directory that vanished mid-walk contributes nothing. */
+async function measureTree(dir) {
+    const entries = await readdirOrNull(dir);
+    return entries === null ? EMPTY_USAGE : measureEntries(dir, entries);
+}
+/**
+ * Size of one entry, without following symlinks.
+ *
+ * A file that disappears between the listing and the stat contributes 0 rather
+ * than failing the clear — the whole tree is about to be deleted anyway, and a
+ * concurrent vat run pruning its own temp file must not turn cleanup into an
+ * error. Only a DISAPPEARANCE is 0: an entry the OS refuses to stat is still
+ * there, still about to be counted as reclaimed, and the `rm` that follows is
+ * about to meet the same refusal — so it is raised here, where it names the
+ * entry, rather than read as an empty file.
+ */
+async function sizeOf(target) {
+    try {
+        const stats = await fs.lstat(target);
+        return stats.size;
+    }
+    catch (error) {
+        if (isPathAbsentError(error))
+            return 0;
+        throw error;
+    }
+}
+//# sourceMappingURL=clear.js.map

package/dist/commands/cache/clear.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"clear.js","sourceRoot":"","sources":["../../../src/commands/cache/clear.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,EAAe,QAAQ,IAAI,EAAE,EAAE,MAAM,SAAS,CAAC;AACtD,OAAO,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAE9C,OAAO,EAAE,mBAAmB,EAAE,MAAM,+BAA+B,CAAC;AACpE,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACtD,OAAO,EAAE,UAAU,EAAE,iBAAiB,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAEpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,8BAA8B,CAAC;AAClE,OAAO,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAC;AACrD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC;AAExD,uFAAuF;AACvF,MAAM,kBAAkB,GAAG,YAAY,CAAC;AAoCxC,MAAM,WAAW,GAAc,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,CAAC;AAExD;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,QAAQ,GAA+C,EAAE,UAAU,EAAE,CAAC,EAAE,UAAU,EAAE,GAAG,EAAE,CAAC;AAEhG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,MAAM,UAAU,YAAY;IAC1B,MAAM,QAAQ,GAAG,mBAAmB,EAAE,CAAC;IACvC,6EAA6E;IAC7E,2EAA2E;IAC3E,6CAA6C;IAC7C,MAAM,IAAI,GAAG,OAAO,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC,CAAC;IAExC,IAAI,QAAQ,CAAC,IAAI,CAAC,KAAK,kBAAkB,EAAE,CAAC;QAC1C,MAAM,IAAI,KAAK,CACb,qBAAqB,IAAI,gCAAgC,kBAAkB,kBAAkB,QAAQ,IAAI,CAC1G,CAAC;IACJ,CAAC;IAED,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,QAAgB;IACxD,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,QAAQ,CAAC,CAAC;IAE9C,IAAI,OAAO,KAAK,IAAI,EAAE,CAAC;QACrB,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,EAAE,EAAE,cAAc,EAAE,CAAC,EAAE,YAAY,EAAE,CAAC,EAAE,CAAC;IAC1G,CAAC;IAED,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,QAAQ,EAAE,OAAO,CAAC,CAAC;IACtD,MAAM,KAAK,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;IAEjD,IAAI,CAAC;QACH,MAAM,EAAE,CAAC,EAAE,CAAC,QAAQ,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,KAAK,EAAE,IAAI,EAAE,GAAG,QAAQ,EAAE,CAAC,CAAC;IACvE,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,aAAa,CAAC,QAAQ,EAAE,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,CAAC;IACtD,CAAC;IAED,OAAO;QACL,MAAM,EAAE,SAAS;QACjB,QAAQ;QACR,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC;QACtB,cAAc,EAAE,KAAK,CAAC,OAAO;QAC7B,YAAY,EAAE,KAAK,CAAC,KAAK;KAC1B,CAAC;AACJ,CAAC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,KAAK,UAAU,aAAa,CAC1B,QAAgB,EAChB,KAAe,EACf,MAAiB,EACjB,KAAc;IAEd,MAAM,SAAS,GAAG,CAAC,MAAM,aAAa,CAAC,QAAQ,CAAC,CAAC,IAAI,EAAE,CAAC;IACxD,MAAM,SAAS,GAAG,IAAI,GAAG,CAAC,SAAS,CAAC,GAAG,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAChE,MAAM,KAAK,GAAG,MAAM,cAAc,CAAC,QAAQ,EAAE,SAAS,CAAC,CAAC;IAExD,OAAO;QACL,MAAM,EAAE,SAAS;QACjB,QAAQ;QACR,OAAO,EAAE,IAAI;QACb,OAAO,EAAE,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;QAC7D,SAAS,EAAE,MAAM,CAAC,CAAC,GAAG,SAAS,CAAC,CAAC;QACjC,MAAM,EAAE,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,KAAK,CAAC;QAC9D,cAAc,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,CAAC;QAC3D,YAAY,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,MAAM,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC;KACtD,CAAC;AACJ,CAAC;AAED,oDAAoD;AACpD,SAAS,MAAM,CAAC,KAAwB;IACtC,OAAO,CAAC,GAAG,KAAK,CAAC,CAAC,IAAI,CAAC,CAAC,IAAI,EAAE,KAAK,EAAE,EAAE,CAAC,IAAI,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;AACrE,CAAC;AAED;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,UAA6B,EAAE;IACrE,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;IAC7B,MAAM,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,EAAE,IAAI,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC;IAElE,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,mBAAmB,CAAC,YAAY,EAAE,CAAC,CAAC;QACzD,MAAM,CAAC,KAAK,CAAC,WAAW,MAAM,CAAC,MAAM,CAAC,cAAc,CAAC,uBAAuB,MAAM,CAAC,QAAQ,EAAE,CAAC,CAAC;QAC/F,eAAe,CAAC,MAAM,CAAC,CAAC;QACxB,yEAAyE;QACzE,4EAA4E;QAC5E,4EAA4E;QAC5E,wEAAwE;QACxE,8EAA8E;QAC9E,OAAO,CAAC,IAAI,CAAC,MAAM,CAAC,MAAM,KAAK,SAAS,CAAC,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;IAC3E,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,kBAAkB,CAAC,KAAK,EAAE,MAAM,EAAE,SAAS,EAAE,YAAY,CAAC,CAAC;IAC7D,CAAC;AACH,CAAC;AAED;;;;;;GAMG;AACH,KAAK,UAAU,aAAa,CAAC,GAAW;IACtC,IAAI,CAAC;QACH,OAAO,MAAM,EAAE,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAC;IACxD,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAK,KAA+B,CAAC,IAAI,KAAK,QAAQ;YAAE,OAAO,IAAI,CAAC;QACpE,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC;AAED,sEAAsE;AACtE,KAAK,UAAU,cAAc,CAC3B,GAAW,EACX,OAAiB;IAEjB,MAAM,MAAM,GAAG,MAAM,OAAO,CAAC,GAAG,CAC9B,OAAO,CAAC,GAAG,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE;QAC1B,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;QAC7C,0EAA0E;QAC1E,qEAAqE;QACrE,wEAAwE;QACxE,kCAAkC;QAClC,OAAO,UAAU,CAAC,KAAK,CAAC,KAAK,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,KAAK,EAAE,MAAM,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC;IAC7G,CAAC,CAAC,CACH,CAAC;IAEF,OAAO,MAAM,CAAC,MAAM,CAClB,CAAC,KAAK,EAAE,KAAK,EAAE,EAAE,CAAC,CAAC,EAAE,OAAO,EAAE,KAAK,CAAC,OAAO,GAAG,KAAK,CAAC,OAAO,EAAE,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC,EAChG,WAAW,CACZ,CAAC;AACJ,CAAC;AAED,iFAAiF;AACjF,KAAK,UAAU,WAAW,CAAC,GAAW;IACpC,MAAM,OAAO,GAAG,MAAM,aAAa,CAAC,GAAG,CAAC,CAAC;IACzC,OAAO,OAAO,KAAK,IAAI,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,cAAc,CAAC,GAAG,EAAE,OAAO,CAAC,CAAC;AACvE,CAAC;AAED;;;;;;;;;;GAUG;AACH,KAAK,UAAU,MAAM,CAAC,MAAc;IAClC,IAAI,CAAC;QACH,MAAM,KAAK,GAAG,MAAM,EAAE,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACrC,OAAO,KAAK,CAAC,IAAI,CAAC;IACpB,CAAC;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,IAAI,iBAAiB,CAAC,KAAK,CAAC;YAAE,OAAO,CAAC,CAAC;QACvC,MAAM,KAAK,CAAC;IACd,CAAC;AACH,CAAC"}

package/dist/commands/cache/index.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Cache command group.
+ *
+ * The paired `--no-cache` control surface lives in `./cache-control.js`:
+ * `--no-cache` decides whether this run *writes* to the caches, `vat cache
+ * clear` decides whether the caches *survive*. They are separate modules only
+ * because `bin.ts` registers the flag on every invocation and must not pay for
+ * this command's imports to do it.
+ *
+ * ⛔ Do NOT re-export `cache-control.js` from here for convenience. Importing it
+ * through this module pulls `./clear.js` and the whole resources package behind
+ * it — the exact ~1.2s that splitting the file removed — so a re-export leaves
+ * the expensive path one identical-looking import away, with nothing pinning
+ * the cheap one. Import from `./cache-control.js` directly.
+ */
+import { Command } from 'commander';
+export declare function createCacheCommand(): Command;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/cache/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/commands/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAKpC,wBAAgB,kBAAkB,IAAI,OAAO,CAoF5C"}

package/dist/commands/cache/index.js

@@ -0,0 +1,94 @@
+/**
+ * Cache command group.
+ *
+ * The paired `--no-cache` control surface lives in `./cache-control.js`:
+ * `--no-cache` decides whether this run *writes* to the caches, `vat cache
+ * clear` decides whether the caches *survive*. They are separate modules only
+ * because `bin.ts` registers the flag on every invocation and must not pay for
+ * this command's imports to do it.
+ *
+ * ⛔ Do NOT re-export `cache-control.js` from here for convenience. Importing it
+ * through this module pulls `./clear.js` and the whole resources package behind
+ * it — the exact ~1.2s that splitting the file removed — so a re-export leaves
+ * the expensive path one identical-looking import away, with nothing pinning
+ * the cheap one. Import from `./cache-control.js` directly.
+ */
+import { Command } from 'commander';
+import { cacheClearCommand } from './clear.js';
+export function createCacheCommand() {
+    const cache = new Command('cache');
+    cache
+        .description("Manage VAT's shared on-disk caches in the system temp directory")
+        .helpCommand(false)
+        .addHelpText('after', `
+Description:
+  VAT keeps four disposable caches under <tmpdir>/.vat-cache: parse facts
+  keyed by file content, external-URL validation results, per-OS-user
+  authenticated-link content, and the projection store — a SQLite database
+  holding one whole scanned tree per entry, on by default, and by far the
+  largest of the four. None of them is durable — recovery is always "rescan".
+
+  How large: one 12,602-file repository measured 71 MB of projection store,
+  and the file holds several trees per repository plus a shared blob tier, so
+  a machine that has scanned a few projects reaches the hundreds of MB. The
+  other three tenants are a few MB between them.
+
+  Only the projection store evicts anything on its own: it keeps the three
+  most recently written trees per root and the 50,000 most recently written
+  content keys, dropping the rest as it writes. The other three rely on the OS
+  temp purge, and every one of them is reclaimed in full by vat cache clear.
+
+  To run WITHOUT the caches rather than remove them, use --no-cache on any
+  command (or VAT_CACHE=0), which also applies to spawned phases and to the
+  projection store. VAT_PROJECTION_STORE=off turns off just the store.
+
+Example:
+  $ vat cache clear                    # Reclaim the temp-directory cache tree
+`);
+    cache
+        .command('clear')
+        .description('Delete the whole VAT cache tree from the system temp directory')
+        .action(async function () {
+        await cacheClearCommand(this.optsWithGlobals());
+    })
+        .addHelpText('after', `
+Description:
+  Removes <tmpdir>/.vat-cache in its entirety — the parse cache, the
+  external-URL validation cache, the per-OS-user authenticated-link cache, and
+  the projection store (<namespace>/projection-<shape>/projection.db), which is
+  usually most of the bytes this reclaims: 71 MB for a single 12,602-file
+  repository, and the hundreds of MB once a machine has scanned several. Every
+  one of them is disposable by design: the next run repopulates what it needs,
+  so the only cost of clearing is one cold pass.
+
+  A projection store relocated with VAT_PROJECTION_STORE_DIR lives outside
+  this tree and is not removed — delete that directory yourself.
+
+  Runs regardless of --no-cache / VAT_CACHE=0. Turning caching off must not
+  disarm the one command that reclaims the space.
+
+  A cache directory that does not exist is not an error — nothing to remove is
+  a successful clear.
+
+  The tree is shared by every VAT on the machine, so another run writing into
+  it can make the delete stop part-way. That is reported as status: partial,
+  naming what went and what stayed, rather than failing with no account of it.
+
+Output:
+  - cacheDir: absolute path that was targeted
+  - existed: whether the directory was there at all
+  - removed: top-level entries that are now gone
+  - remaining / reason: what survived a partial clear, and why (partial only)
+  - entriesRemoved / bytesRemoved: file count and total size actually removed
+
+Exit Codes:
+  0 - Cache cleared (or already absent)
+  1 - Cleared only in part, because something else is using the tree
+  2 - Could not read or target the cache at all (permissions, unexpected layout)
+
+Example:
+  $ vat cache clear                    # Reclaim the temp-directory cache tree
+`);
+    return cache;
+}
+//# sourceMappingURL=index.js.map

package/dist/commands/cache/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/commands/cache/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,iBAAiB,EAA0B,MAAM,YAAY,CAAC;AAGvE,MAAM,UAAU,kBAAkB;IAChC,MAAM,KAAK,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEnC,KAAK;SACF,WAAW,CAAC,iEAAiE,CAAC;SAC9E,WAAW,CAAC,KAAK,CAAC;SAClB,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;;;;;;CAwBL,CACI,CAAC;IAEJ,KAAK;SACF,OAAO,CAAC,OAAO,CAAC;SAChB,WAAW,CAAC,gEAAgE,CAAC;SAC7E,MAAM,CAAC,KAAK;QACX,MAAM,iBAAiB,CAAC,IAAI,CAAC,eAAe,EAAuB,CAAC,CAAC;IACvE,CAAC,CAAC;SACD,WAAW,CACV,OAAO,EACP;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAqCL,CACI,CAAC;IAEJ,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/commands/claude/claude-config.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"claude-config.d.ts","sourceRoot":"","sources":["../../../src/commands/claude/claude-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAGnF,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;CACxC,CAAC,CAWD"}
+{"version":3,"file":"claude-config.d.ts","sourceRoot":"","sources":["../../../src/commands/claude/claude-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAIH,OAAO,EAAmB,KAAK,YAAY,EAAE,MAAM,+BAA+B,CAAC;AAGnF,MAAM,WAAW,kBAAkB;IACjC,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,CAAC;CAC5B;AAED;;;;GAIG;AACH,wBAAsB,uBAAuB,IAAI,OAAO,CAAC;IACvD,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;IAClB,YAAY,EAAE,YAAY,GAAG,SAAS,CAAC;CACxC,CAAC,CAiBD"}

package/dist/commands/claude/claude-config.js

@@ -15,6 +15,12 @@ export async function loadClaudeProjectConfig() {
     if (!configPath) {
         throw new Error('No vibe-agent-toolkit.config.yaml found. Run from a project directory.');
     }
+    // No `onUnknownKeys` argument: `parseConfigFile` already DEFAULTS to writing
+    // the warning to stderr, which is exactly what this lane needs — unknown keys
+    // are a warning rather than a refusal, and stderr keeps the YAML document on
+    // stdout machine-readable. Passing a callback byte-identical to the default
+    // said "this command has an opinion here" while changing nothing, so a later
+    // reader would have to diff it against the default to learn it was dead.
     const config = await parseConfigFile(configPath);
     const configDir = dirname(configPath);
     return { configPath, configDir, claudeConfig: config.claude };

package/dist/commands/claude/claude-config.js.map

@@ -1 +1 @@
-{"version":3,"file":"claude-config.js","sourceRoot":"","sources":["../../../src/commands/claude/claude-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAqB,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAQ3D;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB;IAK3C,+EAA+E;IAC/E,MAAM,UAAU,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACjD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;IAC5F,CAAC;IAED,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,UAAU,CAAC,CAAC;IACjD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAEtC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;AAChE,CAAC"}
+{"version":3,"file":"claude-config.js","sourceRoot":"","sources":["../../../src/commands/claude/claude-config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAEpC,OAAO,EAAE,eAAe,EAAqB,MAAM,+BAA+B,CAAC;AACnF,OAAO,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAC;AAQ3D;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,uBAAuB;IAK3C,+EAA+E;IAC/E,MAAM,UAAU,GAAG,cAAc,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC;IACjD,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,MAAM,IAAI,KAAK,CAAC,wEAAwE,CAAC,CAAC;IAC5F,CAAC;IAED,6EAA6E;IAC7E,8EAA8E;IAC9E,6EAA6E;IAC7E,4EAA4E;IAC5E,6EAA6E;IAC7E,yEAAyE;IACzE,MAAM,MAAM,GAAG,MAAM,eAAe,CAAC,UAAU,CAAC,CAAC;IACjD,MAAM,SAAS,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC;IAEtC,OAAO,EAAE,UAAU,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,CAAC;AAChE,CAAC"}