@cardanvil/frame-kit 0.4.0 → 0.6.0

package/README.md

@@ -129,6 +129,51 @@ Packaging needs Vite — it is what turns `import w from "./w.png"` into a file
 so it is an **optional** peer dependency, loaded only when packaging runs. The
 schemas above work under plain Node and in a browser without it.
 
+### `frame-kit studio`
+
+```bash
+frame-kit studio [--root <dir>] [--port <n>] [--frame <slug>] [--no-write]
+```
+
+A visual box editor, served from `dist/studio` and opened at
+<http://localhost:4620>. It loads frames through the same Vite SSR loader
+`validate` uses, so what it draws is the validated frame, and it reloads when a
+source file changes.
+
+The card name and type line are previewed in Beleren at the authored size and
+flagged when they overflow — one line each, with no wrapping, symbols or
+auto-shrink, so the app remains the authority on a full render.
+
+Working on the studio's own UI: `--dev` serves it from source with hot
+reloading, on the same port as the API, so one command covers both. It needs
+the UI's source, which only exists inside the frames workspace.
+
+Dragging a box rewrites the literal it came from, in place — nothing is
+reprinted, so comments and formatting survive. Editing needs `typescript`
+installed (an optional peer); without it the studio still runs read-only. Values
+that are not written as literals are reported as such rather than edited.
+
+### `@cardanvil/frame-kit/layout`
+
+How a frame's art is chosen and placed, as pure functions:
+
+- `selectFrameLayers(details, options)` — the base frame and section overlays a
+  set of `FrameDetails` selects. Split out of Card Anvil's `getFrameLayers`, so
+  the studio and the renderer cannot drift on two-colour splits, hybrid halves
+  or the coloured-artifact fallback.
+- `frameDetailsFor(shape)` — those details from a plain description of a card
+  (colours plus artifact / vehicle / land / enchantment / hybrid / devoid),
+  for callers with no Scryfall card to parse.
+- `placeAsset(path, config)` — where a piece of art is drawn. Most frame art is
+  full-sheet and centres, but crowns, nicknames and PT plates come from the
+  layout's own render config; centring those puts a legendary crown in the
+  middle of the card.
+- `resolveFrameAsset` / `resolveBaseFrame` — exact per-family lookup, and the
+  base-frame fallback chain.
+
+Card Anvil still owns the other half — reading a Scryfall card into
+`FrameDetails` — because that is where the Scryfall types live.
+
 ## Type it, then validate it
 
 Typing a config as `Frame` is weaker than the schema a loading app enforces. The clearest example:

package/dist/cli/main.js

@@ -9,6 +9,7 @@ import { PackagingError } from "./errors.js";
 import { Reporter, inGitHubActions } from "./report.js";
 import { SCHEMA_NAMES, toJsonSchema } from "./schema.js";
 import { stableStringify } from "./stableJson.js";
+import { runStudio } from "./studio/serve.js";
 import { watchFrames } from "./watch.js";
 const USAGE = `frame-kit — package Card Anvil frames
 
@@ -17,6 +18,7 @@ Usage:
   frame-kit build --out <dir> [options]  check every frame, then pack each one
   frame-kit schema <name> [--out <file>] print a format as JSON Schema
                                          (${SCHEMA_NAMES.join(" | ")})
+  frame-kit studio [options]             open the visual box editor
   frame-kit --help
   frame-kit --version
 
@@ -35,6 +37,17 @@ build only:
                         in the index
   --watch               rebuild a frame whenever its source changes
 
+studio only:
+  --port <n>            port to serve on (default: 4620)
+  --host <h>            interface to bind (default: 127.0.0.1)
+  --open                open the studio in your browser
+  --dev                 serve the studio's own UI from source, with hot
+                        reloading (only inside the frames workspace)
+  --no-write            serve read-only; refuse every edit
+
+The studio edits the literals in your source when you drag a box, so run it on
+a clean working tree. It needs TypeScript installed to find them.
+
 A frame is any directory containing a frame.meta.json. One with "private": true
 is checked by validate but never built.
 `;
@@ -208,6 +221,9 @@ async function main(argv) {
     if (command === "schema") {
         return await runSchema(argv.slice(1));
     }
+    if (command === "studio") {
+        return await runStudio(argv.slice(1));
+    }
     if (command !== "validate" && command !== "build") {
         console.error(`Unknown command "${command}".\n\n${USAGE}`);
         return EXIT.usage;

package/dist/cli/sourceWatcher.d.ts

@@ -0,0 +1,40 @@
+/**
+ * How long to wait for changes to stop before reacting.
+ *
+ * One save can produce several events — a write, a rename, an attribute
+ * change — and a tool upstream may rewrite a whole directory.
+ */
+export declare const DEBOUNCE_MS = 200;
+/** Whether a path is build output, editor debris, or inside a skipped dir. */
+export declare function isIgnored(file: string): boolean;
+export interface SourceWatcherOptions {
+    /** Absolute path the watch is rooted at. Only used for error messages. */
+    root: string;
+    /** Directories to watch recursively. Overlapping entries are fine. */
+    dirs: readonly string[];
+    /**
+     * Called with each batch of changed paths, debounced and never overlapping.
+     *
+     * Anything that arrives while a call is in flight is queued and delivered in
+     * the next batch, so a slow handler cannot drop a change.
+     */
+    onChange: (changed: readonly string[]) => void | Promise<void>;
+    /** Ignored on top of the built-in list — a build's own output directory, say. */
+    ignore?: (file: string) => boolean;
+    /** Defaults to `DEBOUNCE_MS`. */
+    debounceMs?: number;
+    /** Where an unwatchable directory or a throwing handler is reported. */
+    onError?: (message: string) => void;
+}
+export interface SourceWatcher {
+    close: () => void;
+}
+/**
+ * Watches directories and delivers debounced, non-overlapping change batches.
+ *
+ * Shared by `frame-kit build --watch` and `frame-kit studio`, which need the
+ * same three things and get them wrong in the same three ways otherwise:
+ * coalescing a burst of events from one save, never running two handlers at
+ * once, and surviving a handler that throws.
+ */
+export declare function startSourceWatcher(options: SourceWatcherOptions): SourceWatcher;

package/dist/cli/sourceWatcher.js

@@ -0,0 +1,100 @@
+import { watch } from "node:fs";
+import path from "node:path";
+import { relativePosix } from "./discover.js";
+/** Directories never worth watching. Mirrors discovery's own skip list. */
+const SKIP_DIRS = new Set([
+    "node_modules",
+    "dist",
+    ".git",
+    ".pnpm-store",
+    "__fixtures__",
+]);
+/** Files a rebuild produces, or an editor leaves lying around. */
+const IGNORED_FILE = /(\.cardframe|frame-index\.json|\.preview\.[a-z]+|~|\.swp|\.tmp)$/i;
+/**
+ * How long to wait for changes to stop before reacting.
+ *
+ * One save can produce several events — a write, a rename, an attribute
+ * change — and a tool upstream may rewrite a whole directory.
+ */
+export const DEBOUNCE_MS = 200;
+/** Whether a path is build output, editor debris, or inside a skipped dir. */
+export function isIgnored(file) {
+    const segments = file.split(path.sep);
+    return (segments.some((segment) => SKIP_DIRS.has(segment) || segment.startsWith(".")) || IGNORED_FILE.test(file));
+}
+/**
+ * Watches directories and delivers debounced, non-overlapping change batches.
+ *
+ * Shared by `frame-kit build --watch` and `frame-kit studio`, which need the
+ * same three things and get them wrong in the same three ways otherwise:
+ * coalescing a burst of events from one save, never running two handlers at
+ * once, and surviving a handler that throws.
+ */
+export function startSourceWatcher(options) {
+    const { root, dirs, onChange, ignore, debounceMs = DEBOUNCE_MS, onError = (message) => {
+        console.error(message);
+    }, } = options;
+    const watchers = [];
+    const pending = new Set();
+    let timer;
+    let running = false;
+    async function drain() {
+        if (running) {
+            // Whatever arrived is already in `pending`, and the loop below picks it
+            // up when the in-flight handler finishes.
+            return;
+        }
+        running = true;
+        try {
+            // Keyed off `pending` rather than a flag: anything that arrived during a
+            // handler is still queued when it finishes.
+            while (pending.size > 0) {
+                const changed = [...pending];
+                pending.clear();
+                await onChange(changed);
+            }
+        }
+        catch (cause) {
+            // A failed handler must not end the session: the author is mid-edit and
+            // the next save is probably the fix.
+            onError(cause instanceof Error ? cause.message : String(cause));
+        }
+        finally {
+            running = false;
+        }
+    }
+    function onFileEvent(file) {
+        if (isIgnored(file) || ignore?.(file) === true) {
+            return;
+        }
+        pending.add(file);
+        if (timer) {
+            clearTimeout(timer);
+        }
+        timer = setTimeout(() => void drain(), debounceMs);
+    }
+    for (const dir of dirs) {
+        try {
+            watchers.push(watch(dir, { recursive: true }, (_event, name) => {
+                if (name !== null) {
+                    onFileEvent(path.join(dir, name));
+                }
+            }));
+        }
+        catch {
+            onError(`Could not watch ${relativePosix(root, dir)}. Recursive watching is ` +
+                `not supported on this filesystem.`);
+        }
+    }
+    return {
+        close() {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            for (const watcher of watchers) {
+                watcher.close();
+            }
+        },
+    };
+}

package/dist/cli/studio/boxSets.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What a `LayoutConfig` slot holds.
+ *
+ * `boxes` is the only kind the studio can edit geometry in; the other two are
+ * listed so the layer panel can offer them without hard-coding field names.
+ */
+export type SlotKind = "boxes" | "assets" | "masks" | "knobs";
+export interface LayoutSlot {
+    /** The `LayoutConfig` property, e.g. `sagaBackCreatureBoxes`. */
+    readonly key: string;
+    readonly kind: SlotKind;
+    /** False for every slot the contract marks optional. */
+    readonly required: boolean;
+}
+/**
+ * Every box / asset / mask / knob slot the frame contract defines, read off
+ * the schema rather than listed by hand.
+ *
+ * Identity is the test: a slot counts as boxes because its schema *is*
+ * `CardBoxesSchema`, not because its name ends in "Boxes". So a slot added to
+ * `LayoutConfigSchema` shows up here — and in the studio — with no change,
+ * and `boxSets.test.ts` fails if one is added that this cannot classify.
+ */
+export declare function layoutSlots(): LayoutSlot[];
+/** Just the slots holding `CardBoxes` — what the studio can edit. */
+export declare function boxSlots(): LayoutSlot[];
+/**
+ * Names of every member a `CardBoxes` can hold, in contract order.
+ *
+ * Used to enumerate a box set without assuming which optional members a given
+ * frame happens to define.
+ */
+export declare function cardBoxKeys(): string[];

package/dist/cli/studio/boxSets.js

@@ -0,0 +1,87 @@
+import { CardBoxesSchema, LayoutConfigSchema } from "../../schema/frame.js";
+import { FrameAssetsSchema, LayoutMasksSchema, } from "../../schema/frameAssets.js";
+/** Strips `.optional()` and friends to reach the schema that carries identity. */
+function unwrap(schema) {
+    let current = schema;
+    let wrapped = false;
+    for (;;) {
+        const node = current.def;
+        if (node.innerType === undefined ||
+            ![
+                "optional",
+                "nullable",
+                "default",
+                "prefault",
+                "readonly",
+                "nonoptional",
+            ].includes(node.type)) {
+            return { inner: current, wrapped };
+        }
+        current = node.innerType;
+        wrapped = true;
+    }
+}
+const KIND_BY_SCHEMA = new Map([
+    [CardBoxesSchema, "boxes"],
+    [FrameAssetsSchema, "assets"],
+    [LayoutMasksSchema, "masks"],
+]);
+/**
+ * Whether a schema is a plain object of numbers — a layout's render knobs
+ * (`planeswalkerConfig`, `sagaConfig`, `crownConfig`, `nicknameConfig`).
+ *
+ * Recognised by shape rather than by name, so a knob group added to the
+ * contract is editable in the studio without a change here. Records and enums
+ * do not qualify, which is what keeps `templateSettings`, `colorArtOverrides`
+ * and `hybridTitleMask` out.
+ */
+function isNumericObject(schema) {
+    const node = schema.def;
+    if (node.type !== "object" || !node.shape) {
+        return false;
+    }
+    const fields = Object.values(node.shape);
+    return (fields.length > 0 &&
+        fields.every((field) => {
+            const inner = unwrap(field).inner.def;
+            return inner.type === "number" || inner.type === "boolean";
+        }));
+}
+/**
+ * Every box / asset / mask / knob slot the frame contract defines, read off
+ * the schema rather than listed by hand.
+ *
+ * Identity is the test: a slot counts as boxes because its schema *is*
+ * `CardBoxesSchema`, not because its name ends in "Boxes". So a slot added to
+ * `LayoutConfigSchema` shows up here — and in the studio — with no change,
+ * and `boxSets.test.ts` fails if one is added that this cannot classify.
+ */
+export function layoutSlots() {
+    const shape = LayoutConfigSchema.def
+        .shape;
+    const slots = [];
+    for (const [key, schema] of Object.entries(shape)) {
+        const { inner, wrapped } = unwrap(schema);
+        const kind = KIND_BY_SCHEMA.get(inner) ??
+            (isNumericObject(inner) ? "knobs" : undefined);
+        if (kind) {
+            slots.push({ key, kind, required: !wrapped });
+        }
+    }
+    return slots;
+}
+/** Just the slots holding `CardBoxes` — what the studio can edit. */
+export function boxSlots() {
+    return layoutSlots().filter((slot) => slot.kind === "boxes");
+}
+/**
+ * Names of every member a `CardBoxes` can hold, in contract order.
+ *
+ * Used to enumerate a box set without assuming which optional members a given
+ * frame happens to define.
+ */
+export function cardBoxKeys() {
+    const shape = CardBoxesSchema.def
+        .shape;
+    return Object.keys(shape);
+}

package/dist/cli/studio/edit/applyEdits.d.ts

@@ -0,0 +1,71 @@
+import type { FramePath } from "../../../manifest/walk.js";
+import { type ResolveContext, type SourceLocation, type UnsupportedReason } from "./resolvePath.js";
+/** A value a literal may be replaced with. The contract has no others. */
+export type EditableValue = number | string | boolean;
+export interface Edit {
+    readonly path: FramePath;
+    readonly value: EditableValue;
+}
+export interface EditRejection {
+    readonly path: FramePath;
+    readonly reason: UnsupportedReason | "value-mismatch" | "stale" | "overlap";
+    readonly detail: string;
+    readonly source?: SourceLocation;
+}
+export interface AppliedEdit {
+    readonly path: FramePath;
+    readonly file: string;
+    readonly from: string;
+    readonly to: string;
+    /** True when the literal is a helper default other box sets also read. */
+    readonly sharedDefault: boolean;
+}
+export type ApplyResult = {
+    readonly ok: true;
+    readonly applied: readonly AppliedEdit[];
+    /** New sha256 of every file written, for the caller's self-write map. */
+    readonly files: ReadonlyMap<string, string>;
+} | {
+    readonly ok: false;
+    readonly rejected: readonly EditRejection[];
+};
+export interface ApplyOptions {
+    readonly ctx: ResolveContext;
+    readonly entryFile: string;
+    readonly exportName: string;
+    /**
+     * The frame as most recently loaded, used to verify that each literal we are
+     * about to overwrite really is the one that produced the current value.
+     */
+    readonly frame: unknown;
+    readonly edits: readonly Edit[];
+    /**
+     * sha256 each file is expected to still have. A file that has changed since
+     * the studio read it is refused rather than overwritten.
+     */
+    readonly expect?: ReadonlyMap<string, string>;
+}
+/** Whether a literal's source text really denotes `value`. */
+export declare function literalDenotes(text: string, value: unknown): boolean;
+/**
+ * Renders a new literal in the style of the one it replaces.
+ *
+ * Numbers are written plainly — every real frame uses integers, and a drag
+ * produces fractions nobody wants in source. Strings reuse the quote
+ * character already there so the file still satisfies Prettier.
+ */
+export declare function renderLiteral(value: EditableValue, previous: string): string;
+/**
+ * Rewrites literals in place, or refuses and writes nothing.
+ *
+ * Every edit is resolved to a source range, checked against the value the
+ * frame actually loaded with, and only then spliced. The check is the reason
+ * this is safe to run against someone's working tree: if the resolver is ever
+ * wrong — a mis-ordered spread, a followed import that was the wrong one — the
+ * literal will not match the value, and the whole batch is refused. The
+ * failure mode is "refuses to edit", never "edited the wrong number".
+ *
+ * Only the literal's own characters change, so comments, formatting and import
+ * order survive by construction; nothing is reprinted.
+ */
+export declare function applyEdits(options: ApplyOptions): Promise<ApplyResult>;

package/dist/cli/studio/edit/applyEdits.js

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto";
+import { formatPath, getAtPath } from "../../../manifest/walk.js";
+import { writeFileAtomic } from "../../atomic.js";
+import { resolveFramePath, } from "./resolvePath.js";
+import { normalizeFile } from "./sourceIndex.js";
+const sha256 = (text) => createHash("sha256").update(text).digest("hex");
+/** Whether a literal's source text really denotes `value`. */
+export function literalDenotes(text, value) {
+    if (typeof value === "number") {
+        return Number(text) === value;
+    }
+    if (typeof value === "boolean") {
+        return text === String(value);
+    }
+    if (typeof value === "string") {
+        const quote = text[0];
+        if (quote !== '"' && quote !== "'" && quote !== "`") {
+            return false;
+        }
+        return text.slice(1, -1) === value;
+    }
+    return false;
+}
+/**
+ * Renders a new literal in the style of the one it replaces.
+ *
+ * Numbers are written plainly — every real frame uses integers, and a drag
+ * produces fractions nobody wants in source. Strings reuse the quote
+ * character already there so the file still satisfies Prettier.
+ */
+export function renderLiteral(value, previous) {
+    if (typeof value === "number") {
+        return Number.isInteger(value) ? String(value) : String(Math.round(value));
+    }
+    if (typeof value === "boolean") {
+        return String(value);
+    }
+    const quote = previous.startsWith("'")
+        ? "'"
+        : previous.startsWith("`")
+            ? "`"
+            : '"';
+    const escaped = value
+        .replaceAll("\\", "\\\\")
+        .replaceAll(quote, `\\${quote}`);
+    return `${quote}${escaped}${quote}`;
+}
+/**
+ * Rewrites literals in place, or refuses and writes nothing.
+ *
+ * Every edit is resolved to a source range, checked against the value the
+ * frame actually loaded with, and only then spliced. The check is the reason
+ * this is safe to run against someone's working tree: if the resolver is ever
+ * wrong — a mis-ordered spread, a followed import that was the wrong one — the
+ * literal will not match the value, and the whole batch is refused. The
+ * failure mode is "refuses to edit", never "edited the wrong number".
+ *
+ * Only the literal's own characters change, so comments, formatting and import
+ * order survive by construction; nothing is reprinted.
+ */
+export async function applyEdits(options) {
+    const { ctx, entryFile, exportName, frame, edits, expect } = options;
+    const rejected = [];
+    const splices = [];
+    for (const edit of edits) {
+        const resolution = resolveFramePath(ctx, entryFile, exportName, edit.path);
+        if (!resolution.editable) {
+            rejected.push({
+                path: edit.path,
+                reason: resolution.reason,
+                detail: resolution.detail,
+                ...(resolution.source ? { source: resolution.source } : {}),
+            });
+            continue;
+        }
+        // The gate. `getAtPath` reads the value the frame really loaded with; if
+        // the literal we found does not denote it, we found the wrong literal.
+        const current = getAtPath(frame, edit.path);
+        if (!literalDenotes(resolution.text, current)) {
+            rejected.push({
+                path: edit.path,
+                reason: "value-mismatch",
+                detail: `${formatPath(edit.path)} is ${JSON.stringify(current)} in the loaded frame, but ` +
+                    `the literal found at ${resolution.location.file}:${String(resolution.location.line)} is ` +
+                    `${resolution.text}. Refusing to edit a value the studio cannot account for.`,
+                source: resolution.location,
+            });
+            continue;
+        }
+        splices.push({
+            file: resolution.file,
+            start: resolution.start,
+            end: resolution.end,
+            text: renderLiteral(edit.value, resolution.text),
+            applied: {
+                path: edit.path,
+                file: resolution.file,
+                from: resolution.text,
+                to: renderLiteral(edit.value, resolution.text),
+                sharedDefault: resolution.sharedDefault,
+            },
+        });
+    }
+    if (rejected.length > 0) {
+        return { ok: false, rejected };
+    }
+    // Group by file, then reject a batch whose ranges collide — two edits to one
+    // literal have no defined outcome, and silently picking one is worse.
+    const byFile = new Map();
+    for (const splice of splices) {
+        const key = normalizeFile(splice.file);
+        byFile.set(key, [...(byFile.get(key) ?? []), splice]);
+    }
+    for (const [file, group] of byFile) {
+        const sorted = [...group].sort((a, b) => a.start - b.start);
+        for (let i = 1; i < sorted.length; i++) {
+            const previous = sorted[i - 1];
+            const current = sorted[i];
+            if (previous && current && current.start < previous.end) {
+                rejected.push({
+                    path: current.applied.path,
+                    reason: "overlap",
+                    detail: `Two edits target overlapping text in ${file}.`,
+                });
+            }
+        }
+    }
+    if (rejected.length > 0) {
+        return { ok: false, rejected };
+    }
+    const written = new Map();
+    const pending = [];
+    for (const [file, group] of byFile) {
+        const text = ctx.index.text(file);
+        if (text === undefined) {
+            return {
+                ok: false,
+                rejected: [
+                    {
+                        path: group[0]?.applied.path ?? [],
+                        reason: "unreadable",
+                        detail: `Could not read ${file}.`,
+                    },
+                ],
+            };
+        }
+        const wanted = expect?.get(file);
+        if (wanted !== undefined && sha256(text) !== wanted) {
+            return {
+                ok: false,
+                rejected: [
+                    {
+                        path: group[0]?.applied.path ?? [],
+                        reason: "stale",
+                        detail: `${file} changed on disk since the studio last read it.`,
+                    },
+                ],
+            };
+        }
+        // Descending, so an earlier replacement never shifts a later offset.
+        let next = text;
+        for (const splice of [...group].sort((a, b) => b.start - a.start)) {
+            next = next.slice(0, splice.start) + splice.text + next.slice(splice.end);
+        }
+        pending.push({ file, text: next });
+        written.set(file, sha256(next));
+    }
+    for (const { file, text } of pending) {
+        await writeFileAtomic(file, text);
+        ctx.index.invalidate(file);
+    }
+    return {
+        ok: true,
+        applied: splices.map((splice) => splice.applied),
+        files: written,
+    };
+}

package/dist/cli/studio/edit/impact.d.ts

@@ -0,0 +1,53 @@
+import type { FramePath } from "../../../manifest/walk.js";
+import { type ResolveContext } from "./resolvePath.js";
+/** A box set the studio can address, as `session.ts` enumerates them. */
+export interface BoxSetRef {
+    readonly variant: string | null;
+    readonly layout: string;
+    readonly key: string;
+    readonly path: readonly string[];
+}
+/** One place a literal is read from, besides the one being edited. */
+export interface Impact {
+    readonly variant: string | null;
+    readonly layout: string;
+    readonly boxSet: string;
+    readonly path: FramePath;
+}
+export interface ImpactOptions {
+    readonly ctx: ResolveContext;
+    readonly entryFile: string;
+    readonly exportName: string;
+    /** Every `kind: "boxes"` slot in the frame. */
+    readonly boxSets: readonly BoxSetRef[];
+    /** The full logical path of the value being edited. */
+    readonly target: FramePath;
+}
+/**
+ * Every box set that reads the same literal as `target`.
+ *
+ * Frames share geometry heavily — `frame-borderless` spreads
+ * `borderlessNormalBoxes` into most of its layouts, and
+ * `withCollectorInfoDefaults` hands one `collectorInfo` to all ten box sets of
+ * every layout. Moving such a box moves it everywhere, so the studio has to be
+ * able to say so *before* it writes, rather than surprising the author after.
+ *
+ * Identity is the exact source range: two paths are the same value only when
+ * they resolve to the same characters in the same file.
+ *
+ * The scan is per-frame. A literal exported through `/extend` and read by a
+ * different frame package is not counted here; `resolveFramePath` reports that
+ * separately by way of the file it landed in.
+ */
+export declare function impactOf(options: ImpactOptions): Impact[];
+/**
+ * Memoises impact scans for one loaded revision of a frame.
+ *
+ * The scan resolves the same tail against every box set, which for a frame
+ * like `frame-borderless` is ~100 resolutions; the inspector asks for one per
+ * field. Parses are already cached by `sourceIndex`, so this only has to stop
+ * the walk itself from repeating.
+ */
+export declare function createImpactCache(): {
+    get: (revision: number, options: ImpactOptions) => Impact[];
+};