projectionlab-mcp 1.0.1 → 1.2.0

package/dist/diff.js

@@ -0,0 +1,744 @@
+import { CURRENT_FINANCE_COLLECTIONS, } from "./currentFinances.js";
+import { PLAN_SECTIONS, getEvents, keyEvents, } from "./plans.js";
+import { REDACTED, isSecretFieldName } from "./redact.js";
+/**
+ * Field-level diff of two readings of ProjectionLab data, shared by
+ * projectionlab_diff. It compares the same data at two points in time
+ * (`diffSectionData`, `diffPlan`) or two different plans field by field
+ * (`diffPlanPair`), where each event's own id is dropped and each reference to
+ * another event of the same plan is compared by the event it names. Values
+ * render as `before → after` the way `diffFields` renders them, and every path
+ * is a dot path in the form `projectionlab_get_plan_section` and the patch
+ * tools use (`events.2.amount`), so a reported path can be read back or patched
+ * with it.
+ *
+ * The engine is pure and bounds its own output: `DiffBudget` caps how many
+ * field changes and how many list entries one call may report, so the payload
+ * stays small enough for a local model to hold in context, and it can ask for
+ * the differing paths with the values withheld. Omitted items are counted
+ * rather than dropped silently, and whether something counts as changed is
+ * decided from the data, never from what was left to report.
+ *
+ * A change whose path names a credential (`credentials.apiKey`,
+ * `access.0.password`) is recorded as `[REDACTED]`, so neither value leaves
+ * the process, and a value longer than `MAX_VALUE_CHARS` is truncated with its
+ * original length so one long note cannot flood the diff.
+ */
+/** Field changes one diff reports before it starts omitting. */
+export const FIELD_CHANGE_CAP = 200;
+/** Added/removed names and ids one diff reports before it starts omitting. */
+export const ENTRY_CAP = 200;
+/** Serialized values longer than this are truncated in a change entry. */
+export const MAX_VALUE_CHARS = 200;
+/**
+ * Plan fields ProjectionLab computes or re-stamps on its own. Leaving them out
+ * is what makes a snapshot-to-live diff of an untouched plan read as clean:
+ * saving a plan moves `lastUpdated`, and re-running a simulation rewrites
+ * `simKey` and `meta` (same rule as `samePlanContent`).
+ */
+const COMPUTED_PLAN_FIELDS = ["lastUpdated", "simKey", "meta"];
+/**
+ * Plan fields that say which plan an object is rather than what it plans. Two
+ * plans never share them, so a plan-to-plan comparison leaves them out of the
+ * field comparison and reports them as the identity of each side.
+ */
+const PLAN_IDENTITY_FIELDS = ["id", "name"];
+export function createDiffBudget(options = {}) {
+    const { fieldChangeCap = FIELD_CHANGE_CAP, entryCap = ENTRY_CAP, pathsOnly = false, } = options;
+    return {
+        fieldChangeCap,
+        entryCap,
+        pathsOnly,
+        fieldChangesUsed: 0,
+        entriesUsed: 0,
+        omittedFieldChanges: 0,
+        omittedEntries: 0,
+    };
+}
+function isContainer(value) {
+    return !!value && typeof value === "object";
+}
+function renderValue(value) {
+    const json = JSON.stringify(value);
+    if (json === undefined)
+        return "(absent)";
+    if (json.length <= MAX_VALUE_CHARS)
+        return json;
+    return `${json.slice(0, MAX_VALUE_CHARS)}...[truncated from ${json.length} characters]`;
+}
+/**
+ * True when any element of a dot path names a credential, so a nested
+ * `credentials.apiKey` or `access.0.password` is caught even though the whole
+ * path is not a field name. Numeric elements are array positions, not names.
+ */
+function pathHoldsSecret(path) {
+    for (const element of path.split(".")) {
+        if (/^\d+$/.test(element))
+            continue;
+        if (isSecretFieldName(element))
+            return true;
+    }
+    return false;
+}
+/**
+ * Record one added/removed entry, unless the entry cap is reached. The caller
+ * keeps its own count of what it saw, so a capped list still reports the true
+ * count and `omittedEntries` says how many names were left out.
+ */
+function addEntry(list, entry, budget) {
+    if (budget.entriesUsed >= budget.entryCap) {
+        budget.omittedEntries++;
+        return;
+    }
+    budget.entriesUsed++;
+    list.push(entry);
+}
+function walkLeaves(value, prefix, out) {
+    if (Array.isArray(value)) {
+        if (value.length === 0) {
+            if (prefix)
+                out.set(prefix, []);
+            return;
+        }
+        for (let i = 0; i < value.length; i++) {
+            walkLeaves(value[i], prefix ? `${prefix}.${i}` : String(i), out);
+        }
+        return;
+    }
+    if (isContainer(value)) {
+        const keys = Object.keys(value).sort();
+        // An empty container is a leaf, so `{}` versus a value still reads as a
+        // change instead of vanishing.
+        if (keys.length === 0) {
+            if (prefix)
+                out.set(prefix, value);
+            return;
+        }
+        for (const key of keys) {
+            walkLeaves(value[key], prefix ? `${prefix}.${key}` : key, out);
+        }
+        return;
+    }
+    if (prefix)
+        out.set(prefix, value);
+}
+/**
+ * Leaf-by-leaf diff of two values as `path: "before → after"`. Arrays carry
+ * their index in the path, so a reordered list reads as changed leaves rather
+ * than as nothing.
+ */
+export function diffLeafValues(before, after, budget) {
+    const changes = {};
+    const paths = budget.pathsOnly ? [] : undefined;
+    let detected = 0;
+    const record = (path, from, to) => {
+        if (JSON.stringify(from) === JSON.stringify(to))
+            return;
+        detected++;
+        if (budget.fieldChangesUsed >= budget.fieldChangeCap) {
+            budget.omittedFieldChanges++;
+            return;
+        }
+        budget.fieldChangesUsed++;
+        if (paths) {
+            paths.push(path);
+            return;
+        }
+        changes[path] = pathHoldsSecret(path)
+            ? REDACTED
+            : `${renderValue(from)} → ${renderValue(to)}`;
+    };
+    if (!isContainer(before) && !isContainer(after)) {
+        record("(value)", before, after);
+        return { changes, ...(paths ? { paths } : {}), detected };
+    }
+    const beforeLeaves = new Map();
+    const afterLeaves = new Map();
+    walkLeaves(before, "", beforeLeaves);
+    walkLeaves(after, "", afterLeaves);
+    const allPaths = [
+        ...new Set([...beforeLeaves.keys(), ...afterLeaves.keys()]),
+    ].sort();
+    for (const path of allPaths) {
+        record(path, beforeLeaves.get(path), afterLeaves.get(path));
+    }
+    return { changes, ...(paths ? { paths } : {}), detected };
+}
+/**
+ * The change entry for one event or row: its identity, the field changes the
+ * budget recorded (or, when values are withheld, just their paths), and how
+ * many more it found than it could record.
+ */
+function changeEntry(identity, leaf) {
+    const recorded = leaf.paths
+        ? leaf.paths.length
+        : Object.keys(leaf.changes).length;
+    const reported = recorded === 0
+        ? {}
+        : leaf.paths
+            ? { paths: leaf.paths }
+            : { changes: leaf.changes };
+    return {
+        ...identity,
+        ...reported,
+        ...(leaf.detected > recorded
+            ? { omittedChanges: leaf.detected - recorded }
+            : {}),
+    };
+}
+function isEventish(section) {
+    if (Array.isArray(section))
+        return true;
+    return isContainer(section) && Array.isArray(section.events);
+}
+/**
+ * Diff one plan section. Event-shaped sections (`{ events: [] }`, or a bare
+ * array such as `milestones`) compare events by name plus occurrence, the same
+ * keying the section dry run uses, so events sharing a name each keep their
+ * own entry. Anything else (`variables`, `montecarlo`,
+ * `withdrawalStrategy`) compares leaf by leaf.
+ */
+export function diffEventSection(before, after, budget) {
+    const beforeEvents = getEvents(before);
+    const afterEvents = getEvents(after);
+    const beforeKeyed = keyEvents(beforeEvents);
+    const afterKeyed = keyEvents(afterEvents);
+    const added = [];
+    const removed = [];
+    const modified = [];
+    let addedCount = 0;
+    let removedCount = 0;
+    let modifiedCount = 0;
+    let unchangedCount = 0;
+    for (const [key, { name, event }] of afterKeyed) {
+        const previous = beforeKeyed.get(key);
+        if (!previous) {
+            addedCount++;
+            addEntry(added, name, budget);
+            continue;
+        }
+        const leaf = diffLeafValues(previous.event, event, budget);
+        if (leaf.detected > 0) {
+            modifiedCount++;
+            addEntry(modified, changeEntry({ name }, leaf), budget);
+        }
+        else {
+            unchangedCount++;
+        }
+    }
+    for (const [key, { name }] of beforeKeyed) {
+        if (!afterKeyed.has(key)) {
+            removedCount++;
+            addEntry(removed, name, budget);
+        }
+    }
+    added.sort();
+    removed.sort();
+    return {
+        kind: "events",
+        count: `${beforeEvents.length} → ${afterEvents.length}`,
+        changed: addedCount > 0 || removedCount > 0 || modifiedCount > 0,
+        addedCount,
+        ...(added.length > 0 ? { added } : {}),
+        removedCount,
+        ...(removed.length > 0 ? { removed } : {}),
+        modifiedCount,
+        ...(modified.length > 0 ? { modified } : {}),
+        unchangedCount,
+    };
+}
+/**
+ * Diff a data area that holds neither events nor rows: a plan's `variables`,
+ * `montecarlo` or `withdrawalStrategy`, and the whole `progress` or `settings`
+ * section.
+ */
+export function diffFieldSection(before, after, budget) {
+    const leaf = diffLeafValues(before, after, budget);
+    return {
+        kind: "fields",
+        changed: leaf.detected > 0,
+        ...changeEntry({}, leaf),
+    };
+}
+/**
+ * Choose how to compare one plan section. A section that is event-shaped on
+ * either side compares as events, including one that exists on only one side,
+ * so a section added or dropped reads as events appearing or disappearing
+ * rather than as a wall of leaf paths. `compareEvents` decides how two sets of
+ * events are reported: as added/removed/modified over time, or as
+ * onlyInA/onlyInB/different between two plans.
+ */
+function diffSectionShape(before, after, budget, compareEvents) {
+    const beforeIsEvent = isEventish(before);
+    const afterIsEvent = isEventish(after);
+    if (beforeIsEvent && afterIsEvent)
+        return compareEvents(before, after, budget);
+    if (beforeIsEvent && (after === undefined || after === null)) {
+        return compareEvents(before, after, budget);
+    }
+    if (afterIsEvent && (before === undefined || before === null)) {
+        return compareEvents(before, after, budget);
+    }
+    return diffFieldSection(before, after, budget);
+}
+function planNameOf(plan) {
+    return String(plan?.name ?? plan?.id ?? "unnamed");
+}
+/** Match plans across two reads: by id when they carry one, else by name. */
+export function planKey(plan) {
+    const obj = (plan ?? {});
+    const id = obj.id;
+    if (id !== undefined && id !== null && id !== "")
+        return `id:${String(id)}`;
+    return `name:${planNameOf(plan)}`;
+}
+export function planIdentity(plan) {
+    const obj = (plan ?? {});
+    return {
+        id: String(obj.id ?? ""),
+        name: String(obj.name ?? "unnamed"),
+    };
+}
+function asArray(value) {
+    return Array.isArray(value) ? value : [];
+}
+/**
+ * Diff two copies of one plan. `section` narrows the comparison to a single
+ * plan section; the plan's own settings (every field that is not a known
+ * section, such as `retirementAge` or `endAge`) are always compared, minus the
+ * computed fields.
+ */
+export function diffPlan(before, after, budget, section) {
+    const sections = {};
+    const changedSections = [];
+    const sectionNames = section
+        ? [section]
+        : PLAN_SECTIONS.filter((name) => name in before || name in after);
+    for (const name of sectionNames) {
+        const result = diffSectionShape(before[name], after[name], budget, diffEventSection);
+        sections[name] = result;
+        if (result.changed)
+            changedSections.push(name);
+    }
+    // Plan settings are every field that is not a known section and not one of
+    // the fields ProjectionLab computes, whatever the section filter is.
+    const skip = new Set([...PLAN_SECTIONS, ...COMPUTED_PLAN_FIELDS]);
+    const beforeRest = {};
+    const afterRest = {};
+    for (const key of new Set([...Object.keys(before), ...Object.keys(after)])) {
+        if (skip.has(key))
+            continue;
+        beforeRest[key] = before[key];
+        afterRest[key] = after[key];
+    }
+    const planFields = diffLeafValues(beforeRest, afterRest, budget);
+    return {
+        ...planIdentity(after ?? before),
+        changed: changedSections.length > 0 || planFields.detected > 0,
+        ...changeEntry({}, planFields),
+        ...(sectionNames.length > 0 ? { sections } : {}),
+        ...(changedSections.length > 0 ? { changedSections } : {}),
+    };
+}
+/**
+ * Tokens that name each event of `plan` by its section and display name, keyed
+ * by the id that plan's own events use to point at it.
+ *
+ * Events refer to other events of the same plan by id (`start: { type:
+ * "milestone", value: "<milestone id>" }`, a priority's `accountId`), and two
+ * plans built independently give the same milestone unrelated ids. Comparing
+ * the raw ids would report a difference at every reference of a hand-rebuilt
+ * plan; comparing tokens makes a reference to the same-named event compare
+ * equal and a reference to a differently named one read as a difference. An id
+ * that is not an event of this plan (a Current Finances `accountId`, which
+ * every plan shares) gets no token and is compared as it is.
+ */
+export function eventReferenceTokens(plan) {
+    const tokens = new Map();
+    if (!isContainer(plan) || Array.isArray(plan))
+        return tokens;
+    for (const section of Object.keys(plan)) {
+        const value = plan[section];
+        if (!isEventish(value))
+            continue;
+        for (const { name, event } of keyEvents(getEvents(value)).values()) {
+            const id = event?.id;
+            if (id === undefined || id === null || id === "")
+                continue;
+            const token = `@${section}:${name}`;
+            if (!tokens.has(String(id)))
+                tokens.set(String(id), token);
+        }
+    }
+    return tokens;
+}
+/** A copy of `value` with each string naming an event of the plan replaced by its token. */
+function substituteReferences(value, tokens) {
+    if (typeof value === "string")
+        return tokens.get(value) ?? value;
+    if (Array.isArray(value)) {
+        return value.map((element) => substituteReferences(element, tokens));
+    }
+    if (isContainer(value)) {
+        const copy = {};
+        for (const key of Object.keys(value)) {
+            copy[key] = substituteReferences(value[key], tokens);
+        }
+        return copy;
+    }
+    return value;
+}
+/**
+ * One event as plan-to-plan comparison sees it: its own `id` and `key` dropped,
+ * references tokened. ProjectionLab gives each event a random `key` when the
+ * event is created, so two independently built plans never share it.
+ */
+function eventForPair(event, tokens) {
+    if (Array.isArray(event) || !isContainer(event)) {
+        return substituteReferences(event, tokens);
+    }
+    const copy = {};
+    for (const key of Object.keys(event)) {
+        if (key === "id" || key === "key")
+            continue;
+        copy[key] = substituteReferences(event[key], tokens);
+    }
+    return copy;
+}
+/**
+ * One plan section with each event's own `id` and `key` dropped and each
+ * reference tokened.
+ */
+function sectionForPair(section, tokens) {
+    if (Array.isArray(section)) {
+        return section.map((event) => eventForPair(event, tokens));
+    }
+    const obj = section;
+    if (isContainer(section) && Array.isArray(obj.events)) {
+        const copy = {};
+        for (const key of Object.keys(obj)) {
+            copy[key] =
+                key === "events"
+                    ? obj.events.map((event) => eventForPair(event, tokens))
+                    : substituteReferences(obj[key], tokens);
+        }
+        return copy;
+    }
+    return substituteReferences(section, tokens);
+}
+/**
+ * One plan reshaped so it can be compared against a different plan: each
+ * event's own `id` and `key` are dropped and each reference to another event of
+ * the same plan is replaced by that event's token. Those are the only fields
+ * two independently built plans of the same content cannot share.
+ */
+function planForPair(plan) {
+    const tokens = eventReferenceTokens(plan);
+    const prepared = {};
+    for (const key of Object.keys(plan)) {
+        prepared[key] = sectionForPair(plan[key], tokens);
+    }
+    return prepared;
+}
+/**
+ * Compare one event-shaped section of two different plans. `a` is plan A and
+ * `b` is plan B, so each change reads `A's value → B's value`. Both sides carry
+ * the ids and random keys dropped and the references tokened by `planForPair`.
+ */
+export function diffEventPair(a, b, budget) {
+    const aEvents = getEvents(a);
+    const bEvents = getEvents(b);
+    const aKeyed = keyEvents(aEvents);
+    const bKeyed = keyEvents(bEvents);
+    const onlyInA = [];
+    const onlyInB = [];
+    const different = [];
+    let onlyInACount = 0;
+    let onlyInBCount = 0;
+    let differentCount = 0;
+    let sameCount = 0;
+    for (const [key, { name, event }] of bKeyed) {
+        const counterpart = aKeyed.get(key);
+        if (!counterpart) {
+            onlyInBCount++;
+            addEntry(onlyInB, name, budget);
+            continue;
+        }
+        const leaf = diffLeafValues(counterpart.event, event, budget);
+        if (leaf.detected > 0) {
+            differentCount++;
+            addEntry(different, changeEntry({ name }, leaf), budget);
+        }
+        else {
+            sameCount++;
+        }
+    }
+    for (const [key, { name }] of aKeyed) {
+        if (!bKeyed.has(key)) {
+            onlyInACount++;
+            addEntry(onlyInA, name, budget);
+        }
+    }
+    onlyInA.sort();
+    onlyInB.sort();
+    return {
+        kind: "events",
+        count: `${aEvents.length} → ${bEvents.length}`,
+        changed: onlyInACount > 0 || onlyInBCount > 0 || differentCount > 0,
+        onlyInACount,
+        ...(onlyInA.length > 0 ? { onlyInA } : {}),
+        onlyInBCount,
+        ...(onlyInB.length > 0 ? { onlyInB } : {}),
+        differentCount,
+        ...(different.length > 0 ? { different } : {}),
+        sameCount,
+    };
+}
+/**
+ * Compare two different plans field by field, so a plan rebuilt by hand can be
+ * checked against the original. Plan A's values are reported first in every
+ * `A → B` pair. Events match by name plus occurrence, the same keying the
+ * time diff uses; the fields that say which plan an object is (`id`, `name`),
+ * the fields ProjectionLab computes (`lastUpdated`, `simKey`, `meta`) and each
+ * event's own `id` and randomly assigned `key` are left out, and references
+ * between a plan's own events are compared by the event they name. `section`
+ * narrows the section comparison; plan settings outside the sections are always
+ * compared.
+ */
+export function diffPlanPair(planA, planB, budget, section) {
+    const a = planForPair(planA);
+    const b = planForPair(planB);
+    const sections = {};
+    const changedSections = [];
+    const sectionNames = section
+        ? [section]
+        : PLAN_SECTIONS.filter((name) => name in planA || name in planB);
+    for (const name of sectionNames) {
+        const result = diffSectionShape(a[name], b[name], budget, diffEventPair);
+        sections[name] = result;
+        if (result.changed)
+            changedSections.push(name);
+    }
+    const skip = new Set([
+        ...PLAN_SECTIONS,
+        ...COMPUTED_PLAN_FIELDS,
+        ...PLAN_IDENTITY_FIELDS,
+    ]);
+    const aRest = {};
+    const bRest = {};
+    for (const key of new Set([...Object.keys(a), ...Object.keys(b)])) {
+        if (skip.has(key))
+            continue;
+        aRest[key] = a[key];
+        bRest[key] = b[key];
+    }
+    const settings = diffFieldSection(aRest, bRest, budget);
+    return {
+        a: planIdentity(planA),
+        b: planIdentity(planB),
+        changed: changedSections.length > 0 || settings.changed,
+        settings,
+        ...(sectionNames.length > 0 ? { sections } : {}),
+        ...(changedSections.length > 0 ? { changedSections } : {}),
+    };
+}
+/**
+ * Diff two plans arrays. `onlyKey` (from `planKey`) reports one plan alone, so
+ * a caller narrowed to a single plan gets just that plan's entry.
+ */
+export function diffPlanList(before, after, budget, options = {}) {
+    const beforePlans = asArray(before);
+    const afterPlans = asArray(after);
+    const beforeByKey = new Map();
+    for (const plan of beforePlans) {
+        if (isContainer(plan))
+            beforeByKey.set(planKey(plan), plan);
+    }
+    const afterByKey = new Map();
+    for (const plan of afterPlans) {
+        if (isContainer(plan))
+            afterByKey.set(planKey(plan), plan);
+    }
+    const added = [];
+    const removed = [];
+    const changedPlans = [];
+    const unchanged = [];
+    let addedCount = 0;
+    let removedCount = 0;
+    let changedCount = 0;
+    let unchangedCount = 0;
+    for (const [key, plan] of afterByKey) {
+        if (options.onlyKey && key !== options.onlyKey)
+            continue;
+        const previous = beforeByKey.get(key);
+        if (!previous) {
+            addedCount++;
+            addEntry(added, planIdentity(plan), budget);
+            continue;
+        }
+        const diff = diffPlan(previous, plan, budget, options.section);
+        if (diff.changed) {
+            changedCount++;
+            addEntry(changedPlans, diff, budget);
+        }
+        else {
+            unchangedCount++;
+            addEntry(unchanged, diff.name, budget);
+        }
+    }
+    for (const [key, plan] of beforeByKey) {
+        if (options.onlyKey && key !== options.onlyKey)
+            continue;
+        if (!afterByKey.has(key)) {
+            removedCount++;
+            addEntry(removed, planIdentity(plan), budget);
+        }
+    }
+    return {
+        changed: addedCount > 0 || removedCount > 0 || changedCount > 0,
+        planCount: `${beforePlans.length} → ${afterPlans.length}`,
+        addedCount,
+        ...(added.length > 0 ? { added } : {}),
+        removedCount,
+        ...(removed.length > 0 ? { removed } : {}),
+        changedCount,
+        ...(changedPlans.length > 0 ? { changedPlans } : {}),
+        unchangedCount,
+        ...(unchanged.length > 0 ? { unchanged } : {}),
+    };
+}
+/**
+ * Key Current Finances rows for matching: by id when present, since ProjectionLab
+ * ids are stable, else by name plus occurrence the way events are keyed.
+ */
+function keyRows(rows) {
+    // Rows without an id keep their own entry under the event keying, which
+    // numbers repeated names so two of them can't collapse into one.
+    const idlessKeys = [
+        ...keyEvents(rows.filter((row) => {
+            const id = (row ?? {});
+            return id.id === undefined || id.id === null || id.id === "";
+        })).keys(),
+    ];
+    const keyed = new Map();
+    let idlessAt = 0;
+    for (const row of rows) {
+        const obj = (row ?? {});
+        const id = obj.id;
+        if (id !== undefined && id !== null && id !== "") {
+            keyed.set(`id:${String(id)}`, {
+                id: String(id),
+                name: planNameOf(row),
+                row,
+            });
+            continue;
+        }
+        const key = idlessKeys[idlessAt++];
+        keyed.set(key, { id: "", name: planNameOf(row), row });
+    }
+    return keyed;
+}
+function diffCollection(before, after, budget) {
+    const beforeRows = asArray(before);
+    const afterRows = asArray(after);
+    const beforeKeyed = keyRows(beforeRows);
+    const afterKeyed = keyRows(afterRows);
+    const added = [];
+    const removed = [];
+    const modified = [];
+    let addedCount = 0;
+    let removedCount = 0;
+    let modifiedCount = 0;
+    let unchangedCount = 0;
+    for (const [key, { id, name, row }] of afterKeyed) {
+        const previous = beforeKeyed.get(key);
+        if (!previous) {
+            addedCount++;
+            addEntry(added, { id, name }, budget);
+            continue;
+        }
+        const leaf = diffLeafValues(previous.row, row, budget);
+        if (leaf.detected > 0) {
+            modifiedCount++;
+            addEntry(modified, changeEntry({ id, name }, leaf), budget);
+        }
+        else {
+            unchangedCount++;
+        }
+    }
+    for (const [key, { id, name }] of beforeKeyed) {
+        if (!afterKeyed.has(key)) {
+            removedCount++;
+            addEntry(removed, { id, name }, budget);
+        }
+    }
+    return {
+        kind: "rows",
+        count: `${beforeRows.length} → ${afterRows.length}`,
+        changed: addedCount > 0 || removedCount > 0 || modifiedCount > 0,
+        addedCount,
+        ...(added.length > 0 ? { added } : {}),
+        removedCount,
+        ...(removed.length > 0 ? { removed } : {}),
+        modifiedCount,
+        ...(modified.length > 0 ? { modified } : {}),
+        unchangedCount,
+    };
+}
+/**
+ * Diff Current Finances collection by collection, matching rows by id. Fields
+ * outside the account collections (a `today` key that is not one of the four
+ * collections) are compared leaf by leaf.
+ */
+export function diffCurrentFinances(before, after, budget) {
+    const beforeRoot = (isContainer(before) ? before : {});
+    const afterRoot = (isContainer(after) ? after : {});
+    const collections = {};
+    let changed = false;
+    for (const collection of CURRENT_FINANCE_COLLECTIONS) {
+        if (!Array.isArray(beforeRoot[collection]) &&
+            !Array.isArray(afterRoot[collection])) {
+            continue;
+        }
+        const result = diffCollection(beforeRoot[collection], afterRoot[collection], budget);
+        collections[collection] = result;
+        if (result.changed)
+            changed = true;
+    }
+    const skip = new Set(CURRENT_FINANCE_COLLECTIONS);
+    const beforeRest = {};
+    const afterRest = {};
+    for (const key of new Set([
+        ...Object.keys(beforeRoot),
+        ...Object.keys(afterRoot),
+    ])) {
+        if (skip.has(key))
+            continue;
+        beforeRest[key] = beforeRoot[key];
+        afterRest[key] = afterRoot[key];
+    }
+    const rest = diffLeafValues(beforeRest, afterRest, budget);
+    return {
+        changed: changed || rest.detected > 0,
+        collections,
+        ...changeEntry({}, rest),
+    };
+}
+/**
+ * Diff one snapshot data section (`plans`, `currentFinances`, `progress`,
+ * `settings`) by its stored key.
+ */
+export function diffSectionData(section, before, after, budget, options = {}) {
+    switch (section) {
+        case "plans":
+            return diffPlanList(before, after, budget, {
+                section: options.planSection,
+                onlyKey: options.planOnlyKey,
+            });
+        case "currentFinances":
+            return diffCurrentFinances(before, after, budget);
+        default:
+            return diffFieldSection(before, after, budget);
+    }
+}
+//# sourceMappingURL=diff.js.map