verifyhash 0.1.0

package/trustledger/close.js

@@ -0,0 +1,391 @@
+"use strict";
+
+// TrustLedger — close.js
+//
+// T-24.1: the versioned PERIOD-CLOSE artifact + pure build / read / validate,
+// plus a pure continuity check that chains one period to the next.
+//
+// THE PROBLEM THIS SOLVES.
+// A three-way trust reconciliation is a MONTHLY ritual. Each month's reconciled
+// ending balances become the NEXT month's opening balances — the "roll-forward".
+// If June closes at a bank balance of $12,345.67, July MUST open at exactly
+// $12,345.67; any other opening means a period was skipped, edited, or re-keyed,
+// and the chain of custody over the trust money is broken. This module emits a
+// small, strictly-validated JSON "close" artifact at the end of a period so the
+// next period can SEED its opening from it and the tool can CHECK the roll-forward
+// is penny-exact.
+//
+// PURE + DETERMINISTIC. `buildClose(model)` derives the artifact purely from the
+// report packet model (no clock, no I/O, no randomness). Given the same model it
+// returns a byte-identical artifact — including a deterministic `inputsDigest`
+// (a SHA-256 over the normalized inputs the packet already holds, via the
+// vendored pure-JS SHA-256 in ./lib/sha256-vendored — NO new dependency, NO
+// Node-only builtin, so this module is browser-portable; the vendored digest is
+// proven byte-identical to Node's `crypto` by test) that BINDS the close to the
+// data it summarizes, so a tampered or swapped close is detectable.
+//
+// HONEST POSTURE — the close is an UNTRUSTED CONVENIENCE HINT.
+// Consistent with the codebase's standing trust boundary (docs/TRUST-BOUNDARIES.md
+// and the receipt NatSpec): this artifact carries the prior period's ASSERTED
+// ending so the next run can seed + check the opening, but the AUTHORITATIVE
+// verdict is always the freshly RECOMPUTED reconciliation — never the value
+// written here. A broker who edits this file changes a hint, not the truth: the
+// next reconciliation recomputes the three balances from the source files and the
+// continuity check merely reports whether the asserted roll-forward matched. The
+// close is NOT signed and NOT timestamped; like every other artifact in this repo
+// it rides the human trust-root (the broker remains the legal custodian and a CPA
+// review still governs). It does not, and cannot, replace that review.
+
+const { sha256HexUtf8 } = require("./lib/sha256-vendored");
+
+// ---------------------------------------------------------------------------
+// Schema version. Bumped only on a breaking shape change. `validateClose`
+// REJECTS any other value rather than guessing — a close from a future/older
+// tool must be handled deliberately, never silently coerced.
+// ---------------------------------------------------------------------------
+
+const SCHEMA_VERSION = "trustledger.period-close/v1";
+
+// A SHA-256 hex digest is exactly 64 lowercase hex chars.
+const DIGEST_RE = /^[0-9a-f]{64}$/;
+
+// ---------------------------------------------------------------------------
+// Errors — STRICT. A malformed/ambiguous close raises a NAMED error rather than
+// being silently dropped, coerced, or partially accepted.
+// ---------------------------------------------------------------------------
+
+class CloseError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "CloseError";
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Small strict helpers
+// ---------------------------------------------------------------------------
+
+function isPlainObject(v) {
+  return v != null && typeof v === "object" && !Array.isArray(v);
+}
+
+// An integer-cents money value: a JS integer (no floats, no NaN, no Infinity).
+function isCents(v) {
+  return Number.isInteger(v);
+}
+
+// A { bank, book } balance pair where both legs are integer cents.
+function isBalancePair(v) {
+  return isPlainObject(v) && isCents(v.bank) && isCents(v.book);
+}
+
+// ---------------------------------------------------------------------------
+// The deterministic inputs digest.
+//
+// We hash a CANONICAL, order-stable JSON projection of the inputs the packet
+// already summarizes — the period, report date, opening, ending, subledger, and
+// the input record counts — so the digest is reproducible to the byte for the
+// same model and CHANGES if any of those summarized facts change. This binds the
+// close to its data without pulling in a new dependency: the vendored pure-JS
+// SHA-256 (./lib/sha256-vendored), byte-identical to Node's built-in crypto by
+// test, and portable to a browser where the Node `crypto` builtin does not exist.
+//
+// NOTE: this is a convenience integrity tag over the SUMMARY the close carries,
+// NOT a cryptographic proof of the underlying source files (which are the
+// authoritative inputs and are re-read on the next reconciliation). It lets a
+// reader detect a hand-edited close field; it is not a signature.
+// ---------------------------------------------------------------------------
+
+function canonicalInputs(parts) {
+  // Build the object with keys in a fixed, explicit order so JSON.stringify is
+  // byte-stable regardless of how the caller's model was assembled.
+  return JSON.stringify({
+    schemaVersion: SCHEMA_VERSION,
+    period: parts.period,
+    reportDate: parts.reportDate,
+    opening: { bank: parts.opening.bank, book: parts.opening.book },
+    ending: { bank: parts.ending.bank, book: parts.ending.book },
+    subledger: parts.subledger,
+    tiesOut: parts.tiesOut,
+    pass: parts.pass,
+    inputs: {
+      bankRecords: parts.inputs.bankRecords,
+      bookRecords: parts.inputs.bookRecords,
+      rentrollRecords: parts.inputs.rentrollRecords,
+    },
+  });
+}
+
+function digestInputs(parts) {
+  // Exactly crypto.createHash("sha256").update(canonicalInputs(parts), "utf8")
+  // .digest("hex"), computed by the vendored pure-JS SHA-256 so the browser
+  // path needs no Node builtin. Byte-identity with node:crypto is pinned by
+  // test/trustledger.browser-core.test.js (incl. the committed close fixtures).
+  return sha256HexUtf8(canonicalInputs(parts));
+}
+
+// ---------------------------------------------------------------------------
+// buildClose(model) — derive the close artifact PURELY from the packet model.
+//
+// Reuses model.opening / model.balances / model.period / model.reportDate and
+// the model's pass/tiesOut verdict. The `ending` balances are the period's
+// CLOSING bank/book ({ bank: model.balances.bank, book: model.balances.book });
+// `subledger` is model.balances.subledger. Computes the deterministic
+// inputsDigest. Returns a JSON-serializable object; byte-deterministic for a
+// given model.
+// ---------------------------------------------------------------------------
+
+function buildClose(model) {
+  if (!isPlainObject(model)) {
+    throw new CloseError("buildClose requires the report packet model object");
+  }
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(String(model.reportDate || ""))) {
+    throw new CloseError('model.reportDate must be a "YYYY-MM-DD" string');
+  }
+  if (!isBalancePair(model.balances)) {
+    throw new CloseError(
+      "model.balances must carry integer-cents bank/book balances"
+    );
+  }
+  if (!isCents(model.balances.subledger)) {
+    throw new CloseError("model.balances.subledger must be integer cents");
+  }
+
+  // opening: reuse model.opening when present (integer cents both legs), else
+  // treat the period as opening from zero. We never coerce a non-integer opening
+  // into something else — a present-but-garbled opening is a hard error.
+  let opening;
+  if (model.opening == null) {
+    opening = { bank: 0, book: 0 };
+  } else if (isBalancePair(model.opening)) {
+    opening = { bank: model.opening.bank, book: model.opening.book };
+  } else {
+    throw new CloseError(
+      "model.opening, when present, must carry integer-cents bank/book balances"
+    );
+  }
+
+  const ending = { bank: model.balances.bank, book: model.balances.book };
+  const subledger = model.balances.subledger;
+
+  // The verdict the close records: prefer the explicit pass flag, fall back to
+  // tiesOut. Both are booleans on the packet model.
+  const tiesOut = model.tiesOut === true;
+  const pass = model.pass === undefined ? tiesOut : model.pass === true;
+
+  const inputs = {
+    bankRecords: countOf(model, "bankRecords"),
+    bookRecords: countOf(model, "bookRecords"),
+    rentrollRecords: countOf(model, "rentrollRecords"),
+  };
+
+  const digestParts = {
+    period: model.period == null ? null : String(model.period),
+    reportDate: model.reportDate,
+    opening,
+    ending,
+    subledger,
+    tiesOut,
+    pass,
+    inputs,
+  };
+
+  const close = {
+    schemaVersion: SCHEMA_VERSION,
+    period: model.period == null ? null : String(model.period),
+    reportDate: model.reportDate,
+    opening,
+    ending,
+    subledger,
+    tiesOut,
+    pass,
+    inputs,
+    inputsDigest: digestInputs(digestParts),
+  };
+
+  // Self-check: the artifact we just built must itself validate. This guarantees
+  // build/validate stay in lock-step — a build can never emit something read
+  // back as corrupt.
+  validateClose(close);
+  return close;
+}
+
+// Pull a record count off the packet model's `inputs` block, defaulting to 0
+// when the model did not carry it. Always a non-negative integer in the digest.
+function countOf(model, key) {
+  const n = model.inputs && model.inputs[key];
+  return Number.isInteger(n) && n >= 0 ? n : 0;
+}
+
+// ---------------------------------------------------------------------------
+// readClose(text|obj) — parse + validate a close. Accepts either a JSON string
+// (parsed strictly — a parse error is a CloseError, not a thrown SyntaxError) or
+// an already-parsed object. Returns the validated object. STRICT: a partial or
+// corrupt close NEVER round-trips silently — validateClose rejects it.
+// ---------------------------------------------------------------------------
+
+function readClose(input) {
+  let obj;
+  if (typeof input === "string") {
+    try {
+      obj = JSON.parse(input);
+    } catch (e) {
+      throw new CloseError(`close is not valid JSON: ${e.message}`);
+    }
+  } else if (isPlainObject(input)) {
+    obj = input;
+  } else {
+    throw new CloseError("readClose requires a JSON string or a close object");
+  }
+  validateClose(obj);
+  return obj;
+}
+
+// ---------------------------------------------------------------------------
+// validateClose(obj) — STRICT structural + value validation. Throws a named
+// CloseError on the FIRST problem found; returns the object unchanged on success.
+// Rejects: a wrong schemaVersion; a missing/garbled period / reportDate /
+// opening / ending / subledger; a non-integer-cents balance; a malformed digest.
+// ---------------------------------------------------------------------------
+
+function validateClose(obj) {
+  if (!isPlainObject(obj)) {
+    throw new CloseError("close must be an object");
+  }
+
+  if (obj.schemaVersion !== SCHEMA_VERSION) {
+    throw new CloseError(
+      `unsupported schemaVersion: expected "${SCHEMA_VERSION}", got ${JSON.stringify(
+        obj.schemaVersion
+      )}`
+    );
+  }
+
+  // period: required key; null is allowed (a period label is optional metadata),
+  // but a present period MUST be a string — an object/number is garbled.
+  if (!("period" in obj)) {
+    throw new CloseError("close is missing `period`");
+  }
+  if (obj.period !== null && typeof obj.period !== "string") {
+    throw new CloseError("close.period must be a string or null");
+  }
+
+  // reportDate: required, a strict "YYYY-MM-DD" string.
+  if (!/^\d{4}-\d{2}-\d{2}$/.test(String(obj.reportDate || ""))) {
+    throw new CloseError('close.reportDate must be a "YYYY-MM-DD" string');
+  }
+
+  // opening / ending: required integer-cents { bank, book } pairs.
+  if (!("opening" in obj)) {
+    throw new CloseError("close is missing `opening`");
+  }
+  if (!isBalancePair(obj.opening)) {
+    throw new CloseError(
+      "close.opening must carry integer-cents bank/book balances"
+    );
+  }
+  if (!("ending" in obj)) {
+    throw new CloseError("close is missing `ending`");
+  }
+  if (!isBalancePair(obj.ending)) {
+    throw new CloseError(
+      "close.ending must carry integer-cents bank/book balances"
+    );
+  }
+
+  // subledger: required integer cents.
+  if (!("subledger" in obj)) {
+    throw new CloseError("close is missing `subledger`");
+  }
+  if (!isCents(obj.subledger)) {
+    throw new CloseError("close.subledger must be integer cents");
+  }
+
+  // verdict flags: required booleans.
+  if (typeof obj.tiesOut !== "boolean") {
+    throw new CloseError("close.tiesOut must be a boolean");
+  }
+  if (typeof obj.pass !== "boolean") {
+    throw new CloseError("close.pass must be a boolean");
+  }
+
+  // inputs: required record-count block, each a non-negative integer.
+  if (!isPlainObject(obj.inputs)) {
+    throw new CloseError("close is missing `inputs` record counts");
+  }
+  for (const k of ["bankRecords", "bookRecords", "rentrollRecords"]) {
+    const n = obj.inputs[k];
+    if (!Number.isInteger(n) || n < 0) {
+      throw new CloseError(`close.inputs.${k} must be a non-negative integer`);
+    }
+  }
+
+  // inputsDigest: required, a well-formed lowercase SHA-256 hex string.
+  if (typeof obj.inputsDigest !== "string" || !DIGEST_RE.test(obj.inputsDigest)) {
+    throw new CloseError(
+      "close.inputsDigest must be a 64-char lowercase hex SHA-256 digest"
+    );
+  }
+
+  return obj;
+}
+
+// ---------------------------------------------------------------------------
+// checkContinuity(priorClose, opening) — pure roll-forward check.
+//
+// Compares the prior period's asserted `ending` to THIS period's `opening`,
+// PENNY-EXACT. The comparison takes NO tolerance: a roll-forward must be exact,
+// so a one-cent drift is a real gap, not noise.
+//
+// Returns a structured result, never throwing on a gap (the CALLER decides how
+// to surface it — T-24.2 turns a gap into a continuity exception):
+//   { ok: <bool>, bankGap: <int cents>, bookGap: <int cents> }
+// where bankGap = opening.bank - priorEnding.bank (signed; positive means this
+// period opened HIGHER than the prior period closed) and likewise bookGap. `ok`
+// is true iff both gaps are exactly zero.
+//
+// A null/undefined priorClose means there is NO prior period to chain from (the
+// first period a broker runs): that is `{ ok: true }` — nothing to reconcile
+// against, so nothing can be out of continuity.
+//
+// SIDE-EFFECT FREE. Reads its arguments, returns a fresh object, mutates nothing.
+// Honest-posture reminder: a passing continuity check confirms the asserted
+// roll-forward is internally consistent; it does NOT independently verify the
+// prior period — the prior close is an untrusted hint, and the authoritative
+// numbers are the freshly recomputed reconciliation.
+// ---------------------------------------------------------------------------
+
+function checkContinuity(priorClose, opening) {
+  // No prior period to chain from.
+  if (priorClose == null) {
+    return { ok: true };
+  }
+
+  // The prior close must be a well-formed close to be compared against — a
+  // garbled prior is a hard error here (not a silent pass), because chaining
+  // from corrupt data would defeat the whole point of the check. Use readClose
+  // so a JSON string or object both work, and a corrupt one is rejected loudly.
+  const prior = readClose(priorClose);
+
+  if (!isBalancePair(opening)) {
+    throw new CloseError(
+      "checkContinuity opening must carry integer-cents bank/book balances"
+    );
+  }
+
+  const bankGap = opening.bank - prior.ending.bank;
+  const bookGap = opening.book - prior.ending.book;
+  const ok = bankGap === 0 && bookGap === 0;
+  return { ok, bankGap, bookGap };
+}
+
+module.exports = {
+  SCHEMA_VERSION,
+  CloseError,
+  buildClose,
+  readClose,
+  validateClose,
+  checkContinuity,
+  // exported for focused tests / reuse
+  digestInputs,
+};

package/trustledger/corpus.js

@@ -0,0 +1,159 @@
+"use strict";
+
+// TrustLedger — corpus loader + runner (T-44.2).
+//
+// A PURE loader/runner over the COMMITTED out-of-trust corpus under
+// trustledger/fixtures/corpus/. It discovers every scenario folder, runs each
+// one through the REAL reconcile + buildPacket verdict path (the SAME path the
+// CLI/--json reconcile exit code uses), and returns one structured ROW per
+// scenario describing what the corpus EXPECTS versus what the live engine
+// ACTUALLY does:
+//
+//   { id, control, principle, expected, actual, match }
+//
+// This module adds NO crypto, NO control logic, NO severity, and NO verdict
+// rule. It is a faithful caller: the verdict is read straight off
+// buildPacket's `model.pass` flag, exactly as the shipped reconcile gate exits.
+// The CLI (`vh trust corpus`) renders these rows; tests assert them. The whole
+// point is that a CPA or broker can RUN one command to confirm the gate FAILs
+// the exact frauds it claims to catch — WITHOUT reading test/.
+//
+// The runScenario body is a deliberate sibling of test/trustledger.corpus.test.js
+// (T-44.1): both drive the same fixture shape through the same real engine path.
+// Keeping the runner here (not only in the test) is what makes the corpus a
+// shippable, human-runnable artifact rather than a developer-only assertion.
+
+const fs = require("fs");
+const path = require("path");
+
+const report = require("./report");
+
+const CORPUS_DIR = path.join(__dirname, "fixtures", "corpus");
+
+// A scenario verdict is one of these two strings; the corpus meta records the
+// EXPECTED one and the live engine produces the ACTUAL one.
+const VERDICT = Object.freeze({ PASS: "PASS", FAIL: "FAIL" });
+
+// ---------------------------------------------------------------------------
+// Discovery + load.
+// ---------------------------------------------------------------------------
+
+function loadJSON(p) {
+  return JSON.parse(fs.readFileSync(p, "utf8"));
+}
+
+// Every scenario folder under the corpus root, sorted for a DETERMINISTIC row
+// order. A leading-underscore folder (e.g. _shared) holds shared artifacts (a
+// prior-close), not a scenario, and is skipped.
+function scenarioIds(corpusDir = CORPUS_DIR) {
+  return fs
+    .readdirSync(corpusDir, { withFileTypes: true })
+    .filter((d) => d.isDirectory() && !d.name.startsWith("_"))
+    .map((d) => d.name)
+    .sort();
+}
+
+// ---------------------------------------------------------------------------
+// Run ONE scenario through the REAL reconcile + buildPacket verdict path.
+//
+// inputs.json carries already-normalized record arrays (the shape ingest.js
+// produces) plus optional opening / policy / toleranceCents / a priorClosePath
+// (resolved relative to the corpus root, read as the raw close JSON buildPacket
+// re-validates). No engine code is touched — this is a faithful caller, the
+// SAME wiring the corpus regression test uses.
+// ---------------------------------------------------------------------------
+
+function buildArgs(inputs, corpusDir) {
+  const args = {
+    bank: inputs.bank,
+    book: inputs.book,
+    rentroll: inputs.rentroll,
+    reportDate: inputs.reportDate,
+    period: inputs.period,
+  };
+  if (inputs.opening) args.opening = inputs.opening;
+  if (inputs.policy) args.policy = inputs.policy;
+  if (inputs.toleranceCents !== undefined) {
+    args.toleranceCents = inputs.toleranceCents;
+  }
+  if (inputs.priorClosePath) {
+    // Read the prior close as the raw JSON string buildPacket accepts (it calls
+    // close.readClose, which re-validates). Resolved relative to the corpus root.
+    args.priorClose = fs.readFileSync(
+      path.join(corpusDir, inputs.priorClosePath),
+      "utf8"
+    );
+  }
+  return args;
+}
+
+// Run a single scenario folder -> the live packet model + a normalized result.
+// Returns { model, actual } where `actual` is "PASS"/"FAIL" read off model.pass
+// (the SAME flag the CLI reconcile exit code uses).
+function runScenario(id, corpusDir = CORPUS_DIR) {
+  const dir = path.join(corpusDir, id);
+  const inputs = loadJSON(path.join(dir, "inputs.json"));
+  const model = report.buildPacket(buildArgs(inputs, corpusDir));
+  const actual = model.pass ? VERDICT.PASS : VERDICT.FAIL;
+  return { model, actual };
+}
+
+// ---------------------------------------------------------------------------
+// Run the WHOLE corpus -> structured rows + an aggregate result.
+// ---------------------------------------------------------------------------
+
+// Reduce a meta.principle (which may be a full paragraph) to a SINGLE sentence,
+// so the table/JSON `principle` is the one-sentence trust-law annotation the
+// task calls for, not a wall of text. Deterministic: takes the text up to and
+// including the first sentence terminator, collapsing internal whitespace.
+function oneSentence(text) {
+  const s = String(text == null ? "" : text).replace(/\s+/g, " ").trim();
+  if (s === "") return "";
+  const m = s.match(/^[^.!?]*[.!?]/);
+  return (m ? m[0] : s).trim();
+}
+
+// Build the row for one scenario. `expected` comes from the committed meta;
+// `actual` from the live engine; `match` is their equality. A row also carries
+// the meta `control` and the one-sentence `principle` for the human table.
+function buildRow(id, corpusDir = CORPUS_DIR) {
+  const meta = loadJSON(path.join(corpusDir, id, "meta.json"));
+  const { actual } = runScenario(id, corpusDir);
+  const expected = meta.expectedVerdict;
+  return {
+    id,
+    control: meta.control,
+    principle: oneSentence(meta.principle),
+    expected,
+    actual,
+    match: expected === actual,
+  };
+}
+
+// Run every scenario. Returns:
+//   { rows, total, matched, mismatched, ok }
+// `ok` is true iff EVERY row matched — the CI-gateable condition the CLI exits
+// 0 on (and exits 3 on any mismatch / corpus drift). Rows are in deterministic
+// (sorted-id) order, so the output is reproducible run to run.
+function runCorpus(corpusDir = CORPUS_DIR) {
+  const rows = scenarioIds(corpusDir).map((id) => buildRow(id, corpusDir));
+  const matched = rows.filter((r) => r.match).length;
+  const mismatched = rows.length - matched;
+  return {
+    rows,
+    total: rows.length,
+    matched,
+    mismatched,
+    ok: mismatched === 0,
+  };
+}
+
+module.exports = {
+  CORPUS_DIR,
+  VERDICT,
+  scenarioIds,
+  runScenario,
+  buildRow,
+  runCorpus,
+  oneSentence,
+};

package/trustledger/dist/BUILD-PROVENANCE.json

@@ -0,0 +1,99 @@
+{
+  "schema": "verifyhash/build-provenance@1",
+  "description": "Maps the published TrustLedger standalone offline app's sha256 to the ordered, individually-hashed in-tree source files it inlines. Reproduce + attest the whole chain offline with: node trustledger/build-standalone.js --check",
+  "targets": {
+    "trustledger-standalone": {
+      "bundle": "trustledger-standalone.html",
+      "sidecar": "trustledger-standalone.html.sha256",
+      "bundleBytes": 273125,
+      "bundleSha256": "1afa0e08c9624505ad967ab88c91553c6af00b0e5e0f2b790ddf315741ed1742",
+      "sidecarLine": "1afa0e08c9624505ad967ab88c91553c6af00b0e5e0f2b790ddf315741ed1742  trustledger-standalone.html",
+      "page": {
+        "sourceFile": "trustledger/public/index.html",
+        "sourceSha256": "eee5780a7e7cc62dd4e4baf2bcbb2af47fb68babd95d4ad2d4fe1e54b0fee9d4"
+      },
+      "modules": [
+        {
+          "id": "sha256-vendored",
+          "synthetic": false,
+          "sourceFile": "trustledger/lib/sha256-vendored.js",
+          "sourceSha256": "9aa8ca87a66261e36b2468d0bf20f0598b97f818d3dfb3308b9452eb1b5eacbb",
+          "inlinedSha256": "9aa8ca87a66261e36b2468d0bf20f0598b97f818d3dfb3308b9452eb1b5eacbb",
+          "entry": false
+        },
+        {
+          "id": "policy-bundled-loader",
+          "synthetic": true,
+          "sourceFile": null,
+          "sourceSha256": null,
+          "inlinedSha256": "693cadeb0fb79f339532fd0df91bb655ae5c5055b32fd2644017a9fc86c135cb",
+          "note": "swapped body (bundled-policy loader shim; inlines trustledger/fixtures/policy/*.json) — defined in build-standalone.js, not a source file"
+        },
+        {
+          "id": "reconcile",
+          "synthetic": false,
+          "sourceFile": "trustledger/reconcile.js",
+          "sourceSha256": "0177964804e3e993891a3cca617b1a0421f14579ce4a5407741ab902eab44322",
+          "inlinedSha256": "0177964804e3e993891a3cca617b1a0421f14579ce4a5407741ab902eab44322",
+          "entry": false
+        },
+        {
+          "id": "policy",
+          "synthetic": false,
+          "sourceFile": "trustledger/policy.js",
+          "sourceSha256": "a07cf5252991281441e251df31c6336057a61bc0fe45aa81e5321f88b8353b74",
+          "inlinedSha256": "ce3f2b8902d7a94d7e5190808696f53f649fc1357c2c512e2c80884db4823b5e",
+          "entry": false
+        },
+        {
+          "id": "match",
+          "synthetic": false,
+          "sourceFile": "trustledger/match.js",
+          "sourceSha256": "e06f9bc39c66ee748b422270e4edddc67640d8ebdda27838b95ece0e0ba09988",
+          "inlinedSha256": "e06f9bc39c66ee748b422270e4edddc67640d8ebdda27838b95ece0e0ba09988",
+          "entry": false
+        },
+        {
+          "id": "ingest",
+          "synthetic": false,
+          "sourceFile": "trustledger/ingest.js",
+          "sourceSha256": "6076b1f88e05ee175ff134f2ba018454885c71659ce40fbb91f4fb96e2944920",
+          "inlinedSha256": "6076b1f88e05ee175ff134f2ba018454885c71659ce40fbb91f4fb96e2944920",
+          "entry": false
+        },
+        {
+          "id": "close",
+          "synthetic": false,
+          "sourceFile": "trustledger/close.js",
+          "sourceSha256": "ef9312871b59763d76de48e7b6e1225e920577d813e98c25bff66c95fc276134",
+          "inlinedSha256": "10f83eaa35167ef076cd03c03781480b660fb87e97d319a56ba1dd6a731a1f94",
+          "entry": false
+        },
+        {
+          "id": "report",
+          "synthetic": false,
+          "sourceFile": "trustledger/report.js",
+          "sourceSha256": "4fc13974d2b85482c972f2f9617f402a4e6ced04c712042b6bb727f146134bc6",
+          "inlinedSha256": "6e5623fd5f4560925b2dc06d135a1fcab9170b503b37ecfc1b7295f47de0a7c8",
+          "entry": false
+        },
+        {
+          "id": "license",
+          "synthetic": true,
+          "sourceFile": null,
+          "sourceSha256": null,
+          "inlinedSha256": "b9efa9635ddfd6c4beb6f8bf10f268b5b896a72898b42ba3ec73c5b50811380a",
+          "note": "swapped body (fail-closed offline license shim) — defined in build-standalone.js, not a source file"
+        },
+        {
+          "id": "door-core",
+          "synthetic": false,
+          "sourceFile": "trustledger/door-core.js",
+          "sourceSha256": "7c04cb3fbe338f3fd97059974b14d2977828434bd649ff23bef4c85ee57f5b46",
+          "inlinedSha256": "d3b2672104c4c2ed9a97f292f569c4f013bfa120c8085f33f9f054cf47c98654",
+          "entry": true
+        }
+      ]
+    }
+  }
+}