@markstanden/opencode-test-container 0.0.0-stage → 0.1.0

package/dist/contracts/version.d.ts

@@ -0,0 +1,44 @@
+/** The frozen evaluator-semantics version. */
+export declare const EVALUATOR_VERSION = 1;
+/** The package name recorded in every manifest and freeze receipt. */
+export declare const PACKAGE_NAME = "@markstanden/opencode-test-container";
+/** The installed package root, two levels above this module. */
+export declare function packageRoot(): string;
+/**
+ * Read the installed package version, or `unknown` when the metadata is
+ * unavailable. This never reads the caller's working directory.
+ * @returns The version string.
+ */
+export declare function packageVersion(): string;
+/**
+ * The content identity of the executing runtime tree.
+ * @param root The package root; defaults to the running installation.
+ * @param moduleFile The executing module file; defaults to this module.
+ * @returns A stable SHA-256 over sorted paths and file bytes.
+ */
+export declare function artifactSha256(root?: string, moduleFile?: string): string;
+/** The tool identity every manifest and freeze receipt carries. */
+export interface ToolIdentity {
+    /** The package name. */
+    name: string;
+    /** The installed package version, or `unknown`. */
+    version: string;
+    /** The checked evaluator-semantics version. */
+    evaluatorVersion: number;
+    /** The executing runtime content hash. */
+    artifactSha256: string;
+}
+/**
+ * Build the current tool identity. The default installation is cached; an
+ * explicit root is always recomputed.
+ * @param root The package root; defaults to the running installation.
+ * @returns The identity.
+ */
+export declare function toolIdentity(root?: string): ToolIdentity;
+/**
+ * Compare the frozen identity with the installation that is executing now.
+ * @param frozen The identity recorded at freeze time.
+ * @param current The executing identity.
+ * @returns Differences; empty means the same artefact.
+ */
+export declare function toolIdentityProblems(frozen: ToolIdentity, current?: ToolIdentity): string[];

package/dist/contracts/version.js

@@ -0,0 +1,147 @@
+/**
+ * The package and evaluator identity frozen with every campaign.
+ *
+ * The version comes from the installed package metadata and the artifact hash
+ * from the executing runtime tree, so a tarball can be traced to the artefact
+ * that produced its evidence without a Git checkout. The artifact hash covers
+ * executable JavaScript (or TypeScript when running from source) and the
+ * package manifest, so a changed build under the same version is detectable.
+ */
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { dirname, isAbsolute, join, relative, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+/** The frozen evaluator-semantics version. */
+export const EVALUATOR_VERSION = 1;
+/** The package name recorded in every manifest and freeze receipt. */
+export const PACKAGE_NAME = "@markstanden/opencode-test-container";
+/** The installed package root, two levels above this module. */
+export function packageRoot() {
+    return join(dirname(fileURLToPath(import.meta.url)), "..", "..");
+}
+/**
+ * Read the installed package version, or `unknown` when the metadata is
+ * unavailable. This never reads the caller's working directory.
+ * @returns The version string.
+ */
+export function packageVersion() {
+    const root = packageRoot();
+    for (const candidate of [
+        join(root, "package.json"),
+        join(root, "..", "package.json"),
+    ]) {
+        try {
+            const parsed = JSON.parse(readFileSync(candidate, "utf8"));
+            if (typeof parsed === "object" &&
+                parsed !== null &&
+                "version" in parsed &&
+                typeof parsed.version === "string") {
+                return parsed.version;
+            }
+        }
+        catch {
+            // try the next candidate
+        }
+    }
+    return "unknown";
+}
+/**
+ * The runtime tree that is actually executing, derived from the module's own
+ * location rather than the mere presence of a build.
+ * @param root The package root.
+ * @param moduleFile The executing module file.
+ * @returns The `src` or `dist` tree under `root`.
+ */
+function runtimeRoot(root, moduleFile) {
+    const rel = relative(root, moduleFile);
+    if (!rel.startsWith("..") && !isAbsolute(rel)) {
+        const top = rel.split(sep)[0];
+        if (top === "dist" || top === "src")
+            return join(root, top);
+    }
+    return existsSync(join(root, "src"))
+        ? join(root, "src")
+        : join(root, "dist");
+}
+/** Every file under a root, sorted by relative path. */
+function filesUnder(root) {
+    const files = [];
+    const walk = (directory) => {
+        for (const entry of readdirSync(directory, {
+            withFileTypes: true,
+        }).sort((left, right) => left.name.localeCompare(right.name))) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory())
+                walk(path);
+            else if (entry.isFile() && /\.(?:js|ts)$/.test(entry.name)) {
+                files.push(path);
+            }
+        }
+    };
+    if (existsSync(root))
+        walk(root);
+    return files.sort();
+}
+/**
+ * The content identity of the executing runtime tree.
+ * @param root The package root; defaults to the running installation.
+ * @param moduleFile The executing module file; defaults to this module.
+ * @returns A stable SHA-256 over sorted paths and file bytes.
+ */
+export function artifactSha256(root = packageRoot(), moduleFile = fileURLToPath(import.meta.url)) {
+    const hash = createHash("sha256");
+    for (const path of filesUnder(runtimeRoot(root, moduleFile))) {
+        hash.update(relative(root, path).split(sep).join("/"));
+        hash.update("\0");
+        hash.update(readFileSync(path));
+        hash.update("\0");
+    }
+    const manifest = join(root, "package.json");
+    if (existsSync(manifest) && statSync(manifest).isFile()) {
+        hash.update("package.json\0");
+        hash.update(readFileSync(manifest));
+    }
+    return hash.digest("hex");
+}
+let cachedIdentity = null;
+/**
+ * Build the current tool identity. The default installation is cached; an
+ * explicit root is always recomputed.
+ * @param root The package root; defaults to the running installation.
+ * @returns The identity.
+ */
+export function toolIdentity(root) {
+    if (root === undefined && cachedIdentity !== null)
+        return cachedIdentity;
+    const identity = {
+        name: PACKAGE_NAME,
+        version: packageVersion(),
+        evaluatorVersion: EVALUATOR_VERSION,
+        artifactSha256: artifactSha256(root),
+    };
+    if (root === undefined)
+        cachedIdentity = identity;
+    return identity;
+}
+/**
+ * Compare the frozen identity with the installation that is executing now.
+ * @param frozen The identity recorded at freeze time.
+ * @param current The executing identity.
+ * @returns Differences; empty means the same artefact.
+ */
+export function toolIdentityProblems(frozen, current = toolIdentity()) {
+    const problems = [];
+    if (frozen.name !== current.name) {
+        problems.push(`frozen tool name ${frozen.name} differs from executing ${current.name}`);
+    }
+    if (frozen.version !== current.version) {
+        problems.push(`frozen tool version ${frozen.version} differs from executing ${current.version}`);
+    }
+    if (frozen.evaluatorVersion !== current.evaluatorVersion) {
+        problems.push(`frozen evaluator version ${frozen.evaluatorVersion} differs from executing ${current.evaluatorVersion}`);
+    }
+    if (frozen.artifactSha256 !== current.artifactSha256) {
+        problems.push(`frozen tool artifact ${frozen.artifactSha256} differs from executing ${current.artifactSha256}`);
+    }
+    return problems;
+}

package/dist/evaluators/docs/analysis/accounting.d.ts

@@ -0,0 +1,140 @@
+/**
+ * Trial accounting for the analysis framework.
+ *
+ * One scheduled slot becomes one {@link TrialScored}: the shared
+ * `ac-scoring` scored-trial shape plus the utility its loaded evidence
+ * supports. Counting keeps planned slots, recorded launches, unproven
+ * directories, completed and usable runs, assessment states, gate outcomes
+ * and semantic outcomes as separate measures — a blocked gate is never a
+ * semantic failure, and an unassessed trial is never a zero.
+ */
+import { type DocumentationOutcome, type ScoredTrial, type UtilityWeights } from "../scoring.ts";
+import type { AssessmentStatus, AttemptState, TrialRecord } from "./records.ts";
+import type { Disposition, SlotSpec } from "./model.ts";
+/** How one observation relates to the frozen schedule. */
+export type { Disposition };
+/** The declared identity a scored trial carries. */
+export interface ScoredIdentity {
+    /** The scheduled slot number, or null for an undeclared observation. */
+    slot: number | null;
+    /** The declared pair id, when the slot belongs to a pair. */
+    pairId: string | undefined;
+    /** The scenario the slot declared. */
+    scenario: string;
+    /** The arm the slot declared. */
+    arm: string;
+    /** The repetition within scenario and arm. */
+    repetition: number;
+    /** The trial stamp the evidence was loaded under. */
+    stamp: string;
+}
+/** One scored trial: identity, shared scoring shape and derived utility. */
+export interface TrialScored {
+    /** The declared identity. */
+    identity: ScoredIdentity;
+    /** How the observation relates to the schedule. */
+    disposition: Disposition;
+    /** What the trial directory proved about the launch. */
+    attemptState: AttemptState;
+    /** The shared ac-scoring trial shape. */
+    trial: ScoredTrial;
+    /** The utility and its bounds. */
+    utility: {
+        score: number;
+        low: number;
+        high: number;
+        assessed: boolean;
+    };
+    /** The selected judgement layer's status. */
+    assessmentStatus: AssessmentStatus;
+    /** The recorded gate status, or `missing`. */
+    gateStatus: string;
+}
+/** Options for scoring one loaded trial against its declared slot. */
+export interface ScoreOptions {
+    /** The frozen utility weights. */
+    weights?: UtilityWeights;
+    /** Whether a non-compensable guardrail breach is established. */
+    guardrailBreach?: boolean;
+    /** How the observation relates to the schedule. */
+    disposition?: Disposition;
+}
+/** One set of accounting counts. */
+export interface AccountingCounts {
+    /** Scheduled slots in the declared population. */
+    planned: number;
+    /** Slots whose directory proves a recorded launch. */
+    recordedLaunches: number;
+    /** Directories or reservations that prove no launch either way. */
+    unprovenDirectories: number;
+    /** Planned slots with no directory at all. */
+    absent: number;
+    /** Recorded runs whose evidence is usable. */
+    completed: number;
+    /** Slots whose usability cannot be established. */
+    usableUnknown: number;
+    /** Recorded runs whose evidence is unusable. */
+    unusable: number;
+    /** Trials with a known documentation outcome (documentation coverage). */
+    documented: number;
+    /** Trials whose utility is fully known (scored population). */
+    assessed: number;
+    /** Observations excluded from the measured population. */
+    excluded: number;
+    /** Count per assessment status. */
+    assessmentStatuses: Record<AssessmentStatus, number>;
+    /** Primary-task results. */
+    primary: {
+        pass: number;
+        fail: number;
+        unknown: number;
+    };
+    /** Gate outcomes, kept separate from semantic outcomes. */
+    gate: {
+        pass: number;
+        blocked: number;
+        other: number;
+        missing: number;
+    };
+    /** Count per documentation outcome. */
+    outcomes: Record<DocumentationOutcome, number>;
+    /** Sum of assessed trial utilities. */
+    utilityTotal: number;
+    /** Full-population lower bound: assessed total plus missing lows. */
+    utilityLow: number;
+    /** Full-population upper bound: assessed total plus missing highs. */
+    utilityHigh: number;
+    /** Mean over planned slots, or null without a denominator. */
+    meanPerPlanned: number | null;
+    /** Mean over assessed trials, or null without a denominator. */
+    meanPerAssessed: number | null;
+}
+/**
+ * Score one loaded trial against its declared slot.
+ * @param record The loaded trial record.
+ * @param slot The manifest slot the record belongs to.
+ * @param options Weights, guardrail state and disposition overrides.
+ * @returns The scored trial with identity and utility bounds.
+ */
+export declare function scoreTrial(record: TrialRecord, slot: SlotSpec, options?: ScoreOptions): TrialScored;
+/**
+ * Aggregate one measured population.
+ * @param scored The scored trials, one per scheduled slot.
+ * @param planned The number of scheduled slots in the population.
+ * @returns The counts, totals and bounds.
+ */
+export declare function accountTrials(scored: readonly TrialScored[], planned: number): AccountingCounts;
+/**
+ * Aggregate one population per declared arm.
+ * @param scored The scored trials.
+ * @param slots The declared schedule slots, for planned denominators.
+ * @returns Counts keyed by arm id, sorted.
+ */
+export declare function accountByArm(scored: readonly TrialScored[], slots: readonly SlotSpec[]): Record<string, AccountingCounts>;
+/**
+ * Aggregate one population per arm and scenario.
+ * @param scored The scored trials.
+ * @param slots The declared schedule slots, for planned denominators.
+ * @returns Counts keyed by arm then scenario, with only present combinations.
+ */
+export declare function accountByScenarioArm(scored: readonly TrialScored[], slots: readonly SlotSpec[]): Record<string, Record<string, AccountingCounts>>;

package/dist/evaluators/docs/analysis/accounting.js

@@ -0,0 +1,237 @@
+/**
+ * Trial accounting for the analysis framework.
+ *
+ * One scheduled slot becomes one {@link TrialScored}: the shared
+ * `ac-scoring` scored-trial shape plus the utility its loaded evidence
+ * supports. Counting keeps planned slots, recorded launches, unproven
+ * directories, completed and usable runs, assessment states, gate outcomes
+ * and semantic outcomes as separate measures — a blocked gate is never a
+ * semantic failure, and an unassessed trial is never a zero.
+ */
+import { DEFAULT_WEIGHTS, trialUtility, } from "../scoring.js";
+/** The assessment states every accounting record counts. */
+const ASSESSMENT_STATUSES = [
+    "judged",
+    "invalid-verdict",
+    "judge-error",
+    "unassessed",
+    "not-run",
+    "unknown",
+];
+/** The documentation outcomes every accounting record counts. */
+const OUTCOME_KEYS = [
+    "useful-create",
+    "useful-update",
+    "transient",
+    "duplicate",
+    "misleading",
+    "none",
+];
+/** Start a zeroed accounting record. */
+function emptyCounts(planned) {
+    const assessmentStatuses = {};
+    for (const status of ASSESSMENT_STATUSES)
+        assessmentStatuses[status] = 0;
+    const outcomes = {};
+    for (const outcome of OUTCOME_KEYS)
+        outcomes[outcome] = 0;
+    return {
+        planned,
+        recordedLaunches: 0,
+        unprovenDirectories: 0,
+        absent: 0,
+        completed: 0,
+        usableUnknown: 0,
+        unusable: 0,
+        documented: 0,
+        assessed: 0,
+        excluded: 0,
+        assessmentStatuses,
+        primary: { pass: 0, fail: 0, unknown: 0 },
+        gate: { pass: 0, blocked: 0, other: 0, missing: 0 },
+        outcomes,
+        utilityTotal: 0,
+        utilityLow: 0,
+        utilityHigh: 0,
+        meanPerPlanned: null,
+        meanPerAssessed: null,
+    };
+}
+/**
+ * Score one loaded trial against its declared slot.
+ * @param record The loaded trial record.
+ * @param slot The manifest slot the record belongs to.
+ * @param options Weights, guardrail state and disposition overrides.
+ * @returns The scored trial with identity and utility bounds.
+ */
+export function scoreTrial(record, slot, options = {}) {
+    const disposition = options.disposition ?? slot.disposition ?? "first-attempt";
+    const trial = {
+        arm: slot.arm,
+        scenario: slot.scenario,
+        planned: disposition !== "excluded",
+        usable: record.attempt.usable === true,
+        outcome: record.assessment.outcome,
+        primary: record.primary.status,
+        guardrailBreach: options.guardrailBreach ?? false,
+    };
+    return {
+        identity: {
+            slot: slot.slot,
+            pairId: slot.pairId,
+            scenario: slot.scenario,
+            arm: slot.arm,
+            repetition: slot.repetition,
+            stamp: slot.stamp,
+        },
+        disposition,
+        attemptState: record.attempt.state,
+        trial,
+        utility: trialUtility(trial, options.weights ?? DEFAULT_WEIGHTS),
+        assessmentStatus: record.assessment.status,
+        gateStatus: record.gate.state === "available"
+            ? record.gate.value.status
+            : "missing",
+    };
+}
+/**
+ * Count what one trial's attempt record proves.
+ * @param counts The counts to update.
+ * @param row The scored trial.
+ */
+function addAttempt(counts, row) {
+    if (row.attemptState === "recorded") {
+        counts.recordedLaunches += 1;
+    }
+    else if (row.attemptState === "absent") {
+        counts.absent += 1;
+    }
+    else {
+        counts.unprovenDirectories += 1;
+    }
+    if (row.attemptState !== "recorded") {
+        counts.usableUnknown += 1;
+    }
+    else if (row.trial.usable) {
+        counts.completed += 1;
+    }
+    else {
+        counts.unusable += 1;
+    }
+}
+/**
+ * Count one trial's assessment, gate and primary outcomes.
+ * @param counts The counts to update.
+ * @param row The scored trial.
+ */
+function addAssessment(counts, row) {
+    counts.assessmentStatuses[row.assessmentStatus] += 1;
+    if (row.trial.primary === "pass")
+        counts.primary.pass += 1;
+    else if (row.trial.primary === "fail")
+        counts.primary.fail += 1;
+    else
+        counts.primary.unknown += 1;
+    if (row.gateStatus === "pass")
+        counts.gate.pass += 1;
+    else if (row.gateStatus === "blocked")
+        counts.gate.blocked += 1;
+    else if (row.gateStatus === "missing")
+        counts.gate.missing += 1;
+    else
+        counts.gate.other += 1;
+    if (row.assessmentStatus === "judged" && row.trial.outcome !== undefined) {
+        counts.documented += 1;
+        counts.outcomes[row.trial.outcome] += 1;
+    }
+}
+/**
+ * Aggregate one measured population.
+ * @param scored The scored trials, one per scheduled slot.
+ * @param planned The number of scheduled slots in the population.
+ * @returns The counts, totals and bounds.
+ */
+export function accountTrials(scored, planned) {
+    const counts = emptyCounts(planned);
+    let missingLow = 0;
+    let missingHigh = 0;
+    for (const row of scored) {
+        if (row.disposition === "excluded") {
+            counts.excluded += 1;
+            continue;
+        }
+        addAttempt(counts, row);
+        addAssessment(counts, row);
+        if (row.utility.assessed) {
+            counts.assessed += 1;
+            counts.utilityTotal += row.utility.score;
+        }
+        else {
+            missingLow += row.utility.low;
+            missingHigh += row.utility.high;
+        }
+    }
+    counts.utilityLow = counts.utilityTotal + missingLow;
+    counts.utilityHigh = counts.utilityTotal + missingHigh;
+    counts.meanPerPlanned =
+        planned === 0 ? null : counts.utilityTotal / planned;
+    counts.meanPerAssessed =
+        counts.assessed === 0 ? null : counts.utilityTotal / counts.assessed;
+    return counts;
+}
+/**
+ * Aggregate one population per declared arm.
+ * @param scored The scored trials.
+ * @param slots The declared schedule slots, for planned denominators.
+ * @returns Counts keyed by arm id, sorted.
+ */
+export function accountByArm(scored, slots) {
+    const arms = [
+        ...new Set([
+            ...slots.map((slot) => slot.arm),
+            ...scored.map((row) => row.trial.arm),
+        ]),
+    ].sort();
+    const byArm = {};
+    for (const arm of arms) {
+        byArm[arm] = accountTrials(scored.filter((row) => row.trial.arm === arm), slots.filter((slot) => slot.arm === arm).length);
+    }
+    return byArm;
+}
+/**
+ * Aggregate one population per arm and scenario.
+ * @param scored The scored trials.
+ * @param slots The declared schedule slots, for planned denominators.
+ * @returns Counts keyed by arm then scenario, with only present combinations.
+ */
+export function accountByScenarioArm(scored, slots) {
+    const byScenario = {};
+    for (const [arm, armSlots] of Object.entries(groupSlotsByArm(slots)).sort(([left], [right]) => left.localeCompare(right))) {
+        const scenarios = [
+            ...new Set([
+                ...armSlots.map((slot) => slot.scenario),
+                ...scored
+                    .filter((row) => row.trial.arm === arm)
+                    .map((row) => row.trial.scenario),
+            ]),
+        ].sort();
+        byScenario[arm] = {};
+        for (const scenario of scenarios) {
+            byScenario[arm][scenario] = accountTrials(scored.filter((row) => row.trial.arm === arm &&
+                row.trial.scenario === scenario), armSlots.filter((slot) => slot.scenario === scenario).length);
+        }
+    }
+    return byScenario;
+}
+/**
+ * Group declared slots by arm.
+ * @param slots The declared schedule slots.
+ * @returns Slots keyed by arm id.
+ */
+function groupSlotsByArm(slots) {
+    const grouped = {};
+    for (const slot of slots) {
+        grouped[slot.arm] = [...(grouped[slot.arm] ?? []), slot];
+    }
+    return grouped;
+}

package/dist/evaluators/docs/analysis/blinding.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Blinding checks for the trial child and the judge packet.
+ *
+ * The A/B description difference is the treatment and must survive. What must
+ * not cross either boundary is the arm's identity or mapping: an arm label, an
+ * arm-specific worktree path or commit, or a revealing stamp such as
+ * `pd-A-r0-S02`.
+ */
+/** One detected exposure. */
+export interface BlindingFinding {
+    /** The field or value that carried the leak. */
+    field: string;
+    /** The matched fragment, never a whole secret. */
+    fragment: string;
+}
+/**
+ * Find arm-revealing fragments in one value.
+ * @param field The field or path the value came from.
+ * @param value The inspected text.
+ * @returns One finding per matched pattern, with only the matched fragment.
+ */
+export declare function blindingFindings(field: string, value: string): BlindingFinding[];
+/**
+ * Inspect trial-child environment entries.
+ *
+ * Provenance variables differ per arm (the plugin commit and dirty flag), so
+ * they are arm-revealing at the trial boundary; the caller keeps them in the
+ * outer harness instead. Image and fixture identities are identical for both
+ * arms and allowed.
+ * @param env The environment the trial container receives.
+ * @returns Every exposure found.
+ */
+export declare function trialEnvFindings(env: Readonly<Record<string, string | undefined>>): BlindingFinding[];
+/**
+ * Inspect every string field of a nested judge-packet object.
+ * @param packet The packet value, already parsed when it is JSON.
+ * @param prefix The dotted path accumulated so far.
+ * @returns Every exposure found in keys or values.
+ */
+export declare function packetFindings(packet: unknown, prefix?: string): BlindingFinding[];

package/dist/evaluators/docs/analysis/blinding.js

@@ -0,0 +1,80 @@
+/**
+ * Blinding checks for the trial child and the judge packet.
+ *
+ * The A/B description difference is the treatment and must survive. What must
+ * not cross either boundary is the arm's identity or mapping: an arm label, an
+ * arm-specific worktree path or commit, or a revealing stamp such as
+ * `pd-A-r0-S02`.
+ */
+/** Patterns that reveal an arm rather than the treatment. */
+const ARM_PATTERNS = [
+    { label: "stamp", pattern: /pd-[AB]-r\d/ },
+    {
+        label: "arm-path",
+        pattern: /(?:^|[^A-Za-z0-9])arms?[/_-][ab](?:[^A-Za-z0-9]|$)/i,
+    },
+    {
+        label: "arm-flag",
+        pattern: /(?:^|[^A-Za-z0-9])arm[-_ ]?[ab](?:[^A-Za-z0-9]|$)/i,
+    },
+];
+/**
+ * Find arm-revealing fragments in one value.
+ * @param field The field or path the value came from.
+ * @param value The inspected text.
+ * @returns One finding per matched pattern, with only the matched fragment.
+ */
+export function blindingFindings(field, value) {
+    const findings = [];
+    for (const { label, pattern } of ARM_PATTERNS) {
+        const match = pattern.exec(value);
+        if (match === null)
+            continue;
+        findings.push({ field, fragment: `${label}:${match[0].trim()}` });
+    }
+    return findings;
+}
+/**
+ * Inspect trial-child environment entries.
+ *
+ * Provenance variables differ per arm (the plugin commit and dirty flag), so
+ * they are arm-revealing at the trial boundary; the caller keeps them in the
+ * outer harness instead. Image and fixture identities are identical for both
+ * arms and allowed.
+ * @param env The environment the trial container receives.
+ * @returns Every exposure found.
+ */
+export function trialEnvFindings(env) {
+    const findings = [];
+    for (const [key, value] of Object.entries(env)) {
+        if ((key === "PLACEMENT_PLUGIN_COMMIT" ||
+            key === "PLACEMENT_PLUGIN_DIRTY") &&
+            value !== undefined &&
+            value !== "") {
+            findings.push({ field: key, fragment: "arm-specific provenance" });
+        }
+        if (value !== undefined && value !== "") {
+            findings.push(...blindingFindings(key, value));
+        }
+    }
+    return findings;
+}
+/**
+ * Inspect every string field of a nested judge-packet object.
+ * @param packet The packet value, already parsed when it is JSON.
+ * @param prefix The dotted path accumulated so far.
+ * @returns Every exposure found in keys or values.
+ */
+export function packetFindings(packet, prefix = "packet") {
+    if (typeof packet === "string")
+        return blindingFindings(prefix, packet);
+    if (Array.isArray(packet)) {
+        return packet.flatMap((entry, index) => packetFindings(entry, `${prefix}[${String(index)}]`));
+    }
+    if (typeof packet !== "object" || packet === null)
+        return [];
+    return Object.entries(packet).flatMap(([key, value]) => [
+        ...blindingFindings(`${prefix}.${key}`, key),
+        ...packetFindings(value, `${prefix}.${key}`),
+    ]);
+}