@iislee/opencodex 2.11.0 → 2.31.0

package/src/lab/public/operator.ts

@@ -0,0 +1,353 @@
+import { replayLabLedger } from "../ledger/store";
+import { labLedgerPath } from "../paths";
+import { queryLabEvents, queryLabVerdicts } from "../query";
+import type { ObservationEvent } from "../events/types";
+import {
+  importCommunityEvidenceBundle,
+  listCommunityEvidence,
+} from "./community";
+import { readPrivateRegularFile } from "./file-safety";
+import { withPublicEvidenceMutationLock } from "./mutation-lock";
+import { recordLocalPublicOrigin } from "./origin";
+import type { ProjectPublicEvidenceRecordInput } from "./project";
+import { projectPublicEvidenceRecord } from "./project";
+import {
+  signPublicEvidenceBundle,
+  verifyPublicEvidenceBundle,
+} from "./signature";
+import { storePublicEvidenceBundle } from "./storage";
+import { parseStrictPublicJson } from "./strict-json";
+import { publicUtcDay } from "./time";
+import { PUBLIC_EVIDENCE_BUNDLE_SCHEMA_VERSION, PUBLIC_EXPORT_POLICY_VERSION } from "./types";
+import type {
+  PublicEvidenceBundleV1,
+  PublicEvidencePreviewBundleV1,
+  PublicEvidenceRecordV1,
+  PublicProjectionNotExportableReason,
+} from "./types";
+import { PublicEvidenceValidationError } from "./validate";
+
+const MAX_OPERATOR_EVENTS = 256;
+const MAX_PUBLIC_FILE_BYTES = 2 * 1024 * 1024;
+const EMPTY_PREVIEW_DAY = "1970-01-01";
+const PRIVATE_STORAGE_LOCATOR = "<private>";
+
+export interface ProjectPublicEvidenceInput {
+  records: ProjectPublicEvidenceRecordInput[];
+}
+
+export function projectPublicEvidence(input: ProjectPublicEvidenceInput): {
+  bundle: PublicEvidencePreviewBundleV1;
+  excluded: Array<{ index: number; reason: PublicProjectionNotExportableReason }>;
+} {
+  const records: PublicEvidenceRecordV1[] = [];
+  const excluded: Array<{ index: number; reason: PublicProjectionNotExportableReason }> = [];
+  let latestExportableCompletedAt: number | null = null;
+
+  input.records.forEach((recordInput, index) => {
+    const projected = projectPublicEvidenceRecord(recordInput);
+    if (projected.status !== "exportable") {
+      excluded.push({ index, reason: projected.reason });
+      return;
+    }
+    records.push(projected.record);
+    latestExportableCompletedAt = Math.max(
+      latestExportableCompletedAt ?? recordInput.observation.completedAt,
+      recordInput.observation.completedAt,
+    );
+  });
+  records.sort((a, b) => a.recordId < b.recordId ? -1 : a.recordId > b.recordId ? 1 : 0);
+  return {
+    bundle: {
+      schemaVersion: PUBLIC_EVIDENCE_BUNDLE_SCHEMA_VERSION,
+      exportPolicyVersion: PUBLIC_EXPORT_POLICY_VERSION,
+      createdDayUtc: latestExportableCompletedAt === null
+        ? EMPTY_PREVIEW_DAY
+        : publicUtcDay(latestExportableCompletedAt),
+      records,
+      artifacts: [],
+    },
+    excluded,
+  };
+}
+
+export type PublicOperatorExclusionReason =
+  | PublicProjectionNotExportableReason
+  | "event_not_found"
+  | "not_observation"
+  | "event_excluded"
+  | "no_canonical_verdict";
+
+export interface PublicOperatorExclusionV1 {
+  selectionIndex: number;
+  reason: PublicOperatorExclusionReason;
+}
+
+export interface LocalPublicPreviewV1 {
+  bundle: PublicEvidencePreviewBundleV1;
+  excluded: PublicOperatorExclusionV1[];
+}
+
+export interface LocalPublicExportV1 {
+  bundle: PublicEvidenceBundleV1;
+  stored: { path: typeof PRIVATE_STORAGE_LOCATOR; created: boolean };
+  excluded: PublicOperatorExclusionV1[];
+}
+
+export type PublicVerificationSummaryV1 =
+  | { status: "cryptographically_valid"; bundleId: string; publisherKeyId: string; locallyVerified: false }
+  | { status: "schema_rejected" | "digest_invalid" | "signature_invalid"; locallyVerified: false };
+
+function assertOperatorEventIds(eventIds: readonly string[]): Array<{ eventId: string; selectionIndex: number }> {
+  if (eventIds.length === 0 || eventIds.length > MAX_OPERATOR_EVENTS) {
+    throw new PublicEvidenceValidationError(
+      "public_selection_limit",
+      `public evidence selection must contain 1..${MAX_OPERATOR_EVENTS} event ids`,
+    );
+  }
+  const unique: Array<{ eventId: string; selectionIndex: number }> = [];
+  const seen = new Set<string>();
+  for (const [selectionIndex, eventId] of eventIds.entries()) {
+    if (!/^[0-9a-f]{64}$/.test(eventId)) {
+      throw new PublicEvidenceValidationError(
+        "public_selection_event_id",
+        "public evidence event ids must be lowercase sha256 hex",
+      );
+    }
+    if (seen.has(eventId)) continue;
+    seen.add(eventId);
+    unique.push({ eventId, selectionIndex });
+  }
+  return unique;
+}
+
+function projectedObservationState(
+  eventIds: readonly string[],
+  configDir?: string,
+): Map<string, { excluded: boolean }> {
+  const pending = new Set(eventIds);
+  const state = new Map<string, { excluded: boolean }>();
+  let cursor: string | undefined;
+
+  while (pending.size > 0) {
+    const page = queryLabEvents({ eventKind: "observation" }, cursor, 200, configDir);
+    for (const row of page.items) {
+      if (!pending.has(row.eventId)) continue;
+      state.set(row.eventId, { excluded: row.excluded });
+      pending.delete(row.eventId);
+    }
+    if (!page.hasMore || !page.nextCursor) break;
+    cursor = page.nextCursor;
+  }
+
+  return state;
+}
+
+function canonicalVerdictsForObservations(
+  observations: readonly ObservationEvent[],
+  configDir?: string,
+): Map<string, ProjectPublicEvidenceRecordInput["verdict"]> {
+  const verdictByEventId = new Map<string, ProjectPublicEvidenceRecordInput["verdict"]>();
+  const groups = new Map<string, {
+    subjectId: string;
+    evidenceLayer: ObservationEvent["evidenceLayer"];
+    suiteId: string;
+    observations: ObservationEvent[];
+  }>();
+
+  for (const observation of observations) {
+    const key = `${observation.subjectId}\0${observation.evidenceLayer}\0${observation.suiteId}`;
+    const existing = groups.get(key);
+    if (existing) existing.observations.push(observation);
+    else groups.set(key, {
+      subjectId: observation.subjectId,
+      evidenceLayer: observation.evidenceLayer,
+      suiteId: observation.suiteId,
+      observations: [observation],
+    });
+  }
+
+  for (const group of groups.values()) {
+    const pending = new Map(group.observations.map((observation) => [observation.eventId, observation] as const));
+    let cursor: string | undefined;
+    while (pending.size > 0) {
+      const page = queryLabVerdicts({
+        subjectId: group.subjectId,
+        layer: group.evidenceLayer,
+        suiteId: group.suiteId,
+      }, cursor, 200, configDir);
+      for (const row of page.items) {
+        for (const eventId of row.contributingEventIds) {
+          const observation = pending.get(eventId);
+          if (!observation) continue;
+          if (
+            row.subjectId !== observation.subjectId
+            || row.evidenceLayer !== observation.evidenceLayer
+            || row.suiteId !== observation.suiteId
+            || row.suiteVersion !== observation.suiteVersion
+          ) {
+            continue;
+          }
+          verdictByEventId.set(eventId, row.verdict);
+          pending.delete(eventId);
+        }
+      }
+      if (!page.hasMore || !page.nextCursor) break;
+      cursor = page.nextCursor;
+    }
+  }
+
+  return verdictByEventId;
+}
+
+export function previewLocalPublicEvidence(
+  input: { eventIds: readonly string[] },
+  configDir?: string,
+): LocalPublicPreviewV1 {
+  const selections = assertOperatorEventIds(input.eventIds);
+  const replay = replayLabLedger(labLedgerPath(configDir));
+  const byId = new Map(replay.events.map((event) => [event.eventId, event] as const));
+  const observationSelections: Array<{ observation: ObservationEvent; selectionIndex: number }> = [];
+  const excluded: PublicOperatorExclusionV1[] = [];
+
+  for (const { eventId, selectionIndex } of selections) {
+    const event = byId.get(eventId);
+    if (!event) {
+      excluded.push({ selectionIndex, reason: "event_not_found" });
+      continue;
+    }
+    if (event.eventKind !== "observation") {
+      excluded.push({ selectionIndex, reason: "not_observation" });
+      continue;
+    }
+    observationSelections.push({ observation: event, selectionIndex });
+  }
+
+  if (observationSelections.length === 0) {
+    throw new PublicEvidenceValidationError("public_selection_empty", "public evidence selection contains no observation events");
+  }
+
+  const projectionByEventId = projectedObservationState(
+    observationSelections.map(({ observation }) => observation.eventId),
+    configDir,
+  );
+  const candidates: Array<{ observation: ObservationEvent; selectionIndex: number }> = [];
+  for (const candidate of observationSelections) {
+    const projectedEvent = projectionByEventId.get(candidate.observation.eventId);
+    if (!projectedEvent) {
+      excluded.push({ selectionIndex: candidate.selectionIndex, reason: "event_not_found" });
+      continue;
+    }
+    if (projectedEvent.excluded) {
+      excluded.push({ selectionIndex: candidate.selectionIndex, reason: "event_excluded" });
+      continue;
+    }
+    candidates.push(candidate);
+  }
+
+  const verdictByEventId = canonicalVerdictsForObservations(
+    candidates.map((candidate) => candidate.observation),
+    configDir,
+  );
+  const projectInputs: ProjectPublicEvidenceRecordInput[] = [];
+  const projectSelectionIndices: number[] = [];
+  for (const { observation, selectionIndex } of candidates) {
+    const verdict = verdictByEventId.get(observation.eventId);
+    if (!verdict) {
+      excluded.push({ selectionIndex, reason: "no_canonical_verdict" });
+      continue;
+    }
+    projectInputs.push({ observation, verdict });
+    projectSelectionIndices.push(selectionIndex);
+  }
+
+  const projected = projectPublicEvidence({ records: projectInputs });
+  for (const row of projected.excluded) {
+    excluded.push({ selectionIndex: projectSelectionIndices[row.index]!, reason: row.reason });
+  }
+  excluded.sort((a, b) => a.selectionIndex - b.selectionIndex);
+  return { bundle: projected.bundle, excluded };
+}
+
+export function exportLocalPublicEvidence(
+  input: { eventIds: readonly string[] },
+  configDir?: string,
+): LocalPublicExportV1 {
+  const preview = previewLocalPublicEvidence(input, configDir);
+  if (preview.bundle.records.length === 0) {
+    throw new PublicEvidenceValidationError("public_export_empty", "selected events produced no exportable public evidence records");
+  }
+  const bundle = signPublicEvidenceBundle({
+    records: preview.bundle.records,
+    artifacts: preview.bundle.artifacts,
+    createdDayUtc: preview.bundle.createdDayUtc,
+    configDir,
+  });
+  return withPublicEvidenceMutationLock(configDir, () => {
+    // Commit purge-owned provenance first. If export publication later fails or the
+    // process crashes, an orphan marker is conservative and can be reclaimed later;
+    // the inverse state, a durable export without provenance, is not acceptable.
+    recordLocalPublicOrigin({ publisherKeyId: bundle.publisher.keyId, bundleId: bundle.bundleId }, configDir);
+    const stored = storePublicEvidenceBundle(bundle, configDir);
+    return {
+      bundle,
+      stored: { path: PRIVATE_STORAGE_LOCATOR, created: stored.created },
+      excluded: preview.excluded,
+    };
+  });
+}
+
+export function summarizePublicEvidenceVerification(raw: unknown): PublicVerificationSummaryV1 {
+  const result = verifyPublicEvidenceBundle(raw as PublicEvidenceBundleV1);
+  if (result.status !== "cryptographically_valid") {
+    return { status: result.status, locallyVerified: false };
+  }
+  const bundle = raw as PublicEvidenceBundleV1;
+  return {
+    status: "cryptographically_valid",
+    bundleId: bundle.bundleId,
+    publisherKeyId: bundle.publisher.keyId,
+    locallyVerified: false,
+  };
+}
+
+function readBoundedPublicFile(path: string): Buffer {
+  return readPrivateRegularFile(path, {
+    maxBytes: MAX_PUBLIC_FILE_BYTES,
+    errorCode: "public_file_unsafe",
+    errorMessage: "public evidence input must be a regular non-symlink file",
+    sizeErrorCode: "public_file_too_large",
+    sizeErrorMessage: "public evidence input exceeds 2 MiB",
+  });
+}
+
+function parsePublicFile(path: string): unknown {
+  return parseStrictPublicJson(readBoundedPublicFile(path), "public evidence input", "public_file_json");
+}
+
+export function verifyPublicEvidenceFile(path: string): PublicVerificationSummaryV1 {
+  return summarizePublicEvidenceVerification(parsePublicFile(path));
+}
+
+function finishCommunityImport(
+  stored: { path: string; created: boolean; bundleId: string; publisherKeyId: string },
+) {
+  const { path: _privatePath, ...imported } = stored;
+  return { ...imported, trustClass: "community_untrusted_v1" as const, locallyVerified: false as const };
+}
+
+export function importCommunityEvidenceFile(path: string, configDir?: string) {
+  return finishCommunityImport(importCommunityEvidenceBundle(readBoundedPublicFile(path), configDir));
+}
+
+export function importCommunityEvidenceValue(raw: unknown, configDir?: string) {
+  return finishCommunityImport(importCommunityEvidenceBundle(raw, configDir));
+}
+
+export function listCommunityEvidenceContext(configDir?: string) {
+  return {
+    evidence: listCommunityEvidence(configDir),
+    trustClass: "community_untrusted_v1" as const,
+    locallyVerified: false as const,
+  };
+}

package/src/lab/public/origin-purge.ts

@@ -0,0 +1,79 @@
+import { readdirSync } from "node:fs";
+import { join } from "node:path";
+import { ensureLabDirs, labPublicOriginDir } from "../paths";
+import { readPrivateRegularFile } from "./file-safety";
+import { cleanupStalePrivateFileStagesInDir, isPrivateFileStageName } from "./private-file";
+import { parseStrictPublicJson } from "./strict-json";
+
+const MAX_ORIGIN_BYTES = 1024;
+const ORIGIN_RE = /^origin-([0-9a-f]{64})-([0-9a-f]{64})\.json$/;
+
+export interface PurgeOriginIdentity {
+  publisherKeyId: string;
+  bundleId: string;
+}
+
+export interface PurgeOriginRecovery {
+  identities: PurgeOriginIdentity[];
+  skipped: number;
+}
+
+/**
+ * Purge must salvage each provenance marker independently. A corrupt marker is untrusted
+ * and skipped, but it cannot hide later valid markers that are needed to classify local
+ * community copies after the export or publisher key is unavailable. The operational
+ * 1024-marker quota is deliberately not a read cutoff here: recovery must inspect every
+ * valid-format marker present after a race/crash instead of silently losing provenance.
+ */
+export function recoverPublicOriginsForPurge(configDir?: string): PurgeOriginRecovery {
+  ensureLabDirs(configDir);
+  const dir = labPublicOriginDir(configDir);
+  cleanupStalePrivateFileStagesInDir(dir);
+  const names = readdirSync(dir)
+    .filter((name) => !isPrivateFileStageName(name) && ORIGIN_RE.test(name))
+    .sort();
+  const identities: PurgeOriginIdentity[] = [];
+  let skipped = 0;
+
+  for (const name of names) {
+    const match = ORIGIN_RE.exec(name)!;
+    const expected = { publisherKeyId: match[1]!, bundleId: match[2]! };
+    try {
+      const raw = parseStrictPublicJson(
+        readPrivateRegularFile(join(dir, name), {
+          maxBytes: MAX_ORIGIN_BYTES,
+          errorCode: "public_origin_unsafe",
+          errorMessage: "public origin marker is unsafe during purge",
+          sizeErrorCode: "public_origin_unsafe",
+          sizeErrorMessage: "public origin marker exceeds its size bound",
+          requireMode600: true,
+        }),
+        "public origin marker during purge",
+        "public_origin_json",
+      );
+      if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+        skipped += 1;
+        continue;
+      }
+      const row = raw as Record<string, unknown>;
+      if (
+        Object.keys(row).sort().join(",") !== "bundleId,publisherKeyId,schemaVersion"
+        || row.schemaVersion !== "public_origin_v1"
+        || row.publisherKeyId !== expected.publisherKeyId
+        || row.bundleId !== expected.bundleId
+      ) {
+        skipped += 1;
+        continue;
+      }
+      identities.push(expected);
+    } catch {
+      skipped += 1;
+      // Salvage continues with the next marker.
+    }
+  }
+  return { identities, skipped };
+}
+
+export function listValidPublicOriginsForPurge(configDir?: string): PurgeOriginIdentity[] {
+  return recoverPublicOriginsForPurge(configDir).identities;
+}

package/src/lab/public/origin.ts

@@ -0,0 +1,203 @@
+import { lstatSync, readdirSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { jcsStringify } from "../digest";
+import { ensureLabDirs, labCommunityDir, labExportDir, labPublicOriginDir } from "../paths";
+import { communityBundleFileName } from "./community-files";
+import { readPrivateRegularFile } from "./file-safety";
+import {
+  cleanupStalePrivateFileStagesInDir,
+  isPrivateFileStageName,
+  publishPrivateFileExclusive,
+} from "./private-file";
+import { parseStrictPublicJson } from "./strict-json";
+import { PublicEvidenceValidationError } from "./validate";
+
+// The community cache itself is capped at 512 files. Keeping twice that many origin
+// markers leaves headroom for in-flight/local exports while allowing unreferenced
+// provenance to be reclaimed instead of permanently locking future exports.
+const MAX_ORIGINS = 1024;
+const MAX_ORIGIN_BYTES = 1024;
+const ORIGIN_RE = /^origin-([0-9a-f]{64})-([0-9a-f]{64})\.json$/;
+
+export interface PublicOriginIdentityV1 {
+  publisherKeyId: string;
+  bundleId: string;
+}
+
+function originPath(identity: PublicOriginIdentityV1, configDir?: string): string {
+  if (!/^[0-9a-f]{64}$/.test(identity.publisherKeyId) || !/^[0-9a-f]{64}$/.test(identity.bundleId)) {
+    throw new PublicEvidenceValidationError("public_origin_id", "public origin identity is invalid");
+  }
+  return join(
+    labPublicOriginDir(configDir),
+    `origin-${identity.publisherKeyId}-${identity.bundleId}.json`,
+  );
+}
+
+function originBody(identity: PublicOriginIdentityV1): Buffer {
+  return Buffer.from(jcsStringify({
+    schemaVersion: "public_origin_v1",
+    publisherKeyId: identity.publisherKeyId,
+    bundleId: identity.bundleId,
+  }), "utf8");
+}
+
+function readOrigin(path: string, expected?: PublicOriginIdentityV1): PublicOriginIdentityV1 {
+  const bytes = readPrivateRegularFile(path, {
+    maxBytes: MAX_ORIGIN_BYTES,
+    errorCode: "public_origin_unsafe",
+    errorMessage: "public origin marker is not a private regular file with 0600 permissions",
+    sizeErrorCode: "public_origin_unsafe",
+    sizeErrorMessage: "public origin marker exceeds its size bound",
+    requireMode600: true,
+  });
+  const raw = parseStrictPublicJson(bytes, "public origin marker", "public_origin_json");
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new PublicEvidenceValidationError("public_origin_json", "public origin marker must be an object");
+  }
+  const row = raw as Record<string, unknown>;
+  if (Object.keys(row).sort().join(",") !== "bundleId,publisherKeyId,schemaVersion"
+    || row.schemaVersion !== "public_origin_v1"
+    || typeof row.publisherKeyId !== "string"
+    || typeof row.bundleId !== "string"
+    || !/^[0-9a-f]{64}$/.test(row.publisherKeyId)
+    || !/^[0-9a-f]{64}$/.test(row.bundleId)) {
+    throw new PublicEvidenceValidationError("public_origin_json", "public origin marker schema is invalid");
+  }
+  const identity = { publisherKeyId: row.publisherKeyId, bundleId: row.bundleId };
+  if (expected && (identity.publisherKeyId !== expected.publisherKeyId || identity.bundleId !== expected.bundleId)) {
+    throw new PublicEvidenceValidationError("public_origin_conflict", "public origin marker identity mismatch");
+  }
+  return identity;
+}
+
+/** Marker names only. Quota accounting, reclaim, and listing must agree on this set. */
+function originNames(dir: string): string[] {
+  cleanupStalePrivateFileStagesInDir(dir);
+  return readdirSync(dir)
+    .filter((name) => !isPrivateFileStageName(name) && ORIGIN_RE.test(name))
+    .sort();
+}
+
+function foreignOriginNames(dir: string): string[] {
+  return readdirSync(dir)
+    .filter((name) => !isPrivateFileStageName(name) && !ORIGIN_RE.test(name))
+    .sort();
+}
+
+function pathExistsConservatively(path: string): boolean {
+  try {
+    lstatSync(path);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") return false;
+    return true;
+  }
+}
+
+function communityBundlePath(identity: PublicOriginIdentityV1, configDir?: string): string {
+  return join(
+    labCommunityDir(configDir),
+    communityBundleFileName(identity.publisherKeyId, identity.bundleId),
+  );
+}
+
+function localExportPath(identity: PublicOriginIdentityV1, configDir?: string): string {
+  return join(labExportDir(configDir), `${identity.bundleId}.json`);
+}
+
+/**
+ * Origin markers exist to recover local provenance for community copies when the export
+ * or publisher key is later unavailable. A marker is reclaimable only when neither the
+ * exact community copy nor its matching local export still exists.
+ */
+function reclaimUnreferencedOrigins(
+  dir: string,
+  preservePath: string,
+  configDir?: string,
+): void {
+  for (const name of originNames(dir)) {
+    const match = ORIGIN_RE.exec(name)!;
+    const path = join(dir, name);
+    if (path === preservePath) continue;
+    const identity = { publisherKeyId: match[1]!, bundleId: match[2]! };
+    if (pathExistsConservatively(communityBundlePath(identity, configDir))) continue;
+    if (pathExistsConservatively(localExportPath(identity, configDir))) continue;
+    try {
+      unlinkSync(path);
+    } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}
+
+export function recordLocalPublicOrigin(identity: PublicOriginIdentityV1, configDir?: string): void {
+  ensureLabDirs(configDir);
+  const dir = labPublicOriginDir(configDir);
+  const path = originPath(identity, configDir);
+  try {
+    readOrigin(path, identity);
+    return;
+  } catch (error) {
+    if (error instanceof PublicEvidenceValidationError) throw error;
+    if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+  }
+
+  let names = originNames(dir);
+  if (names.length >= MAX_ORIGINS) {
+    reclaimUnreferencedOrigins(dir, path, configDir);
+    names = originNames(dir);
+  }
+  if (names.length >= MAX_ORIGINS) {
+    throw new PublicEvidenceValidationError("public_origin_bound", "public origin marker bound exceeded");
+  }
+
+  const bytes = originBody(identity);
+  const published = publishPrivateFileExclusive(path, bytes);
+  if (!published.created) {
+    readOrigin(path, identity);
+    return;
+  }
+
+  // Separate CLI processes can both observe one free slot before either publishes.
+  // Reclaim unreferenced history after publication, then remove only this call's marker
+  // if the directory still cannot converge inside the hard cap.
+  if (originNames(dir).length > MAX_ORIGINS) {
+    reclaimUnreferencedOrigins(dir, path, configDir);
+    if (originNames(dir).length > MAX_ORIGINS) {
+      try { unlinkSync(path); } catch { /* preserve the quota failure */ }
+      throw new PublicEvidenceValidationError("public_origin_bound", "public origin marker bound exceeded");
+    }
+  }
+}
+
+export function listLocalPublicOrigins(configDir?: string): PublicOriginIdentityV1[] {
+  ensureLabDirs(configDir);
+  const dir = labPublicOriginDir(configDir);
+  const names = originNames(dir);
+  if (names.length > MAX_ORIGINS) {
+    throw new PublicEvidenceValidationError("public_origin_bound", "public origin marker bound exceeded");
+  }
+  if (foreignOriginNames(dir).length > 0) {
+    throw new PublicEvidenceValidationError("public_origin_unsafe", "unexpected public origin marker entry");
+  }
+  const identities: PublicOriginIdentityV1[] = [];
+  for (const name of names) {
+    const match = ORIGIN_RE.exec(name)!;
+    const expected = { publisherKeyId: match[1]!, bundleId: match[2]! };
+    identities.push(readOrigin(join(dir, name), expected));
+  }
+  return identities;
+}
+
+export function clearLocalPublicOrigins(configDir?: string): void {
+  ensureLabDirs(configDir);
+  const dir = labPublicOriginDir(configDir);
+  cleanupStalePrivateFileStagesInDir(dir);
+  for (const name of readdirSync(dir)) {
+    if (!ORIGIN_RE.test(name)) continue;
+    try { unlinkSync(join(dir, name)); } catch (error) {
+      if ((error as NodeJS.ErrnoException).code !== "ENOENT") throw error;
+    }
+  }
+}