@modelprofile.com/flexharness 10.0.0 → 10.2.0

package/ts/classes.stores.ts

@@ -35,8 +35,6 @@ import {
   assertFlexProjectManagementTombstone,
 } from './utils.projectmanagement.js';
 import {
-  assertExactKeys,
-  assertRecord,
   createAgentEventSnapshot,
   createToolJobSnapshot,
   normalizeJsonObjectUndefined,
@@ -44,101 +42,17 @@ import {
   validateAgentEventSnapshot,
   validateToolJobSnapshot,
 } from './utils.storecodecs.js';
-
-type TSnapshot =
-  | IFlexScopeSnapshot
-  | TFlexProjectionSnapshot
-  | IFlexPermissionSnapshot
-  | TFlexProjectManagementRecord;
-type TSnapshotValidator<TSnapshotValue extends TSnapshot> = (
-  value: unknown,
-) => asserts value is TSnapshotValue;
-
-function validateIdentifier(value: string, name: string): void {
-  if (typeof value !== 'string' || !value.trim()) {
-    throw new FlexHarnessValidationError(`${name} must be a non-empty string.`);
-  }
-}
-
-function validateExpectedRevision(expectedRevision: number): void {
-  if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
-    throw new FlexHarnessValidationError('expectedRevision must be a non-negative integer.');
-  }
-}
-
-function validateProjectManagementWriteContext(
-  writeContext: IFlexProjectManagementWriteContext,
-): void {
-  assertJsonSerializable(writeContext, '$writeContext');
-  assertRecord(writeContext, 'writeContext');
-  assertExactKeys(writeContext, ['actor', 'runId', 'agent', 'toolCallId'], 'writeContext');
-  if (writeContext.actor !== 'agent' && writeContext.actor !== 'application') {
-    throw new FlexHarnessValidationError('writeContext.actor must be agent or application.');
-  }
-  for (const key of ['runId', 'agent', 'toolCallId'] as const) {
-    if (writeContext[key] !== undefined) validateIdentifier(writeContext[key], `writeContext.${key}`);
-  }
-}
-
-function validateSnapshotSave<TSnapshotValue extends TSnapshot>(
-  snapshot: TSnapshotValue,
-  expectedRevision: number,
-  validator: TSnapshotValidator<TSnapshotValue>,
-): TSnapshotValue {
-  validator(snapshot);
-  validateExpectedRevision(expectedRevision);
-  if (snapshot.revision !== expectedRevision + 1) {
-    throw new FlexHarnessStoreFormatError(
-      `Snapshot revision ${snapshot.revision} must equal expected revision ${expectedRevision} plus one.`,
-    );
-  }
-  return cloneSerializable(snapshot);
-}
-
-function providerKey(storageKey: string, sessionId: string): string {
-  validateIdentifier(storageKey, 'storageKey');
-  validateIdentifier(sessionId, 'sessionId');
-  return JSON.stringify([storageKey, sessionId]);
-}
-
-function sameProjectManagementGeneration(
-  left: TFlexProjectManagementRecord,
-  right: TFlexProjectManagementRecord,
-): boolean {
-  return left.sessionGenerationId === right.sessionGenerationId
-    && left.sessionGenerationSequence === right.sessionGenerationSequence;
-}
-
-function canInitializeProjectManagementGeneration(
-  current: TFlexProjectManagementRecord,
-  next: TFlexProjectManagementRecord,
-  expectedRevision: number,
-): boolean {
-  return 'deletedAt' in current
-    && expectedRevision === 0
-    && next.sessionGenerationId !== current.sessionGenerationId
-    && next.sessionGenerationSequence > current.sessionGenerationSequence;
-}
-
-function assertProjectionSession(snapshot: TFlexProjectionSnapshot, sessionId: string): void {
-  for (const message of snapshot.messages) {
-    if (message.sessionId !== sessionId) {
-      throw new FlexHarnessStoreFormatError(
-        `Projection message "${message.messageId}" does not belong to session "${sessionId}".`,
-      );
-    }
-  }
-  for (const terminal of snapshot.stagedTerminals) {
-    if (
-      terminal.userMessage.sessionId !== sessionId
-      || terminal.assistantMessage.sessionId !== sessionId
-    ) {
-      throw new FlexHarnessStoreFormatError(
-        `Staged terminal "${terminal.runId}" does not belong to session "${sessionId}".`,
-      );
-    }
-  }
-}
+import {
+  assertProjectionSession,
+  assertProjectManagementSaveAdmitted,
+  assertSameArchiveEvents,
+  isProjectManagementTombstoneAdmitted,
+  providerKey,
+  validateExpectedRevision,
+  validateIdentifier,
+  validateProjectManagementWriteContext,
+  validateSnapshotSave,
+} from './utils.storerules.js';
 
 class InMemoryScopeStore implements IFlexScopeStore {
   private readonly snapshots = new Map<string, IFlexScopeSnapshot>();
@@ -253,15 +167,7 @@ export class InMemoryFlexProjectManagementStore implements IFlexProjectManagemen
       expectedRevision,
       assertFlexProjectManagementSnapshot,
     );
-    const current = this.snapshots.get(key);
-    const actualRevision = current?.revision ?? 0;
-    if (current && !sameProjectManagementGeneration(current, validated)) {
-      if (!canInitializeProjectManagementGeneration(current, validated, expectedRevision)) {
-        throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
-      }
-    } else if ((current && 'deletedAt' in current) || actualRevision !== expectedRevision) {
-      throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
-    }
+    assertProjectManagementSaveAdmitted(key, this.snapshots.get(key), validated, expectedRevision);
     this.snapshots.set(key, validated);
   }
 
@@ -277,19 +183,8 @@ export class InMemoryFlexProjectManagementStore implements IFlexProjectManagemen
       expectedRevision,
       assertFlexProjectManagementTombstone,
     );
-    const current = this.snapshots.get(key);
-    const actualRevision = current?.revision ?? 0;
-    if (current && sameProjectManagementGeneration(current, validated)) {
-      if ('deletedAt' in current) return;
-      if (actualRevision !== expectedRevision) {
-        throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
-      }
-    } else if (current) {
-      if (!canInitializeProjectManagementGeneration(current, validated, expectedRevision)) {
-        throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
-      }
-    } else if (actualRevision !== expectedRevision) {
-      throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+    if (!isProjectManagementTombstoneAdmitted(key, this.snapshots.get(key), validated, expectedRevision)) {
+      return;
     }
     this.snapshots.set(key, validated);
   }
@@ -346,12 +241,7 @@ class InMemoryAgentEventStore implements plugins.IAgentEventStoreV2 {
     const validated = validateAgentEventArchive(normalized, this.sessionId, archive.archiveId);
     const existing = this.archives.get(archive.archiveId);
     if (existing) {
-      if (
-        JSON.stringify(existing.events.map((event) => event.id))
-        !== JSON.stringify(validated.events.map((event) => event.id))
-      ) {
-        throw new Error(`Archive "${archive.archiveId}" already exists with different events.`);
-      }
+      assertSameArchiveEvents(existing, validated);
       return;
     }
     this.archives.set(archive.archiveId, cloneSerializable(validated));
@@ -1007,22 +897,12 @@ class JsonProjectManagementStore implements IFlexProjectManagementStore {
           assertFlexProjectManagementRecord(value);
           return value;
         });
-        const actualRevision = current?.revision ?? 0;
-        if (current && !sameProjectManagementGeneration(current, validated)) {
-          if (!canInitializeProjectManagementGeneration(current, validated, expectedRevision)) {
-            throw new FlexHarnessStoreConflictError(
-              providerKey(storageKey, sessionId),
-              expectedRevision,
-              actualRevision,
-            );
-          }
-        } else if ((current && 'deletedAt' in current) || actualRevision !== expectedRevision) {
-          throw new FlexHarnessStoreConflictError(
-            providerKey(storageKey, sessionId),
-            expectedRevision,
-            actualRevision,
-          );
-        }
+        assertProjectManagementSaveAdmitted(
+          providerKey(storageKey, sessionId),
+          current,
+          validated,
+          expectedRevision,
+        );
         await this.root.write(filePath, validated);
       }),
     );
@@ -1046,31 +926,12 @@ class JsonProjectManagementStore implements IFlexProjectManagementStore {
           assertFlexProjectManagementRecord(value);
           return value;
         });
-        const actualRevision = current?.revision ?? 0;
-        if (current && sameProjectManagementGeneration(current, validated)) {
-          if ('deletedAt' in current) return;
-          if (actualRevision !== expectedRevision) {
-            throw new FlexHarnessStoreConflictError(
-              providerKey(storageKey, sessionId),
-              expectedRevision,
-              actualRevision,
-            );
-          }
-        } else if (current) {
-          if (!canInitializeProjectManagementGeneration(current, validated, expectedRevision)) {
-            throw new FlexHarnessStoreConflictError(
-              providerKey(storageKey, sessionId),
-              expectedRevision,
-              actualRevision,
-            );
-          }
-        } else if (actualRevision !== expectedRevision) {
-          throw new FlexHarnessStoreConflictError(
-            providerKey(storageKey, sessionId),
-            expectedRevision,
-            actualRevision,
-          );
-        }
+        if (!isProjectManagementTombstoneAdmitted(
+          providerKey(storageKey, sessionId),
+          current,
+          validated,
+          expectedRevision,
+        )) return;
         await this.root.write(filePath, validated);
       }),
     );
@@ -1163,12 +1024,7 @@ class JsonAgentEventStore implements plugins.IAgentEventStoreV2 {
         (value) => validateAgentEventArchive(value, this.sessionId, archive.archiveId),
       );
       if (current) {
-        if (
-          JSON.stringify(current.events.map((event) => event.id))
-          !== JSON.stringify(validated.events.map((event) => event.id))
-        ) {
-          throw new Error(`Archive "${archive.archiveId}" already exists with different events.`);
-        }
+        assertSameArchiveEvents(current, validated);
         return;
       }
       await this.root.write(filePath, validated);

package/ts/errors.ts

@@ -173,13 +173,19 @@ export class FlexHarnessStoreFormatError extends FlexHarnessError {
   }
 }
 
+/**
+ * What a store was doing when it could not confirm the outcome: `write` and `delete` name a
+ * database record, `delete-file` and `delete-directory` a file-system path.
+ */
+export type TFlexStoreCommitOperation = 'write' | 'delete' | 'delete-file' | 'delete-directory';
+
 export class FlexHarnessStoreCommitUncertainError extends FlexHarnessError {
   public readonly path: string;
-  public readonly operation: 'write' | 'delete-file' | 'delete-directory';
+  public readonly operation: TFlexStoreCommitOperation;
 
   constructor(
     path: string,
-    operation: 'write' | 'delete-file' | 'delete-directory',
+    operation: TFlexStoreCommitOperation,
     options: ErrorOptions,
   ) {
     super(

package/ts/interfaces.ts

@@ -513,6 +513,25 @@ export interface IFlexMessagePage {
   nextCursor?: string;
 }
 
+/**
+ * A session as the events up to `sequence` describe it, read in one step. Replaying the events of
+ * the same harness instance after `sequence` onto it gives the session's later states.
+ */
+export interface IFlexSessionView {
+  /** Current metadata. Its status can be ahead of `sequence`: status changes emit no event. */
+  session: IFlexSession;
+  /** The visible messages, including what a running turn has streamed so far. */
+  messages: IFlexMessage[];
+  /**
+   * The session's pending permission requests, oldest first. A request its run leaves unanswered,
+   * because the run was stopped or failed, leaves this list without an event of its own; the run's
+   * `run.finished` follows.
+   */
+  pendingPermissions: IFlexPermissionRequest[];
+  /** The `sequence` of the instance's last event this view includes; 0 before the first event. */
+  sequence: number;
+}
+
 export interface IFlexResolvedScope<TScope> {
   storageKey: string;
   scope: TScope;

package/ts/readme.md

@@ -61,10 +61,12 @@ or provider SDKs.
 | `/chat` | Portable streaming `ChatSession`, history and usage | None |
 | `/chat/cli` | Ink/React terminal chat | `ink ink-text-input react`; TypeScript: `@types/react` |
 | `/chat/web` | Lit `flexchat-window`, `flexchat-message`, `flexchat-input` | `lit` |
+| `/chat/harness` | `FlexHarnessTranscript` and intents for the `@design.estate/dees-catalog` harness components, browser-safe | `@design.estate/dees-catalog` (types only) |
 | `/kvm` | Browser control, terminal framing and OCR observation | `puppeteer` |
 | `/documents` | PDF and image documents, `extractTextFromPdf` | `@push.rocks/smartpdf`; for image documents `sharp` |
 | `/mcp` | MCP clients and AI SDK tool conversion | `@modelcontextprotocol/sdk` |
 | `/migration` | Existing versioned harness migrations | None |
+| `/stores/nosqldb` | `NoSqlFlexHarnessStores`: cross-process CAS stores on `@lossless.org/client/nosqldb` | `@lossless.org/client` |
 
 The integrations in the last column use optional peer dependencies. Install them
 only for the entrypoints your project imports, for example:
@@ -1032,6 +1034,8 @@ unsubscribe();
 
 Events are discriminated, deeply immutable values with one global sequence within each `FlexHarness` instance. Every `IFlexEventBase` carries the exact source `sessionGenerationId` and `sessionGenerationSequence`; `session.deleted` retains the deleted generation after live metadata is removed. Listener exceptions are isolated from runs and other listeners. Every accepted queue entry emits `prompt.queued` and exactly one `prompt.finished`. Every accepted steer emits `prompt.steer.accepted`, and `prompt.steer.applied`, after the `message.*` events of its user message, once the run took it in; `run.finished` lists it in `unappliedSteerIds` unless it is in the model context of later turns. Durable promotion additionally emits `prompt.started`, and actual model preparation emits `prompt.running`; cancellation or failure can omit either intermediate event. Existing durable run/message terminal events precede `prompt.finished`. Every callback-backed streamed text part emits exactly one `part.completed` event before the corresponding `run.finished` event. Every `part.started`, `part.delta`, `part.updated`, and `part.completed` event carries zero-based `messageIndex` and `partIndex` coordinates from the session's authoritative message and part sequences.
 
+`getSessionView(scopeId, sessionId)` reads a session's metadata, visible messages and pending permission requests in one step, together with the instance's event `sequence` they include. The messages include what a running turn has streamed so far, so a consumer that applies every event of the instance with a greater `sequence` follows the session exactly from the view on; events up to `sequence` are already in it. The read waits while a queued write or a change that emits events for the session is in progress; a session that keeps changing through 64 consecutive waits is refused with `FlexHarnessSessionBusyError`, and the read can be repeated. Session metadata is current: status changes such as `waiting_permission` emit no event. A permission request its run leaves unanswered leaves `pendingPermissions` without an event of its own; the run's `run.finished` follows.
+
 `part.started`, `part.updated`, and `part.completed` are snapshot events with a complete immutable `part`. A newly streamed text part emits `part.started` with empty text before its first delta; reasoning parts also start empty. `part.delta` is a separate delta-only event: it has no cumulative `part`, and carries `partType`, the required exact source `delta`, and `baseTextUtf8Bytes`/`textUtf8Bytes` for the cumulative text before and after that delta. The counters remain correct when a UTF-16 surrogate pair is split across callbacks. Exact deltas are never truncated, including a single delta above the 96 KiB message-transfer text limit. `part.updated` remains a cumulative replacement snapshot for running tool output or metadata, not a text delta. `session.history.changed` carries `direction: 'undo' | 'redo' | 'branch'`; `runId` is present for undo and redo. Events contain public IDs, exact delta payloads, and public snapshots only; they do not expose prompt payloads, the resolved scope object, storage key, model object, provider options, or raw storage key.
 
 Part events narrow through the exported `TFlexPartEvent` union. `IFlexPartEventBase` contains their shared coordinates, `IFlexPartSnapshotEvent` owns snapshot events and their complete `part`, and `IFlexPartDeltaEvent` owns exact delta-only events and their UTF-8 counters.
@@ -1068,6 +1072,8 @@ After every harness using a `JsonFileFlexHarnessStores` instance has been dispos
 
 The JSON stores are explicitly not cross-process safe. When several processes can access the same storage namespace, every core `IFlexHarnessStores` domain and `stores.projectManagement` must use database-backed or equivalent cross-process CAS. Process-local CAS for the core stores or for PM alone is insufficient: session generation creation, cleanup tombstones, PM replacement, and stale-writer rejection must all retain their respective atomic preconditions across processes.
 
+`NoSqlFlexHarnessStores` from `/stores/nosqldb` is that database-backed bundle for every domain. Pass it an initialized `SmartdataDb` and `await stores.prepare()` at startup, before the first harness uses it; the subpath readme describes chunked snapshots and failure reporting.
+
 Direct store operations and non-run session mutations surface conflicts as `FlexHarnessStoreConflictError` or the corresponding AgentSession store conflict. Malformed, wrong-schema, or non-JSON snapshots are surfaced as `FlexHarnessStoreFormatError`. A write or deletion that changed its target but cannot confirm parent-directory durability surfaces `FlexHarnessStoreCommitUncertainError` with the affected path, operation, and cause. Run persistence failures cross the external error boundary and therefore become `FlexHarnessExternalError`. FlexHarness does not merge conflicts.
 
 Each domain serializes its own mutations. A successful run first persists a hidden completed projection, then finalizes the canonical Agent generation as `accepted`, then promotes the hidden projection publicly. Recovery uses the canonical generation outcome to promote an accepted stage or publish a failed/cancelled projection. Failed and cancelled generations remain auditable but never enter future model context.

package/ts/utils.storerules.ts

@@ -0,0 +1,177 @@
+import type * as plugins from './plugins.js';
+import {
+  FlexHarnessStoreConflictError,
+  FlexHarnessStoreFormatError,
+  FlexHarnessValidationError,
+} from './errors.js';
+import type {
+  IFlexPermissionSnapshot,
+  IFlexProjectManagementSnapshot,
+  IFlexProjectManagementTombstone,
+  IFlexProjectManagementWriteContext,
+  IFlexScopeSnapshot,
+  TFlexProjectionSnapshot,
+  TFlexProjectManagementRecord,
+} from './interfaces.js';
+import { assertJsonSerializable, cloneSerializable } from './utils.json.js';
+import { assertExactKeys, assertRecord } from './utils.storecodecs.js';
+
+/**
+ * Store-independent admission rules every `IFlexHarnessStores` implementation applies: argument
+ * validation, the next-revision rule, exact session keys, and the project-management generation
+ * fence. Backends own only how they read, compare and write.
+ */
+
+type TSnapshot =
+  | IFlexScopeSnapshot
+  | TFlexProjectionSnapshot
+  | IFlexPermissionSnapshot
+  | TFlexProjectManagementRecord;
+type TSnapshotValidator<TSnapshotValue extends TSnapshot> = (
+  value: unknown,
+) => asserts value is TSnapshotValue;
+
+export function validateIdentifier(value: string, name: string): void {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new FlexHarnessValidationError(`${name} must be a non-empty string.`);
+  }
+}
+
+export function validateExpectedRevision(expectedRevision: number): void {
+  if (!Number.isSafeInteger(expectedRevision) || expectedRevision < 0) {
+    throw new FlexHarnessValidationError('expectedRevision must be a non-negative integer.');
+  }
+}
+
+export function validateProjectManagementWriteContext(
+  writeContext: IFlexProjectManagementWriteContext,
+): void {
+  assertJsonSerializable(writeContext, '$writeContext');
+  assertRecord(writeContext, 'writeContext');
+  assertExactKeys(writeContext, ['actor', 'runId', 'agent', 'toolCallId'], 'writeContext');
+  if (writeContext.actor !== 'agent' && writeContext.actor !== 'application') {
+    throw new FlexHarnessValidationError('writeContext.actor must be agent or application.');
+  }
+  for (const key of ['runId', 'agent', 'toolCallId'] as const) {
+    if (writeContext[key] !== undefined) validateIdentifier(writeContext[key], `writeContext.${key}`);
+  }
+}
+
+export function validateSnapshotSave<TSnapshotValue extends TSnapshot>(
+  snapshot: TSnapshotValue,
+  expectedRevision: number,
+  validator: TSnapshotValidator<TSnapshotValue>,
+): TSnapshotValue {
+  validator(snapshot);
+  validateExpectedRevision(expectedRevision);
+  if (snapshot.revision !== expectedRevision + 1) {
+    throw new FlexHarnessStoreFormatError(
+      `Snapshot revision ${snapshot.revision} must equal expected revision ${expectedRevision} plus one.`,
+    );
+  }
+  return cloneSerializable(snapshot);
+}
+
+export function providerKey(storageKey: string, sessionId: string): string {
+  validateIdentifier(storageKey, 'storageKey');
+  validateIdentifier(sessionId, 'sessionId');
+  return JSON.stringify([storageKey, sessionId]);
+}
+
+export function assertProjectionSession(snapshot: TFlexProjectionSnapshot, sessionId: string): void {
+  for (const message of snapshot.messages) {
+    if (message.sessionId !== sessionId) {
+      throw new FlexHarnessStoreFormatError(
+        `Projection message "${message.messageId}" does not belong to session "${sessionId}".`,
+      );
+    }
+  }
+  for (const terminal of snapshot.stagedTerminals) {
+    if (
+      terminal.userMessage.sessionId !== sessionId
+      || terminal.assistantMessage.sessionId !== sessionId
+    ) {
+      throw new FlexHarnessStoreFormatError(
+        `Staged terminal "${terminal.runId}" does not belong to session "${sessionId}".`,
+      );
+    }
+  }
+}
+
+function sameProjectManagementGeneration(
+  left: TFlexProjectManagementRecord,
+  right: TFlexProjectManagementRecord,
+): boolean {
+  return left.sessionGenerationId === right.sessionGenerationId
+    && left.sessionGenerationSequence === right.sessionGenerationSequence;
+}
+
+function canInitializeProjectManagementGeneration(
+  current: TFlexProjectManagementRecord,
+  next: TFlexProjectManagementRecord,
+  expectedRevision: number,
+): boolean {
+  return 'deletedAt' in current
+    && expectedRevision === 0
+    && next.sessionGenerationId !== current.sessionGenerationId
+    && next.sessionGenerationSequence > current.sessionGenerationSequence;
+}
+
+/**
+ * Admits a live project-management save over the stored record: a CAS save within the stored
+ * generation, or a newer generation that replaces a tombstone at expected revision 0.
+ */
+export function assertProjectManagementSaveAdmitted(
+  key: string,
+  current: TFlexProjectManagementRecord | undefined,
+  snapshot: IFlexProjectManagementSnapshot,
+  expectedRevision: number,
+): void {
+  const actualRevision = current?.revision ?? 0;
+  if (current && !sameProjectManagementGeneration(current, snapshot)) {
+    if (!canInitializeProjectManagementGeneration(current, snapshot, expectedRevision)) {
+      throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+    }
+  } else if ((current && 'deletedAt' in current) || actualRevision !== expectedRevision) {
+    throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+  }
+}
+
+/**
+ * Admits a project-management tombstone over the stored record. Returns false when the same
+ * generation is already tombstoned, which makes a repeated cleanup idempotent.
+ */
+export function isProjectManagementTombstoneAdmitted(
+  key: string,
+  current: TFlexProjectManagementRecord | undefined,
+  tombstone: IFlexProjectManagementTombstone,
+  expectedRevision: number,
+): boolean {
+  const actualRevision = current?.revision ?? 0;
+  if (current && sameProjectManagementGeneration(current, tombstone)) {
+    if ('deletedAt' in current) return false;
+    if (actualRevision !== expectedRevision) {
+      throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+    }
+  } else if (current) {
+    if (!canInitializeProjectManagementGeneration(current, tombstone, expectedRevision)) {
+      throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+    }
+  } else if (actualRevision !== expectedRevision) {
+    throw new FlexHarnessStoreConflictError(key, expectedRevision, actualRevision);
+  }
+  return true;
+}
+
+/** An archive is written once; repeating it with the same events is a no-op. */
+export function assertSameArchiveEvents(
+  existing: plugins.IAgentEventArchiveV2,
+  next: plugins.IAgentEventArchiveV2,
+): void {
+  if (
+    JSON.stringify(existing.events.map((event) => event.id))
+    !== JSON.stringify(next.events.map((event) => event.id))
+  ) {
+    throw new Error(`Archive "${next.archiveId}" already exists with different events.`);
+  }
+}