@bitkyc08/opencodex
Version:
Universal provider proxy for OpenAI Codex & Claude Code — use any LLM with Codex CLI/App/SDK and Claude Code
137 lines (124 loc) • 4.58 kB
text/typescript
import type {
ClaimSnapshotEvent,
InvalidationEvent,
LabEvent,
LedgerCorruption,
ObservationEvent,
PurgeTombstoneEvent,
} from "../events/types";
import { LabValidationError } from "../events/validate";
export interface InvalidationIndex {
/** eventId -> invalidation eventIds that targeted it */
invalidatedBy: Map<string, string[]>;
purgedEventIds: Set<string>;
purgedArtifactDigests: Set<string>;
corruptions: LedgerCorruption[];
}
type EventPosition = { kind: LabEvent["eventKind"]; index: number };
/**
* Apply purge tombstones before ordinary invalidations.
* Invalidation target lists are atomic: any bad target rejects the whole event.
*/
export function buildInvalidationIndex(events: LabEvent[]): InvalidationIndex {
const purgedEventIds = new Set<string>();
const purgedArtifactDigests = new Set<string>();
const invalidatedBy = new Map<string, string[]>();
const corruptions: LedgerCorruption[] = [];
const validEvidenceIds = new Map<string, { kind: "observation" | "claim_snapshot"; index: number }>();
const allEventIds = new Map<string, EventPosition>();
// First pass: record event positions and evidence positions; apply purges as encountered.
for (let i = 0; i < events.length; i++) {
const event = events[i]!;
allEventIds.set(event.eventId, { kind: event.eventKind, index: i });
if (event.eventKind === "observation" || event.eventKind === "claim_snapshot") {
validEvidenceIds.set(event.eventId, { kind: event.eventKind, index: i });
continue;
}
if (event.eventKind === "purge_tombstone") {
applyPurge(event, purgedEventIds, purgedArtifactDigests);
}
}
// Second pass: validate and apply invalidations against earlier evidence.
for (let i = 0; i < events.length; i++) {
const event = events[i]!;
if (event.eventKind !== "invalidation") continue;
try {
validateInvalidationTargets(event, i, validEvidenceIds, allEventIds);
for (const target of event.targetEventIds) {
const list = invalidatedBy.get(target) ?? [];
list.push(event.eventId);
invalidatedBy.set(target, list);
}
} catch (err) {
corruptions.push({
kind: "invalid_reference",
eventId: event.eventId,
detail: err instanceof Error ? err.message : String(err),
});
}
}
return { invalidatedBy, purgedEventIds, purgedArtifactDigests, corruptions };
}
function applyPurge(
event: PurgeTombstoneEvent,
purgedEventIds: Set<string>,
purgedArtifactDigests: Set<string>,
): void {
for (const id of event.targetEventIds) purgedEventIds.add(id);
for (const digest of event.targetArtifactDigests) purgedArtifactDigests.add(digest);
}
function validateInvalidationTargets(
event: InvalidationEvent,
index: number,
validEvidenceIds: Map<string, { kind: "observation" | "claim_snapshot"; index: number }>,
allEventIds: Map<string, EventPosition>,
): void {
for (const target of event.targetEventIds) {
if (target === event.eventId) {
throw new LabValidationError("self_target", "invalidation cannot target itself");
}
const meta = validEvidenceIds.get(target);
if (!meta) {
const other = allEventIds.get(target);
if (
other &&
other.index < index &&
(other.kind === "invalidation" || other.kind === "purge_tombstone")
) {
throw new LabValidationError("bad_target_kind", `cannot invalidate ${other.kind}`);
}
throw new LabValidationError("unknown_target", `unknown target ${target}`);
}
if (meta.index >= index) {
throw new LabValidationError("future_target", `target ${target} is not earlier`);
}
// Purged targets may no longer have a ledger line. A previously valid evidence
// ID remains addressable because validEvidenceIds records its original position.
}
}
export function isEventExcluded(
eventId: string,
index: InvalidationIndex,
): boolean {
if (index.purgedEventIds.has(eventId)) return true;
if (index.invalidatedBy.has(eventId)) return true;
return false;
}
export function usableObservations(
events: LabEvent[],
index: InvalidationIndex,
): ObservationEvent[] {
return events.filter(
(e): e is ObservationEvent =>
e.eventKind === "observation" && !isEventExcluded(e.eventId, index),
);
}
export function usableClaims(
events: LabEvent[],
index: InvalidationIndex,
): ClaimSnapshotEvent[] {
return events.filter(
(e): e is ClaimSnapshotEvent =>
e.eventKind === "claim_snapshot" && !isEventExcluded(e.eventId, index),
);
}