@akagilnc/pi-workflow-roles 0.1.3572 → 0.1.3621

package/dist/analyst-gate-cycles-read.js

@@ -0,0 +1,387 @@
+/**
+ * Sole nested-volume reader for gate-cycle facts under session/auditor-roles/.
+ *
+ * Consumers: Analyst sole ledger scan (classifyScopedRun) and Terminal gate
+ * projection (#478). Metric families must not open a second disk scan — they
+ * consume retained facts. Terminal settlement reuses this same pairing seam
+ * (no second auditor-roles scanner).
+ *
+ * Naming: records may carry pre-#440 menxia/jishizhong/fubaolang tool faces or
+ * the current gatekeeper/inspector/notary English face. Projection always uses
+ * the current English officer identity (inspector | notary).
+ *
+ * Missing auditor-roles directory (ENOENT only) → empty rounds (lawful zero).
+ * Path present but not a directory (ENOTDIR) and discovered nested JSONL that
+ * fails canonical read/parse must fail loudly (never silently under-count).
+ * An accepted gate terminating receipt (isError:false pair on dispatch/officer
+ * tool) whose required typed facts are unusable — status, dispatch officer, or
+ * first/last span missing/unknown/unparseable/inverted — also fails loudly via
+ * the same throw→ledger `auditor-roles` unreadable seam. Unknown/non-contract
+ * dispatch status stays loud (#475 abolished Gatekeeper incomplete special-case).
+ * Lawful province non-dispatch release (`pass` on a dispatch tool) opens no
+ * round and must not throw (#597 / ADR 0074 gate-non-mandatory).
+ * True non-gate volumes (soul-audit noise, etc.) stay omitted from pairing.
+ * Historical dispatch↔officer pairing requires a shared typed
+ * `ak_auditor_parent_attempt_binding.parent.attemptEntryId` — never seat/time guessing.
+ * An orphan accepted dispatch must not consume a later same-seat direct officer.
+ */
+import { readdir } from "node:fs/promises";
+import { join } from "node:path";
+import { AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE, } from "./compliance-transport.js";
+import { extractSessionTimestampSpan, intervalRowsAroundAnchor, readLedgerSessionJsonl, } from "./ledger-session-read.js";
+const DISPATCH_TOOLS = new Set(["ak_menxia_output", "ak_gatekeeper_output"]);
+/** Officer terminating tool → current English officer identity. */
+const OFFICER_TOOL_TO_FACE = {
+    ak_jishizhong_output: "inspector",
+    ak_inspector_output: "inspector",
+    ak_fubaolang_output: "notary",
+    ak_notary_output: "notary",
+};
+/** Dispatch `officer` argument aliases → current English face. */
+const OFFICER_ARG_ALIASES = {
+    jishizhong: "inspector",
+    inspector: "inspector",
+    fubaolang: "notary",
+    notary: "notary",
+};
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isParentAttemptBindingRow(row) {
+    return row.type === "custom" && row.customType === AUDITOR_PARENT_ATTEMPT_BINDING_ENTRY_TYPE;
+}
+/** One summons' interval via shared #636 binding-slice (parent-attempt markers). */
+function intervalRowsForGateCall(rows, callRowIndex) {
+    return intervalRowsAroundAnchor(rows, callRowIndex, isParentAttemptBindingRow).rows;
+}
+/** Only true absence (ENOENT). ENOTDIR is damaged topology — must stay loud. */
+function isMissingDirectoryError(error) {
+    return (error instanceof Error
+        && "code" in error
+        && error.code === "ENOENT");
+}
+function normalizeOfficerArg(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    return OFFICER_ARG_ALIASES[raw.trim()];
+}
+/** Typed string findings only — non-strings dropped; missing/non-array → []. */
+function asStringFindings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.filter((item) => typeof item === "string");
+}
+/**
+ * Optional non-empty dispatch reason. Trim only decides emptiness; a non-empty
+ * durable reason is returned as written (gatekeeper keeps reason as-is).
+ */
+function optionalDispatchReason(raw) {
+    if (typeof raw !== "string")
+        return undefined;
+    if (raw.trim() === "")
+        return undefined;
+    return raw;
+}
+function isGateTerminatingToolName(toolName) {
+    return DISPATCH_TOOLS.has(toolName) || OFFICER_TOOL_TO_FACE[toolName] !== undefined;
+}
+/**
+ * toolCallIds whose paired toolResult is an accepted receipt (`isError === false`).
+ * Receipt is the sole lawful role product — rejected / missing results never qualify.
+ */
+function acceptedGateReceiptIds(rows) {
+    const accepted = new Set();
+    for (const row of rows) {
+        const message = isRecord(row.message) ? row.message : undefined;
+        if (message?.role !== "toolResult")
+            continue;
+        if (typeof message.toolCallId !== "string" || message.toolCallId.length === 0)
+            continue;
+        if (message.isError === false)
+            accepted.add(message.toolCallId);
+    }
+    return accepted;
+}
+function requireAcceptedGateStatus(args, filePath) {
+    if (args === undefined || typeof args.status !== "string" || args.status.trim() === "") {
+        throw new Error(`accepted gate receipt missing usable status in ${filePath}`);
+    }
+    return args.status.trim();
+}
+function requireAcceptedGateSpan(rows, filePath) {
+    const span = extractSessionTimestampSpan(rows);
+    if (span.startedAt === undefined || span.endedAt === undefined) {
+        throw new Error(`accepted gate volume missing session timestamp span in ${filePath}`);
+    }
+    const startedMs = Date.parse(span.startedAt);
+    const endedMs = Date.parse(span.endedAt);
+    if (!Number.isFinite(startedMs) || !Number.isFinite(endedMs) || endedMs < startedMs) {
+        throw new Error(`accepted gate volume has unusable timestamp span in ${filePath}`);
+    }
+    return {
+        startedAt: span.startedAt,
+        endedAt: span.endedAt,
+        wallMs: endedMs - startedMs,
+    };
+}
+/** Nearest preceding attempt binding (id + parent session file) before row index. */
+function nearestAttemptBindingBefore(rows, beforeIndex) {
+    for (let i = beforeIndex - 1; i >= 0; i -= 1) {
+        const row = rows[i];
+        if (!isParentAttemptBindingRow(row))
+            continue;
+        if (!isRecord(row.data) || !isRecord(row.data.parent))
+            continue;
+        const id = row.data.parent.attemptEntryId;
+        const sessionFile = row.data.parent.sessionFile;
+        return {
+            ...(typeof id === "string" && id.length > 0 ? { attemptEntryId: id } : {}),
+            ...(typeof sessionFile === "string" && sessionFile.length > 0
+                ? { parentSessionFile: sessionFile }
+                : {}),
+        };
+    }
+    return {};
+}
+/**
+ * All accepted gate terminating toolCalls on a volume (dispatch or officer),
+ * each with nearest preceding attempt binding. Ticket-seat continuous memory
+ * (#636) may carry multiple parent summons in one file — last-only would drop rounds.
+ */
+function extractAllAcceptedGateToolCalls(rows) {
+    const acceptedIds = acceptedGateReceiptIds(rows);
+    const out = [];
+    for (let rowIndex = 0; rowIndex < rows.length; rowIndex += 1) {
+        const row = rows[rowIndex];
+        const message = isRecord(row.message) ? row.message : undefined;
+        if (message?.role !== "assistant" || !Array.isArray(message.content))
+            continue;
+        for (const part of message.content) {
+            if (!isRecord(part) || part.type !== "toolCall")
+                continue;
+            if (typeof part.id !== "string" || part.id.length === 0)
+                continue;
+            if (typeof part.name !== "string" || part.name.length === 0)
+                continue;
+            if (!isGateTerminatingToolName(part.name))
+                continue;
+            if (!acceptedIds.has(part.id))
+                continue;
+            const binding = nearestAttemptBindingBefore(rows, rowIndex);
+            out.push({
+                toolName: part.name,
+                args: isRecord(part.arguments) ? part.arguments : undefined,
+                accepted: true,
+                rowIndex,
+                ...binding,
+            });
+        }
+    }
+    return out;
+}
+function projectAcceptedGateCall(filePath, rows, call) {
+    // Continuous memory volumes carry many summons; span only this binding's interval.
+    const span = requireAcceptedGateSpan(intervalRowsForGateCall(rows, call.rowIndex), filePath);
+    const status = requireAcceptedGateStatus(call.args, filePath);
+    const findings = asStringFindings(call.args?.findings);
+    const findingsCount = findings.length;
+    const bindingFields = {
+        ...(call.attemptEntryId === undefined ? {} : { attemptEntryId: call.attemptEntryId }),
+        ...(call.parentSessionFile === undefined ? {} : { parentSessionFile: call.parentSessionFile }),
+    };
+    if (DISPATCH_TOOLS.has(call.toolName)) {
+        // Lawful province non-dispatch release — opens no round, never unreadable (#597).
+        if (status === "pass") {
+            return undefined;
+        }
+        // Pairing terminal is dispatch; unknown/non-contract status stays loud (#475).
+        if (status !== "dispatch") {
+            throw new Error(`accepted dispatch receipt has non-dispatch status ${JSON.stringify(status)} in ${filePath}`);
+        }
+        const officer = normalizeOfficerArg(call.args?.officer);
+        if (officer === undefined) {
+            throw new Error(`accepted dispatch receipt missing or unknown officer in ${filePath}`);
+        }
+        const reason = optionalDispatchReason(call.args?.reason);
+        return {
+            kind: "dispatch",
+            startedAt: span.startedAt,
+            officer,
+            status,
+            ...(reason === undefined ? {} : { reason }),
+            ...bindingFields,
+        };
+    }
+    const officer = OFFICER_TOOL_TO_FACE[call.toolName];
+    if (officer === undefined) {
+        // isGateTerminatingToolName already screened; keep loud if tables drift.
+        throw new Error(`accepted gate receipt has unknown officer tool ${call.toolName} in ${filePath}`);
+    }
+    return {
+        kind: "officer",
+        startedAt: span.startedAt,
+        endedAt: span.endedAt,
+        officer,
+        status,
+        findings,
+        findingsCount,
+        officerWallMs: span.wallMs,
+        ...bindingFields,
+    };
+}
+async function classifyAuditorVolume(filePath) {
+    // Canonical JSONL errors propagate — failure honesty (never wash to fewer rounds).
+    const rows = await readLedgerSessionJsonl(filePath);
+    const accepted = extractAllAcceptedGateToolCalls(rows);
+    // Rejected-only / non-gate volumes omit (empty accepted set).
+    if (accepted.length === 0)
+        return [];
+    const volumes = [];
+    for (const call of accepted) {
+        const projected = projectAcceptedGateCall(filePath, rows, call);
+        if (projected !== undefined)
+            volumes.push(projected);
+    }
+    return volumes;
+}
+function pairGateRounds(volumes) {
+    const ordered = [...volumes].sort((a, b) => {
+        if (a.startedAt !== b.startedAt)
+            return a.startedAt.localeCompare(b.startedAt);
+        // Stable tie-break: dispatch before officer at identical start (should not happen).
+        if (a.kind !== b.kind)
+            return a.kind === "dispatch" ? -1 : 1;
+        return 0;
+    });
+    const usedOfficerIdx = new Set();
+    const rounds = [];
+    for (let i = 0; i < ordered.length; i += 1) {
+        const vol = ordered[i];
+        if (vol.kind !== "dispatch")
+            continue;
+        let match;
+        for (let j = i + 1; j < ordered.length; j += 1) {
+            if (usedOfficerIdx.has(j))
+                continue;
+            const candidate = ordered[j];
+            if (candidate.kind !== "officer")
+                continue;
+            if (candidate.officer !== vol.officer)
+                continue;
+            // Durable invocation association — seat/time alone must not pair.
+            if (vol.attemptEntryId === undefined
+                || candidate.attemptEntryId === undefined
+                || candidate.attemptEntryId !== vol.attemptEntryId) {
+                continue;
+            }
+            match = { index: j, officer: candidate };
+            break;
+        }
+        if (match === undefined)
+            continue;
+        usedOfficerIdx.add(match.index);
+        rounds.push({
+            roundIndex: rounds.length + 1,
+            officer: match.officer.officer,
+            status: match.officer.status,
+            officerWallMs: match.officer.officerWallMs,
+            officerStartedAt: match.officer.startedAt,
+            officerEndedAt: match.officer.endedAt,
+            findings: match.officer.findings,
+            findingsCount: match.officer.findingsCount,
+            origin: {
+                kind: "historical_dispatch",
+                ...(vol.reason === undefined ? {} : { reason: vol.reason }),
+            },
+        });
+    }
+    // Current direct-summons volumes have no preceding province dispatch. Every
+    // accepted officer receipt not consumed by a historical pair is its own round.
+    for (let i = 0; i < ordered.length; i += 1) {
+        const vol = ordered[i];
+        if (vol.kind !== "officer" || usedOfficerIdx.has(i))
+            continue;
+        rounds.push({
+            roundIndex: 0,
+            officer: vol.officer,
+            status: vol.status,
+            officerWallMs: vol.officerWallMs,
+            officerStartedAt: vol.startedAt,
+            officerEndedAt: vol.endedAt,
+            findings: vol.findings,
+            findingsCount: vol.findingsCount,
+            origin: { kind: "direct" },
+        });
+    }
+    return rounds
+        .sort((a, b) => a.officerStartedAt.localeCompare(b.officerStartedAt))
+        .map((round, index) => ({ ...round, roundIndex: index + 1 }));
+}
+/** Resolve a direct-officer-run-pointer file to the officer session 正本 path. */
+async function resolveOfficerSessionFromPointerFile(pointerPath) {
+    const { readFile } = await import("node:fs/promises");
+    let raw;
+    try {
+        raw = JSON.parse(await readFile(pointerPath, "utf8"));
+    }
+    catch (error) {
+        throw new Error(`direct officer run pointer unreadable in ${pointerPath}: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+    if (!isRecord(raw) || raw.kind !== "direct-officer-run-pointer" || raw.version !== 1) {
+        throw new Error(`direct officer run pointer has unknown shape in ${pointerPath}`);
+    }
+    const sessionFile = raw.sessionFile;
+    if (typeof sessionFile !== "string" || sessionFile.trim() === "") {
+        throw new Error(`direct officer run pointer missing sessionFile in ${pointerPath}`);
+    }
+    return sessionFile;
+}
+/**
+ * Read and pair gate-cycle rounds from one or more auditor-roles directories.
+ * Accepts historical nested JSONL volumes and #675 direct-officer-run-pointer
+ * files that name the independent officer session 正本.
+ * ENOENT (directory truly absent) → []. ENOTDIR and other errors propagate
+ * (failure honesty — damaged topology must not wash to zero rounds).
+ *
+ * Pass `parentSessionFile` to keep only rounds whose attempt binding names that parent.
+ */
+export async function readAnalystGateCyclesFromAuditorRoles(auditorRolesDirectory, options = {}) {
+    const directories = typeof auditorRolesDirectory === "string"
+        ? [auditorRolesDirectory]
+        : auditorRolesDirectory;
+    const volumes = [];
+    for (const directory of directories) {
+        let names;
+        try {
+            const entries = await readdir(directory, { withFileTypes: true });
+            names = entries
+                .filter((e) => e.isFile()
+                && (e.name.endsWith(".jsonl") || e.name.endsWith(".pointer.json")))
+                .map((e) => e.name)
+                .sort();
+        }
+        catch (error) {
+            if (isMissingDirectoryError(error))
+                continue;
+            throw error;
+        }
+        for (const name of names) {
+            const path = join(directory, name);
+            const sessionPath = name.endsWith(".pointer.json")
+                ? await resolveOfficerSessionFromPointerFile(path)
+                : path;
+            if (sessionPath === undefined)
+                continue;
+            const classified = await classifyAuditorVolume(sessionPath);
+            for (const volume of classified) {
+                if (options.parentSessionFile !== undefined &&
+                    volume.parentSessionFile !== undefined &&
+                    volume.parentSessionFile !== options.parentSessionFile) {
+                    continue;
+                }
+                volumes.push(volume);
+            }
+        }
+    }
+    return pairGateRounds(volumes);
+}

package/dist/archivist-record-entry.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync, writeFileSync } from "node:fs";
 import { dirname, resolve, join } from "node:path";
 import { SessionManager } from "@earendil-works/pi-coding-agent";
 import { resolveBookKeyFromGit } from "./activation-ledger-git.js";
@@ -130,8 +130,29 @@ function createRecordSessionOpen(options) {
 function createRecordSession(options) {
   return createRecordSessionOpen(options).session;
 }
+const DIRECT_OFFICER_RUN_POINTER_KIND = "direct-officer-run-pointer";
+function bookDirectOfficerRunPointer(options) {
+  const nest = join(dirname(options.parentSessionFile), "auditor-roles");
+  mkdirSync(nest, { recursive: true });
+  const pointer = {
+    version: 1,
+    kind: DIRECT_OFFICER_RUN_POINTER_KIND,
+    officer: options.officer,
+    sessionFile: options.sessionFile,
+    ...options.runDirectory !== void 0 && options.runDirectory.trim() !== "" ? { runDirectory: options.runDirectory } : {}
+  };
+  writeFileSync(
+    join(nest, `${options.officer}-${Date.now().toString(36)}.pointer.json`),
+    `${JSON.stringify(pointer)}
+`,
+    "utf8"
+  );
+  return pointer;
+}
 export {
+  DIRECT_OFFICER_RUN_POINTER_KIND,
   WORKER_SUBMISSION_GATE_KIND,
+  bookDirectOfficerRunPointer,
   createRecordSession,
   createRecordSessionOpen,
   subjectKeyedRecordDirectory2 as subjectKeyedRecordDirectory

package/dist/audit-escalation.js

@@ -121,6 +121,12 @@ export async function disposeComplianceDecision(decision, handlers, deliveredOut
                 throw new Error("Compliance no-receipt projection handler is unavailable");
             }
             return await handlers.noReceipt(decision, decision.usage === undefined ? {} : { usage: decision.usage });
+        case "unreadable":
+            // Parent candidate stands; audit shape failure is a typed parallel fact — not pass.
+            if (handlers.unreadable === undefined) {
+                throw new Error("Compliance unreadable projection handler is unavailable");
+            }
+            return await handlers.unreadable(decision, decision.usage === undefined ? {} : { usage: decision.usage });
         case "revise":
             return await handlers.revise(decision.violations);
         case "escalate":

package/dist/auditor-soul.js

@@ -0,0 +1,74 @@
+import { joinPackageMaterials, readPackageMaterial, } from "./session-opening-materials.js";
+/**
+ * Active auditor seats.
+ * Fixer LLM auditor retired by #242; reviewer-side 审刑院 gate retired by #495 S6.
+ * souls/fixer-auditor.md and souls/reviewer-auditor.md retained-or-deleted on disk as owner decisions; not active.
+ */
+export const AUDITOR_SOUL_ROLES = [
+    "judge",
+    "doctor",
+];
+/**
+ * Audited-subject input for public 审刑院 (#675 owner):
+ * 「审的是谁」is an input selecting judge-auditor.md / doctor-auditor.md —
+ * not a caller-identity fork. Same env for direct `ak-role auditor --subject`
+ * and nested compliance summons.
+ */
+export const AK_ROLE_AUDITOR_SUBJECT_ENV = "AK_ROLE_AUDITOR_SUBJECT";
+/**
+ * Audited source-run input for public 审刑院 (#675):
+ * same --source-run face for direct `ak-role auditor` and nested compliance summons.
+ * Never falls back to the auditor's own run directory.
+ */
+export const AK_ROLE_AUDITOR_SOURCE_RUN_ENV = "AK_ROLE_AUDITOR_SOURCE_RUN";
+function auditorSoulRelativePath(role) {
+    return `souls/${role}-auditor.md`;
+}
+/**
+ * #470 auditor session materials. Judge carries audit-law + quality-law; doctor does
+ * not (御批四: 参审席 = 大理寺主会话 + 其审计席; 太医线不动).
+ * Reviewer auditor roster removed with #495 S6 gate retirement.
+ * #675 owner: no generic auditor.md — subject selects this table.
+ */
+export const AUDITOR_SESSION_MATERIALS = {
+    judge: [
+        "CLAUDE.md",
+        "souls/judge-auditor.md",
+        "souls/audit-law.md",
+        "souls/quality-law.md",
+    ],
+    doctor: ["CLAUDE.md", "souls/doctor-auditor.md"],
+};
+export function isAuditorSoulRole(value) {
+    return value === "judge" || value === "doctor";
+}
+/** Resolve audited subject from explicit value or the subject-input env. */
+export function resolveAuditorSubject(raw) {
+    const value = typeof raw === "string" && raw.trim() !== ""
+        ? raw.trim()
+        : typeof process.env[AK_ROLE_AUDITOR_SUBJECT_ENV] === "string"
+            ? process.env[AK_ROLE_AUDITOR_SUBJECT_ENV].trim()
+            : "";
+    if (!isAuditorSoulRole(value)) {
+        throw new Error(`auditor subject must be judge|doctor (input --subject / ${AK_ROLE_AUDITOR_SUBJECT_ENV}), got ${value === "" ? "(missing)" : value}`);
+    }
+    return value;
+}
+/**
+ * Load one complete auditor session afresh for each audit invocation.
+ * Blank-soul identity stays owned here; composition reuses joinPackageMaterials.
+ * Subject selects the materials table (#675 owner — same for direct and nested).
+ */
+export async function loadAuditorSoul(role) {
+    const materials = AUDITOR_SESSION_MATERIALS[role];
+    const soulPath = auditorSoulRelativePath(role);
+    const soul = await readPackageMaterial(soulPath);
+    if (soul.trim().length === 0) {
+        throw new Error(`The ${role} auditor Soul is blank`);
+    }
+    return joinPackageMaterials(materials);
+}
+/** Runtime loader: subject input decides which soul file to assemble. */
+export async function loadAuditorSoulFromSubjectInput(raw) {
+    return loadAuditorSoul(resolveAuditorSubject(raw));
+}

package/dist/collector-config.js

@@ -0,0 +1,86 @@
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+export const COLLECTOR_HOST = "github.com";
+export const COLLECTOR_OWNER_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,37}[A-Za-z0-9])?$/;
+export const COLLECTOR_REPO_PATTERN = /^[A-Za-z0-9](?:[A-Za-z0-9._-]{0,98}[A-Za-z0-9])?$/;
+export const COLLECTOR_FIXED_KICKOFF = "采集目标已受理，本局开始。";
+function fail(message, cause) {
+    throw new Error(message, cause === undefined ? undefined : { cause });
+}
+function conservativeAscii(input) {
+    for (let i = 0; i < input.length; i += 1) {
+        const code = input.charCodeAt(i);
+        if (code <= 0x1f || code === 0x7f || code > 0x7f)
+            return false;
+    }
+    return true;
+}
+export function parseCollectorRepository(raw) {
+    if (typeof raw !== "string" || raw.trim() !== raw || raw.length === 0)
+        fail("Collector repository must be a string owner/repo");
+    if (!conservativeAscii(raw) || raw.includes("://") || /[?#@%\\ ]/.test(raw))
+        fail("Collector repository rejects URL syntax and non-identity bytes");
+    const parts = raw.split("/");
+    if (parts.length !== 2)
+        fail("Collector repository must contain exactly one '/' separating owner and repo");
+    const [ownerDisplay, repoDisplay] = parts;
+    if (!COLLECTOR_OWNER_PATTERN.test(ownerDisplay) || !COLLECTOR_REPO_PATTERN.test(repoDisplay))
+        fail("Collector repository does not match the conservative owner/repo grammar");
+    const owner = ownerDisplay.toLowerCase();
+    const repo = repoDisplay.toLowerCase();
+    return { display: raw, canonical: `${owner}/${repo}`, owner, repo };
+}
+export function parseCollectorPrNumber(raw) {
+    if (typeof raw === "string" && !/^[1-9][0-9]*$/.test(raw))
+        fail("Collector pull request number must be a positive safe integer string");
+    if (typeof raw !== "string" && typeof raw !== "number")
+        fail("Collector pull request number is required");
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < 1)
+        fail("Collector pull request number must be a positive safe integer");
+    return value;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalManifest(requests) {
+    return `${JSON.stringify({ requests: requests.map((request) => ({ id: request.id, body: request.requestBody })) })}\n`;
+}
+export function emptyCollectorManifest() {
+    const canonicalJson = canonicalManifest([]);
+    return { requests: [], canonicalJson, digest: createHash("sha256").update(canonicalJson).digest("hex") };
+}
+/** Optional request configuration. It names requests, never expected observers. */
+export async function loadCollectorManifest(path) {
+    let bytes;
+    try {
+        bytes = await readFile(path);
+    }
+    catch (error) {
+        fail(`Collector request manifest is unreadable at ${path}`, error);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes));
+    }
+    catch (error) {
+        fail("Collector request manifest must be UTF-8 JSON", error);
+    }
+    if (!record(parsed))
+        fail("Collector request manifest must be an object");
+    const rawRequests = parsed.requests ?? [];
+    if (!Array.isArray(rawRequests))
+        fail("Collector request manifest requests must be an array");
+    const requests = [];
+    const ids = new Set();
+    for (const [index, item] of rawRequests.entries()) {
+        if (!record(item) || typeof item.id !== "string" || item.id.length === 0 || typeof item.body !== "string" || item.body.trim() === "")
+            fail(`Collector request manifest requests[${index}] is invalid`);
+        if (ids.has(item.id))
+            fail(`Collector request manifest has duplicate request id "${item.id}"`);
+        ids.add(item.id);
+        requests.push({ id: item.id, requestBody: item.body });
+    }
+    const canonicalJson = canonicalManifest(requests);
+    return { requests, canonicalJson, digest: createHash("sha256").update(canonicalJson).digest("hex"), sourcePath: path };
+}