harnery 0.33.0 → 0.34.0

package/src/core/events/v3/fingerprint-keys.ts

@@ -0,0 +1,260 @@
+import { createHash, randomBytes, randomUUID } from "node:crypto";
+import {
+  chmodSync,
+  closeSync,
+  existsSync,
+  fsyncSync,
+  mkdirSync,
+  openSync,
+  readFileSync,
+  renameSync,
+  statSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { hostname } from "node:os";
+import { join, resolve } from "node:path";
+import { fsyncParentDirectory } from "../../workflow/durable-record.ts";
+import { acquireNoClobberLease } from "../../workflow/workspaces/leases.ts";
+import type { FingerprintContextV3 } from "./canonical.ts";
+
+const KEY_BYTES = 32;
+const LOCK_RETRIES = 200;
+const LOCK_RETRY_MS = 5;
+const sleepCell = new Int32Array(new SharedArrayBuffer(4));
+
+export const FINGERPRINT_KEY_STORE_RELATIVE_PATH =
+  ".harnery/private/fingerprint-keys.json" as const;
+
+export interface FingerprintKeyEpochV3 {
+  epoch_id: `pep_${string}`;
+  key_base64url: string;
+  created_at: string;
+}
+
+export interface FingerprintKeyStoreV3 {
+  format: "harnery-v3-fingerprint-keys";
+  format_version: 1;
+  active_epoch_id: `pep_${string}`;
+  epochs: FingerprintKeyEpochV3[];
+}
+
+export interface RotateFingerprintEpochV3Options {
+  activeGenerationCount: number;
+  now?: () => Date;
+}
+
+export function fingerprintKeyStorePathV3(coordRoot: string): string {
+  return join(resolve(coordRoot), FINGERPRINT_KEY_STORE_RELATIVE_PATH);
+}
+
+/** Load the private key store, creating its first epoch under an exclusive publication lock. */
+export function loadOrCreateFingerprintKeyStoreV3(
+  coordRoot: string,
+  now: () => Date = () => new Date(),
+): FingerprintKeyStoreV3 {
+  const path = fingerprintKeyStorePathV3(coordRoot);
+  if (existsSync(path)) {
+    return readFingerprintKeyStoreV3(coordRoot);
+  }
+  return withKeyStoreLock(coordRoot, () => {
+    if (existsSync(path)) return readFingerprintKeyStoreV3(coordRoot);
+    const epoch = createEpoch(now);
+    const store: FingerprintKeyStoreV3 = {
+      format: "harnery-v3-fingerprint-keys",
+      format_version: 1,
+      active_epoch_id: epoch.epoch_id,
+      epochs: [epoch],
+    };
+    publishKeyStore(path, store, false);
+    return store;
+  });
+}
+
+export function readFingerprintKeyStoreV3(coordRoot: string): FingerprintKeyStoreV3 {
+  const path = fingerprintKeyStorePathV3(coordRoot);
+  return validateKeyStore(readKeyStoreValue(path));
+}
+
+function readKeyStoreValue(path: string): unknown {
+  const mode = statSync(path).mode & 0o777;
+  if ((mode & 0o077) !== 0) {
+    throw new Error("fingerprint key store permissions are not owner-only");
+  }
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    throw new Error("fingerprint key store is unreadable or malformed");
+  }
+  return parsed;
+}
+
+/** Start a new comparison epoch only when no generation can still emit under the prior key. */
+export function rotateFingerprintEpochV3(
+  coordRoot: string,
+  options: RotateFingerprintEpochV3Options,
+): FingerprintKeyStoreV3 {
+  if (!Number.isSafeInteger(options.activeGenerationCount) || options.activeGenerationCount < 0) {
+    throw new Error("active generation count must be a non-negative integer");
+  }
+  if (options.activeGenerationCount !== 0) {
+    throw new Error("fingerprint epoch rotation is blocked while generations are active");
+  }
+  loadOrCreateFingerprintKeyStoreV3(coordRoot, options.now);
+  return withKeyStoreLock(coordRoot, () => {
+    const current = readFingerprintKeyStoreV3(coordRoot);
+    const epoch = createEpoch(options.now ?? (() => new Date()));
+    const next: FingerprintKeyStoreV3 = {
+      ...current,
+      active_epoch_id: epoch.epoch_id,
+      epochs: [...current.epochs, epoch],
+    };
+    publishKeyStore(fingerprintKeyStorePathV3(coordRoot), next, true);
+    return next;
+  });
+}
+
+export function fingerprintContextV3(
+  coordRoot: string,
+  rootId: `root_${string}`,
+  generationId?: `gen_${string}`,
+  epochId?: `pep_${string}`,
+): FingerprintContextV3 {
+  const store = readFingerprintKeyStoreV3(coordRoot);
+  const selectedId = epochId ?? store.active_epoch_id;
+  const epoch = store.epochs.find((candidate) => candidate.epoch_id === selectedId);
+  if (!epoch) throw new Error("requested fingerprint epoch is unavailable");
+  return {
+    epochId: epoch.epoch_id,
+    epochKey: Buffer.from(epoch.key_base64url, "base64url"),
+    rootId,
+    generationId,
+  };
+}
+
+function withKeyStoreLock<T>(coordRoot: string, operation: () => T): T {
+  const privateDir = join(resolve(coordRoot), ".harnery/private");
+  mkdirSync(privateDir, { recursive: true, mode: 0o700 });
+  chmodSync(privateDir, 0o700);
+  const leasePath = join(privateDir, "fingerprint-key-lease");
+  const authority = createHash("sha256").update(resolve(coordRoot)).digest("hex");
+  let lease: ReturnType<typeof acquireNoClobberLease> | undefined;
+  for (let attempt = 0; attempt < LOCK_RETRIES; attempt += 1) {
+    try {
+      lease = acquireNoClobberLease({
+        path: leasePath,
+        scope: "event-v3-fingerprint-key",
+        authoritySha256: authority,
+        staleAfterMs: 5_000,
+        validateStaleOwner: (owner) => owner.host === hostname() && !pidIsAlive(owner.pid),
+      });
+      break;
+    } catch (error) {
+      if (attempt === LOCK_RETRIES - 1) throw error;
+      Atomics.wait(sleepCell, 0, 0, LOCK_RETRY_MS);
+    }
+  }
+  if (!lease) throw new Error("fingerprint key store publication lease is busy");
+  try {
+    return operation();
+  } finally {
+    lease.release();
+  }
+}
+
+function pidIsAlive(pid: number): boolean {
+  if (!Number.isSafeInteger(pid) || pid < 1) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return (error as NodeJS.ErrnoException).code !== "ESRCH";
+  }
+}
+
+function publishKeyStore(path: string, store: FingerprintKeyStoreV3, replacing: boolean): void {
+  if (!replacing && existsSync(path)) throw new Error("fingerprint key store already exists");
+  const temporary = `${path}.tmp-${process.pid}-${randomUUID()}`;
+  let fd: number | undefined;
+  try {
+    fd = openSync(temporary, "wx", 0o600);
+    writeFileSync(fd, `${JSON.stringify(store)}\n`, "utf8");
+    fsyncSync(fd);
+    closeSync(fd);
+    fd = undefined;
+    chmodSync(temporary, 0o600);
+    if (!replacing && existsSync(path)) throw new Error("fingerprint key store already exists");
+    renameSync(temporary, path);
+    fsyncParentDirectory(path);
+  } finally {
+    if (fd !== undefined) closeSync(fd);
+    if (existsSync(temporary)) unlinkSync(temporary);
+  }
+}
+
+function createEpoch(now: () => Date): FingerprintKeyEpochV3 {
+  return {
+    epoch_id: `pep_${randomUUID()}`,
+    key_base64url: randomBytes(KEY_BYTES).toString("base64url"),
+    created_at: now().toISOString(),
+  };
+}
+
+function validateKeyStore(value: unknown): FingerprintKeyStoreV3 {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error("fingerprint key store has an invalid envelope");
+  }
+  const record = value as Record<string, unknown>;
+  const keys = Object.keys(record).sort();
+  if (keys.join("\0") !== "active_epoch_id\0epochs\0format\0format_version") {
+    throw new Error("fingerprint key store has unsupported fields");
+  }
+  if (record.format !== "harnery-v3-fingerprint-keys" || record.format_version !== 1) {
+    throw new Error("fingerprint key store format is unsupported");
+  }
+  if (
+    typeof record.active_epoch_id !== "string" ||
+    !/^pep_[a-zA-Z0-9._-]{1,128}$/.test(record.active_epoch_id)
+  ) {
+    throw new Error("fingerprint key store active epoch is invalid");
+  }
+  if (!Array.isArray(record.epochs) || record.epochs.length === 0) {
+    throw new Error("fingerprint key store has no epochs");
+  }
+  const seen = new Set<string>();
+  const epochs = record.epochs.map((candidate) => {
+    if (!candidate || typeof candidate !== "object" || Array.isArray(candidate)) {
+      throw new Error("fingerprint key epoch is invalid");
+    }
+    const epoch = candidate as Record<string, unknown>;
+    if (Object.keys(epoch).sort().join("\0") !== "created_at\0epoch_id\0key_base64url") {
+      throw new Error("fingerprint key epoch has unsupported fields");
+    }
+    if (typeof epoch.epoch_id !== "string" || !/^pep_[a-zA-Z0-9._-]{1,128}$/.test(epoch.epoch_id)) {
+      throw new Error("fingerprint key epoch ID is invalid");
+    }
+    if (seen.has(epoch.epoch_id)) throw new Error("fingerprint key epoch is duplicated");
+    seen.add(epoch.epoch_id);
+    if (typeof epoch.key_base64url !== "string") {
+      throw new Error("fingerprint key bytes are invalid");
+    }
+    const key = Buffer.from(epoch.key_base64url, "base64url");
+    if (key.length !== KEY_BYTES || key.toString("base64url") !== epoch.key_base64url) {
+      throw new Error("fingerprint key bytes are invalid");
+    }
+    if (typeof epoch.created_at !== "string" || Number.isNaN(Date.parse(epoch.created_at))) {
+      throw new Error("fingerprint key epoch time is invalid");
+    }
+    return epoch as unknown as FingerprintKeyEpochV3;
+  });
+  if (!seen.has(record.active_epoch_id)) {
+    throw new Error("fingerprint key store active epoch is missing");
+  }
+  return {
+    format: "harnery-v3-fingerprint-keys",
+    format_version: 1,
+    active_epoch_id: record.active_epoch_id as `pep_${string}`,
+    epochs,
+  };
+}

package/src/core/events/v3/generated.ts

@@ -0,0 +1,48 @@
+/** Generated by scripts/generate-event-v3-contract.ts. Do not edit. */
+export const EVENT_V3_SCHEMA_DIGEST =
+  "sha256:682272a35f16177217a272e119c4dea2bf1980a522a183fefd6dceaf1e4509b8" as const;
+export const EVENT_V3_GENERATED_CORE_TYPES = [
+  "ledger.genesis",
+  "ledger.activated",
+  "ledger.schema_advanced",
+  "ledger.comparability_advanced",
+  "session.started",
+  "session.attestation_changed",
+  "session.resumed",
+  "session.ended",
+  "session.termination_observed",
+  "run.started",
+  "run.completed",
+  "turn.started",
+  "turn.completed",
+  "tool.requested",
+  "tool.completed",
+  "command.started",
+  "command.output_observed",
+  "command.completed",
+  "context.observed",
+  "context.compaction_started",
+  "context.compaction_completed",
+  "context.checkpointed",
+  "context.recovery_injected",
+  "agent.delegated",
+  "agent.started",
+  "agent.completed",
+  "artifact.observed",
+  "progress.observed",
+  "coord.task_changed",
+  "coord.lifecycle_changed",
+  "coord.status_observed",
+  "coord.claim_changed",
+  "coord.presence_changed",
+  "coord.message_observed",
+  "coord.identity_attested",
+  "council.state_changed",
+  "decision.state_changed",
+  "lifecycle.recovered",
+  "lifecycle.sweep_observed",
+  "health.observed",
+  "wait.started",
+  "wait.ended",
+  "health.capability_drift",
+] as const;

package/src/core/events/v3/ids.ts

@@ -0,0 +1,33 @@
+import { v7 as uuidv7 } from "uuid";
+
+export function eventIdV3(): `evt_${string}` {
+  return `evt_${uuidv7()}`;
+}
+
+export function generationIdV3(): `gen_${string}` {
+  return `gen_${uuidv7()}`;
+}
+
+export function spanIdV3(): `span_${string}` {
+  return `span_${uuidv7()}`;
+}
+
+export function delegationIdV3(): `del_${string}` {
+  return `del_${uuidv7()}`;
+}
+
+export function attestationIdV3(): `att_${string}` {
+  return `att_${uuidv7()}`;
+}
+
+export function clockIdV3(): `clk_${string}` {
+  return `clk_${uuidv7()}`;
+}
+
+export function genesisIdV3(): `gex_${string}` {
+  return `gex_${uuidv7()}`;
+}
+
+export function activationIdV3(): `act_${string}` {
+  return `act_${uuidv7()}`;
+}

package/src/core/events/v3/index.ts

@@ -0,0 +1,322 @@
+export {
+  type SchemaAdvanceEligibilityV3,
+  validateAdditiveSchemaAdvanceV3,
+} from "./advance.ts";
+export {
+  type AuthorityMutationV3,
+  type AuthorityReceiptV3,
+  type AuthorityReconcilerV3,
+  type AuthorityTransactionV3,
+  buildAuthorityTransactionV3,
+  listPendingAuthorityTransactionsV3,
+  type PrepareAuthorityTransactionV3Input,
+  prepareAuthorityTransactionV3,
+  publishAuthorityTransactionV3,
+  readAuthorityReceiptV3,
+  readAuthorityTransactionV3,
+  reconcileAuthorityTransactionV3,
+} from "./authority-outbox.ts";
+export {
+  ensureEventLedgerV3,
+  type InitializeEventLedgerV3Input,
+  type InitializeEventLedgerV3Result,
+  initializeEventLedgerV3,
+} from "./bootstrap.ts";
+export { type BuildEventV3Input, buildEventV3 } from "./builder.ts";
+export {
+  canonicalJsonV3,
+  EVENT_V3_CANONICALIZER,
+  type FingerprintContextV3,
+  type FingerprintV3,
+  fingerprintV3,
+  normalizeNativeIdV3,
+  sha256V3,
+} from "./canonical.ts";
+export {
+  ADAPTER_CAPABILITY_PROFILES_V3,
+  type AdapterCapabilityProfileV3,
+  type AdapterSignalV3,
+  adapterCapabilityProfileDigestV3,
+  adapterCapabilityProfileV3,
+  adapterSignalSupportV3,
+  type CapabilitySupportV3,
+} from "./capabilities.ts";
+export {
+  type CapabilityDeliveryV3,
+  type CapabilityDriftPayloadV3,
+  capabilityDriftPayloadsV3,
+  measurableDeliveriesV3,
+} from "./capability-drift.ts";
+export {
+  EVENT_V3_CONTRACT_MAJOR,
+  EVENT_V3_CONTRACT_NAME,
+  EVENT_V3_CORE_EVENT_TYPES,
+  EVENT_V3_SCHEMA_ID,
+  type EventOfTypeV3,
+  type EventPayloadV3,
+  type EventTypeV3,
+  type EventV3,
+  EventV3Schema,
+  ObservationV3Schema,
+  OutcomeV3Schema,
+  RecoveryV3Schema,
+  type SpanSummaryV3,
+  SpanSummaryV3Schema,
+  type TurnHarnessV3,
+  type TurnInferenceV3,
+  type TurnUsageV3,
+  type WaitKindV3,
+  WaitKindV3Schema,
+} from "./contract.ts";
+export {
+  type ActivationManifestV3,
+  type BuildActivationManifestV3Input,
+  type BuildCandidateGenesisManifestV3Input,
+  buildActivationManifestV3,
+  buildCandidateGenesisManifestV3,
+  type CandidateGenesisManifestV3,
+  type CandidateProfileV3,
+  type ControlManifestValidationV3,
+  type ControlProducerV3,
+  candidateManifestDigestV3,
+  candidateProfileDigestV3,
+  EVENT_V3_ACTIVATION_MANIFEST,
+  EVENT_V3_GENESIS_MANIFEST,
+  type EventV3ControlState,
+  type EventV3WriteMode,
+  eventV3WriteGateOpen,
+  readEventV3ControlState,
+  repairEventV3ControlPair,
+  validateActivationManifestV3,
+  validateCandidateGenesisManifestV3,
+} from "./control.ts";
+export {
+  type CoordinationGenerationViewV3,
+  type CoordinationViewV3,
+  CoordinationViewV3Error,
+  EVENT_V3_COORDINATION_VIEW_VERSION,
+  projectCoordinationViewV3,
+  readCoordinationViewV3,
+  requireAuthoritySafeCoordinationViewV3,
+} from "./coordination-view.ts";
+export {
+  type CostMetricV3,
+  type DelegationRollupDiagnosticCodeV3,
+  type DelegationRollupV3,
+  type EconomicsProjectionOptionsV3,
+  type EconomicsProjectionV3,
+  EVENT_V3_ECONOMICS_PROJECTION_VERSION,
+  type GenerationEconomicsV3,
+  type ModelPricingV3,
+  projectDelegationRollupV3,
+  projectEconomicsV3,
+  type TokenTotalsMetricV3,
+  type TokenTotalsV3,
+  type TurnEconomicsV3,
+} from "./economics.ts";
+export {
+  EVENT_V3_FINALIZATION_VIEW_VERSION,
+  type FinalizationScopeV3,
+  FinalizationScopeV3Error,
+  type FinalizationScopeV3ErrorCode,
+  projectFinalizationScopeV3,
+  readFinalizationScopeV3,
+} from "./finalization-view.ts";
+export {
+  FINGERPRINT_KEY_STORE_RELATIVE_PATH,
+  type FingerprintKeyEpochV3,
+  type FingerprintKeyStoreV3,
+  fingerprintContextV3,
+  fingerprintKeyStorePathV3,
+  loadOrCreateFingerprintKeyStoreV3,
+  type RotateFingerprintEpochV3Options,
+  readFingerprintKeyStoreV3,
+  rotateFingerprintEpochV3,
+} from "./fingerprint-keys.ts";
+export { EVENT_V3_SCHEMA_DIGEST } from "./generated.ts";
+export {
+  activationIdV3,
+  attestationIdV3,
+  clockIdV3,
+  delegationIdV3,
+  eventIdV3,
+  generationIdV3,
+  genesisIdV3,
+  spanIdV3,
+} from "./ids.ts";
+export {
+  type ContextCoverageStateV3,
+  type ContextCoverageV3,
+  EVENT_V3_LATENCY_PROJECTION_VERSION,
+  type LatencyMetricV3,
+  type LatencyProjectionDiagnosticCodeV3,
+  type LatencyProjectionDiagnosticV3,
+  type LatencyProjectionV3,
+  projectLatencyV3,
+  type ToolLatencyV3,
+  type TurnLatencyV3,
+} from "./latency.ts";
+export {
+  EVENT_V3_LIVE_RELATIVE_ROOT,
+  janitorLiveDisplayV3,
+  type LiveDisplayInputV3,
+  type LiveDisplayJanitorResultV3,
+  type LiveDisplayRowV3,
+  listLiveDisplayV3,
+  readLiveDisplayV3,
+  safeIntentDisplayV3,
+  tryWriteLiveDisplayV3,
+  writeLiveDisplayV3,
+} from "./live-feed.ts";
+export type { LiveCoordinationObservationV3 } from "./live-observation.ts";
+export {
+  hookSignalV3,
+  LIVE_COMMAND_V3_PRODUCER_ID,
+  LIVE_HOOK_V3_PRODUCER_ID,
+  type LiveEventLedgerRouteV3,
+  liveEventV3BuildId,
+  liveInstanceIdV3,
+  livePlatformV3,
+  nativeInstanceIdV3,
+  recordLiveHookSignalV3,
+  resolveLiveEventLedgerRouteV3,
+} from "./live-routing.ts";
+export {
+  type CommandObservationV3,
+  type CommandProducerContextV3,
+  type CommandSignalV3,
+  normalizeCommandEventV3,
+} from "./producers/command.ts";
+export {
+  type RecordCommandSignalV3Input,
+  type RecordCommandSignalV3Result,
+  recordCommandSignalV3,
+} from "./producers/command-recorder.ts";
+export {
+  type ClaimChangedObservationV3,
+  type CoordinationAuthoritySignalV3,
+  type CoordinationObservationBySignalV3,
+  type CoordinationProducerContextV3,
+  type DecisionStateChangedObservationV3,
+  type IdentityAttestedObservationV3,
+  type LifecycleChangedObservationV3,
+  type NormalizedCoordinationAuthorityV3,
+  normalizeCoordinationAuthorityV3,
+  type TaskChangedObservationV3,
+  type WaitEndedObservationV3,
+  type WaitStartedObservationV3,
+} from "./producers/coordination.ts";
+export {
+  type RecordCoordinationAuthorityV3Input,
+  type RecordCoordinationAuthorityV3Result,
+  recordCoordinationAuthorityV3,
+} from "./producers/coordination-recorder.ts";
+export {
+  type HookEventV3,
+  type HookProducerContextV3,
+  normalizeHookEventV3,
+  upgradeHookEventV3,
+} from "./producers/hook.ts";
+export {
+  type ApprovedSessionEndReasonV3,
+  type DrainHookIntakeSpoolV3Result,
+  drainHookIntakeSpoolV3,
+  type HookProducerStateRecordV3,
+  type HookProducerStateV3,
+  listHookProducerStateRecordsV3,
+  type RecordApprovedSessionEndV3Input,
+  type RecordApprovedSessionEndV3Result,
+  type RecordHookSignalV3Input,
+  type RecordHookSignalV3Result,
+  readHookProducerStateV3,
+  recordApprovedSessionEndV3,
+  recordHookSignalV3,
+} from "./producers/recorder.ts";
+export {
+  type ClaimProjectionV3,
+  type DelegationProjectionV3,
+  EVENT_V3_SAFETY_REDUCER_BUILD,
+  type GenerationSafetyStateV3,
+  reduceSafetyProjectionV3,
+  type SafetyProjectionDiagnosticCodeV3,
+  type SafetyProjectionDiagnosticV3,
+  type SafetyProjectionV3,
+  type WaitProjectionV3,
+} from "./projection.ts";
+export {
+  digestEventV3AuthorityDirectoryV3,
+  inspectInvalidActiveAuthorityV3,
+  type LedgerCursorV3,
+  type LedgerDiagnosticCodeV3,
+  type LedgerDiagnosticV3,
+  type LedgerFrameV3,
+  type PositionedEventV3,
+  type ReadLedgerV3Options,
+  type ReadLedgerV3Result,
+  type ReadLedgerV3SinceResult,
+  readLedgerFramesV3,
+  readLedgerFramesV3Since,
+  readLedgerV3,
+  readLedgerV3Since,
+  type SchemaAdvanceV3,
+} from "./reader.ts";
+export {
+  type RecoverInvalidEventLedgerV3Input,
+  type RecoverInvalidEventLedgerV3Result,
+  recoverInvalidEventLedgerV3,
+} from "./recovery.ts";
+export {
+  type EventV3RecoveryDiagnostic,
+  type EventV3RecoveryFailure,
+  type EventV3RecoveryIntent,
+  type EventV3RecoveryReceipt,
+  eventV3RecoveryRecordsRoot,
+  listEventV3RecoveryReceipts,
+  readEventV3RecoveryIntent,
+  readEventV3RecoveryReceipt,
+  validateEventV3RecoveryIntent,
+  validateEventV3RecoveryReceipt,
+} from "./recovery-record.ts";
+export {
+  type CloseSpanV3Input,
+  captureSpanClockV3,
+  closeSpanStateV3,
+  linuxUptimeNanosecondsV3,
+  type OpenSpanStateV3,
+  type OpenSpanV3Input,
+  openSpanStateV3,
+  type SpanClockV3,
+} from "./span-state.ts";
+export {
+  type DescribePathTargetV3Input,
+  describePathTargetV3,
+  type ExtractTargetsV3Input,
+  exactToolInputFingerprintV3,
+  extractTargetsV3,
+  type TargetDescriptorV3,
+} from "./targets.ts";
+export {
+  type ContextMeasurementV3,
+  emptyHarnessTimingV3,
+  extractTurnTelemetryV3,
+  type HarnessTimingAccumulatorV3,
+  harnessObservationV3,
+  recordHarnessTimingV3,
+  type TelemetryObservationV3,
+  type TurnTelemetryV3,
+} from "./turn-telemetry.ts";
+export {
+  assertEventV3,
+  type EventV3ValidationResult,
+  validateEventV3,
+} from "./validate.ts";
+export {
+  drainReadyEventsV3,
+  EVENT_V3_LEDGER_RELATIVE_ROOT,
+  type EventV3DurabilityState,
+  type EventV3WriteStep,
+  eventV3Paths,
+  type WriteEventV3Options,
+  type WriteEventV3Result,
+  writeEventV3,
+} from "./writer.ts";