nilometer 0.0.0-stage → 0.1.0

package/dist/core/settings/statusline.js

@@ -0,0 +1,240 @@
+/**
+ * @file Deciding how `init` and `uninstall` change the `statusLine` entry in settings.
+ *
+ * Implements README § How it works ("Chaining, not clobbering") and the `statusline-collector`
+ * skill. Everything here is pure: functions take a settings object and return a new one plus a
+ * description of what changed. Reading and writing files is `settings-file.ts`'s job, so every
+ * decision can be tested without touching a disk.
+ */
+import { existsSync } from "node:fs";
+import { isAbsolute } from "node:path";
+import { readSettings } from "./settings-file.js";
+/**
+ * Comment appended to the hook command. It identifies our entry even if the repository moves,
+ * so `init` never wraps its own hook (docs/development.md P1.2, "already ours").
+ */
+export const HOOK_MARKER = "# nilometer-hook";
+/**
+ * Quotes a string for safe use as one word in a POSIX shell command.
+ * @param value - Any string, including spaces, quotes, or `$`.
+ * @returns The value in single quotes, with embedded single quotes escaped as `'\''`.
+ * @example
+ * shellQuote("/a b/it's"); // "'/a b/it'\\''s'"
+ */
+export function shellQuote(value) {
+    // Inside single quotes nothing is special except the closing quote itself.
+    return `'${value.replaceAll("'", `'\\''`)}'`;
+}
+/**
+ * Reads the data directory out of a command {@link buildHookCommand} produced.
+ *
+ * `uninstall` needs the install record, which lives in the data directory, to put the user's own
+ * status line back. When it's run without the `--data-dir` the install used, the only other place
+ * that path is written down is the command being removed, so read it from there (D-050). Without
+ * this, an uninstall that can't find the record deletes the `statusLine` entry instead of
+ * restoring it.
+ * @param command - A `statusLine.command` value.
+ * @returns The data directory, or `null` if the command isn't one of ours or can't be parsed.
+ * @example
+ * dataDirFromHookCommand("/bin/sh '/repo/hooks/statusline.sh' '/data' # nilometer-hook"); // "/data"
+ */
+export function dataDirFromHookCommand(command) {
+    if (!command.includes(HOOK_MARKER)) {
+        return null;
+    }
+    // Two single-quoted words, the hook path then the data directory, as buildHookCommand writes
+    // them: `''` can't appear inside one, because shellQuote escapes an embedded quote as `'\''`.
+    const match = /^\/bin\/sh '((?:[^']|'\\'')*)' '((?:[^']|'\\'')*)' /.exec(command);
+    const quoted = match?.[2];
+    if (quoted === undefined) {
+        return null;
+    }
+    return quoted.replaceAll(`'\\''`, "'");
+}
+/**
+ * Reads the hook's own path out of a command {@link buildHookCommand} produced (D-081).
+ * @param command - A `statusLine.command` value.
+ * @returns The hook script's path, or `null` if the command isn't one of ours or can't be parsed.
+ * @example
+ * hookPathFromHookCommand("/bin/sh '/repo/hooks/statusline.sh' '/data' # nilometer-hook"); // "/repo/hooks/statusline.sh"
+ */
+export function hookPathFromHookCommand(command) {
+    if (!command.includes(HOOK_MARKER)) {
+        return null;
+    }
+    // The same two quoted words dataDirFromHookCommand reads; the first is the hook.
+    const match = /^\/bin\/sh '((?:[^']|'\\'')*)' '((?:[^']|'\\'')*)' /.exec(command);
+    const quoted = match?.[1];
+    if (quoted === undefined) {
+        return null;
+    }
+    return quoted.replaceAll(`'\\''`, "'");
+}
+/**
+ * Checks whether the status line in settings runs this tool's hook from a file that exists (D-081).
+ *
+ * Read only: the settings file is never written here. A machine move or a deleted checkout leaves
+ * `statusLine.command` naming a hook that isn't there; Claude Code then runs nothing, and the
+ * hook's own error log can't record a hook that never starts.
+ * @param settingsPath - The settings file, located as `init` locates it.
+ * @param exists - File existence check, injectable for tests.
+ * @returns `missing` with the hook's path when the command is ours and its file is gone;
+ *   `present`, `not_ours`, or `no_settings` otherwise. An unreadable or invalid settings file is
+ *   `no_settings`: there is no command to check.
+ */
+export function checkHook(settingsPath, exists = existsSync) {
+    let read;
+    try {
+        read = readSettings(settingsPath);
+    }
+    catch {
+        return { kind: "no_settings" };
+    }
+    if (read.kind !== "ok") {
+        return { kind: "no_settings" };
+    }
+    const value = read.settings["statusLine"];
+    if (!isCommandEntry(value)) {
+        return { kind: "not_ours" };
+    }
+    const hookPath = hookPathFromHookCommand(value.command);
+    if (hookPath === null) {
+        return { kind: "not_ours" };
+    }
+    return exists(hookPath) ? { kind: "present" } : { kind: "missing", hookPath };
+}
+/**
+ * Builds the exact `statusLine.command` string that runs our hook.
+ * @param hookPath - Absolute path to `hooks/statusline.sh`.
+ * @throws {Error} If either path is relative: the hook would resolve it against whatever directory
+ *   Claude Code runs in, which the user doesn't control (D-050).
+ * @param dataDir - Absolute path to the tool's data directory.
+ * @returns A shell command running the hook under `/bin/sh`, ending in {@link HOOK_MARKER}.
+ * @example
+ * buildHookCommand("/opt/aua/hooks/statusline.sh", "/home/example/.local/share/nilometer");
+ * // "/bin/sh '/opt/aua/hooks/statusline.sh' '/home/example/.local/share/nilometer' # nilometer-hook"
+ */
+export function buildHookCommand(hookPath, dataDir) {
+    for (const path of [hookPath, dataDir]) {
+        if (!isAbsolute(path)) {
+            throw new Error(`the status line command needs absolute paths; got ${path}`);
+        }
+    }
+    // Running through /bin/sh explicitly means the script needn't be executable after a git checkout.
+    return `/bin/sh ${shellQuote(hookPath)} ${shellQuote(dataDir)} ${HOOK_MARKER}`;
+}
+/**
+ * Reports whether a value is a usable `statusLine` entry of type `command`.
+ * @param value - The raw `statusLine` value from settings.
+ * @returns `true` if it is an object with `type: "command"` and a string `command`.
+ */
+export function isCommandEntry(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return false;
+    }
+    const record = value;
+    return record["type"] === "command" && typeof record["command"] === "string";
+}
+/**
+ * Classifies the current `statusLine` entry.
+ * @param settings - Parsed settings; `null` when the settings file doesn't exist.
+ * @param hookCommand - The command {@link buildHookCommand} produces for this installation.
+ * @returns The entry's state: absent, someone else's, ours (current or outdated), or unsupported.
+ */
+export function classifyStatusLine(settings, hookCommand) {
+    // `in` rather than a truthiness check: an explicit `"statusLine": null` isn't "absent".
+    if (settings === null || !("statusLine" in settings)) {
+        return { kind: "absent" };
+    }
+    const value = settings["statusLine"];
+    // Anything that isn't a command entry is left alone: wrapping it could change what the user sees.
+    if (!isCommandEntry(value)) {
+        return { kind: "unsupported", value };
+    }
+    if (!value.command.includes(HOOK_MARKER)) {
+        return { kind: "foreign", entry: value };
+    }
+    // Ours, but pointing somewhere else (e.g. the repository moved): update the command in place.
+    return value.command === hookCommand
+        ? { kind: "ours", entry: value }
+        : { kind: "ours-outdated", entry: value };
+}
+/**
+ * Returns a copy of settings with `statusLine` replaced, keeping key order.
+ * @param settings - Original settings.
+ * @param entry - New `statusLine` value, or `undefined` to remove the key.
+ * @returns A new object. An existing key stays in place; a new key goes last.
+ */
+export function withStatusLine(settings, entry) {
+    const result = {};
+    let replaced = false;
+    for (const [key, value] of Object.entries(settings)) {
+        if (key === "statusLine") {
+            replaced = true;
+            // Replacing in position keeps the diff to the one changed entry.
+            if (entry !== undefined) {
+                result[key] = entry;
+            }
+            continue;
+        }
+        result[key] = value;
+    }
+    if (!replaced && entry !== undefined) {
+        result["statusLine"] = entry;
+    }
+    return result;
+}
+/**
+ * Plans the settings change for `init`. Pure: nothing is written.
+ * @param settings - Current settings; `null` when the file doesn't exist.
+ * @param hookCommand - The command that runs our hook.
+ * @returns The plan: install (with the original to record), update our command, do nothing, or
+ *   refuse because the existing entry isn't a command.
+ */
+export function planInstall(settings, hookCommand) {
+    const state = classifyStatusLine(settings, hookCommand);
+    const base = settings ?? {};
+    switch (state.kind) {
+        case "absent":
+            return {
+                action: "install",
+                settings: withStatusLine(base, { type: "command", command: hookCommand }),
+                original: null,
+            };
+        case "foreign":
+            // Keep every other field of the user's entry (padding and anything added later).
+            return {
+                action: "install",
+                settings: withStatusLine(base, { ...state.entry, command: hookCommand }),
+                original: state.entry,
+            };
+        case "ours":
+            // Running init twice must not wrap the wrapper.
+            return { action: "none", reason: "already-installed" };
+        case "ours-outdated":
+            return {
+                action: "update-command",
+                settings: withStatusLine(base, { ...state.entry, command: hookCommand }),
+            };
+        case "unsupported":
+            return { action: "refuse", reason: "unsupported-statusline", value: state.value };
+    }
+}
+/**
+ * Plans the settings change for `uninstall`. Pure: nothing is written.
+ * @param settings - Current settings; `null` when the file doesn't exist.
+ * @param original - The entry recorded at install time; `null` if there was none.
+ * @returns Restore the original entry (or remove ours), or do nothing. If the current entry isn't
+ *   ours, the user changed it after install, and it's left alone rather than clobbered.
+ */
+export function planUninstall(settings, original) {
+    if (settings === null || !("statusLine" in settings)) {
+        return { action: "none", reason: "not-installed" };
+    }
+    const value = settings["statusLine"];
+    if (!isCommandEntry(value) || !value.command.includes(HOOK_MARKER)) {
+        return { action: "none", reason: "replaced-by-user" };
+    }
+    return { action: "restore", settings: withStatusLine(settings, original ?? undefined) };
+}
+//# sourceMappingURL=statusline.js.map

package/dist/core/util/commands.js

@@ -0,0 +1,91 @@
+/**
+ * @file Starting another program the same way on macOS, Linux, and Windows (D-051).
+ *
+ * On Windows the tools npm installs are `.cmd` shims, which Node refuses to spawn unless a shell
+ * runs them, so a command that works everywhere else fails there with ENOENT. Going through a shell
+ * brings two problems of its own: Node concatenates arguments without escaping them (DEP0190), so a
+ * path containing a space is split into two words, and `cmd.exe` reports a command it can't find as
+ * exit 1, which is indistinguishable from a tool that ran and failed.
+ *
+ * This module answers both: the command line is quoted here and passed as one pre-built string, and
+ * a command is looked up before it runs, so "not installed" is reported as itself.
+ */
+import { spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
+/** Exit code reported when a command isn't installed, or couldn't be started. */
+export const NOT_STARTED = 127;
+/**
+ * `cmd.exe`'s code for "is not recognized as an internal or external command".
+ *
+ * Windows ships a `python3` stub that exits with this instead of running Python, so a command that
+ * returns it hasn't really run.
+ */
+export const WINDOWS_NOT_RECOGNIZED = 9009;
+/** Characters that make `cmd.exe` read a word as something other than one plain argument. */
+const NEEDS_QUOTING = /[\s&|<>^()%!]/;
+/**
+ * Quotes one word of a `cmd.exe` command line.
+ * @param word - A command name or argument.
+ * @returns The word, in double quotes when it would otherwise be split or interpreted.
+ * @throws {Error} If the word contains a double quote. Nothing here needs one, and quoting it
+ *   correctly depends on how the receiving program parses its arguments, so this refuses rather
+ *   than building a command line that might mean something else (report, don't fix).
+ * @example
+ * quoteForCmd("C:\\Program Files\\nodejs\\node.exe"); // '"C:\\Program Files\\nodejs\\node.exe"'
+ */
+export function quoteForCmd(word) {
+    if (word.includes('"')) {
+        throw new Error(`cannot quote ${word} for cmd.exe: it contains a double quote`);
+    }
+    return word === "" || NEEDS_QUOTING.test(word) ? `"${word}"` : word;
+}
+/**
+ * Builds one `cmd.exe` command line from a command and its arguments.
+ * @param command - Executable name or path.
+ * @param args - Arguments, in order.
+ * @returns A single command line with every word quoted as it needs.
+ */
+export function windowsCommandLine(command, args) {
+    return [command, ...args].map(quoteForCmd).join(" ");
+}
+/**
+ * Decides how to start a command on this platform.
+ *
+ * Windows gets one pre-quoted command line and no separate arguments, because Node only
+ * concatenates arguments when a shell is used and doesn't escape them. Everywhere else the command
+ * and arguments are passed as they are, with no shell involved at all.
+ * @param command - Executable name or path.
+ * @param args - Arguments, in order.
+ * @param platform - The platform; defaults to this one.
+ * @returns The command, arguments, and shell flag to spawn with.
+ */
+export function invocation(command, args, platform = process.platform) {
+    if (platform !== "win32") {
+        return { command, args, shell: false };
+    }
+    return { command: windowsCommandLine(command, args), args: [], shell: true };
+}
+/**
+ * Reports whether a command can be started, where that can't be told from its exit code.
+ *
+ * On POSIX a missing command reports itself (the spawn fails with ENOENT), so this always says yes
+ * and lets the spawn answer. On Windows a shell reports a missing command as exit 1, so the name is
+ * looked up first with `where.exe` — a real executable, which spawns without a shell.
+ * @param command - Executable name or path.
+ * @param deps - Injectable platform and lookups.
+ * @returns False only when Windows could not find the command.
+ */
+export function commandFound(command, deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    if (platform !== "win32") {
+        return true;
+    }
+    const exists = deps.exists ?? existsSync;
+    // A path is checked on disk: `where` takes patterns to search for, not paths that already resolve.
+    if (command.includes("/") || command.includes("\\")) {
+        return exists(command);
+    }
+    const probe = deps.probe ?? ((name) => spawnSync("where.exe", [name], { stdio: "ignore" }).status);
+    return probe(command) === 0;
+}
+//# sourceMappingURL=commands.js.map

package/dist/core/util/node-version.js

@@ -0,0 +1,58 @@
+/**
+ * @file The Node.js version check that runs before any command (D-066).
+ *
+ * The database is Node's built-in `node:sqlite` (D-093). On a Node.js older than 24 it's missing
+ * (Node 22.11 throws on import without a flag) or experimental (Node 22.23 prints a warning on
+ * every run), and the suite isn't run there. Before D-093 the reason was harsher: better-sqlite3's
+ * binary segfaulted under Node 22 (D-057, D-066). This module turns that into a sentence the user
+ * can act on. It imports nothing, so the entry point can call it before loading `node:sqlite`.
+ */
+/** The oldest Node.js major Nilometer runs on: `.nvmrc` (the development version) and `engines`. */
+export const SUPPORTED_NODE_MAJOR = 24;
+/**
+ * The majors the test suite runs on in CI: the long-term support lines from the minimum on (D-094).
+ * An odd major between them is short-lived and isn't run.
+ */
+export const TESTED_NODE_MAJORS = [24, 26];
+/** The tested majors as words, e.g. "24 or 26". */
+const TESTED_TEXT = TESTED_NODE_MAJORS.join(" or ");
+/** Where the install guide lives, relative to the repository root. */
+export const REQUIREMENTS_DOC = "docs/requirements.md";
+/**
+ * Decides whether a Node.js version can run Nilometer, and what to tell the user.
+ *
+ * Older majors stop: `node:sqlite` is missing or experimental there (D-093). A tested major runs
+ * quietly. Any other major from the minimum on runs with a warning, since no CI job runs it (D-066,
+ * D-094): Node 26 was such a major until SQLite 3.54 broke two views on it.
+ * @param version - `process.versions.node`, such as `24.21.0` (no leading `v`).
+ * @returns The status and the message to print, if any.
+ * @example
+ * checkNodeVersion("24.21.0").status; // "ok"
+ * checkNodeVersion("22.11.0").status; // "too_old"
+ */
+export function checkNodeVersion(version) {
+    // `process.versions.node` has no "v"; tolerate one anyway so a caller passing
+    // `process.version` gets the same answer.
+    const match = /^v?(\d+)\.\d+\.\d+/.exec(version);
+    if (match === null) {
+        return {
+            status: "unrecognized",
+            message: `Nilometer couldn't read the Node.js version ("${version}"). It needs Node.js ${TESTED_TEXT}; see ${REQUIREMENTS_DOC} if a command fails.`,
+        };
+    }
+    const major = Number(match[1]);
+    if (major < SUPPORTED_NODE_MAJOR) {
+        return {
+            status: "too_old",
+            message: `Nilometer needs Node.js ${SUPPORTED_NODE_MAJOR} or newer, and this is Node.js ${version}. Older versions lack the SQLite built into Node.js ${SUPPORTED_NODE_MAJOR}, or have only an experimental one. Install Node.js ${TESTED_TEXT} (see ${REQUIREMENTS_DOC} in the Nilometer repository) and run the command again. Nothing was changed.`,
+        };
+    }
+    if (!TESTED_NODE_MAJORS.includes(major)) {
+        return {
+            status: "untested",
+            message: `Nilometer is tested on Node.js ${TESTED_TEXT}, and this is Node.js ${version}. Other versions aren't tested; if a command fails, switch to Node.js ${TESTED_TEXT} (see ${REQUIREMENTS_DOC} in the Nilometer repository).`,
+        };
+    }
+    return { status: "ok", message: undefined };
+}
+//# sourceMappingURL=node-version.js.map

package/dist/core/util/open-page.js

@@ -0,0 +1,69 @@
+/**
+ * @file Opening a saved HTML page with the platform's own opener (D-082, step G2.10).
+ *
+ * `report --save --html --open` hands the page to whatever opens files on this machine: `open` on
+ * macOS, `start` on Windows, `xdg-open` elsewhere. Nothing here decides which browser runs. A failed
+ * open is reported to the caller, which still succeeds: the page is saved either way, and over SSH
+ * or in a script there may be no browser to open.
+ */
+import { spawnSync } from "node:child_process";
+import { invocation } from "./commands.js";
+/** How long an opener may take before it's taken as not having opened the page. */
+const OPENER_TIMEOUT_MS = 15_000;
+/**
+ * Names the platform's opener for a file.
+ * @param path - The file to open.
+ * @param platform - The platform.
+ * @returns The command and arguments.
+ * @example
+ * openerFor("/tmp/report.html", "darwin"); // { command: "open", args: ["/tmp/report.html"] }
+ */
+export function openerFor(path, platform) {
+    if (platform === "darwin") {
+        return { command: "open", args: [path] };
+    }
+    if (platform === "win32") {
+        // start is a cmd.exe builtin, and its first quoted word is a window title; the empty title
+        // keeps a quoted path from being read as one.
+        return { command: "start", args: ["", path] };
+    }
+    return { command: "xdg-open", args: [path] };
+}
+/**
+ * Runs an opener and waits for it to exit. `open`, `start`, and `xdg-open` hand the file over and
+ * return; the timeout covers one that doesn't.
+ * @param call - The command, arguments, and shell flag from {@link invocation}.
+ * @returns Its exit code, and the error when it couldn't start or timed out.
+ */
+export function spawnOpener(call) {
+    const result = spawnSync(call.command, call.args, {
+        shell: call.shell,
+        // Nothing the opener prints belongs in the report's output, which may be JSON on stdout.
+        stdio: "ignore",
+        timeout: OPENER_TIMEOUT_MS,
+    });
+    return { status: result.status, error: result.error };
+}
+/**
+ * Opens a saved page with the platform's opener (D-082).
+ * @param path - The saved page.
+ * @param deps - Injectable platform and process start.
+ * @returns Opened, or why not.
+ */
+export function openPage(path, deps = {}) {
+    const platform = deps.platform ?? process.platform;
+    const run = deps.run ?? spawnOpener;
+    const opener = openerFor(path, platform);
+    const result = run(invocation(opener.command, opener.args, platform));
+    if (result.error !== undefined) {
+        return { opened: false, reason: `${opener.command} couldn't run: ${result.error.message}` };
+    }
+    if (result.status !== 0) {
+        return {
+            opened: false,
+            reason: `${opener.command} exited with ${result.status === null ? "no code" : String(result.status)}`,
+        };
+    }
+    return { opened: true };
+}
+//# sourceMappingURL=open-page.js.map

package/dist/core/util/paths.js

@@ -0,0 +1,36 @@
+/**
+ * @file Path helpers shared by ingestion and `init`.
+ *
+ * Implements README § How it works (session logs are read from `~/.claude/projects/`).
+ * Paths in configuration and environment variables may start with `~`, which Node's `fs`
+ * does not expand, so every path from outside the program passes through {@link expandHome}.
+ */
+import { homedir } from "node:os";
+import { join } from "node:path";
+/**
+ * Expands a leading `~` in a path to the given home directory.
+ *
+ * Only the current user's home is supported: `~` alone and `~/...`. A `~user/...` form is
+ * returned unchanged, because resolving another user's home needs a system lookup this tool
+ * has no reason to make.
+ * @param path - A filesystem path, possibly starting with `~`.
+ * @param home - The home directory to substitute. Defaults to the current user's home; tests
+ *   pass a fixed value so results don't depend on the machine.
+ * @returns The path with `~` expanded, or the input unchanged if it has no leading `~`.
+ * @example
+ * expandHome("~/.claude/projects", "/home/example"); // "/home/example/.claude/projects"
+ * expandHome("/tmp/logs", "/home/example");          // "/tmp/logs"
+ */
+export function expandHome(path, home = homedir()) {
+    // A bare "~" means the home directory itself.
+    if (path === "~") {
+        return home;
+    }
+    // Only "~/" is expanded. "~user/" and "~" in the middle of a path are left alone on purpose.
+    if (path.startsWith("~/")) {
+        // join() normalizes separators, so "~//x" still becomes "<home>/x".
+        return join(home, path.slice(2));
+    }
+    return path;
+}
+//# sourceMappingURL=paths.js.map

package/dist/core/verify/compare.js

@@ -0,0 +1,77 @@
+/**
+ * @file Comparing token totals against ccusage, shared by the fixture audit and `nilometer verify`.
+ *
+ * The rules for "do these totals agree" live here once. The audit (check A7) applies them to the
+ * committed fixtures; `verify` applies the same rules to a user's own logs on their own machine
+ * (D-064). Two implementations of the same question would be free to drift, and the whole point of
+ * comparing against a reference implementation is that the comparison itself is trustworthy.
+ */
+/** The fields compared, in the order they're reported. */
+export const FIELDS = ["input", "output", "cache_read", "cache_write", "cost_usd"];
+/**
+ * Normalizes ccusage daily JSON to per-day, per-model totals.
+ * @param json - Parsed output of `ccusage claude daily --json --breakdown`.
+ * @returns Totals keyed by `"<day>|<model>"`.
+ */
+export function normalizeCcusage(json) {
+    const result = {};
+    for (const day of json.daily) {
+        for (const model of day.modelBreakdowns) {
+            result[`${day.date}|${model.modelName}`] = {
+                input: model.inputTokens,
+                output: model.outputTokens,
+                cache_read: model.cacheReadTokens,
+                // ccusage reports one cache-write total; its JSON has no 5m/1h split (skill § Comparing).
+                cache_write: model.cacheCreationTokens,
+                cost_usd: model.cost,
+            };
+        }
+    }
+    return result;
+}
+/**
+ * Compares two values of a field: token counts exactly, costs within floating-point noise.
+ * @param field - The field compared.
+ * @param a - One value.
+ * @param b - The other value.
+ * @returns True when the values are equal for that field.
+ */
+export function sameValue(field, a, b) {
+    if (field !== "cost_usd") {
+        return a === b;
+    }
+    // Summing binary floats in a different order differs in the 17th digit; a millionth of a cent doesn't.
+    return Math.abs(a - b) <= 1e-9 * Math.max(1, Math.abs(a), Math.abs(b));
+}
+/**
+ * Lists every field that differs between two totals maps.
+ * @param ours - Nilometer's totals.
+ * @param theirs - ccusage's totals.
+ * @param fields - Fields to compare; defaults to all of them.
+ * @returns Differences sorted by key, then field order.
+ */
+export function diffTotals(ours, theirs, fields = FIELDS) {
+    const differences = [];
+    const keys = [...new Set([...Object.keys(ours), ...Object.keys(theirs)])].sort();
+    for (const key of keys) {
+        for (const field of fields) {
+            // A day/model missing on one side compares as zero, so it shows up as a difference.
+            const oursValue = ours[key]?.[field] ?? 0;
+            const theirsValue = theirs[key]?.[field] ?? 0;
+            if (!sameValue(field, oursValue, theirsValue)) {
+                differences.push({ key, field, ours: oursValue, theirs: theirsValue });
+            }
+        }
+    }
+    return differences;
+}
+/**
+ * Takes the day out of a `"<day>|<model>"` key.
+ * @param key - The key.
+ * @returns The `YYYY-MM-DD` part.
+ */
+export function dayOf(key) {
+    // split always yields at least one element, so this needs no fallback.
+    return key.split("|")[0];
+}
+//# sourceMappingURL=compare.js.map