prehello 0.0.0-stage → 0.1.0

package/dist/adapters/skills.js

@@ -0,0 +1,155 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MAX_SKILLS_PER_DIR = void 0;
+exports.toRec = toRec;
+exports.discoverSkills = discoverSkills;
+exports.skillItems = skillItems;
+const node_path_1 = __importDefault(require("node:path"));
+const fs_safe_1 = require("../fs-safe");
+const frontmatter_1 = require("../text/frontmatter");
+const fmt_1 = require("../util/fmt");
+exports.MAX_SKILLS_PER_DIR = 400;
+function firstLine(body) {
+    for (const l of body.split("\n")) {
+        const t = l.trim().replace(/^#+\s*/, "");
+        if (t)
+            return t;
+    }
+    return "";
+}
+function toRec(name, file, realPath, text) {
+    const fm = (0, frontmatter_1.parseFrontmatter)(text);
+    const desc = (0, frontmatter_1.asString)(fm.data.description).trim() || firstLine(fm.body);
+    const dmi = fm.data["disable-model-invocation"];
+    return {
+        name: ((0, frontmatter_1.asString)(fm.data.name).trim() || name).slice(0, 200),
+        file,
+        realPath,
+        desc,
+        when: (0, frontmatter_1.asString)(fm.data.when_to_use).trim(),
+        body: fm.body,
+        fm: fm.data,
+        scopedTo: [...(0, frontmatter_1.asList)(fm.data.paths), ...(0, frontmatter_1.asList)(fm.data.globs)],
+        disableModelInvocation: dmi === true || (typeof dmi === "string" && /^(true|yes|on|1)$/i.test(dmi.trim())), // Claude Code docs: booleans accept yes/no/on/off/1/0
+    };
+}
+/** Find <dir>/<name>/SKILL.md (and, if recursive, deeper). Hidden directories (.trash, .system, …) are skipped. */
+function discoverSkills(ctx, dir, o = {}) {
+    const out = [];
+    const maxDepth = o.maxDepth ?? 4;
+    const visit = (d, depth) => {
+        for (const e of (0, fs_safe_1.listDir)(d)) {
+            if (out.length >= exports.MAX_SKILLS_PER_DIR) {
+                ctx.warn(`${ctx.display(dir)}: more than ${exports.MAX_SKILLS_PER_DIR} skills; only the first ${exports.MAX_SKILLS_PER_DIR} were counted, so skill totals here are a lower bound`);
+                return;
+            }
+            if (e.name.startsWith("."))
+                continue;
+            const p = node_path_1.default.join(d, e.name);
+            const isD = e.isDirectory() || (e.isSymbolicLink() && (0, fs_safe_1.isDir)(p));
+            if (!isD)
+                continue;
+            const f = node_path_1.default.join(p, "SKILL.md");
+            const r = ctx.read(f, o.jail ? { jail: o.jail } : {});
+            if (r.ok)
+                out.push(toRec(e.name, f, r.realPath, r.text));
+            else if (o.recursive && depth < maxDepth && e.isDirectory())
+                visit(p, depth + 1);
+        }
+    };
+    visit(dir, 0);
+    return out.sort((a, b) => (0, fmt_1.cmp)(a.file, b.file));
+}
+/**
+ * Turn a set of skills into: a listing item (name+description, loads up front), a body item (loads when the skill
+ * is used) and an on-demand item for skills the model cannot see (disable-model-invocation / overrides).
+ */
+function skillItems(ctx, s) {
+    const listed = [];
+    const hidden = [];
+    for (const r of s.recs) {
+        const line = s.lineFor(r);
+        if (line === null)
+            hidden.push(r);
+        else
+            listed.push({ r, line });
+    }
+    const items = [];
+    const noun = (k) => `skill${k === 1 ? "" : "s"}`;
+    const fromTag = s.tag.startsWith("from ");
+    const phrase = (k) => (fromTag ? `${k} ${noun(k)} ${s.tag}` : `${k} ${s.tag} ${noun(k)}`);
+    const bodyPhrase = (k) => (fromTag ? `${k} ${noun(k)} ${s.tag}` : `${k} ${s.tag}`);
+    const base = { agent: s.agent, path: s.dir, scope: s.scope, evidence: s.evidence, confidence: s.confidence };
+    if (listed.length) {
+        const text = listed.map((l) => l.line).join("\n") + "\n";
+        const raw = ctx.count(`skills-l|${s.agent}|${s.dir}|${text.length}`, text);
+        const prof = ctx.profile(s.agent);
+        const perAll = listed.map((l) => ({ label: sanitizeLabel(l.r.name), source: l.r.source, tokens: prof.apply(ctx.counter.count(l.line + "\n")).est }));
+        const per = [...perAll].sort((a, b) => b.tokens - a.tokens || (0, fmt_1.cmp)(a.label, b.label)).slice(0, 8).map(({ label, tokens }) => ({ label, tokens }));
+        const it = ctx.makeItem({
+            ...base,
+            kind: "skills-listing",
+            loadMode: s.listingMode,
+            raw,
+            chars: text.length,
+            label: `Skills listing (${phrase(listed.length)})`,
+            cardLabel: s.cardLabel ?? "skills listing",
+            notes: s.notes,
+            group: s.group,
+        });
+        it.breakdown = per;
+        // "What to cut" parts: one per plugin (or, without a plugin, the whole group), scaled so they add up to the item's estimate.
+        if (it.tokens) {
+            const groups = new Map();
+            for (const x of perAll) {
+                const key = x.source ? `plugin ${sanitizeLabel(x.source)}` : phrase(listed.length);
+                const g = groups.get(key) ?? { tokens: 0, count: 0 };
+                g.tokens += x.tokens;
+                g.count++;
+                groups.set(key, g);
+            }
+            const sum = [...groups.values()].reduce((a, g) => a + g.tokens, 0);
+            const k = sum > 0 ? it.tokens.est / sum : 1;
+            it.parts = [...groups.entries()]
+                .map(([name, g]) => ({ name, tokens: Math.round(g.tokens * k), count: g.count }))
+                .filter((x) => x.tokens > 0)
+                .sort((a, b) => b.tokens - a.tokens || (0, fmt_1.cmp)(a.name, b.name));
+        }
+        items.push(it);
+    }
+    const bodyOf = (rs) => rs.map((r) => r.body).join("\n") + "\n";
+    const visible = listed.map((l) => l.r);
+    if (visible.length) {
+        const text = bodyOf(visible);
+        items.push(ctx.makeItem({
+            ...base,
+            kind: "skill-body",
+            loadMode: "deferred",
+            raw: ctx.count(`skills-b|${s.agent}|${s.dir}|${text.length}`, text),
+            chars: text.length,
+            label: `Skill bodies (${bodyPhrase(visible.length)})`,
+            cardLabel: "skill bodies",
+            notes: ["loaded only when a skill is used; supporting files in the skill folder are not counted"],
+        }));
+    }
+    if (hidden.length) {
+        const text = bodyOf(hidden);
+        items.push(ctx.makeItem({
+            ...base,
+            kind: "skill-body",
+            loadMode: "on-demand",
+            raw: ctx.count(`skills-h|${s.agent}|${s.dir}|${text.length}`, text),
+            chars: text.length,
+            label: `Skills hidden from the model (${bodyPhrase(hidden.length)}, manual invoke only)`,
+            cardLabel: "manual-only skills",
+            notes: ["not in the listing; the body loads only if you invoke the skill yourself"],
+        }));
+    }
+    return items;
+}
+function sanitizeLabel(s) {
+    return s.replace(/[\u0000-\u001f\u007f-\u009f]/g, "?").slice(0, 60);
+}

package/dist/adapters/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/analyze/findings.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.crossFindings = crossFindings;
+exports.rankFindings = rankFindings;
+const context_1 = require("../context");
+const model_1 = require("../model");
+const fmt_1 = require("../util/fmt");
+const MAX_DUP_DOCS = 300;
+const MAX_DUP_PAIRS = 20;
+/** Cross-document findings (F2 duplicates) and MCP lower-bound notes (F5). */
+function crossFindings(ctx, agents) {
+    // Bounded on purpose: comparing every pair is quadratic, and 200 copies of one rule file are 19,900 "duplicate" pairs.
+    // Compare the biggest MAX_DUP_DOCS files, list the MAX_DUP_PAIRS most similar pairs, and say how many were left out.
+    const all = [...ctx.docs.values()].filter((d) => d.tokens >= 200 && d.shingles.size > 0).sort((x, y) => y.tokens - x.tokens || (0, fmt_1.cmp)(x.path, y.path));
+    const docs = all.slice(0, MAX_DUP_DOCS);
+    if (all.length > docs.length)
+        ctx.warn(`duplicate check compared only the ${MAX_DUP_DOCS} largest of ${all.length} context files`);
+    const pairs = [];
+    for (let i = 0; i < docs.length; i++) {
+        for (let j = i + 1; j < docs.length; j++) {
+            const a = docs[i];
+            const b = docs[j];
+            const sim = (0, context_1.jaccard)(a.shingles, b.shingles);
+            if (sim < 0.6)
+                continue;
+            const common = [...a.agents].filter((x) => b.agents.has(x));
+            let savings;
+            if (common.length) {
+                const smaller = Math.min(a.tokens, b.tokens);
+                savings = Math.round(ctx.profile(common[0]).apply(smaller).est * sim);
+            }
+            pairs.push({ a, b, sim, common, savings });
+        }
+    }
+    pairs.sort((x, y) => y.sim - x.sim || (y.savings ?? 0) - (x.savings ?? 0) || (0, fmt_1.cmp)(x.a.path, y.a.path) || (0, fmt_1.cmp)(x.b.path, y.b.path));
+    for (const { a, b, sim, common, savings } of pairs.slice(0, MAX_DUP_PAIRS)) {
+        ctx.addFinding({
+            id: "F2",
+            severity: "warn",
+            agent: common[0] ?? "all",
+            message: `${ctx.display(a.path)} and ${ctx.display(b.path)} are ~${Math.round(sim * 100)}% duplicate text${common.length ? "" : " (loaded by different agents)"}`,
+            paths: [a.path, b.path],
+            savingsTokens: savings,
+            confidence: sim >= 0.9 ? "high" : "medium",
+            data: { similarityPct: Math.round(sim * 100) },
+            fix: common.length
+                ? "Keep one copy. Claude Code @imports do not reduce cost, so delete the duplicate rather than importing it."
+                : "Different agents read these files, so do not delete either. To stop them drifting apart, make one the source of truth (for example, a CLAUDE.md that contains just `@AGENTS.md`, or a symlink). This saves no tokens.",
+        });
+    }
+    if (pairs.length > MAX_DUP_PAIRS) {
+        ctx.addFinding({
+            id: "F2",
+            severity: "info",
+            agent: "all",
+            message: `${pairs.length - MAX_DUP_PAIRS} more near-duplicate pairs are not listed (the ${MAX_DUP_PAIRS} most similar are shown)`,
+            paths: [],
+            confidence: "high",
+            data: { omittedPairs: pairs.length - MAX_DUP_PAIRS },
+        });
+    }
+    for (const ag of agents) {
+        const n = ag.totals.always.unmeasuredItems;
+        const unm = ag.items.filter((i) => i.loadMode === "always" && i.tokens === null);
+        const what = unm.every((i) => i.kind === "mcp-server") ? "MCP servers" : unm.some((i) => i.kind === "mcp-server") ? "MCP servers and unreadable files" : "files that could not be read";
+        if (n > 0 && !ag.presentInRepoOnly) {
+            ctx.addFinding({
+                id: "F5",
+                severity: "info",
+                agent: ag.id,
+                message: `${model_1.AGENT_NAMES[ag.id]}: ${n} always-loaded item${n > 1 ? "s are" : " is"} unmeasured (${what}); the always-on total is a lower bound ("at least")`,
+                paths: [],
+                confidence: "needs-your-call",
+                fix: unm.some((i) => i.kind === "mcp-server") ? "If a server is unused, disable or remove it in the agent's own settings. prehello never edits MCP configs." : undefined,
+            });
+        }
+    }
+}
+function rankFindings(fs) {
+    const sev = { warn: 0, info: 1 };
+    return [...fs].sort((a, b) => (b.savingsTokens ?? 0) - (a.savingsTokens ?? 0) || sev[a.severity] - sev[b.severity] || (0, fmt_1.cmp)(a.id, b.id) || (0, fmt_1.cmp)(a.message, b.message));
+}

package/dist/analyze/grade.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RUBRIC = void 0;
+exports.gradeAgent = gradeAgent;
+exports.RUBRIC = [
+    "Start at 100 points per agent. Rubric uses only documented guidelines; it is a heuristic, not an industry standard.",
+    "Always-on tokens as a share of the window (estimate): ≥20% −45 · ≥10% −30 · ≥5% −15 · ≥2% −5",
+    "Each always-on instruction file over its documented guideline (Claude Code 200 lines, Cursor rules 500 lines): −5, max −15",
+    "Each place content is silently truncated (Codex 32 KiB cap, MEMORY.md 200 lines/25 KB, skill description cap): −5, max −15",
+    "Each file the agent ignores (e.g. AGENTS.md under CLAUDE.md precedence, .md in .cursor/rules): −3, max −9",
+    "Each near-duplicate file pair (≥60% shared text): −5, max −10",
+    "Letters: A ≥ 90 · B ≥ 80 · C ≥ 70 · D ≥ 60 · F below",
+    "Unmeasured always-loaded items (e.g. MCP servers) are NOT scored (we don't punish what we can't see). The grade is marked provisional, and an A is capped at B, because a top grade cannot be certified for a setup we could only partly see.",
+    "No grade at all is printed when nothing that loads up front was measured.",
+];
+function gradeAgent(ag, findings, window) {
+    const reasons = [];
+    let score = 100;
+    const always = ag.totals.always.est;
+    const share = (always / window) * 100;
+    const shareCost = share >= 20 ? 45 : share >= 10 ? 30 : share >= 5 ? 15 : share >= 2 ? 5 : 0;
+    if (shareCost) {
+        score -= shareCost;
+        reasons.push(`always-on is ~${share.toFixed(1)}% of the window (−${shareCost})`);
+    }
+    const mine = findings.filter((f) => f.agent === ag.id || f.agent === "all");
+    const count = (pred) => mine.filter(pred).length;
+    const long = count((f) => f.id === "F1");
+    const trunc = count((f) => f.id === "F4" || f.id === "F8" || f.id === "F12");
+    const ignored = count((f) => f.id === "F7" || f.id === "F11");
+    const dup = count((f) => f.id === "F2" && !f.data?.omittedPairs);
+    const apply = (n, per, max, why) => {
+        if (!n)
+            return;
+        const c = Math.min(max, n * per);
+        score -= c;
+        reasons.push(`${n} ${why} (−${c})`);
+    };
+    apply(long, 5, 15, "file(s) over the documented length guideline");
+    apply(trunc, 5, 15, "silent truncation(s)");
+    apply(ignored, 3, 9, "ignored file(s)");
+    apply(dup, 5, 10, "duplicate pair(s)");
+    score = Math.max(0, score);
+    let letter = score >= 90 ? "A" : score >= 80 ? "B" : score >= 70 ? "C" : score >= 60 ? "D" : "F";
+    const unm = ag.totals.always.unmeasuredItems;
+    const partial = ag.lowerBound && unm === 0; // the scan budget cut the scan short
+    let cappedAt;
+    if (ag.lowerBound && letter === "A") {
+        // An "A" would claim a clean bill of health for a setup we could only partly see.
+        letter = "B";
+        cappedAt = "B";
+        reasons.push(partial ? "capped at B: the scan stopped at its budget, so a top grade cannot be certified" : `capped at B: ${unm} always-loaded item${unm > 1 ? "s" : ""} could not be measured, so a top grade cannot be certified`);
+    }
+    return { letter, score, provisional: ag.lowerBound, ...(cappedAt ? { cappedAt } : {}), reasons };
+}

package/dist/analyze/savings.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CUT_N = void 0;
+exports.cutCandidates = cutCandidates;
+exports.cutCandidatesWithSource = cutCandidatesWithSource;
+exports.savingsOf = savingsOf;
+exports.cardTiles = cardTiles;
+const fmt_1 = require("../util/fmt");
+/** Default number of groups in the "what to cut" line. */
+exports.DEFAULT_CUT_N = 3;
+/** Below this the cut list is noise, not advice. */
+const MIN_SAVINGS_TOKENS = 500;
+/**
+ * Things a person can actually remove and that cost tokens before the first message: a plugin's skills, a skills folder,
+ * an MCP server with a measured size. Instruction files and rules are NOT candidates (they are your own words; use the findings for those).
+ */
+function cutCandidates(items) {
+    return cutCandidatesWithSource(items).map(({ source: _source, ...c }) => c);
+}
+/** Same list, same order as cutCandidates(), plus the item each group came from (for renderers that need its scope / file). */
+function cutCandidatesWithSource(items) {
+    const out = [];
+    for (const it of items) {
+        if (it.loadMode !== "always" || !it.tokens || it.tokens.est <= 0)
+            continue;
+        if (it.kind === "skills-listing" && it.parts?.length) {
+            for (const p of it.parts)
+                out.push({ label: p.name, kind: "skills", tokens: p.tokens, count: p.count, source: it });
+        }
+        else if (it.kind === "skills-listing") {
+            out.push({ label: it.label.replace(/^Skills listing \((.*)\)$/, "$1"), kind: "skills", tokens: it.tokens.est, count: 1, source: it });
+        }
+        else if (it.kind === "mcp-server" && it.server) {
+            out.push({ label: `MCP server ${it.server.name}`, kind: "mcp", tokens: it.tokens.est, count: 1, source: it });
+        }
+    }
+    return out.sort((a, b) => b.tokens - a.tokens || (0, fmt_1.cmp)(a.label, b.label));
+}
+/** What removing the top `n` groups would save (estimate). Null when there is nothing meaningful to say. */
+function savingsOf(items, alwaysEst, window, n = exports.DEFAULT_CUT_N) {
+    const cands = cutCandidates(items);
+    if (!cands.length || alwaysEst <= 0)
+        return null;
+    const top = cands.slice(0, n);
+    const topTokens = top.reduce((s, c) => s + c.tokens, 0);
+    if (topTokens < MIN_SAVINGS_TOKENS)
+        return null;
+    const groupsTokens = cands.reduce((s, c) => s + c.tokens, 0);
+    return {
+        n: top.length,
+        top,
+        topTokens,
+        groupsTokens,
+        groupsCount: cands.length,
+        pctOfAlways: (topTokens / alwaysEst) * 100,
+        pctOfGroups: groupsTokens ? (topTokens / groupsTokens) * 100 : 0,
+        pctOfWindow: (topTokens / window) * 100,
+    };
+}
+/** A tile label must never read like a path: drop any word that looks like one ("3 legacy ~/.codex skills" -> "3 legacy skills"). */
+function pathFree(label) {
+    const words = label.split(/\s+/).filter((w) => w && !/[\\/~]/.test(w));
+    return words.join(" ") || "skills";
+}
+/**
+ * Always-on tiles for the card treemap. Skills listings and MCP servers are expanded into the SAME groups as the cut list
+ * (cutCandidates), so the card matches its headline; everything else keeps its generic card label ("rule file 2").
+ * Sorted by size. `anonymize` replaces plugin and MCP server names with "plugin 2" / "MCP server 1".
+ */
+function cardTiles(items, anonymize = false) {
+    const out = [];
+    cutCandidates(items).forEach((c, k) => {
+        const named = c.kind === "mcp" || /^plugin /.test(c.label);
+        out.push({ label: named ? c.label : pathFree(c.label), tokens: c.tokens, kind: c.kind === "mcp" ? "mcp" : "group", named, cut: k });
+    });
+    // Always-on items that are not removable groups: repeated generic labels collapse into one tile ("rule file x14"), not 14 slivers.
+    const plain = items.filter((i) => i.loadMode === "always" && i.tokens && i.tokens.est > 0 && i.kind !== "mcp-server" && i.kind !== "skills-listing");
+    const byLabel = new Map();
+    for (const it of plain) {
+        const g = byLabel.get(it.cardLabel) ?? { n: 0, tokens: 0 };
+        g.n++;
+        g.tokens += it.tokens.est;
+        byLabel.set(it.cardLabel, g);
+    }
+    for (const [label, g] of byLabel)
+        out.push({ label: g.n > 1 ? `${label} x${g.n}` : label, tokens: g.tokens, kind: "item", named: false });
+    out.sort((a, b) => b.tokens - a.tokens || (0, fmt_1.cmp)(a.label, b.label));
+    if (anonymize) {
+        let plugins = 0;
+        let servers = 0;
+        for (const t of out) {
+            if (!t.named)
+                continue;
+            t.label = t.kind === "mcp" ? `MCP server ${++servers}` : `plugin ${++plugins}`;
+            t.named = false;
+        }
+    }
+    // identical labels (two "3 user skills" groups, two servers with the same name) must stay distinguishable
+    const dup = new Map();
+    for (const t of out)
+        dup.set(t.label, (dup.get(t.label) ?? 0) + 1);
+    const idx = new Map();
+    for (const t of out) {
+        if ((dup.get(t.label) ?? 1) > 1) {
+            const k = (idx.get(t.label) ?? 0) + 1;
+            idx.set(t.label, k);
+            t.label = `${t.label} (${k})`;
+        }
+    }
+    return out;
+}

package/dist/analyze/summary.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.coverageOf = coverageOf;
+exports.mcpServersOf = mcpServersOf;
+exports.offendersOf = offendersOf;
+const fmt_1 = require("../util/fmt");
+/** What the scan measured vs. could not measure among always-on items. Counts only; no content. */
+function coverageOf(agent, items) {
+    const always = items.filter((i) => i.loadMode === "always");
+    const measuredKinds = {};
+    const unmeasuredKinds = {};
+    let m = 0;
+    let u = 0;
+    for (const it of always) {
+        if (it.tokens) {
+            m++;
+            measuredKinds[it.kind] = (measuredKinds[it.kind] ?? 0) + 1;
+        }
+        else {
+            u++;
+            unmeasuredKinds[it.kind] = (unmeasuredKinds[it.kind] ?? 0) + 1;
+        }
+    }
+    const servers = new Set(items.filter((i) => i.server).map((i) => `${i.server.name}|${i.path}|${i.scope}`));
+    return { agent, alwaysMeasuredItems: m, alwaysUnmeasuredItems: u, alwaysFraction: m + u ? m / (m + u) : null, measuredKinds, unmeasuredKinds, mcpServers: servers.size };
+}
+function mcpServersOf(items) {
+    const map = new Map();
+    for (const it of items) {
+        if (!it.server)
+            continue;
+        const key = `${it.server.name}|${it.path}|${it.scope}`;
+        const cur = map.get(key);
+        const measured = it.tokens !== null;
+        if (!cur)
+            map.set(key, { name: it.server.name, source: it.path, scope: it.scope, transport: it.server.transport, measured });
+        else
+            cur.measured = cur.measured && measured;
+    }
+    return [...map.values()].sort((a, b) => (0, fmt_1.cmp)(a.name, b.name) || (0, fmt_1.cmp)(a.source, b.source));
+}
+/** Heaviest always-on contributors. Aggregated listings (skills) are expanded into their biggest entries. */
+function offendersOf(agent, items, limit = 15) {
+    const out = [];
+    for (const it of items) {
+        if (it.loadMode !== "always" || !it.tokens)
+            continue;
+        if (it.breakdown && it.breakdown.length) {
+            for (const b of it.breakdown)
+                out.push({ agent, label: `skill "${b.label}"`, path: it.path, kind: it.kind, loadMode: it.loadMode, tokens: b.tokens, note: `inside ${it.label}` });
+        }
+        else {
+            out.push({ agent, label: it.label, path: it.path, kind: it.kind, loadMode: it.loadMode, tokens: it.tokens.est });
+        }
+    }
+    return out.sort((a, b) => b.tokens - a.tokens || (0, fmt_1.cmp)(a.label, b.label)).slice(0, limit);
+}

package/dist/analyze/totals.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumTotals = sumTotals;
+const model_1 = require("../model");
+function sumTotals(items) {
+    const out = {};
+    for (const m of model_1.LOAD_MODES)
+        out[m] = { est: 0, low: 0, high: 0, measuredItems: 0, unmeasuredItems: 0 };
+    for (const it of items) {
+        const t = out[it.loadMode];
+        if (!it.tokens) {
+            t.unmeasuredItems++;
+            continue;
+        }
+        t.est += it.tokens.est;
+        t.low += it.tokens.low;
+        t.high += it.tokens.high;
+        t.measuredItems++;
+    }
+    return out;
+}