@yiaany/ghostapi 0.1.9 → 0.2.0

package/dist/reliability/index.js

@@ -1,5 +1,5 @@
-export { LocalSloController, SloError, SLO_LATENCY_METRICS, SLO_METRICS, createDisabledSloOperatorAuthorizer, createLocalSloController, createSloRecordIdentity, createTestSloOperatorAuthorizer, examplePilotSloTargets, formatSloReport } from "./slo.js";
-export { LocalReconciliationService, ReconciliationError, RECONCILIATION_OUTCOMES, createDisabledReconciliationOperatorAuthorizer, createLocalReconciliationService, createTestReconciliationOperatorAuthorizer, createWorldStateReconciliationProvider, formatReconciliationReport } from "./reconciliation.js";
-export { CostGovernanceError, COST_AMOUNT_KEYS, COST_DIMENSIONS, LocalCostGovernance, createDisabledCostOperatorAuthorizer, createLocalCostGovernance, createTestCostOperatorAuthorizer, formatCostReport } from "./costGovernance.js";
-export { RuntimeHealthError, backupRuntime, checkRuntimeHealth, formatRuntimeHealth, restoreRuntimeBackup } from "./runtimeHealth.js";
+export { LocalSloController, SloError, SLO_LATENCY_METRICS, SLO_METRICS, createDisabledSloOperatorAuthorizer, createLocalSloController, createSloRecordIdentity, createTestSloOperatorAuthorizer, examplePilotSloTargets, formatSloReport, } from "./slo.js";
+export { LocalReconciliationService, ReconciliationError, RECONCILIATION_OUTCOMES, createDisabledReconciliationOperatorAuthorizer, createLocalReconciliationService, createTestReconciliationOperatorAuthorizer, createWorldStateReconciliationProvider, formatReconciliationReport, } from "./reconciliation.js";
+export { CostGovernanceError, COST_AMOUNT_KEYS, COST_DIMENSIONS, LocalCostGovernance, createDisabledCostOperatorAuthorizer, createLocalCostGovernance, createTestCostOperatorAuthorizer, formatCostReport, } from "./costGovernance.js";
+export { RuntimeHealthError, backupRuntime, checkRuntimeHealth, formatRuntimeHealth, restoreRuntimeBackup, } from "./runtimeHealth.js";
 //# sourceMappingURL=index.js.map

package/dist/reliability/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/reliability/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,QAAQ,EAAE,mBAAmB,EAAE,WAAW,EAAE,mCAAmC,EAAE,wBAAwB,EAAE,uBAAuB,EAAE,+BAA+B,EAAE,sBAAsB,EAAE,eAAe,EAAE,MAAM,UAAU,CAAC;AAE5P,OAAO,EAAE,0BAA0B,EAAE,mBAAmB,EAAE,uBAAuB,EAAE,8CAA8C,EAAE,gCAAgC,EAAE,0CAA0C,EAAE,sCAAsC,EAAE,0BAA0B,EAAE,MAAM,qBAAqB,CAAC;AAEjT,OAAO,EAAE,mBAAmB,EAAE,gBAAgB,EAAE,eAAe,EAAE,mBAAmB,EAAE,oCAAoC,EAAE,yBAAyB,EAAE,gCAAgC,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAEvO,OAAO,EAAE,kBAAkB,EAAE,aAAa,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/reliability/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,kBAAkB,EAClB,QAAQ,EACR,mBAAmB,EACnB,WAAW,EACX,mCAAmC,EACnC,wBAAwB,EACxB,uBAAuB,EACvB,+BAA+B,EAC/B,sBAAsB,EACtB,eAAe,GAChB,MAAM,UAAU,CAAC;AAclB,OAAO,EACL,0BAA0B,EAC1B,mBAAmB,EACnB,uBAAuB,EACvB,8CAA8C,EAC9C,gCAAgC,EAChC,0CAA0C,EAC1C,sCAAsC,EACtC,0BAA0B,GAC3B,MAAM,qBAAqB,CAAC;AAgB7B,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,eAAe,EACf,mBAAmB,EACnB,oCAAoC,EACpC,yBAAyB,EACzB,gCAAgC,EAChC,gBAAgB,GACjB,MAAM,qBAAqB,CAAC;AAmB7B,OAAO,EACL,kBAAkB,EAClB,aAAa,EACb,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,GACrB,MAAM,oBAAoB,CAAC"}

package/dist/reliability/reconciliation.js

@@ -3,16 +3,22 @@ import { lstat, readFile } from "node:fs/promises";
 import { dirname } from "node:path";
 import { getDataPaths } from "../config/dataPaths.js";
 import { sanitizeSecretString } from "../security/secrets.js";
-import { atomicWriteJson, ensurePrivateDirectory, withFileLock } from "../storage/fileStore.js";
+import { atomicWriteJson, ensurePrivateDirectory, withFileLock, } from "../storage/fileStore.js";
 import { inspectWorld, SyntheticWorldError } from "../worlds/index.js";
-import { createSloRecordIdentity } from "./slo.js";
+import { createSloRecordIdentity, } from "./slo.js";
 const SCHEMA_VERSION = 1;
 const KIND = "ghostapi.reconciliation";
 const MAX_STORE_BYTES = 4 * 1024 * 1024;
 const MAX_FINDINGS = 1_000;
 const IDENTIFIER = /^[a-z0-9][a-z0-9._-]{0,127}$/;
 const HASH = /^[a-f0-9]{64}$/;
-export const RECONCILIATION_OUTCOMES = ["committed", "not_committed", "unknown", "compensated", "drifted"];
+export const RECONCILIATION_OUTCOMES = [
+    "committed",
+    "not_committed",
+    "unknown",
+    "compensated",
+    "drifted",
+];
 export class ReconciliationError extends Error {
     constructor(message) {
         super(message);
@@ -39,7 +45,9 @@ export class LocalReconciliationService {
         this.provider = options.provider;
         this.sloController = options.sloController;
         this.sloRecordIdentity = createSloRecordIdentity();
-        this.operatorAuthorizer = options.operatorAuthorizer ?? createDisabledReconciliationOperatorAuthorizer();
+        this.operatorAuthorizer =
+            options.operatorAuthorizer ??
+                createDisabledReconciliationOperatorAuthorizer();
     }
     async runReconciliation(input) {
         await this.authorize(input.identity, "reconciliation.manage");
@@ -69,7 +77,8 @@ export class LocalReconciliationService {
             let opened = 0;
             for (const result of results) {
                 if (result.outcome === "drifted" || result.outcome === "unknown") {
-                    const alreadyOpen = state.findings.some((finding) => finding.actionHash === result.actionHash && finding.status === "open");
+                    const alreadyOpen = state.findings.some((finding) => finding.actionHash === result.actionHash &&
+                        finding.status === "open");
                     if (!alreadyOpen) {
                         if (state.findings.length >= MAX_FINDINGS)
                             throw new ReconciliationError("Reconciliation findings limit was reached.");
@@ -87,17 +96,53 @@ export class LocalReconciliationService {
                 const measurement = measurements[index];
                 if (!measurement.executed)
                     continue;
-                samples.push({ metric: "duplicate_prevention", ok: measurement.duplicateOk, runId, actionId: result.actionId, labels: { tenantId } });
-                samples.push({ metric: "availability", ok: measurement.availabilityOk, runId, actionId: result.actionId, labels: { tenantId } });
+                samples.push({
+                    metric: "duplicate_prevention",
+                    ok: measurement.duplicateOk,
+                    runId,
+                    actionId: result.actionId,
+                    labels: { tenantId },
+                });
+                samples.push({
+                    metric: "availability",
+                    ok: measurement.availabilityOk,
+                    runId,
+                    actionId: result.actionId,
+                    labels: { tenantId },
+                });
                 if (measurement.verificationOk !== null)
-                    samples.push({ metric: "receipt_verification", ok: measurement.verificationOk, runId, actionId: result.actionId, labels: { tenantId } });
+                    samples.push({
+                        metric: "receipt_verification",
+                        ok: measurement.verificationOk,
+                        runId,
+                        actionId: result.actionId,
+                        labels: { tenantId },
+                    });
                 if (measurement.latencyMs !== null)
-                    samples.push({ metric: "execution_latency", ok: true, durationMs: measurement.latencyMs, runId, actionId: result.actionId, labels: { tenantId } });
+                    samples.push({
+                        metric: "execution_latency",
+                        ok: true,
+                        durationMs: measurement.latencyMs,
+                        runId,
+                        actionId: result.actionId,
+                        labels: { tenantId },
+                    });
             }
             if (samples.length > 0)
                 await this.sloController.recordSamples(samples, this.sloRecordIdentity);
         }
-        return { schemaVersion: 1, kind: "ghostapi.reconciliation-report", runId, tenantId, ranAt: now, integrity: "valid", actions: results, counts, sli, findingsOpened };
+        return {
+            schemaVersion: 1,
+            kind: "ghostapi.reconciliation-report",
+            runId,
+            tenantId,
+            ranAt: now,
+            integrity: "valid",
+            actions: results,
+            counts,
+            sli,
+            findingsOpened,
+        };
     }
     async listFindings(input) {
         await this.authorize(input.identity, "reconciliation.inspect");
@@ -115,7 +160,11 @@ export class LocalReconciliationService {
             if (finding.status === "resolved")
                 throw new ReconciliationError("Reconciliation finding is already resolved.");
             finding.status = "resolved";
-            finding.resolution = { resolvedAt: this.timestamp(), resolvedBy: operator.principalId, reason };
+            finding.resolution = {
+                resolvedAt: this.timestamp(),
+                resolvedBy: operator.principalId,
+                reason,
+            };
             return clone(finding);
         });
     }
@@ -131,7 +180,12 @@ export class LocalReconciliationService {
             if (finding.status === "resolved")
                 throw new ReconciliationError("Reconciliation finding is already resolved.");
             finding.status = "resolved";
-            finding.resolution = { resolvedAt: this.timestamp(), resolvedBy: operator.principalId, reason, evidenceRef };
+            finding.resolution = {
+                resolvedAt: this.timestamp(),
+                resolvedBy: operator.principalId,
+                reason,
+                evidenceRef,
+            };
             return clone(finding);
         });
     }
@@ -143,7 +197,9 @@ export class LocalReconciliationService {
         let providerPresent = null;
         if (worldId !== null) {
             const world = await this.provider.read({ worldId });
-            providerPresent = world !== null && world.receipts.some((receipt) => receipt.actionId === actionId);
+            providerPresent =
+                world !== null &&
+                    world.receipts.some((receipt) => receipt.actionId === actionId);
         }
         const decided = decideOutcome(intent, providerPresent);
         if (providerPresent === null)
@@ -151,7 +207,9 @@ export class LocalReconciliationService {
         if (decided.reconciledFromProvider)
             reasons.push("ledger outcome was incomplete; provider evidence confirms the commitment");
         if (decided.outcome === "drifted")
-            reasons.push(providerPresent ? "provider has a receipt the ledger does not record" : "ledger records a commitment the provider does not confirm");
+            reasons.push(providerPresent
+                ? "provider has a receipt the ledger does not record"
+                : "ledger records a commitment the provider does not confirm");
         return {
             tenantId,
             actionId,
@@ -162,7 +220,7 @@ export class LocalReconciliationService {
             outcome: decided.outcome,
             retrySafe: decided.retrySafe,
             reconciledFromProvider: decided.reconciledFromProvider,
-            reasons
+            reasons,
         };
     }
     async authorize(identity, permission) {
@@ -206,14 +264,29 @@ export class LocalReconciliationService {
     }
 }
 export function createDisabledReconciliationOperatorAuthorizer() {
-    return { async authenticate() { throw new ReconciliationError("Reconciliation operator authorization is not configured."); } };
+    return {
+        async authenticate() {
+            throw new ReconciliationError("Reconciliation operator authorization is not configured.");
+        },
+    };
 }
 export function createTestReconciliationOperatorAuthorizer() {
     const issued = new WeakSet();
     return {
-        authorizer: { async authenticate(identity) { if (identity === null || typeof identity !== "object" || !issued.has(identity))
-                throw new ReconciliationError("Reconciliation operator identity is not authenticated."); return validateOperator(identity); } },
-        issue(input) { const operator = Object.freeze(validateOperator(input)); issued.add(operator); return operator; }
+        authorizer: {
+            async authenticate(identity) {
+                if (identity === null ||
+                    typeof identity !== "object" ||
+                    !issued.has(identity))
+                    throw new ReconciliationError("Reconciliation operator identity is not authenticated.");
+                return validateOperator(identity);
+            },
+        },
+        issue(input) {
+            const operator = Object.freeze(validateOperator(input));
+            issued.add(operator);
+            return operator;
+        },
     };
 }
 export function createWorldStateReconciliationProvider(resolveWorld) {
@@ -224,18 +297,25 @@ export function createWorldStateReconciliationProvider(resolveWorld) {
         async read(input) {
             try {
                 const world = await inspectWorld(input.worldId);
-                return { receipts: world.state.receipts.map((receipt) => ({ actionId: receipt.actionId })) };
+                return {
+                    receipts: world.state.receipts.map((receipt) => ({
+                        actionId: receipt.actionId,
+                    })),
+                };
             }
             catch (error) {
-                if (error instanceof SyntheticWorldError && error.code === "WORLD_NOT_FOUND")
+                if (error instanceof SyntheticWorldError &&
+                    error.code === "WORLD_NOT_FOUND")
                     return null;
                 throw error;
             }
-        }
+        },
     };
 }
 export function formatReconciliationReport(report) {
-    const lines = [`Reconciliation run ${report.runId} for tenant ${report.tenantId} at ${report.ranAt}`];
+    const lines = [
+        `Reconciliation run ${report.runId} for tenant ${report.tenantId} at ${report.ranAt}`,
+    ];
     lines.push(`  ledger integrity: ${report.integrity}`);
     lines.push(`  outcomes: committed=${report.counts.committed} not_committed=${report.counts.not_committed} unknown=${report.counts.unknown} compensated=${report.counts.compensated} drifted=${report.counts.drifted}`);
     lines.push(`  findings opened: ${report.findingsOpened}`);
@@ -277,36 +357,79 @@ function decideOutcome(intent, providerPresent) {
     switch (intent) {
         case "committed":
             if (providerPresent === true)
-                return { outcome: "committed", retrySafe: false, reconciledFromProvider: false };
+                return {
+                    outcome: "committed",
+                    retrySafe: false,
+                    reconciledFromProvider: false,
+                };
             if (providerPresent === false)
-                return { outcome: "drifted", retrySafe: false, reconciledFromProvider: false };
-            return { outcome: "unknown", retrySafe: false, reconciledFromProvider: false };
+                return {
+                    outcome: "drifted",
+                    retrySafe: false,
+                    reconciledFromProvider: false,
+                };
+            return {
+                outcome: "unknown",
+                retrySafe: false,
+                reconciledFromProvider: false,
+            };
         case "committed_unverified":
         case "ambiguous":
         case "failed":
         case "attempted":
             if (providerPresent === true)
-                return { outcome: "committed", retrySafe: false, reconciledFromProvider: true };
-            return { outcome: "unknown", retrySafe: false, reconciledFromProvider: false };
+                return {
+                    outcome: "committed",
+                    retrySafe: false,
+                    reconciledFromProvider: true,
+                };
+            return {
+                outcome: "unknown",
+                retrySafe: false,
+                reconciledFromProvider: false,
+            };
         case "not_committed":
             if (providerPresent === true)
-                return { outcome: "drifted", retrySafe: false, reconciledFromProvider: false };
+                return {
+                    outcome: "drifted",
+                    retrySafe: false,
+                    reconciledFromProvider: false,
+                };
             if (providerPresent === false)
-                return { outcome: "not_committed", retrySafe: true, reconciledFromProvider: false };
-            return { outcome: "unknown", retrySafe: false, reconciledFromProvider: false };
+                return {
+                    outcome: "not_committed",
+                    retrySafe: true,
+                    reconciledFromProvider: false,
+                };
+            return {
+                outcome: "unknown",
+                retrySafe: false,
+                reconciledFromProvider: false,
+            };
         case "compensated":
-            return { outcome: "compensated", retrySafe: false, reconciledFromProvider: false };
+            return {
+                outcome: "compensated",
+                retrySafe: false,
+                reconciledFromProvider: false,
+            };
     }
 }
 function intentReasons(intent) {
     switch (intent) {
-        case "committed": return ["ledger shows a verified provider receipt"];
-        case "committed_unverified": return ["ledger records a provider receipt without a verified proof"];
-        case "ambiguous": return ["ledger records an ambiguous execution outcome"];
-        case "failed": return ["ledger records a failed execution outcome"];
-        case "attempted": return ["ledger records an execution attempt without a receipt"];
-        case "not_committed": return ["ledger never reached the provider"];
-        case "compensated": return ["ledger records an attempted compensation"];
+        case "committed":
+            return ["ledger shows a verified provider receipt"];
+        case "committed_unverified":
+            return ["ledger records a provider receipt without a verified proof"];
+        case "ambiguous":
+            return ["ledger records an ambiguous execution outcome"];
+        case "failed":
+            return ["ledger records a failed execution outcome"];
+        case "attempted":
+            return ["ledger records an execution attempt without a receipt"];
+        case "not_committed":
+            return ["ledger never reached the provider"];
+        case "compensated":
+            return ["ledger records an attempted compensation"];
     }
 }
 function measureAction(timeline, outcome) {
@@ -315,11 +438,19 @@ function measureAction(timeline, outcome) {
     const attempts = entries(timeline, "execution_attempt");
     const executed = attempts.length > 0 || providerReceipts.length > 0;
     const duplicateOk = providerReceipts.length <= 1 && verifications.length <= 1;
-    const verificationOk = providerReceipts.length === 0 ? null : verifications.at(-1)?.data.status === "verified";
-    const availabilityOk = !executed ? false : outcome === "committed" || outcome === "not_committed" || outcome === "compensated";
+    const verificationOk = providerReceipts.length === 0
+        ? null
+        : verifications.at(-1)?.data.status === "verified";
+    const availabilityOk = !executed
+        ? false
+        : outcome === "committed" ||
+            outcome === "not_committed" ||
+            outcome === "compensated";
     const receipt = providerReceipts[0];
     const proof = verifications.at(-1);
-    const latencyMs = receipt !== undefined && proof !== undefined ? Math.max(0, Date.parse(proof.timestamp) - Date.parse(receipt.timestamp)) : null;
+    const latencyMs = receipt !== undefined && proof !== undefined
+        ? Math.max(0, Date.parse(proof.timestamp) - Date.parse(receipt.timestamp))
+        : null;
     return { executed, duplicateOk, verificationOk, availabilityOk, latencyMs };
 }
 function aggregateSli(results, measurements) {
@@ -346,16 +477,41 @@ function aggregateSli(results, measurements) {
             latencies.push(measurement.latencyMs);
     }
     const ordered = [...latencies].sort((left, right) => left - right);
-    const percentile = (value) => ordered.length === 0 ? 0 : ordered[Math.min(ordered.length - 1, Math.max(0, Math.ceil((value / 100) * ordered.length) - 1))];
+    const percentile = (value) => ordered.length === 0
+        ? 0
+        : ordered[Math.min(ordered.length - 1, Math.max(0, Math.ceil((value / 100) * ordered.length) - 1))];
     return {
-        duplicatePrevention: { ...duplicatePrevention, okRateBps: rateBps(duplicatePrevention.ok, duplicatePrevention.measured) },
-        receiptVerification: { ...receiptVerification, okRateBps: rateBps(receiptVerification.ok, receiptVerification.measured) },
-        availability: { ...availability, okRateBps: rateBps(availability.ok, availability.measured) },
-        executionLatency: { measured: latencies.length, avgMs: latencies.length === 0 ? 0 : latencies.reduce((sum, value) => sum + value, 0) / latencies.length, p95Ms: percentile(95), p99Ms: percentile(99), basis: "ledger_record_interval" }
+        duplicatePrevention: {
+            ...duplicatePrevention,
+            okRateBps: rateBps(duplicatePrevention.ok, duplicatePrevention.measured),
+        },
+        receiptVerification: {
+            ...receiptVerification,
+            okRateBps: rateBps(receiptVerification.ok, receiptVerification.measured),
+        },
+        availability: {
+            ...availability,
+            okRateBps: rateBps(availability.ok, availability.measured),
+        },
+        executionLatency: {
+            measured: latencies.length,
+            avgMs: latencies.length === 0
+                ? 0
+                : latencies.reduce((sum, value) => sum + value, 0) / latencies.length,
+            p95Ms: percentile(95),
+            p99Ms: percentile(99),
+            basis: "ledger_record_interval",
+        },
     };
 }
 function countOutcomes(results) {
-    const counts = { committed: 0, not_committed: 0, unknown: 0, compensated: 0, drifted: 0 };
+    const counts = {
+        committed: 0,
+        not_committed: 0,
+        unknown: 0,
+        compensated: 0,
+        drifted: 0,
+    };
     for (const result of results)
         counts[result.outcome] += 1;
     return counts;
@@ -372,7 +528,7 @@ function makeFinding(result, now) {
         classification,
         detail: result.reasons.join("; "),
         detectedAt: now,
-        status: "open"
+        status: "open",
     };
 }
 function groupByAction(entries) {
@@ -391,7 +547,12 @@ function lastEntry(timeline, stage) {
     return entries(timeline, stage).at(-1);
 }
 function emptyState() {
-    return { schemaVersion: 1, kind: "ghostapi.reconciliation", lastRun: null, findings: [] };
+    return {
+        schemaVersion: 1,
+        kind: "ghostapi.reconciliation",
+        lastRun: null,
+        findings: [],
+    };
 }
 function validateState(value) {
     const state = object(value, "Reconciliation store must be an object.");
@@ -406,19 +567,45 @@ function validateState(value) {
         exactKeys(run, ["runId", "ranAt", "counts"], "Reconciliation last run");
         const counts = object(run.counts, "Reconciliation outcome counts are invalid.");
         for (const outcome of RECONCILIATION_OUTCOMES) {
-            if (typeof counts[outcome] !== "number" || !Number.isInteger(counts[outcome]) || counts[outcome] < 0)
+            if (typeof counts[outcome] !== "number" ||
+                !Number.isInteger(counts[outcome]) ||
+                counts[outcome] < 0)
                 throw new ReconciliationError("Reconciliation outcome counts are invalid.");
         }
-        lastRun = { runId: identifier(run.runId, "Reconciliation run id"), ranAt: timestamp(run.ranAt, "Reconciliation run time"), counts: counts };
+        lastRun = {
+            runId: identifier(run.runId, "Reconciliation run id"),
+            ranAt: timestamp(run.ranAt, "Reconciliation run time"),
+            counts: counts,
+        };
     }
-    return { schemaVersion: 1, kind: "ghostapi.reconciliation", lastRun, findings };
+    return {
+        schemaVersion: 1,
+        kind: "ghostapi.reconciliation",
+        lastRun,
+        findings,
+    };
 }
 function validateFinding(value) {
     const finding = object(value, "Reconciliation finding is invalid.");
-    exactKeys(finding, ["schemaVersion", "kind", "findingId", "tenantId", "actionId", "actionHash", "classification", "detail", "detectedAt", "status", "resolution"], "Reconciliation finding", ["resolution"]);
-    if (finding.schemaVersion !== SCHEMA_VERSION || finding.kind !== "ghostapi.reconciliation-finding")
+    exactKeys(finding, [
+        "schemaVersion",
+        "kind",
+        "findingId",
+        "tenantId",
+        "actionId",
+        "actionHash",
+        "classification",
+        "detail",
+        "detectedAt",
+        "status",
+        "resolution",
+    ], "Reconciliation finding", ["resolution"]);
+    if (finding.schemaVersion !== SCHEMA_VERSION ||
+        finding.kind !== "ghostapi.reconciliation-finding")
         throw new ReconciliationError("Unsupported reconciliation finding schema.");
-    if ((finding.classification !== "drifted" && finding.classification !== "unknown") || (finding.status !== "open" && finding.status !== "resolved"))
+    if ((finding.classification !== "drifted" &&
+        finding.classification !== "unknown") ||
+        (finding.status !== "open" && finding.status !== "resolved"))
         throw new ReconciliationError("Reconciliation finding classification or status is invalid.");
     let resolution;
     if (finding.resolution !== undefined) {
@@ -428,7 +615,11 @@ function validateFinding(value) {
             resolvedAt: timestamp(value.resolvedAt, "Reconciliation resolution time"),
             resolvedBy: identifier(value.resolvedBy, "Reconciliation resolution operator"),
             reason: text(value.reason, "Reconciliation resolution reason", 300),
-            ...(value.evidenceRef === undefined ? {} : { evidenceRef: evidence(value.evidenceRef, "Reconciliation evidence reference") })
+            ...(value.evidenceRef === undefined
+                ? {}
+                : {
+                    evidenceRef: evidence(value.evidenceRef, "Reconciliation evidence reference"),
+                }),
         };
     }
     if (finding.status === "resolved" && resolution === undefined)
@@ -446,7 +637,7 @@ function validateFinding(value) {
         detail: text(finding.detail, "Reconciliation finding detail", 600),
         detectedAt: timestamp(finding.detectedAt, "Reconciliation detection time"),
         status: finding.status,
-        ...(resolution === undefined ? {} : { resolution })
+        ...(resolution === undefined ? {} : { resolution }),
     };
 }
 function findFinding(state, findingId) {
@@ -459,18 +650,25 @@ function validateOperator(value) {
     const operator = object(value, "Reconciliation operator is invalid.");
     exactKeys(operator, ["id", "principalId", "permissions"], "Reconciliation operator");
     const permissions = array(operator.permissions, "Reconciliation operator permissions", 8).map((permission) => {
-        if (permission !== "reconciliation.manage" && permission !== "reconciliation.inspect")
+        if (permission !== "reconciliation.manage" &&
+            permission !== "reconciliation.inspect")
             throw new ReconciliationError("Reconciliation operator permission is invalid.");
         return permission;
     });
     unique(permissions, "Reconciliation operator permissions");
-    return { id: identifier(operator.id, "Reconciliation operator id"), principalId: identifier(operator.principalId, "Reconciliation operator principal id"), permissions };
+    return {
+        id: identifier(operator.id, "Reconciliation operator id"),
+        principalId: identifier(operator.principalId, "Reconciliation operator principal id"),
+        permissions,
+    };
 }
 function rateBps(count, total) {
     return total === 0 ? 0 : Math.floor((count * 10_000) / total);
 }
 function identifier(value, label) {
-    if (typeof value !== "string" || !IDENTIFIER.test(value) || sanitizeSecretString(value) !== value)
+    if (typeof value !== "string" ||
+        !IDENTIFIER.test(value) ||
+        sanitizeSecretString(value) !== value)
         throw new ReconciliationError(`${label} must be a safe identifier.`);
     return value;
 }
@@ -480,17 +678,27 @@ function hash(value, label) {
     return value;
 }
 function evidence(value, label) {
-    if (typeof value !== "string" || value.trim() === "" || value.length > 128 || /[\u0000-\u001f]/.test(value) || sanitizeSecretString(value) !== value)
+    if (typeof value !== "string" ||
+        value.trim() === "" ||
+        value.length > 128 ||
+        /[\u0000-\u001f]/.test(value) ||
+        sanitizeSecretString(value) !== value)
         throw new ReconciliationError(`${label} must be a bounded non-secret reference.`);
     return value.trim();
 }
 function timestamp(value, label) {
-    if (typeof value !== "string" || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) || !Number.isFinite(Date.parse(value)))
+    if (typeof value !== "string" ||
+        !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/.test(value) ||
+        !Number.isFinite(Date.parse(value)))
         throw new ReconciliationError(`${label} must be an ISO UTC timestamp.`);
     return value;
 }
 function text(value, label, max) {
-    if (typeof value !== "string" || value.trim() === "" || value.length > max || /[\u0000-\u001f]/.test(value) || sanitizeSecretString(value) !== value)
+    if (typeof value !== "string" ||
+        value.trim() === "" ||
+        value.length > max ||
+        /[\u0000-\u001f]/.test(value) ||
+        sanitizeSecretString(value) !== value)
         throw new ReconciliationError(`${label} is invalid.`);
     return value.trim();
 }
@@ -506,7 +714,8 @@ function array(value, label, max) {
 }
 function exactKeys(value, keys, label, optional = []) {
     for (const key of Object.keys(value))
-        if (!keys.includes(key) || (value[key] === undefined && !optional.includes(key)))
+        if (!keys.includes(key) ||
+            (value[key] === undefined && !optional.includes(key)))
             throw new ReconciliationError(`${label} contains unsupported field: ${key}`);
 }
 function unique(values, label) {