@codyswann/lisa 4.6.9 → 4.6.11

package/dist/core/anchored-rewrite.d.ts

@@ -0,0 +1,153 @@
+/**
+ * anchored-rewrite — make every step of a multi-step text transform
+ * individually accountable (CodySwannGT/lisa#3081).
+ *
+ * @remarks
+ * ## The defect this removes
+ *
+ * A transform with N anchored rewrites, guarded by comparing its finished
+ * output to its input, passes as soon as **any one** step lands:
+ *
+ * ```ts
+ * const out = source.replace(A, A2).replace(B, B2);
+ * if (out === source) throw new Error("the rewrite no longer applies");
+ * ```
+ *
+ * That guard asks "did something change". It cannot answer "did everything I
+ * asked for happen". The N−1 other steps can silently stop matching and it
+ * stays green — and it degrades in the direction nobody watches, because it was
+ * written when N was 1, where the check is sound, and became unsound the moment
+ * a second step was added without anyone noticing the question had changed
+ * underneath them.
+ *
+ * It has already bitten this repository. CodySwannGT/lisa#2980 deleted the
+ * import line that the FIRST rewrite of a test fixture anchored on. The second
+ * rewrite still matched, so `out !== source`, so the guard passed — and the
+ * fixture built a module referencing `fileURLToPath` without importing it.
+ * Every case downstream then failed inside a module-resolution error, in a test
+ * about repository layout, for a reason that had nothing to do with what it was
+ * testing. The partially-applied output was not merely incomplete, it was
+ * **invalid**, and it surfaced far from the guard that let it through.
+ *
+ * ## Why a helper rather than a convention
+ *
+ * The remedy — assert each anchor is present before replacing — is uniform and
+ * cheap, and writing it by hand is three lines per step that read like noise.
+ * An idiom is adopted when the safe form is the SHORTEST one to write, so this
+ * module exists to make `replaceOrThrow(text, anchor, replacement, context)`
+ * shorter than the unguarded `text.replace(anchor, replacement)` plus the
+ * hand-rolled assertion it needs to be correct.
+ *
+ * ## The failure names the step
+ *
+ * "Something did not apply" is barely better than the guard it replaces: the
+ * reader still has to find which of the N steps it means. Every failure here
+ * names the anchor verbatim (truncated for legibility, never elided to a
+ * count), the caller-supplied `context`, and the step's `label` or ordinal when
+ * one is available. The replaced guard in #2980 said "the root default moved",
+ * which was not what had happened and sent its reader to the wrong file.
+ *
+ * ## Optional steps are declared, not implied
+ *
+ * Some rewrites genuinely may or may not apply — reconciling a block that a
+ * given host file may simply not have, for instance. A mechanism with no way to
+ * say that is a mechanism people route around, and a routed-around guard
+ * protects nothing. So `optional: true` is a first-class part of the rewrite
+ * shape: it says "this step is allowed to find nothing", it is visible in
+ * review, and it is visible to the `check:whole-output-guards` sweep, which
+ * reads a declared-optional step as accounted for rather than as a finding.
+ *
+ * `optional` never suppresses a REQUIRED step's failure — each entry carries
+ * its own flag, so one optional step in a list of four leaves the other three
+ * fully enforced.
+ * @module core/anchored-rewrite
+ */
+/** One anchored step of a multi-step transform. */
+export interface Rewrite {
+    /**
+     * The text (or pattern) the step replaces. A string anchor replaces its
+     * FIRST occurrence, matching `String.prototype.replace`; a regular
+     * expression replaces according to its own flags.
+     */
+    readonly anchor: string | RegExp;
+    /** What the anchor is replaced with. */
+    readonly replacement: string;
+    /**
+     * Whether this step is allowed to find nothing. Defaults to `false` — a step
+     * is REQUIRED unless it says otherwise, so forgetting the flag fails loudly
+     * rather than silently weakening the guard.
+     */
+    readonly optional?: boolean;
+    /**
+     * Human-readable name for this step, quoted in the failure. Without one the
+     * failure names the step by its 1-based position, which is usable but worse:
+     * a position shifts when someone inserts a step above it.
+     */
+    readonly label?: string;
+}
+/**
+ * A required anchored rewrite whose anchor was not present.
+ *
+ * Carries the anchor, label and context as fields as well as in the message so
+ * a caller that wants to report the miss its own way does not have to parse
+ * prose back out of a string.
+ */
+export declare class MissingAnchorError extends Error {
+    /** The anchor that was not found, verbatim. */
+    readonly anchor: string;
+    /** The step's label, or its 1-based position when it had none. */
+    readonly step: string;
+    /** What the caller said it was transforming. */
+    readonly context: string;
+    /**
+     * Build the failure, naming the step and quoting the anchor verbatim.
+     * @param anchor - The anchor that was not found.
+     * @param step - The step's label or 1-based position.
+     * @param context - What the caller said it was transforming.
+     */
+    constructor(anchor: string, step: string, context: string);
+}
+/**
+ * Replace an anchor, failing when it is not there.
+ *
+ * The shortest correct spelling of one step of a multi-step transform. Use it
+ * everywhere a rewrite is REQUIRED to land; for a step that may legitimately
+ * find nothing use {@link replaceOptional}, which says so in the source.
+ * @param text - The text to transform.
+ * @param anchor - The text or pattern to replace.
+ * @param replacement - What to put in its place.
+ * @param context - What is being transformed, quoted in the failure (e.g. the
+ *   file path, or the name of the fixture being built).
+ * @param step - Optional name for this step, quoted in the failure.
+ * @returns The transformed text.
+ * @throws {MissingAnchorError} When the anchor is not present.
+ */
+export declare function replaceOrThrow(text: string, anchor: string | RegExp, replacement: string, context: string, step?: string): string;
+/**
+ * Replace an anchor that is allowed not to be there.
+ *
+ * The declared escape hatch. It does exactly what a bare `.replace` does — the
+ * value is that it SAYS the step is optional, which a reader can see and the
+ * `check:whole-output-guards` sweep can read. A transform mixing required and
+ * optional steps stays fully enforced on the required ones.
+ * @param text - The text to transform.
+ * @param anchor - The text or pattern to replace, if present.
+ * @param replacement - What to put in its place.
+ * @returns The transformed text, or the input unchanged when absent.
+ */
+export declare function replaceOptional(text: string, anchor: string | RegExp, replacement: string): string;
+/**
+ * Apply an ordered list of anchored rewrites, each individually accountable.
+ *
+ * Steps run in order against the running text, so a later step may anchor on
+ * text an earlier one produced. The first REQUIRED step whose anchor is absent
+ * throws, naming that step — nothing partially applied is ever returned,
+ * because the throw happens before the caller receives anything.
+ * @param text - The text to transform.
+ * @param rewrites - The steps, in order.
+ * @param context - What is being transformed, quoted in any failure.
+ * @returns The transformed text.
+ * @throws {MissingAnchorError} On the first required step that does not apply.
+ */
+export declare function applyRewrites(text: string, rewrites: readonly Rewrite[], context: string): string;
+//# sourceMappingURL=anchored-rewrite.d.ts.map

package/dist/core/anchored-rewrite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchored-rewrite.d.ts","sourceRoot":"","sources":["../../src/core/anchored-rewrite.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAKH,mDAAmD;AACnD,MAAM,WAAW,OAAO;IACtB;;;;OAIG;IACH,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC;IACjC,wCAAwC;IACxC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B;;;;OAIG;IACH,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;CACzB;AAED;;;;;;GAMG;AACH,qBAAa,kBAAmB,SAAQ,KAAK;IAC3C,+CAA+C;IAC/C,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IAExB,kEAAkE;IAClE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,gDAAgD;IAChD,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB;;;;;OAKG;gBACS,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;CAY1D;AAyCD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,WAAW,EAAE,MAAM,EACnB,OAAO,EAAE,MAAM,EACf,IAAI,CAAC,EAAE,MAAM,GACZ,MAAM,CASR;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,MAAM,GAAG,MAAM,EACvB,WAAW,EAAE,MAAM,GAClB,MAAM,CAER;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,aAAa,CAC3B,IAAI,EAAE,MAAM,EACZ,QAAQ,EAAE,SAAS,OAAO,EAAE,EAC5B,OAAO,EAAE,MAAM,GACd,MAAM,CAaR"}

package/dist/core/anchored-rewrite.js

@@ -0,0 +1,192 @@
+/**
+ * anchored-rewrite — make every step of a multi-step text transform
+ * individually accountable (CodySwannGT/lisa#3081).
+ *
+ * @remarks
+ * ## The defect this removes
+ *
+ * A transform with N anchored rewrites, guarded by comparing its finished
+ * output to its input, passes as soon as **any one** step lands:
+ *
+ * ```ts
+ * const out = source.replace(A, A2).replace(B, B2);
+ * if (out === source) throw new Error("the rewrite no longer applies");
+ * ```
+ *
+ * That guard asks "did something change". It cannot answer "did everything I
+ * asked for happen". The N−1 other steps can silently stop matching and it
+ * stays green — and it degrades in the direction nobody watches, because it was
+ * written when N was 1, where the check is sound, and became unsound the moment
+ * a second step was added without anyone noticing the question had changed
+ * underneath them.
+ *
+ * It has already bitten this repository. CodySwannGT/lisa#2980 deleted the
+ * import line that the FIRST rewrite of a test fixture anchored on. The second
+ * rewrite still matched, so `out !== source`, so the guard passed — and the
+ * fixture built a module referencing `fileURLToPath` without importing it.
+ * Every case downstream then failed inside a module-resolution error, in a test
+ * about repository layout, for a reason that had nothing to do with what it was
+ * testing. The partially-applied output was not merely incomplete, it was
+ * **invalid**, and it surfaced far from the guard that let it through.
+ *
+ * ## Why a helper rather than a convention
+ *
+ * The remedy — assert each anchor is present before replacing — is uniform and
+ * cheap, and writing it by hand is three lines per step that read like noise.
+ * An idiom is adopted when the safe form is the SHORTEST one to write, so this
+ * module exists to make `replaceOrThrow(text, anchor, replacement, context)`
+ * shorter than the unguarded `text.replace(anchor, replacement)` plus the
+ * hand-rolled assertion it needs to be correct.
+ *
+ * ## The failure names the step
+ *
+ * "Something did not apply" is barely better than the guard it replaces: the
+ * reader still has to find which of the N steps it means. Every failure here
+ * names the anchor verbatim (truncated for legibility, never elided to a
+ * count), the caller-supplied `context`, and the step's `label` or ordinal when
+ * one is available. The replaced guard in #2980 said "the root default moved",
+ * which was not what had happened and sent its reader to the wrong file.
+ *
+ * ## Optional steps are declared, not implied
+ *
+ * Some rewrites genuinely may or may not apply — reconciling a block that a
+ * given host file may simply not have, for instance. A mechanism with no way to
+ * say that is a mechanism people route around, and a routed-around guard
+ * protects nothing. So `optional: true` is a first-class part of the rewrite
+ * shape: it says "this step is allowed to find nothing", it is visible in
+ * review, and it is visible to the `check:whole-output-guards` sweep, which
+ * reads a declared-optional step as accounted for rather than as a finding.
+ *
+ * `optional` never suppresses a REQUIRED step's failure — each entry carries
+ * its own flag, so one optional step in a list of four leaves the other three
+ * fully enforced.
+ * @module core/anchored-rewrite
+ */
+/** Longest anchor text quoted verbatim in a failure before truncation. */
+const ANCHOR_EXCERPT_LIMIT = 120;
+/**
+ * A required anchored rewrite whose anchor was not present.
+ *
+ * Carries the anchor, label and context as fields as well as in the message so
+ * a caller that wants to report the miss its own way does not have to parse
+ * prose back out of a string.
+ */
+export class MissingAnchorError extends Error {
+    /** The anchor that was not found, verbatim. */
+    anchor;
+    /** The step's label, or its 1-based position when it had none. */
+    step;
+    /** What the caller said it was transforming. */
+    context;
+    /**
+     * Build the failure, naming the step and quoting the anchor verbatim.
+     * @param anchor - The anchor that was not found.
+     * @param step - The step's label or 1-based position.
+     * @param context - What the caller said it was transforming.
+     */
+    constructor(anchor, step, context) {
+        super(`${context}: rewrite ${step} did not apply — the text does not contain ` +
+            `${excerpt(anchor)}. Re-anchor the rewrite on text that is still ` +
+            `there, or mark the step \`optional: true\` if it is allowed to find ` +
+            `nothing.`);
+        this.name = "MissingAnchorError";
+        this.anchor = anchor;
+        this.step = step;
+        this.context = context;
+    }
+}
+/**
+ * Quote an anchor for a failure message, truncating a long one.
+ * @param anchor - The anchor's source text.
+ * @returns A quoted, length-bounded excerpt.
+ */
+function excerpt(anchor) {
+    const quoted = JSON.stringify(anchor);
+    return quoted.length <= ANCHOR_EXCERPT_LIMIT
+        ? quoted
+        : `${quoted.slice(0, ANCHOR_EXCERPT_LIMIT)}…"`;
+}
+/**
+ * The anchor's source text, for reporting.
+ * @param anchor - A string or regular-expression anchor.
+ * @returns The text to quote in a failure.
+ */
+function anchorText(anchor) {
+    return typeof anchor === "string" ? anchor : String(anchor);
+}
+/**
+ * Whether an anchor is present in the text.
+ *
+ * A global regular expression is tested with a FRESH copy rather than the
+ * caller's: `RegExp.prototype.test` advances `lastIndex` on a `/g` pattern, so
+ * testing the caller's object first would leave it mid-string and make the
+ * `replace` that follows start from the wrong offset. That is a defect the
+ * presence check would have INTRODUCED, which is the worst kind for a guard to
+ * carry.
+ * @param text - The text being transformed.
+ * @param anchor - The anchor to look for.
+ * @returns Whether the anchor matches at least once.
+ */
+function anchorPresent(text, anchor) {
+    if (typeof anchor === "string")
+        return text.includes(anchor);
+    return new RegExp(anchor.source, anchor.flags.replace("g", "")).test(text);
+}
+/**
+ * Replace an anchor, failing when it is not there.
+ *
+ * The shortest correct spelling of one step of a multi-step transform. Use it
+ * everywhere a rewrite is REQUIRED to land; for a step that may legitimately
+ * find nothing use {@link replaceOptional}, which says so in the source.
+ * @param text - The text to transform.
+ * @param anchor - The text or pattern to replace.
+ * @param replacement - What to put in its place.
+ * @param context - What is being transformed, quoted in the failure (e.g. the
+ *   file path, or the name of the fixture being built).
+ * @param step - Optional name for this step, quoted in the failure.
+ * @returns The transformed text.
+ * @throws {MissingAnchorError} When the anchor is not present.
+ */
+export function replaceOrThrow(text, anchor, replacement, context, step) {
+    if (!anchorPresent(text, anchor)) {
+        throw new MissingAnchorError(anchorText(anchor), step === undefined ? "(unnamed)" : `"${step}"`, context);
+    }
+    return text.replace(anchor, replacement);
+}
+/**
+ * Replace an anchor that is allowed not to be there.
+ *
+ * The declared escape hatch. It does exactly what a bare `.replace` does — the
+ * value is that it SAYS the step is optional, which a reader can see and the
+ * `check:whole-output-guards` sweep can read. A transform mixing required and
+ * optional steps stays fully enforced on the required ones.
+ * @param text - The text to transform.
+ * @param anchor - The text or pattern to replace, if present.
+ * @param replacement - What to put in its place.
+ * @returns The transformed text, or the input unchanged when absent.
+ */
+export function replaceOptional(text, anchor, replacement) {
+    return text.replace(anchor, replacement);
+}
+/**
+ * Apply an ordered list of anchored rewrites, each individually accountable.
+ *
+ * Steps run in order against the running text, so a later step may anchor on
+ * text an earlier one produced. The first REQUIRED step whose anchor is absent
+ * throws, naming that step — nothing partially applied is ever returned,
+ * because the throw happens before the caller receives anything.
+ * @param text - The text to transform.
+ * @param rewrites - The steps, in order.
+ * @param context - What is being transformed, quoted in any failure.
+ * @returns The transformed text.
+ * @throws {MissingAnchorError} On the first required step that does not apply.
+ */
+export function applyRewrites(text, rewrites, context) {
+    return rewrites.reduce((current, rewrite, index) => {
+        if (rewrite.optional === true) {
+            return replaceOptional(current, rewrite.anchor, rewrite.replacement);
+        }
+        return replaceOrThrow(current, rewrite.anchor, rewrite.replacement, context, rewrite.label ?? `#${index + 1}`);
+    }, text);
+}
+//# sourceMappingURL=anchored-rewrite.js.map

package/dist/core/anchored-rewrite.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anchored-rewrite.js","sourceRoot":"","sources":["../../src/core/anchored-rewrite.ts"],"names":[],"mappings":"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"}

package/dist/core/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./config.js";
 export * from "./bootstrap-environment.js";
 export { Lisa, type LisaDependencies } from "./lisa.js";
+export * from "./anchored-rewrite.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/core/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAE,KAAK,gBAAgB,EAAE,MAAM,WAAW,CAAC;AACxD,cAAc,uBAAuB,CAAC"}

package/dist/core/index.js

@@ -1,4 +1,5 @@
 export * from "./config.js";
 export * from "./bootstrap-environment.js";
 export { Lisa } from "./lisa.js";
+export * from "./anchored-rewrite.js";
 //# sourceMappingURL=index.js.map

package/dist/core/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAyB,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,4BAA4B,CAAC;AAC3C,OAAO,EAAE,IAAI,EAAyB,MAAM,WAAW,CAAC;AACxD,cAAc,uBAAuB,CAAC"}

package/dist/core/upstream-evidence-manifest.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"upstream-evidence-manifest.d.ts","sourceRoot":"","sources":["../../src/core/upstream-evidence-manifest.ts"],"names":[],"mappings":"AACA,iFAAiF;AACjF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CA84EpE,CAAC;AAEL,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CA6kPjE,CAAC;AAEL,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAk6I/D,CAAC"}
+{"version":3,"file":"upstream-evidence-manifest.d.ts","sourceRoot":"","sources":["../../src/core/upstream-evidence-manifest.ts"],"names":[],"mappings":"AACA,iFAAiF;AACjF,eAAO,MAAM,0BAA0B,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAg5EpE,CAAC;AAEL,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAolPjE,CAAC;AAEL,sFAAsF;AACtF,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,CAk6I/D,CAAC"}

package/dist/core/upstream-evidence-manifest.js

@@ -139,7 +139,7 @@ export const UPSTREAM_EVIDENCE_MANIFEST = Object.freeze({
     "expo/create-only/jest.setup.local.ts": "f0266cf872f41b6599e476e135f0b8947c3d226abe5bc4e02fb4087c836abac0",
     "expo/create-only/jest.setup.pre.local.js": "92d24da88f69ac3d5325d2221b570308d13e81d02deaa936c24866ed1acd8363",
     "expo/create-only/lighthouserc-config.json": "48637345034564923cefc96ea8192d807b7d64f4f94a6daa63625ca71e1bea5b",
-    "expo/create-only/lighthouserc.js": "8e6fb0a37cd2884cec32378fcd8e213bc7489d2b9e9ad862e61c90435b2679a7",
+    "expo/create-only/lighthouserc.js": "5686fb51020edab301abe612b467b082c5d80580e78437914f0d6cbd434d905d",
     "expo/create-only/scripts/zap-baseline.sh": "7ecfcb911f2f2284eb672c9eb960a1588792a984a713cb2e5f5d9963b32af910",
     "expo/create-only/stryker.conf.json": "a49c9563b2a3337a7b4bc198e259cd06e681ed043b194506a90f9fe0e8eb6ab3",
     "expo/create-only/tsconfig.json": "fdb99e32d1588e75735755d7b5caab406ad8387c21a3d820cd3b40cb9218a191",
@@ -1085,6 +1085,7 @@ export const UPSTREAM_EVIDENCE_MANIFEST = Object.freeze({
     "scripts/check-security-floors.mjs": "6122404ea247c7d70718472e44bb007c0c5dad2fcc064c8a2d797cd9d0f85b29",
     "scripts/check-state-classification.mjs": "26baaa85c0758fa41f1f66257f7d3a31ea4dd5cf17a9c0acaa3e89caaaf6265a",
     "scripts/check-template-workflow-refs.mjs": "f784a822ae82f41b7501d61e45a1badeecb84f118083f4c53c66402d6c50ffa2",
+    "scripts/check-whole-output-guards.mjs": "bb3c959fe67a6f481a9b8442a5a9a51a49599b4efd8fbefe3329fdf5c96b9c02",
     "scripts/check-workflow-package-paths.mjs": "d057c7666ad048cfbd11a1ef83ad1e13fb1c61a9d399ec83221c99c4256728a1",
     "scripts/claude-remote-setup.sh": "0e33accf8aa057c70497f01c38bef9f9f3801d649272f583578d89201b242655",
     "scripts/clean-dist.mjs": "04970d768464acbf96ebeb77c16a6a3b3da56c744eef0da64c573c6152ee0dc7",
@@ -7075,6 +7076,7 @@ export const UPSTREAM_SURFACE_MANIFEST = Object.freeze({
     "scripts/check-security-floors.mjs": true,
     "scripts/check-state-classification.mjs": true,
     "scripts/check-template-workflow-refs.mjs": true,
+    "scripts/check-whole-output-guards.mjs": true,
     "scripts/check-workflow-package-paths.mjs": true,
     "scripts/claude-remote-setup.sh": true,
     "scripts/clean-dist.mjs": true,
@@ -7345,6 +7347,7 @@ export const UPSTREAM_SURFACE_MANIFEST = Object.freeze({
     "src/configs/worktrees.ts": true,
     "src/copilot/copilot-instructions-installer.ts": true,
     "src/copilot/plugin-installer.ts": true,
+    "src/core/anchored-rewrite.ts": true,
     "src/core/apply-receipt.ts": true,
     "src/core/bootstrap-environment.ts": true,
     "src/core/config.ts": true,
@@ -7438,6 +7441,7 @@ export const UPSTREAM_SURFACE_MANIFEST = Object.freeze({
     "src/migrations/ensure-jest-rn-mock-accessibility-manager.ts": true,
     "src/migrations/ensure-learnings-gitattributes.ts": true,
     "src/migrations/ensure-learnings-merge-driver.ts": true,
+    "src/migrations/ensure-lighthouse-collect-options.ts": true,
     "src/migrations/ensure-lisa-postinstall.ts": true,
     "src/migrations/ensure-oxlint-base-configs.ts": true,
     "src/migrations/ensure-playwright-dedicated-caller.ts": true,
@@ -7987,7 +7991,9 @@ export const UPSTREAM_SURFACE_MANIFEST = Object.freeze({
     "tests/unit/config/work-item-traceability-scope-gate.test.ts": true,
     "tests/unit/config/workspace-suite-collection.test.ts": true,
     "tests/unit/config/worktree-exclusion-anchoring.test.ts": true,
+    "tests/unit/configs/lighthouse-collect-config.test.ts": true,
     "tests/unit/configs/lintstaged-matcher-ordering.test.ts": true,
+    "tests/unit/core/anchored-rewrite.test.ts": true,
     "tests/unit/core/bootstrap-environment.test.ts": true,
     "tests/unit/core/fs-extra-namespace-callsites.test.ts": true,
     "tests/unit/core/fs-extra-namespace-members.test.ts": true,
@@ -8132,6 +8138,7 @@ export const UPSTREAM_SURFACE_MANIFEST = Object.freeze({
     "tests/unit/migrations/ensure-jest-rn-mock-accessibility-manager.test.ts": true,
     "tests/unit/migrations/ensure-learnings-gitattributes.test.ts": true,
     "tests/unit/migrations/ensure-learnings-merge-driver.test.ts": true,
+    "tests/unit/migrations/ensure-lighthouse-collect-options.test.ts": true,
     "tests/unit/migrations/ensure-lisa-postinstall.test.ts": true,
     "tests/unit/migrations/ensure-oxlint-base-configs.test.ts": true,
     "tests/unit/migrations/ensure-playwright-dedicated-caller.test.ts": true,
@@ -8192,6 +8199,7 @@ export const UPSTREAM_SURFACE_MANIFEST = Object.freeze({
     "tests/unit/scripts/check-orphan-test-processes.test.ts": true,
     "tests/unit/scripts/check-pipeline-status-reads.test.ts": true,
     "tests/unit/scripts/check-template-workflow-refs.test.ts": true,
+    "tests/unit/scripts/check-whole-output-guards.test.ts": true,
     "tests/unit/scripts/check-workflow-package-contracts.test.ts": true,
     "tests/unit/scripts/check-workflow-package-paths.test.ts": true,
     "tests/unit/scripts/codex-hook-filter.test.ts": true,