@codyswann/lisa 4.45.17 → 4.47.0

package/all/copy-overwrite/scripts/lib/gate-failure-diagnosis.mjs

@@ -58,6 +58,8 @@ export const DIAGNOSIS = Object.freeze({
   COMMENT_TERMINATED: "comment-terminated",
   /** A type checker ran and reported errors in named files. */
   TYPE_ERRORS: "type-errors",
+  /** The prover printed a failure shape the project declared for its gate. */
+  DECLARED_FAILURE: "declared-failure",
   /** Output was read and matched nothing this module knows. */
   UNDIAGNOSED: "undiagnosed",
   /** No output was available to read, so nothing can be said. */
@@ -1107,7 +1109,11 @@ function classify(output, code, load, read, tempRoot) {
 
   return {
     kind: DIAGNOSIS.UNDIAGNOSED,
-    summary: "no recognised failure signature; the command's last lines follow",
+    summary:
+      "no recognised failure signature: Lisa could not read this tool's " +
+      "output, so nothing here is a verdict about the code. Re-run this one " +
+      "check on its own — the tool names what the classifier could not. The " +
+      "command's last lines follow",
     evidence: capped(tailLines(output)),
   };
 }
@@ -1381,6 +1387,81 @@ function findTerminatedComments(output, read) {
   return found;
 }
 
+/**
+ * The verdict for a transcript carrying a failure shape the project declared.
+ *
+ * ## Why the shapes come from OUTSIDE this module
+ *
+ * Everything above this function recognises a fixed set of transcript forms,
+ * and every content signature among them is a vitest or `tsc` form. A prover
+ * that prints anything else falls into the residual bucket wearing
+ * `UNPROVABLE` — the word this fleet reads as *"the box, re-run it somewhere
+ * quieter"* — so a run that genuinely measured a property and found it wanting
+ * is routed into the re-run path.
+ *
+ * The tempting repair is one more entry in the table. It does not converge:
+ * every project points its gates at provers this module has never seen, so
+ * each new one re-introduces the defect once and the cost is paid by whoever
+ * hits it first. Measured on one repository (CodySwannGT/lisa#3974), four
+ * distinct provers hit it — and a Lisa-repo-specific pattern in a module every
+ * consumer installs is the same objection that keeps a Lisa-repo-specific gate
+ * out of the shipped registry.
+ *
+ * So the project that owns the prover says how its output reads as measured,
+ * and this module carries the MECHANISM and none of the vocabulary. Nothing
+ * below names a tool, a script, or an artifact.
+ *
+ * ## Why the shapes are literal substrings and not patterns
+ *
+ * A declaration is untrusted input compiled from configuration, and this
+ * function parses a multi-megabyte transcript inside a git hook. A regular
+ * expression from config would be an operator-authored ReDoS with a
+ * transcript-sized haystack — see `SCRATCH_REMOVAL_RACE` and `PATH_DELIMITER`
+ * for how carefully this module already avoids that shape in patterns it wrote
+ * itself. A literal substring cannot backtrack, needs no escaping, and is what
+ * an operator copying a line out of a failed transcript would write anyway.
+ *
+ * ## Why this is consulted separately rather than folded into `classify`
+ *
+ * The runner calls it ONLY when the shipped classifier has already returned
+ * `undiagnosed`. That placement is the whole safety argument: a killed,
+ * refused, interfered-with or zero-test run never reaches a content signature
+ * at all, so a declaration cannot promote non-measurement into a failure. The
+ * guarantee is structural rather than a matter of where a line was inserted.
+ * @param {string|null|undefined} output The command's combined output.
+ * @param {Array<{gate: string, shape: string[]}>|null|undefined} declarations
+ *   What each gate sharing this prover declared its failure looks like.
+ * @returns {Diagnosis|null} The verdict, or null when nothing declared matched.
+ */
+export function declaredFailure(output, declarations) {
+  if (typeof output !== "string" || output.length === 0) return null;
+  if (!Array.isArray(declarations)) return null;
+
+  const lines = output.split("\n");
+  for (const declaration of declarations) {
+    const shapes = declaration?.shape;
+    if (!Array.isArray(shapes)) continue;
+    const matched = lines.filter(line =>
+      shapes.some(
+        shape =>
+          typeof shape === "string" && shape !== "" && line.includes(shape)
+      )
+    );
+    if (matched.length === 0) continue;
+    const gate = declaration.gate ?? null;
+    return {
+      kind: DIAGNOSIS.DECLARED_FAILURE,
+      summary:
+        `the prover printed a failure shape ${gate ?? "this project"} ` +
+        `declared, so it ran and found this property wanting. That is a ` +
+        `verdict about the code, not about the machine`,
+      evidence: capped(matched.map(line => line.trim())),
+      proves: gate,
+    };
+  }
+  return null;
+}
+
 /**
  * Classify a failure and say whose property it belongs to.
  *
@@ -1429,5 +1510,11 @@ export function diagnoseFailure(
   tempRoot
 ) {
   const verdict = classify(output, code, load, read, tempRoot);
-  return { ...verdict, proves: ATTRIBUTION[verdict.kind] ?? null };
+  // A verdict that already knows whose property it is keeps that answer. The
+  // static table maps a KIND to a gate, which cannot express a failure whose
+  // owner is whichever gate declared the shape that matched.
+  return {
+    ...verdict,
+    proves: verdict.proves ?? ATTRIBUTION[verdict.kind] ?? null,
+  };
 }

package/all/copy-overwrite/scripts/lisa-gates.mjs

@@ -193,6 +193,57 @@ export const STATE_FAMILIES = [CONTINUOUS];
 /** Keys on a gate entry that are settings rather than moments. */
 export const GATE_FIELDS = new Set(["run", "needs", "task", "reuse"]);
 
+/**
+ * The per-moment field saying how this gate's prover prints a MEASURED failure.
+ *
+ * `gate-failure-diagnosis.mjs` recognises a fixed set of transcript forms, and
+ * every content signature among them is a vitest or `tsc` form. A prover that
+ * prints anything else lands in the residual bucket wearing `UNPROVABLE` — the
+ * word this fleet reads as "the box, re-run it" — so a run that measured a
+ * property and found it wanting is routed into the re-run path
+ * (CodySwannGT/lisa#3974).
+ *
+ * Enumerating other tools' output in the shipped module cannot converge: every
+ * project points its gates at provers Lisa has never seen. So the project that
+ * OWNS the prover declares how its failure reads, beside the `run:` that names
+ * the prover.
+ *
+ * ## Why per MOMENT and not per gate
+ *
+ * The first draft put it on the gate, reasoning that output shape is a
+ * property of the prover. Two facts overruled that, and the second is the one
+ * with consequences.
+ *
+ * **A gate's prover already varies by moment.** `code-style` runs `lint:staged`
+ * at commit and `lint` at pull-request here; the first prints lint-staged's
+ * `✖ <task>` banner and the second does not. A gate-level shape would assert
+ * one prover's vocabulary for both.
+ *
+ * **The gate level is a CLOSED allowlist and the moment level is open.**
+ * `GATE_FIELDS` is exhaustive, so an older Lisa refuses any gate-level key it
+ * does not know — and refuses the WHOLE gates block with it. Measured against
+ * the packaged resolver this repository's own quality facade resolves first:
+ *
+ * ```
+ * Invalid gates configuration:
+ *   gates."code-style"."failure_shape" is not a moment Lisa knows.
+ * ```
+ *
+ * Every facade then reads `configured=false` and falls through to built-in
+ * behaviour, so declaring a shape would silently un-configure every job in the
+ * repository until the pin caught up. A moment entry's extra keys are ignored
+ * by an older validator instead, which makes the declaration inert there
+ * rather than destructive. Inert-until-upgraded is the safe direction; every
+ * other per-moment field (`await`, `posted_by`, `evidence`, `caller_chain`)
+ * already lives with the same property.
+ *
+ * The value is a list of literal substrings, not patterns. A regular
+ * expression from configuration would be an operator-authored ReDoS run
+ * against a multi-megabyte transcript inside a git hook, and a literal is what
+ * somebody copying a line out of a failed transcript writes anyway.
+ */
+export const FAILURE_SHAPE_FIELD = "failure_shape";
+
 /**
  * The per-declaration field naming the job chain this gate's prover sits under.
  *
@@ -4489,6 +4540,22 @@ function validateGate(id, gate) {
       // as "this is not a moment" and sends the author looking for a moment
       // spelling. The mistake is real but different: the field exists, and it
       // belongs one level down.
+      if (moment === FAILURE_SHAPE_FIELD) {
+        // Named before the generic typo message for the reason the caller
+        // chain is: "this is not a moment" sends the author looking for a
+        // moment spelling, and the mistake is a level, not a spelling.
+        problems.push(
+          `gates."${id}"."${FAILURE_SHAPE_FIELD}" is declared for the whole ` +
+            `gate, but a gate's prover can differ by moment — this ` +
+            `repository runs code-style through "lint:staged" at commit and ` +
+            `"lint" at pull-request, and only the first prints lint-staged's ` +
+            `own banner. Declare it inside the moment whose prover prints ` +
+            `it, e.g. gates."${id}"."${COMMIT}".${FAILURE_SHAPE_FIELD}. ` +
+            `A gate-level key is also refused outright by any older Lisa, ` +
+            `which refuses the whole gates block with it.`
+        );
+        continue;
+      }
       if (moment === CALLER_CHAIN_FIELD) {
         problems.push(
           `gates."${id}"."${CALLER_CHAIN_FIELD}" is declared for the whole ` +
@@ -4517,6 +4584,61 @@ function validateGate(id, gate) {
   return problems;
 }
 
+/**
+ * Validate a gate's declared failure shape.
+ *
+ * Three refusals, and all three are the same defect wearing different clothes:
+ * a declaration that looks configured and governs nothing.
+ *
+ * - **Not an array.** A bare string is the natural typo, and it would iterate
+ *   as characters — every transcript containing the letter `c` would match.
+ * - **Empty array.** Reads as "declared" at a glance and matches nothing ever.
+ * - **Empty string.** The declaration that cannot fail: an empty needle is
+ *   contained in every line, so every unrecognised failure would report FAILED
+ *   against whichever gate declared it. That is this mechanism's own inverse
+ *   defect, and shipping it by accident is one keystroke away.
+ * @param {string} id Gate id.
+ * @param {string} moment Moment key.
+ * @param {*} shape The declared value, if any.
+ * @returns {string[]} Problems.
+ */
+function validateFailureShape(id, moment, shape) {
+  if (shape === undefined) return [];
+  const where = `gates."${id}"."${moment}".${FAILURE_SHAPE_FIELD}`;
+  if (!Array.isArray(shape)) {
+    return [
+      `${where} is ${JSON.stringify(shape)}; expected a list of literal ` +
+        `strings this gate's prover prints when it measures the property and ` +
+        `finds it wanting. A bare string would be read one character at a ` +
+        `time, and every transcript contains most characters.`,
+    ];
+  }
+  if (shape.length === 0) {
+    return [
+      `${where} is empty, so it declares nothing while looking configured. ` +
+        `Remove it, or name the line the prover actually prints.`,
+    ];
+  }
+  const problems = [];
+  for (const [index, entry] of shape.entries()) {
+    if (typeof entry !== "string") {
+      problems.push(
+        `${where}[${index}] is ${JSON.stringify(entry)}; expected a literal ` +
+          `string from the prover's own output.`
+      );
+      continue;
+    }
+    if (entry.trim() === "") {
+      problems.push(
+        `${where}[${index}] is blank. An empty needle is contained in every ` +
+          `line, so this would report a measured failure for any output at ` +
+          `all — the inverse of the defect the field exists to fix.`
+      );
+    }
+  }
+  return problems;
+}
+
 /**
  * Validate a gate's reuse declaration (#3013).
  *
@@ -4620,6 +4742,9 @@ function validateMoment(id, moment, value, known, interceptor, gateRun) {
         `alongside it, or drop the evidence block — it governs nothing here.`
     );
   }
+  problems.push(
+    ...validateFailureShape(id, moment, entry[FAILURE_SHAPE_FIELD])
+  );
   problems.push(...validatePostedBy(id, moment, entry));
   problems.push(...validateCallerChain(id, moment, entry));
   if (!known && !interceptor && !entry.await && !entry.run && !gateRun) {
@@ -5107,7 +5232,7 @@ export function auditConfigKeys(config) {
  *   UNKNOWN, and an unknown manifest resolves exactly as it did before this
  *   option existed — a caller that has not been taught to read the manifest
  *   must not have its answers changed by silence.
- * @returns {Array<{id: string, level: string, mode: string, awaits: string|null, postedBy: number|null, declared: string|null, task: string|null, command: string|null, label: string, work: string|null, alias: {from: string, to: string}|null, evidence: {proof: string[], no_work: string[], on_hollow: string, wait_minutes: number|null, on_timeout: string}|null}>} Resolved provers, sorted by gate id. `declared` is the project's own `run:` — the PROVENANCE of the command, which `task` alone cannot carry because a project may spell its `run:` exactly as the registry default.
+ * @returns {Array<{id: string, level: string, mode: string, awaits: string|null, postedBy: number|null, declared: string|null, task: string|null, command: string|null, label: string, work: string|null, alias: {from: string, to: string}|null, evidence: {proof: string[], no_work: string[], on_hollow: string, wait_minutes: number|null, on_timeout: string}|null, callerChain: string[]|null, failureShape: string[]|null, mayRewrite: boolean, costly: boolean}>} Resolved provers, sorted by gate id. `declared` is the project's own `run:` — the PROVENANCE of the command, which `task` alone cannot carry because a project may spell its `run:` exactly as the registry default.
  */
 export function resolveMoment({
   gates,
@@ -5174,6 +5299,7 @@ export function resolveMoment({
           alias: null,
           evidence: null,
           callerChain: null,
+          failureShape: entry[FAILURE_SHAPE_FIELD] ?? null,
           mayRewrite: false,
           costly: false,
         });
@@ -5265,6 +5391,11 @@ export function resolveMoment({
       // malformed chain at declaration time; `contextsFor` refuses it again at
       // derivation time.
       callerChain: entry.await ? null : (entry[CALLER_CHAIN_FIELD] ?? null),
+      // Carried on every resolved entry, including an awaited one. It describes
+      // what the project SAID about this moment's prover, and the project said
+      // it whatever mode the moment resolves to — the same argument `declared`
+      // makes one field up.
+      failureShape: entry[FAILURE_SHAPE_FIELD] ?? null,
       mayRewrite: definition?.mayRewrite === true,
       costly: definition?.costly === true,
     });

package/all/copy-overwrite/scripts/lisa-run-gates.mjs

@@ -54,6 +54,7 @@ import { dirname, join, relative } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import {
+  declaredFailure,
   DIAGNOSIS,
   diagnoseFailure,
   ranNoTests,
@@ -423,7 +424,7 @@ function stateFor(kind) {
   return kind === DIAGNOSIS.KILLED ? STATE.KILLED : STATE.UNPROVABLE;
 }
 
-function execute(gate, exec) {
+function execute(gate, exec, declarations) {
   const { code, output } = normaliseExec(exec(gate.command, gate));
   if (code === 0) {
     // A zero exit is not by itself a measurement. A runner invoked with
@@ -466,7 +467,11 @@ function execute(gate, exec) {
   // reads exactly like a real gate failure — which is how one `exit 1` came to
   // have three distinct causes with re-running a rational response to all of
   // them (CodySwannGT/lisa#2897).
-  const diagnosis = diagnoseFailure(output, code);
+  const diagnosis = withDeclarations(
+    diagnoseFailure(output, code),
+    output,
+    declarations
+  );
   return {
     state: stateFor(diagnosis.kind),
     detail: `${gate.command} (exit ${shown}) — ${diagnosis.summary}`,
@@ -477,6 +482,53 @@ function execute(gate, exec) {
   };
 }
 
+/**
+ * Give a shape the project declared its say, but only where nothing else did.
+ *
+ * The shipped classifier knows a fixed set of transcript forms, and every
+ * prover outside that set lands in the residual bucket wearing `UNPROVABLE` —
+ * the word this fleet reads as "the box, re-run it". Enumerating other tools'
+ * output in a module every consumer installs cannot converge, so a project
+ * declares its own prover's measured-failure shape instead
+ * (CodySwannGT/lisa#3974).
+ *
+ * **Consulted ONLY on `undiagnosed`, and that is the entire safety argument.**
+ * A killed, refused, interfered-with or zero-test run is classified before any
+ * content signature is read, so it can never reach this function — a
+ * declaration cannot promote non-measurement into a failure. The guarantee is
+ * structural rather than a matter of where a line was inserted, which is what
+ * the constraint carried in from CodySwannGT/lisa#3946 asks for.
+ *
+ * **A declaration that matched nothing is REPORTED rather than dropped.** A
+ * mechanism wired to a field nothing reads passes exactly the way the current
+ * absence passes: silently. A typo'd shape and no shape at all must not look
+ * the same to the operator who wrote one.
+ * @param {object} diagnosis What the shipped classifier decided.
+ * @param {string|null|undefined} output The command's combined output.
+ * @param {Array<{gate: string, shape: string[]}>} declarations What the gates
+ *   sharing this prover declared.
+ * @returns {object} The diagnosis as it should read.
+ */
+function withDeclarations(diagnosis, output, declarations) {
+  if (diagnosis.kind !== DIAGNOSIS.UNDIAGNOSED) return diagnosis;
+  if (!Array.isArray(declarations) || declarations.length === 0) {
+    return diagnosis;
+  }
+  const declared = declaredFailure(output, declarations);
+  if (declared) return declared;
+  const count = declarations.reduce(
+    (total, entry) => total + (entry.shape?.length ?? 0),
+    0
+  );
+  return {
+    ...diagnosis,
+    summary:
+      `${diagnosis.summary}. ${count} declared failure shape(s) from ` +
+      `${declarations.map(entry => entry.gate).join(", ")} were consulted ` +
+      `and none matched, so the declaration did not help here`,
+  };
+}
+
 /**
  * Re-attribute one command's failure to the property it actually belongs to.
  *
@@ -658,7 +710,7 @@ function summarise(result, priorKills = []) {
  * @param {{proved: Map<string, object>, blockedBy: string|null, exec: Function}} ctx Run state.
  * @returns {{outcome: object, shared: object|undefined, ran: boolean}} The verdict.
  */
-function verdictFor(gate, { proved, blockedBy, exec, siblings }) {
+function verdictFor(gate, { proved, blockedBy, exec, siblings, declarations }) {
   const own = classifyStatic(gate);
   if (own) return { outcome: own, shared: undefined, ran: false };
 
@@ -704,7 +756,7 @@ function verdictFor(gate, { proved, blockedBy, exec, siblings }) {
       ran: false,
     };
   }
-  const raw = execute(gate, exec);
+  const raw = execute(gate, exec, declarations);
   return {
     outcome: attributed(gate, raw, siblings),
     raw,
@@ -768,12 +820,23 @@ export function runGates({
   // the failure belongs to — `coverage-adequacy` runs `test:cov` and
   // `test-correctness` is the one the timeout indicts.
   const sharers = new Map();
+  // Declared failure shapes, keyed the same way and for the same reason: one
+  // command runs once, and the shape that explains its output may have been
+  // declared by a gate other than the one that happened to run it.
+  const declaredShapes = new Map();
   for (const gate of resolved) {
     if (!gate.command) continue;
     sharers.set(
       gate.command,
       (sharers.get(gate.command) ?? new Set()).add(gate.id)
     );
+    if (!Array.isArray(gate.failureShape) || gate.failureShape.length === 0) {
+      continue;
+    }
+    declaredShapes.set(gate.command, [
+      ...(declaredShapes.get(gate.command) ?? []),
+      { gate: gate.id, shape: gate.failureShape },
+    ]);
   }
 
   // One command proves every gate that names it, so it runs once.
@@ -796,6 +859,7 @@ export function runGates({
       blockedBy,
       exec,
       siblings: sharers.get(gate.command) ?? new Set(),
+      declarations: declaredShapes.get(gate.command) ?? [],
     });
 
     // Only what this iteration actually executed is shareable, and `ran` says

package/dist/core/lisa-owned-hash-ledger.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAwmCjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA2gCjC,CAAC"}
+{"version":3,"file":"lisa-owned-hash-ledger.d.ts","sourceRoot":"","sources":["../../src/core/lisa-owned-hash-ledger.ts"],"names":[],"mappings":"AACA,6EAA6E;AAE7E;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAC3C,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CA6mCjC,CAAC;AAEH;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,+BAA+B,EAAE,QAAQ,CACpD,MAAM,CAAC,MAAM,EAAE,SAAS,MAAM,EAAE,CAAC,CAghCjC,CAAC"}

package/dist/core/lisa-owned-hash-ledger.js

@@ -365,9 +365,11 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "4503ddbe7bd54cd553db2b5952972d5319d6b6eb39a258b7c58577b61c7e7ce7",
         "45bff9913d5a9e75b712a67cd42fe69bd4620cf4d7807f153ea83ab24319f425",
         "503b51e9239411d07ce6b51dbe2b3079bb12e94bf7c0310e76247af19ff667e6",
+        "59cdf9163880189a18e1b9ff6e587048101812f424d219f429189f0978df8a0f",
         "5d0aee00b95dba43cae499f338358ad4b0286f869c993508c1146448e92bd777",
         "6742cc12ea14fc99b7bef31ff03df68d5c4610b56fad43107790372e6d777eb1",
         "6b72a6a71078c838fdb0531e74898a5e36d942cad424b20480e2cd370b5264eb",
+        "7f5f40819835d8f7cfc2fd36ce4c377ea9d52cd0d3d69fd8049996e0050e6d38",
         "7ffcd3f6a0595ae26c697bb0f77044b8a100200985774ad7059ebc3dc2e6bedd",
         "9bce79d2cdcf709be40fee1bec469796bee2bb06a4cd38b11905677b97c12bc3",
         "a36a7bd7845878e5f1f991e896739ba4cc468e50f562b71a251ebe193ca151b6",
@@ -537,6 +539,7 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "49f37c7e896df0c43c07827b02bbecc570cccf3c27b2f7741ed53dc139a7824c",
         "4a1dd584267006e0538590ec183d40f90a87a5eea40bf041027920145f4f39d3",
         "4b8236c11146725b2f0ae297c1741193bba2808cfc408336e9741dfa4eb424ad",
+        "4bbebb7516227532a13136e34f4ea86e7df3d5bb2524924871fdaab82c7562c8",
         "4e663692d9ae7d4631b6493674aa75e19b74fd35687d4b403a2d57effb877a97",
         "4fe7003d048086a366b9bea1711275c2186e095f4bf976279d1ff825fd4eca1d",
         "50cb619a56ed4c81c078ef4b680f781a6e0d89a606d3c68acab129f25e9aa893",
@@ -608,6 +611,7 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "d93cd07b576ab630a29cb381b9e845042684b6003fde290965bf9c2619d57314",
         "dab7ae5948e26b49eb4caf0ef6be5f3a29b6ed013edef73904a20ba5e06a1b22",
         "dbca450e5a17133841ab015e71808feb028996f8297fda362dbeca4f07af2352",
+        "de1bb66dd26e504a98485e090691df43dd22e961929abfc1bf70a32a4fb84959",
         "e13d9c5ee11648cebae22d71890c0b81415c72e5e5b977472bffa810dfe52dd4",
         "e1c5edde3e8ca79f079fe2f350a41c984ecbae152c09db8dde11957c26f9d2ba",
         "e35a175f8f97f841b2b21de7b6e62bc31eb6de2ba2fa502742325a5e95bf05eb",
@@ -900,6 +904,7 @@ export const LISA_OWNED_HASH_LEDGER = Object.freeze({
         "23574bf396cadfaa1e8f8c59b70bca4ecebd145e23917a90d79ee2ded74f2b69",
         "235c541534fc0eca510135ac39b9fbd196965fbeb54d42a09fbf052da1c925cd",
         "242ac60aa8d77842e3704c5568b426084d9f2643ec9bce2a0601f66497835093",
+        "2a961b0ea1a8cbd0311dbb3643b427afdf46157c9372165b1a757ad8efb7062b",
         "2d166a07c9809800771c7f41e515bff8d66c23aeeae2838dd52d5f2547037422",
         "305b0567b309eba1176d3ff003fe32e87731497130cddd1281bdbcd0dd08f733",
         "36f96d5be341004417d005746baeef902b610c5708b75c4a3fbbf84cf05b478c",
@@ -1488,8 +1493,10 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "4503ddbe7bd54cd553db2b5952972d5319d6b6eb39a258b7c58577b61c7e7ce7",
         "45bff9913d5a9e75b712a67cd42fe69bd4620cf4d7807f153ea83ab24319f425",
         "503b51e9239411d07ce6b51dbe2b3079bb12e94bf7c0310e76247af19ff667e6",
+        "59cdf9163880189a18e1b9ff6e587048101812f424d219f429189f0978df8a0f",
         "5d0aee00b95dba43cae499f338358ad4b0286f869c993508c1146448e92bd777",
         "6742cc12ea14fc99b7bef31ff03df68d5c4610b56fad43107790372e6d777eb1",
+        "7f5f40819835d8f7cfc2fd36ce4c377ea9d52cd0d3d69fd8049996e0050e6d38",
         "7ffcd3f6a0595ae26c697bb0f77044b8a100200985774ad7059ebc3dc2e6bedd",
         "9bce79d2cdcf709be40fee1bec469796bee2bb06a4cd38b11905677b97c12bc3",
         "a36a7bd7845878e5f1f991e896739ba4cc468e50f562b71a251ebe193ca151b6",
@@ -1640,6 +1647,7 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "49f37c7e896df0c43c07827b02bbecc570cccf3c27b2f7741ed53dc139a7824c",
         "4a1dd584267006e0538590ec183d40f90a87a5eea40bf041027920145f4f39d3",
         "4b8236c11146725b2f0ae297c1741193bba2808cfc408336e9741dfa4eb424ad",
+        "4bbebb7516227532a13136e34f4ea86e7df3d5bb2524924871fdaab82c7562c8",
         "4e663692d9ae7d4631b6493674aa75e19b74fd35687d4b403a2d57effb877a97",
         "4fe7003d048086a366b9bea1711275c2186e095f4bf976279d1ff825fd4eca1d",
         "50cb619a56ed4c81c078ef4b680f781a6e0d89a606d3c68acab129f25e9aa893",
@@ -1691,6 +1699,7 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "d6ce40929ead45c4df1fa79a607bc17b967a88df00833807d1e3b0b727964b1b",
         "d93cd07b576ab630a29cb381b9e845042684b6003fde290965bf9c2619d57314",
         "dab7ae5948e26b49eb4caf0ef6be5f3a29b6ed013edef73904a20ba5e06a1b22",
+        "de1bb66dd26e504a98485e090691df43dd22e961929abfc1bf70a32a4fb84959",
         "e1c5edde3e8ca79f079fe2f350a41c984ecbae152c09db8dde11957c26f9d2ba",
         "e35a175f8f97f841b2b21de7b6e62bc31eb6de2ba2fa502742325a5e95bf05eb",
         "e3bf3269817b857d20747b2c73c8088d95c281d4cae5e08d47086b7ac0fb23cf",
@@ -1959,6 +1968,7 @@ export const LISA_OWNED_HASH_HISTORY_DERIVED = Object.freeze({
         "23574bf396cadfaa1e8f8c59b70bca4ecebd145e23917a90d79ee2ded74f2b69",
         "235c541534fc0eca510135ac39b9fbd196965fbeb54d42a09fbf052da1c925cd",
         "242ac60aa8d77842e3704c5568b426084d9f2643ec9bce2a0601f66497835093",
+        "2a961b0ea1a8cbd0311dbb3643b427afdf46157c9372165b1a757ad8efb7062b",
         "2d166a07c9809800771c7f41e515bff8d66c23aeeae2838dd52d5f2547037422",
         "305b0567b309eba1176d3ff003fe32e87731497130cddd1281bdbcd0dd08f733",
         "36f96d5be341004417d005746baeef902b610c5708b75c4a3fbbf84cf05b478c",