@opengeni/sdk 0.52.1 → 1.0.0

package/dist/editable-artifacts.js

@@ -1,3 +1,7 @@
+import {
+  OPENGENI_API_CONTRACT_HEADER,
+  OPENGENI_API_CONTRACT_REVISION
+} from "./chunk-YIKA2QT4.js";
 import {
   DEFAULT_ARTIFACT_WORKER_RPC_LIMITS,
   decodeArtifactWorkerRpcMessage,
@@ -14,26 +18,26 @@ import {
   encodeSnapshotMetadata,
   ownedTransferBuffer,
   transferListForArtifactWorkerRpcMessage
-} from "./chunk-VWE2QIVO.js";
-import {
-  OPENGENI_API_CONTRACT_HEADER,
-  OPENGENI_API_CONTRACT_REVISION
-} from "./chunk-FRJFNDIR.js";
+} from "./chunk-XNG7YGR3.js";
 
 // src/editable-artifacts/controller.ts
 import {
   decodeEditableArtifactMutationIntent as decodeEditableArtifactMutationIntent2,
   EDITABLE_ARTIFACT_COMMAND_MAX_BYTES as EDITABLE_ARTIFACT_COMMAND_MAX_BYTES2,
   EDITABLE_ARTIFACT_INTENT_MAX_BYTES as EDITABLE_ARTIFACT_INTENT_MAX_BYTES2,
+  EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION,
   EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES as EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES2,
   hashEditableArtifactMutationIntentBytes as hashEditableArtifactMutationIntentBytes2
 } from "@opengeni/contracts/editable-artifacts";
 import {
+  COMMITTED_TRANSACTION_PROTOCOL_VERSION,
   decodeCommittedTransactionSummary as decodeCommittedTransactionSummary2,
   MAX_COMMITTED_TRANSACTION_BYTES
 } from "@opengeni/contracts/editable-artifact-committed-transaction";
 import { editableArtifactCodecFor as editableArtifactCodecFor2 } from "@opengeni/contracts/editable-artifact-codec-registry";
+import { EDITABLE_ARTIFACT_LIVE_WIRE_VERSION } from "@opengeni/contracts/editable-artifact-live";
 import { decodeEditableArtifactSerializedCommit as decodeEditableArtifactSerializedCommit2 } from "@opengeni/contracts/editable-artifact-serialized-commit";
+import { SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION } from "@opengeni/contracts/editable-artifact-versions";
 
 // src/editable-artifacts/errors.ts
 var EditableArtifactSyncError = class extends Error {
@@ -61,6 +65,67 @@ var EditableArtifactTransportError = class extends Error {
   }
 };
 
+// src/editable-artifacts/open-failure.ts
+var BYTE_CORRUPTION_CODES = /* @__PURE__ */ new Set([
+  "byte_corruption",
+  "artifact_bad_magic",
+  "artifact_checksum_mismatch",
+  "artifact_invalid_collaboration_snapshot",
+  "artifact_invalid_snapshot",
+  "artifact_invalid_tag",
+  "artifact_invalid_utf8",
+  "artifact_non_canonical",
+  "artifact_trailing_bytes",
+  "artifact_truncated"
+]);
+var AUTHORED_CAUSAL_CODES = /* @__PURE__ */ new Set([
+  "artifact_state_mismatch",
+  "authored_causal_mismatch",
+  "committed_metadata_mismatch",
+  "invalid_frontier",
+  "kernel_diverged"
+]);
+var RUNTIME_PACKAGE_CODES = /* @__PURE__ */ new Set([
+  "artifact_runtime_incompatible",
+  "artifact_runtime_integrity",
+  "artifact_runtime_manifest_invalid",
+  "artifact_runtime_unavailable",
+  "artifact_runtime_unsupported_target",
+  "incompatible_wasm_build",
+  "runtime_identity_mismatch"
+]);
+function classifyEditableArtifactOpenFailure(error) {
+  const code = normalizedErrorCode(error);
+  if (code === null) return null;
+  let category = null;
+  if (code === "unsupported_protocol" || code === "artifact_unsupported_version") {
+    category = "unsupported_old_format";
+  } else if (BYTE_CORRUPTION_CODES.has(code)) {
+    category = "byte_corruption";
+  } else if (AUTHORED_CAUSAL_CODES.has(code)) {
+    category = "authored_causal_mismatch";
+  } else if (RUNTIME_PACKAGE_CODES.has(code)) {
+    category = "runtime_package_mismatch";
+  } else if (code === "artifact_runtime_projection_parity") {
+    category = "projection_parity_ci_failure";
+  }
+  return category === null ? null : Object.freeze({ category, code });
+}
+function normalizedErrorCode(error) {
+  if (typeof error !== "object" || error === null) return null;
+  let descriptor;
+  try {
+    descriptor = Object.getOwnPropertyDescriptor(error, "code");
+  } catch {
+    return null;
+  }
+  if (!descriptor || !("value" in descriptor)) return null;
+  const value = descriptor.value;
+  if (typeof value !== "string") return null;
+  const code = value.toLowerCase();
+  return /^[a-z][a-z0-9_]{0,127}$/u.test(code) ? code : null;
+}
+
 // src/editable-artifacts/storage.ts
 import {
   assertCanonicalSpreadsheetArtifactCommandBytes,
@@ -111,7 +176,7 @@ var MemoryEditableArtifactStorage = class {
         cursor: replica.head.cursor,
         stateHash: replica.head.stateHash,
         modality: replica.head.modality,
-        ...replica.head.snapshot.modality === "spreadsheet" ? { protocolVersion: replica.head.snapshot.protocolVersion } : {}
+        ...replica.head.snapshot.modality === "spreadsheet" ? { operationProtocolVersion: replica.head.snapshot.operationProtocolVersion } : {}
       },
       input
     );
@@ -177,7 +242,7 @@ var MemoryEditableArtifactStorage = class {
     if (namespace?.size === 0) this.#pending.delete(scope.namespace);
   }
 };
-var DATABASE_VERSION = 3;
+var DATABASE_VERSION = 4;
 var REPLICA_HEAD_STORE = "replicas";
 var SNAPSHOT_STORE = "snapshots";
 var COMMITTED_STORE = "committedTransactions";
@@ -271,7 +336,7 @@ var IndexedDbEditableArtifactStorage = class {
     assertStoredHeadAccounting(head, tail.length, retainedTailBytes);
     const {
       namespace: _headNamespace,
-      protocolVersion: retainedProtocolVersion,
+      operationProtocolVersion: retainedOperationProtocolVersion,
       tailCount: _tailCount,
       tailBytes: _tailBytes,
       ...storedHead
@@ -281,11 +346,10 @@ var IndexedDbEditableArtifactStorage = class {
     const normalizedTail = tail.map(
       ({ namespace: _transactionNamespace, ...value }) => normalizeStoredCommitted(value, ownedScope.modality)
     ).sort(compareCommittedTransactions);
-    const headModality = head.modality ?? "spreadsheet";
-    if (headModality !== ownedScope.modality) {
+    if (head.modality !== ownedScope.modality) {
       throw new TypeError("retained head modality does not match its storage scope");
     }
-    if (storedSnapshot.modality === "spreadsheet" && retainedProtocolVersion !== storedSnapshot.protocolVersion)
+    if (storedSnapshot.modality === "spreadsheet" && retainedOperationProtocolVersion !== storedSnapshot.operationProtocolVersion)
       throw new TypeError("retained head protocol does not match its snapshot");
     const replica = {
       ...storedHead,
@@ -501,7 +565,11 @@ function assertStoredReplica(replica) {
   assertSha256(replica.snapshot.digest, "snapshot.digest");
   if (replica.snapshot.modality === "spreadsheet") {
     assertFrontier(replica.snapshot.causalFrontier, "snapshot.causalFrontier");
-    assertPositiveInteger(replica.snapshot.protocolVersion, "snapshot.protocolVersion");
+    assertPositiveInteger(
+      replica.snapshot.operationProtocolVersion,
+      "snapshot.operationProtocolVersion"
+    );
+    assertPositiveInteger(replica.snapshot.snapshotVersion, "snapshot.snapshotVersion");
   } else {
     assertSequence(replica.snapshot.nativeRevision, "snapshot.nativeRevision");
   }
@@ -529,7 +597,7 @@ function assertStoredReplica(replica) {
     if (transaction.startSequence !== cursor + 1) {
       throw new TypeError("stored committed tail must be contiguous after its snapshot");
     }
-    if (transaction.modality === "spreadsheet" && replica.snapshot.modality === "spreadsheet" && transaction.protocolVersion !== replica.snapshot.protocolVersion)
+    if (transaction.modality === "spreadsheet" && replica.snapshot.modality === "spreadsheet" && transaction.operationProtocolVersion !== replica.snapshot.operationProtocolVersion)
       throw new TypeError("stored committed tail protocol does not match its snapshot");
     if (transaction.modality !== "spreadsheet") {
       if (nativeRevision !== transaction.priorNativeRevision) {
@@ -631,9 +699,9 @@ function assertCommittedTransaction(transaction, artifactId) {
   }
   if (transaction.modality === "spreadsheet") {
     assertFrontier(transaction.causalFrontier, "causalFrontier");
-    assertPositiveInteger(transaction.protocolVersion, "protocolVersion");
+    assertPositiveInteger(transaction.operationProtocolVersion, "operationProtocolVersion");
     const summary2 = decodeCommittedTransactionSummary(transaction.committedTransactionBytes);
-    if (summary2.transactionId !== transaction.transactionId || summary2.operationProtocolVersion !== transaction.protocolVersion || summary2.priorStateHash !== transaction.priorStateHash || summary2.stateHash !== transaction.stateHash || !frontiersEqual(summary2.resultingCausalFrontier, transaction.causalFrontier))
+    if (summary2.transactionId !== transaction.transactionId || summary2.operationProtocolVersion !== transaction.operationProtocolVersion || summary2.priorStateHash !== transaction.priorStateHash || summary2.stateHash !== transaction.stateHash || !frontiersEqual(summary2.resultingCausalFrontier, transaction.causalFrontier))
       throw new TypeError("committed fields do not exactly match their OGACO envelope");
     return;
   }
@@ -701,13 +769,12 @@ function assertAppendCanApply(head, input) {
       `artifact ${input.artifactId} retained head no longer matches append expectation`
     );
   }
-  const headModality = head.modality ?? "spreadsheet";
-  if (input.transaction.modality !== headModality) {
+  if (input.transaction.modality !== head.modality) {
     throw new EditableArtifactStorageConflictError(
       `artifact ${input.artifactId} append modality does not match retained snapshot`
     );
   }
-  if (input.transaction.modality === "spreadsheet" && input.transaction.protocolVersion !== head.protocolVersion) {
+  if (input.transaction.modality === "spreadsheet" && input.transaction.operationProtocolVersion !== head.operationProtocolVersion) {
     throw new EditableArtifactStorageConflictError(
       `artifact ${input.artifactId} append protocol does not match retained snapshot`
     );
@@ -746,7 +813,7 @@ function pendingTransactionsEqual(left, right) {
   return left.artifactId === right.artifactId && left.modality === right.modality && left.clientTransactionId === right.clientTransactionId && left.requestHash === right.requestHash && left.protocolVersion === right.protocolVersion && left.modelSchemaVersion === right.modelSchemaVersion && left.commandVersion === right.commandVersion && left.replicaId === right.replicaId && left.replicaCounter === right.replicaCounter && left.previousLocalTransactionId === right.previousLocalTransactionId && left.observedHeadSequence === right.observedHeadSequence && left.createdAt === right.createdAt && (left.modality === "spreadsheet" && right.modality === "spreadsheet" ? frontiersEqual(left.causalBase, right.causalBase) && identifiersEqual(left.selectiveUndoTargets, right.selectiveUndoTargets) : left.modality !== "spreadsheet" && right.modality !== "spreadsheet" && left.observedNativeRevision === right.observedNativeRevision) && bytesEqual(left.commandBytes, right.commandBytes) && bytesEqual(left.intentBytes, right.intentBytes);
 }
 function committedTransactionsEqual(left, right) {
-  return left.artifactId === right.artifactId && left.modality === right.modality && left.transactionId === right.transactionId && left.requestHash === right.requestHash && left.startSequence === right.startSequence && left.endSequence === right.endSequence && left.priorStateHash === right.priorStateHash && left.stateHash === right.stateHash && (left.modality === "spreadsheet" && right.modality === "spreadsheet" ? left.protocolVersion === right.protocolVersion && frontiersEqual(left.causalFrontier, right.causalFrontier) : left.modality !== "spreadsheet" && right.modality !== "spreadsheet" && left.priorNativeRevision === right.priorNativeRevision && left.nativeRevision === right.nativeRevision && left.commitProtocolVersion === right.commitProtocolVersion) && bytesEqual(left.committedTransactionBytes, right.committedTransactionBytes);
+  return left.artifactId === right.artifactId && left.modality === right.modality && left.transactionId === right.transactionId && left.requestHash === right.requestHash && left.startSequence === right.startSequence && left.endSequence === right.endSequence && left.priorStateHash === right.priorStateHash && left.stateHash === right.stateHash && (left.modality === "spreadsheet" && right.modality === "spreadsheet" ? left.operationProtocolVersion === right.operationProtocolVersion && frontiersEqual(left.causalFrontier, right.causalFrontier) : left.modality !== "spreadsheet" && right.modality !== "spreadsheet" && left.priorNativeRevision === right.priorNativeRevision && left.nativeRevision === right.nativeRevision && left.commitProtocolVersion === right.commitProtocolVersion) && bytesEqual(left.committedTransactionBytes, right.committedTransactionBytes);
 }
 function frontiersEqual(left, right) {
   return left.length === right.length && left.every(
@@ -790,22 +857,19 @@ function assertScopeModality(scope, modality) {
   }
 }
 function normalizeStoredSnapshot(snapshot, modality) {
-  const retainedModality = snapshot.modality ?? "spreadsheet";
-  if (retainedModality !== modality) {
+  if (snapshot.modality !== modality) {
     throw new TypeError("retained snapshot modality does not match its storage scope");
   }
   return { ...snapshot, modality };
 }
 function normalizeStoredCommitted(transaction, modality) {
-  const retainedModality = transaction.modality ?? "spreadsheet";
-  if (retainedModality !== modality) {
+  if (transaction.modality !== modality) {
     throw new TypeError("retained transaction modality does not match its storage scope");
   }
   return { ...transaction, modality };
 }
 function normalizeStoredPending(transaction, modality) {
-  const retainedModality = transaction.modality ?? "spreadsheet";
-  if (retainedModality !== modality) {
+  if (transaction.modality !== modality) {
     throw new TypeError("retained pending modality does not match its storage scope");
   }
   return { ...transaction, modality };
@@ -912,14 +976,10 @@ function openDatabase(factory, databaseName) {
     };
     request.onupgradeneeded = (event) => {
       const database = request.result;
-      if (event.oldVersion < 2) {
+      if (event.oldVersion < DATABASE_VERSION) {
         for (const name of [REPLICA_HEAD_STORE, SNAPSHOT_STORE, PENDING_STORE, COMMITTED_STORE]) {
           if (database.objectStoreNames.contains(name)) database.deleteObjectStore(name);
         }
-      } else if (event.oldVersion < 3) {
-        for (const name of [REPLICA_HEAD_STORE, SNAPSHOT_STORE, COMMITTED_STORE]) {
-          if (database.objectStoreNames.contains(name)) database.deleteObjectStore(name);
-        }
       }
       if (!database.objectStoreNames.contains(REPLICA_HEAD_STORE)) {
         database.createObjectStore(REPLICA_HEAD_STORE, {
@@ -1001,7 +1061,9 @@ function replaceIndexedDbReplica(database, scope, replica, expectedHead) {
               stateHash: replica.stateHash,
               updatedAt: replica.updatedAt,
               modality: replica.modality,
-              ...replica.snapshot.modality === "spreadsheet" ? { protocolVersion: replica.snapshot.protocolVersion } : {},
+              ...replica.snapshot.modality === "spreadsheet" ? {
+                operationProtocolVersion: replica.snapshot.operationProtocolVersion
+              } : {},
               tailCount: replica.tail.length,
               tailBytes: committedTailBytes(replica.tail)
             };
@@ -1283,7 +1345,6 @@ function putIndexedDbPending(database, scope, value) {
 }
 
 // src/editable-artifacts/controller.ts
-var DEFAULT_PROTOCOL_VERSION = 1;
 var DEFAULT_REPLAY_PAGE_SIZE = 256;
 var DEFAULT_MAX_QUEUE_MESSAGES = 512;
 var DEFAULT_MAX_QUEUE_BYTES = 8 * 1024 * 1024;
@@ -1330,6 +1391,7 @@ var EditableArtifactSyncControllerImpl = class {
   maxReconnectAttempts;
   scheduler;
   clientTransactionIdFactory;
+  onOpenFailure;
   abortController = new AbortController();
   listeners = /* @__PURE__ */ new Set();
   liveWaiters = /* @__PURE__ */ new Set();
@@ -1396,10 +1458,10 @@ var EditableArtifactSyncControllerImpl = class {
     );
     this.modelSchemaVersion = positiveSafeInteger(options.modelSchemaVersion, "modelSchemaVersion");
     this.commandVersion = positiveSafeInteger(options.commandVersion, "commandVersion");
-    this.protocolVersion = positiveSafeInteger(
-      options.protocolVersion ?? DEFAULT_PROTOCOL_VERSION,
-      "protocolVersion"
-    );
+    this.protocolVersion = positiveSafeInteger(options.protocolVersion, "protocolVersion");
+    if (this.protocolVersion !== EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION) {
+      throw new TypeError("protocolVersion is incompatible with the current intent protocol");
+    }
     this.replayPageSize = positiveSafeInteger(
       options.replayPageSize ?? DEFAULT_REPLAY_PAGE_SIZE,
       "replayPageSize"
@@ -1458,12 +1520,14 @@ var EditableArtifactSyncControllerImpl = class {
     this.maxReconnectAttempts = options.maxReconnectAttempts === void 0 ? Number.POSITIVE_INFINITY : nonNegativeSafeInteger(options.maxReconnectAttempts, "maxReconnectAttempts");
     this.scheduler = options.scheduler ?? defaultScheduler;
     this.clientTransactionIdFactory = options.clientTransactionIdFactory ?? (() => crypto.randomUUID());
+    this.onOpenFailure = options.onOpenFailure;
   }
   start() {
     if (this.runTask || this.state === "closed") return;
     this.runTask = this.run().catch((error) => {
       if (this.abortController.signal.aborted) return;
       const failure = asError(error);
+      this.reportOpenFailure(failure);
       if (failure instanceof EditableArtifactSyncError && failure.code === "unsupported_protocol") {
         this.lastError = failure;
         this.setState("unsupported");
@@ -1498,6 +1562,10 @@ var EditableArtifactSyncControllerImpl = class {
     this.rejectLiveWaiters(new Error("artifact sync controller closed"));
   }
   getView() {
+    const blockedPending = this.allBlockedPending();
+    const authoringBlockedReason = this.modality !== "spreadsheet" && blockedPending.length > 0 ? "pending_conflict" : this.orderedPending().some(
+      (transaction) => transaction.replicaId !== this.writerReplicaId
+    ) ? "prior_writer" : void 0;
     return {
       artifactId: this.artifactId,
       modality: this.modality,
@@ -1506,7 +1574,8 @@ var EditableArtifactSyncControllerImpl = class {
       headSequence: this.headSequence,
       writable: this.writable,
       pendingTransactions: this.pending.size,
-      blockedPending: this.allBlockedPending(),
+      blockedPending,
+      authoringBlockedReason,
       queuedMessages: this.liveQueue.length,
       reconnectAttempt: this.reconnectAttempt,
       lastError: this.lastError
@@ -1748,7 +1817,8 @@ var EditableArtifactSyncControllerImpl = class {
     try {
       await this.restoreReplica(stored);
       await this.replacePendingOverlay();
-    } catch {
+    } catch (error) {
+      this.reportOpenFailure(error);
       await this.kernel.reset();
       this.replica = null;
       this.retainedTailTransactions = 0;
@@ -1763,8 +1833,8 @@ var EditableArtifactSyncControllerImpl = class {
       stored.snapshot,
       this.artifactId,
       this.modality,
-      this.protocolVersion,
-      this.kernelVersion,
+      COMMITTED_TRANSACTION_PROTOCOL_VERSION,
+      SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION,
       this.modelSchemaVersion,
       this.maxSnapshotBytes
     );
@@ -1782,12 +1852,13 @@ var EditableArtifactSyncControllerImpl = class {
     let stateHash = stored.snapshot.stateHash;
     let causalFrontier = stored.snapshot.modality === "spreadsheet" ? stored.snapshot.causalFrontier : null;
     let nativeRevision = stored.snapshot.modality === "spreadsheet" ? null : stored.snapshot.nativeRevision;
+    const retainedAcceptances = [];
     for (const transaction of stored.tail) {
-      validateCommittedTransaction(
+      const embeddedPending = validateCommittedTransaction(
         transaction,
         this.artifactId,
         this.modality,
-        this.protocolVersion,
+        COMMITTED_TRANSACTION_PROTOCOL_VERSION,
         this.maxCommittedTransactionBytes
       );
       if (transaction.startSequence !== cursor + 1) {
@@ -1796,6 +1867,12 @@ var EditableArtifactSyncControllerImpl = class {
       requireStateHash(transaction.priorStateHash, stateHash, "retained transaction prior state");
       const applied = await this.kernel.applyRecovered(transaction);
       requireStateHash(applied.stateHash, transaction.stateHash, "retained transaction");
+      if (embeddedPending) {
+        const pending = this.pending.get(embeddedPending.clientTransactionId);
+        if (pending?.requestHash === embeddedPending.requestHash && bytesEqual2(pending.intentBytes, embeddedPending.intentBytes)) {
+          retainedAcceptances.push({ transaction, pending: embeddedPending });
+        }
+      }
       cursor = transaction.endSequence;
       stateHash = transaction.stateHash;
       if (transaction.modality === "spreadsheet") {
@@ -1828,6 +1905,10 @@ var EditableArtifactSyncControllerImpl = class {
     this.retainedTailTransactions = stored.tail.length;
     this.cursor = cursor;
     this.headSequence = cursor;
+    for (const { transaction, pending } of retainedAcceptances) {
+      this.recordAcceptedMappingIdentity(transaction.transactionId, pending);
+      await this.settlePending(transaction, true);
+    }
   }
   async run() {
     await this.initialize();
@@ -1851,6 +1932,7 @@ var EditableArtifactSyncControllerImpl = class {
           delayMs = this.reconnectDelayMs;
         }
         const failure = asError(error);
+        this.reportOpenFailure(failure);
         this.lastError = failure;
         if (failure instanceof EditableArtifactSyncError && failure.requiresSnapshot) {
           this.requireSnapshot = true;
@@ -2001,11 +2083,11 @@ var EditableArtifactSyncControllerImpl = class {
     if (bootstrap.modality !== this.modality) {
       throw invalidBootstrap("bootstrap modality does not match the controller");
     }
-    this.requireProtocol(bootstrap.protocolVersion);
-    if (bootstrap.kernelVersion !== this.kernelVersion || bootstrap.modelSchemaVersion !== this.modelSchemaVersion) {
+    this.requireLiveProtocol(bootstrap.liveProtocolVersion);
+    if (bootstrap.modelSchemaVersion !== this.modelSchemaVersion) {
       throw new EditableArtifactSyncError(
         "unsupported_protocol",
-        `artifact kernel/schema ${bootstrap.kernelVersion}/${bootstrap.modelSchemaVersion} is incompatible with ${this.kernelVersion}/${this.modelSchemaVersion}`
+        `artifact schema ${bootstrap.modelSchemaVersion} is incompatible with ${this.modelSchemaVersion}`
       );
     }
     requireSha256(bootstrap.headStateHash, "bootstrap.headStateHash");
@@ -2064,8 +2146,8 @@ var EditableArtifactSyncControllerImpl = class {
       snapshot,
       this.artifactId,
       this.modality,
-      this.protocolVersion,
-      this.kernelVersion,
+      COMMITTED_TRANSACTION_PROTOCOL_VERSION,
+      SPREADSHEET_COLLABORATION_SNAPSHOT_VERSION,
       this.modelSchemaVersion,
       this.maxSnapshotBytes
     );
@@ -2154,7 +2236,7 @@ var EditableArtifactSyncControllerImpl = class {
           transaction,
           this.artifactId,
           this.modality,
-          this.protocolVersion,
+          COMMITTED_TRANSACTION_PROTOCOL_VERSION,
           this.maxCommittedTransactionBytes
         );
         pageBytes += estimateCommittedTransactionBytes(transaction);
@@ -2184,7 +2266,7 @@ var EditableArtifactSyncControllerImpl = class {
         message,
         this.artifactId,
         this.modality,
-        this.protocolVersion,
+        COMMITTED_TRANSACTION_PROTOCOL_VERSION,
         this.maxCommittedTransactionBytes
       );
       bytes = estimateLiveMessageBytes(message);
@@ -2270,7 +2352,7 @@ var EditableArtifactSyncControllerImpl = class {
       transaction,
       this.artifactId,
       this.modality,
-      this.protocolVersion,
+      COMMITTED_TRANSACTION_PROTOCOL_VERSION,
       this.maxCommittedTransactionBytes
     );
     if (embeddedPending) {
@@ -2508,7 +2590,7 @@ var EditableArtifactSyncControllerImpl = class {
         receipt.committed,
         this.artifactId,
         this.modality,
-        this.protocolVersion,
+        COMMITTED_TRANSACTION_PROTOCOL_VERSION,
         this.maxCommittedTransactionBytes
       );
       this.recordAcceptedMapping(receipt);
@@ -2566,7 +2648,7 @@ var EditableArtifactSyncControllerImpl = class {
         "sync ticket is not bound to the requested writer replica"
       );
     }
-    this.requireProtocol(ticket.protocolVersion);
+    this.requireLiveProtocol(ticket.protocolVersion);
     boundedNonEmpty(ticket.token, "ticket.token", MAX_TICKET_BYTES);
     const expiresAt = Date.parse(ticket.expiresAt);
     if (!Number.isFinite(expiresAt)) {
@@ -2661,11 +2743,11 @@ var EditableArtifactSyncControllerImpl = class {
       (left, right) => compareCodeUnits(left.clientTransactionId, right.clientTransactionId)
     );
   }
-  requireProtocol(actual) {
-    if (actual !== this.protocolVersion) {
+  requireLiveProtocol(actual) {
+    if (actual !== EDITABLE_ARTIFACT_LIVE_WIRE_VERSION) {
       throw new EditableArtifactSyncError(
         "unsupported_protocol",
-        `artifact protocol ${actual} is incompatible with client ${this.protocolVersion}`
+        `live protocol ${actual} is incompatible with ${EDITABLE_ARTIFACT_LIVE_WIRE_VERSION}`
       );
     }
   }
@@ -2691,6 +2773,14 @@ var EditableArtifactSyncControllerImpl = class {
     for (const waiter of this.liveWaiters) waiter.reject(error);
     this.liveWaiters.clear();
   }
+  reportOpenFailure(error) {
+    const event = classifyEditableArtifactOpenFailure(error);
+    if (event === null || this.onOpenFailure === void 0) return;
+    try {
+      this.onOpenFailure(event);
+    } catch {
+    }
+  }
   fail(error) {
     this.lastError = error;
     this.setState("failed");
@@ -2796,7 +2886,7 @@ function bytesEqual2(left, right) {
   }
   return true;
 }
-function validateCommittedTransaction(transaction, artifactId, modality, protocolVersion, maxCommittedTransactionBytes) {
+function validateCommittedTransaction(transaction, artifactId, modality, operationProtocolVersion, maxCommittedTransactionBytes) {
   if (transaction.artifactId !== artifactId || transaction.modality !== modality) {
     throw invalidSequence("transaction artifact authority mismatch");
   }
@@ -2819,10 +2909,10 @@ function validateCommittedTransaction(transaction, artifactId, modality, protoco
     throw invalidSequence("transaction committedTransactionBytes exceeds the configured bound");
   }
   if (transaction.modality === "spreadsheet") {
-    if (transaction.protocolVersion !== protocolVersion) {
+    if (transaction.operationProtocolVersion !== operationProtocolVersion) {
       throw new EditableArtifactSyncError(
         "unsupported_protocol",
-        `transaction protocol ${transaction.protocolVersion} is incompatible with client ${protocolVersion}`
+        `transaction operation protocol ${transaction.operationProtocolVersion} is incompatible with ${operationProtocolVersion}`
       );
     }
     validateFrontier(transaction.causalFrontier, "causalFrontier");
@@ -2832,7 +2922,7 @@ function validateCommittedTransaction(transaction, artifactId, modality, protoco
     } catch (error) {
       throw invalidSequence(`invalid OGACO envelope: ${asError(error).message}`);
     }
-    if (summary2.transactionId !== transaction.transactionId || summary2.operationProtocolVersion !== transaction.protocolVersion || summary2.priorStateHash !== transaction.priorStateHash || summary2.stateHash !== transaction.stateHash || !frontiersEqual2(summary2.resultingCausalFrontier, transaction.causalFrontier)) {
+    if (summary2.transactionId !== transaction.transactionId || summary2.operationProtocolVersion !== transaction.operationProtocolVersion || summary2.priorStateHash !== transaction.priorStateHash || summary2.stateHash !== transaction.stateHash || !frontiersEqual2(summary2.resultingCausalFrontier, transaction.causalFrontier)) {
       throw invalidSequence("committed routing fields do not exactly match the OGACO envelope");
     }
     return null;
@@ -2857,7 +2947,7 @@ function validateCommittedTransaction(transaction, artifactId, modality, protoco
     intentBytes: summary.intentBytes
   });
 }
-function validateSnapshot(snapshot, artifactId, modality, protocolVersion, kernelVersion, modelSchemaVersion, maxSnapshotBytes) {
+function validateSnapshot(snapshot, artifactId, modality, operationProtocolVersion, snapshotVersion, modelSchemaVersion, maxSnapshotBytes) {
   if (snapshot.artifactId !== artifactId || snapshot.modality !== modality) {
     throw invalidBootstrap("snapshot artifact authority mismatch");
   }
@@ -2868,19 +2958,19 @@ function validateSnapshot(snapshot, artifactId, modality, protocolVersion, kerne
   positiveSafeInteger(snapshot.modelSchemaVersion, "snapshot.modelSchemaVersion");
   if (snapshot.modality === "spreadsheet") {
     validateFrontier(snapshot.causalFrontier, "snapshot.causalFrontier");
-    if (snapshot.protocolVersion !== protocolVersion) {
+    if (snapshot.operationProtocolVersion !== operationProtocolVersion || snapshot.snapshotVersion !== snapshotVersion) {
       throw new EditableArtifactSyncError(
         "unsupported_protocol",
-        `snapshot protocol ${snapshot.protocolVersion} is incompatible with client ${protocolVersion}`
+        `snapshot operation/state versions ${snapshot.operationProtocolVersion}/${snapshot.snapshotVersion} are incompatible with ${operationProtocolVersion}/${snapshotVersion}`
       );
     }
   } else {
     requireNativeRevision(snapshot.nativeRevision, "snapshot.nativeRevision");
   }
-  if (snapshot.kernelVersion !== kernelVersion || snapshot.modelSchemaVersion !== modelSchemaVersion) {
+  if (snapshot.modelSchemaVersion !== modelSchemaVersion) {
     throw new EditableArtifactSyncError(
       "unsupported_protocol",
-      `snapshot kernel/schema ${snapshot.kernelVersion}/${snapshot.modelSchemaVersion} is incompatible with ${kernelVersion}/${modelSchemaVersion}`
+      `snapshot schema ${snapshot.modelSchemaVersion} is incompatible with ${modelSchemaVersion}`
     );
   }
   if (!(snapshot.bytes instanceof Uint8Array)) {
@@ -2909,7 +2999,7 @@ function validateFrontier(frontier, label) {
     previous = entry.replicaId;
   }
 }
-function validateLiveMessage(message, artifactId, modality, protocolVersion, maxCommittedTransactionBytes) {
+function validateLiveMessage(message, artifactId, modality, operationProtocolVersion, maxCommittedTransactionBytes) {
   if (!message || typeof message !== "object") {
     throw invalidSequence("live message must be an object");
   }
@@ -2918,7 +3008,7 @@ function validateLiveMessage(message, artifactId, modality, protocolVersion, max
       message.transaction,
       artifactId,
       modality,
-      protocolVersion,
+      operationProtocolVersion,
       maxCommittedTransactionBytes
     );
     return;
@@ -2963,7 +3053,7 @@ function estimateCommittedTransactionBytes(transaction) {
 function requireStateHash(actual, expected, source) {
   if (actual !== expected) {
     throw new EditableArtifactSyncError(
-      "kernel_diverged",
+      "authored_causal_mismatch",
       `${source} produced state hash ${actual}; expected ${expected}`,
       { retryable: true, requiresSnapshot: true }
     );
@@ -2973,7 +3063,7 @@ function requireDigest(actual, expected, source) {
   requireSha256(actual, `${source} computed digest`);
   if (actual !== expected) {
     throw new EditableArtifactSyncError(
-      "kernel_diverged",
+      "byte_corruption",
       `${source} bytes produced digest ${actual}; expected ${expected}`,
       { retryable: true, requiresSnapshot: true }
     );
@@ -2984,7 +3074,7 @@ function requireFrontier(actual, expected, source) {
     (entry, index) => entry.replicaId !== expected[index]?.replicaId || entry.counter !== expected[index]?.counter
   )) {
     throw new EditableArtifactSyncError(
-      "kernel_diverged",
+      "authored_causal_mismatch",
       `${source} causal frontier does not match the authoritative barrier`,
       { retryable: true, requiresSnapshot: true }
     );
@@ -3111,7 +3201,7 @@ function requireNativeRevisionEqual(actual, expected, source) {
   requireNativeRevision(expected, `${source} expected native revision`);
   if (actual !== expected) {
     throw new EditableArtifactSyncError(
-      "kernel_diverged",
+      "authored_causal_mismatch",
       `${source} native revision ${actual} does not match ${expected}`,
       { retryable: true, requiresSnapshot: true }
     );
@@ -3292,9 +3382,11 @@ var defaultScheduler = {
 };
 
 // src/editable-artifacts/browser-session.ts
-import { DOCUMENT_ARTIFACT_COMMAND_VERSION as DOCUMENT_ARTIFACT_COMMAND_VERSION2 } from "@opengeni/contracts/document-artifact-commands";
-import { PRESENTATION_ARTIFACT_COMMAND_VERSION as PRESENTATION_ARTIFACT_COMMAND_VERSION2 } from "@opengeni/contracts/presentation-artifact-commands";
-import { SPREADSHEET_ARTIFACT_COMMAND_VERSION as SPREADSHEET_ARTIFACT_COMMAND_VERSION2 } from "@opengeni/contracts/spreadsheet-artifact-commands";
+import { EDITABLE_ARTIFACT_LIVE_WIRE_VERSION as EDITABLE_ARTIFACT_LIVE_WIRE_VERSION2 } from "@opengeni/contracts/editable-artifact-live";
+import {
+  EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION as EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION2,
+  currentEditableArtifactCompatibility as currentEditableArtifactCompatibility2
+} from "@opengeni/contracts/editable-artifacts";
 
 // src/editable-artifacts/http-live-transport.ts
 import {
@@ -3307,11 +3399,12 @@ import {
   EDITABLE_ARTIFACT_COMMAND_MAX_BYTES as EDITABLE_ARTIFACT_COMMAND_MAX_BYTES3,
   EDITABLE_ARTIFACT_INTENT_MAX_BYTES as EDITABLE_ARTIFACT_INTENT_MAX_BYTES3,
   EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES as EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES3,
+  currentEditableArtifactCompatibility,
   hashEditableArtifactMutationIntentBytes as hashEditableArtifactMutationIntentBytes3
 } from "@opengeni/contracts/editable-artifacts";
 import { MAX_COMMITTED_TRANSACTION_BYTES as MAX_COMMITTED_TRANSACTION_BYTES2 } from "@opengeni/contracts/editable-artifact-committed-transaction";
 var LIVE_PATH = "/v1/editable-artifacts/live";
-var LIVE_SUBPROTOCOL = "opengeni-artifact-v1";
+var LIVE_SUBPROTOCOL = "opengeni-artifact-v2";
 var DEFAULT_MAX_SERVER_FRAME_BYTES = 8 * 1024 * 1024 + 64 * 1024;
 var DEFAULT_MAX_SNAPSHOT_BYTES2 = EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES3;
 var DEFAULT_HANDSHAKE_TIMEOUT_MS = 2e4;
@@ -3327,9 +3420,13 @@ var HttpLiveTransport = class {
   baseUrl;
   socketUrl;
   workspaceId;
-  protocolVersion;
+  modality;
+  liveProtocolVersion;
   kernelVersion;
   modelSchemaVersion;
+  snapshotVersion;
+  commandProtocolVersion;
+  committedTransactionProtocolVersion;
   apiKey;
   headerSource;
   credentials;
@@ -3345,9 +3442,34 @@ var HttpLiveTransport = class {
     const insecure = options.allowInsecureDevelopmentTransport ?? false;
     requireTransportSecurity(this.baseUrl, this.socketUrl, insecure);
     this.workspaceId = boundedString(options.workspaceId, "workspaceId", 256);
-    this.protocolVersion = positiveU162(options.protocolVersion, "protocolVersion");
+    const current = currentEditableArtifactCompatibility(options.modality);
+    this.modality = options.modality;
+    this.liveProtocolVersion = exactVersion(
+      options.liveProtocolVersion,
+      current.liveProtocolVersion,
+      "liveProtocolVersion"
+    );
     this.kernelVersion = boundedString(options.kernelVersion, "kernelVersion", 512);
-    this.modelSchemaVersion = positiveU162(options.modelSchemaVersion, "modelSchemaVersion");
+    this.modelSchemaVersion = exactVersion(
+      options.modelSchemaVersion,
+      current.modelSchemaVersion,
+      "modelSchemaVersion"
+    );
+    this.snapshotVersion = exactVersion(
+      options.snapshotVersion,
+      current.snapshotVersion,
+      "snapshotVersion"
+    );
+    this.commandProtocolVersion = exactVersion(
+      options.commandProtocolVersion,
+      current.commandProtocolVersion,
+      "commandProtocolVersion"
+    );
+    this.committedTransactionProtocolVersion = exactVersion(
+      options.committedTransactionProtocolVersion,
+      current.committedTransactionProtocolVersion,
+      "committedTransactionProtocolVersion"
+    );
     this.apiKey = options.apiKey;
     if (this.apiKey !== void 0) boundedString(this.apiKey, "apiKey", 16 * 1024);
     this.headerSource = options.headers;
@@ -3395,9 +3517,13 @@ var HttpLiveTransport = class {
         },
         body: JSON.stringify({
           replicaId: input.replicaId,
-          protocolVersion: this.protocolVersion,
+          modality: this.modality,
+          liveProtocolVersion: this.liveProtocolVersion,
           kernelVersion: this.kernelVersion,
-          modelSchemaVersion: this.modelSchemaVersion
+          modelSchemaVersion: this.modelSchemaVersion,
+          snapshotVersion: this.snapshotVersion,
+          commandProtocolVersion: this.commandProtocolVersion,
+          committedTransactionProtocolVersion: this.committedTransactionProtocolVersion
         }),
         signal: input.signal
       });
@@ -3419,7 +3545,7 @@ var HttpLiveTransport = class {
       );
     }
     const value = await readBoundedJson(response, MAX_TICKET_RESPONSE_BYTES);
-    return validateTicket(value, input.artifactId, input.replicaId, this.protocolVersion);
+    return validateTicket(value, input.artifactId, input.replicaId, this.liveProtocolVersion);
   }
   async openLive(input) {
     if (input.resume.modality !== input.ticket.modality) {
@@ -3438,6 +3564,7 @@ var HttpLiveTransport = class {
     };
     const resume = input.resume.modality === "spreadsheet" ? {
       ...commonResume,
+      modality: "spreadsheet",
       localCausalFrontier: cloneFrontier3(input.resume.causalFrontier)
     } : {
       ...commonResume,
@@ -3593,7 +3720,7 @@ var HttpLiveConnection = class {
     }
     const commonBootstrap = {
       artifactId: this.ticket.artifactId,
-      protocolVersion: this.ticket.protocolVersion,
+      liveProtocolVersion: this.ticket.protocolVersion,
       headSequence: boundarySequence,
       headStateHash: boundaryStateHash,
       kernelVersion: snapshot?.kernelVersion ?? this.kernelVersion,
@@ -3667,12 +3794,6 @@ var HttpLiveConnection = class {
     if (pending.artifactId !== this.ticket.artifactId) {
       throw new TypeError("pending transaction belongs to another artifact");
     }
-    if (pending.protocolVersion !== this.ticket.protocolVersion) {
-      throw new EditableArtifactTransportError("pending protocol does not match live stream", {
-        code: "unsupported",
-        retryable: false
-      });
-    }
     if (pending.commandBytes.byteLength > Math.min(open.maxCommandBytes, EDITABLE_ARTIFACT_COMMAND_MAX_BYTES3)) {
       throw new EditableArtifactTransportError("pending command exceeds negotiated live limit", {
         code: "limit_exceeded",
@@ -3693,7 +3814,7 @@ var HttpLiveConnection = class {
     }
     const frame = encodeEditableArtifactLiveMutationWireFrame({
       type: "mutation",
-      protocolVersion: pending.protocolVersion,
+      protocolVersion: this.ticket.protocolVersion,
       artifactId: pending.artifactId,
       streamEpoch: open.streamEpoch,
       requestHash: pending.requestHash,
@@ -3850,11 +3971,9 @@ var HttpLiveConnection = class {
         if (frame.transaction.artifactId !== this.ticket.artifactId) {
           throw new TypeError("live transaction belongs to another artifact");
         }
-        if (transactionModality(frame.transaction) !== this.ticket.modality) {
+        if (frame.transaction.modality !== this.ticket.modality) {
           throw new TypeError("live transaction modality mismatch");
         }
-        if ((frame.transaction.modality === void 0 || frame.transaction.modality === "spreadsheet") && frame.transaction.protocolVersion !== this.ticket.protocolVersion)
-          throw new TypeError("live transaction protocol mismatch");
         if (frame.transaction.committedTransactionBytes.byteLength > this.limits.maxCommittedTransactionBytes) {
           throw new RangeError("live transaction exceeds negotiated committed byte limit");
         }
@@ -3933,7 +4052,7 @@ var HttpLiveConnection = class {
     if (frame.protocolVersion !== this.ticket.protocolVersion) {
       throw new TypeError("live snapshot protocol mismatch");
     }
-    if (serverModality(frame.modality) !== this.ticket.modality) {
+    if (frame.modality !== this.ticket.modality) {
       throw new TypeError("live snapshot modality mismatch");
     }
     if (this.snapshotAssembly === null) {
@@ -3968,7 +4087,8 @@ var HttpLiveConnection = class {
       ...commonSnapshot,
       modality: "spreadsheet",
       causalFrontier: cloneFrontier3(frame.causalFrontier),
-      protocolVersion: frame.protocolVersion
+      operationProtocolVersion: frame.operationProtocolVersion,
+      snapshotVersion: frame.snapshotVersion
     }) : Object.freeze({
       ...commonSnapshot,
       modality: requireSerializedModality(frame.modality),
@@ -4027,7 +4147,7 @@ var HttpLiveConnection = class {
     if (frame.protocolVersion !== this.ticket.protocolVersion) {
       throw new TypeError("live server frame protocol mismatch");
     }
-    if (frame.type === "open" && serverModality(frame.modality) !== this.ticket.modality) {
+    if (frame.type === "open" && frame.modality !== this.ticket.modality) {
       throw new TypeError("live open modality does not match its ticket");
     }
     if (this.openFrame && frame.streamEpoch !== this.openFrame.streamEpoch) {
@@ -4145,12 +4265,6 @@ function cloneCommitted2(transaction) {
     committedTransactionBytes: transaction.committedTransactionBytes.slice()
   };
 }
-function transactionModality(transaction) {
-  return transaction.modality ?? "spreadsheet";
-}
-function serverModality(value) {
-  return value ?? "spreadsheet";
-}
 function serializedBoundaryRevision(snapshot, resume, modality) {
   if (snapshot !== null) {
     if (snapshot.modality !== modality) throw new TypeError("snapshot modality mismatch");
@@ -4166,8 +4280,7 @@ function serializedBoundaryRevision(snapshot, resume, modality) {
   return resume.localNativeRevision;
 }
 function snapshotChunkAuthorityEqual(frame, metadata) {
-  const modality = serverModality(frame.modality);
-  if (modality !== serverModality(metadata.modality)) return false;
+  if (frame.modality !== metadata.modality) return false;
   if ("causalFrontier" in frame) {
     if (!("causalFrontier" in metadata)) return false;
     return frontiersEqual3(frame.causalFrontier, metadata.causalFrontier);
@@ -4382,6 +4495,13 @@ function positiveU162(value, label) {
   const number = positiveBounded(value, 65535, label);
   return number;
 }
+function exactVersion(value, expected, label) {
+  const actual = positiveU162(value, label);
+  if (actual !== expected) {
+    throw new TypeError(`${label} ${actual} is incompatible with current version ${expected}`);
+  }
+  return actual;
+}
 function positiveBounded(value, maximum, label) {
   if (!Number.isSafeInteger(value) || value <= 0 || value > maximum) {
     throw new TypeError(`${label} is invalid`);
@@ -5753,17 +5873,20 @@ function createBrowserEditableArtifactSession(options) {
   const baseUrl = canonicalBaseUrl(options.baseUrl);
   const workspaceId = boundedIdentity(options.workspaceId, "workspaceId");
   assertCacheAuthority(options.storageAuthority, baseUrl, workspaceId);
-  const protocolVersion = positiveVersion2(options.runtime.protocolVersion ?? 1, "protocolVersion");
+  const protocolVersion = positiveVersion2(options.runtime.protocolVersion, "protocolVersion");
+  if (protocolVersion !== EDITABLE_ARTIFACT_INTENT_PROTOCOL_VERSION2) {
+    throw new TypeError("protocolVersion is incompatible with the current intent protocol");
+  }
   const modelSchemaVersion = positiveVersion2(
     options.runtime.modelSchemaVersion,
     "modelSchemaVersion"
   );
   const kernelVersion = boundedIdentity(options.runtime.kernelVersion, "kernelVersion", 512);
   const commandVersion = positiveVersion2(options.runtime.commandVersion, "commandVersion");
-  const expectedCommandVersion = commandVersionFor(options.artifact.modality);
-  if (commandVersion !== expectedCommandVersion) {
+  const current = currentEditableArtifactCompatibility2(options.artifact.modality);
+  if (modelSchemaVersion !== current.modelSchemaVersion || commandVersion !== current.commandProtocolVersion) {
     throw new TypeError(
-      `commandVersion ${commandVersion} is incompatible with ${options.artifact.modality} ${expectedCommandVersion}`
+      `runtime versions are incompatible with current ${options.artifact.modality} compatibility`
     );
   }
   const {
@@ -5787,9 +5910,13 @@ function createBrowserEditableArtifactSession(options) {
       ...options.transport,
       baseUrl,
       workspaceId,
-      protocolVersion,
+      modality: options.artifact.modality,
+      liveProtocolVersion: EDITABLE_ARTIFACT_LIVE_WIRE_VERSION2,
       kernelVersion,
-      modelSchemaVersion
+      modelSchemaVersion,
+      snapshotVersion: current.snapshotVersion,
+      commandProtocolVersion: current.commandProtocolVersion,
+      committedTransactionProtocolVersion: current.committedTransactionProtocolVersion
     });
     return createEditableArtifactSession({
       artifactId: options.artifact.id,
@@ -5802,6 +5929,7 @@ function createBrowserEditableArtifactSession(options) {
       modelSchemaVersion,
       commandVersion,
       protocolVersion,
+      ...options.onOpenFailure ? { onOpenFailure: options.onOpenFailure } : {},
       ...replicaId ? { writerReplicaIdFactory: () => replicaId } : {},
       ownsWorker: true
     });
@@ -5816,16 +5944,6 @@ function createEditableArtifactReplicaId() {
     if (value !== "0000000000000000") return value;
   }
 }
-function commandVersionFor(modality) {
-  switch (modality) {
-    case "spreadsheet":
-      return SPREADSHEET_ARTIFACT_COMMAND_VERSION2;
-    case "document":
-      return DOCUMENT_ARTIFACT_COMMAND_VERSION2;
-    case "presentation":
-      return PRESENTATION_ARTIFACT_COMMAND_VERSION2;
-  }
-}
 function canonicalBaseUrl(value) {
   const url = new URL(value);
   if (url.username || url.password || url.search || url.hash) {
@@ -5908,16 +6026,16 @@ var EditableArtifactSyncPool = class {
 
 // src/editable-artifacts/index.ts
 import {
-  SPREADSHEET_ARTIFACT_COMMAND_VERSION as SPREADSHEET_ARTIFACT_COMMAND_VERSION3,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION as SPREADSHEET_ARTIFACT_COMMAND_VERSION2,
   editableArtifactStableId as editableArtifactStableId2,
   spreadsheetSheetId as spreadsheetSheetId3
 } from "@opengeni/contracts/spreadsheet-artifact-commands";
 import {
-  DOCUMENT_ARTIFACT_COMMAND_VERSION as DOCUMENT_ARTIFACT_COMMAND_VERSION3,
+  DOCUMENT_ARTIFACT_COMMAND_VERSION as DOCUMENT_ARTIFACT_COMMAND_VERSION2,
   encodeDocumentArtifactCommandBatch as encodeDocumentArtifactCommandBatch2
 } from "@opengeni/contracts/document-artifact-commands";
 import {
-  PRESENTATION_ARTIFACT_COMMAND_VERSION as PRESENTATION_ARTIFACT_COMMAND_VERSION3,
+  PRESENTATION_ARTIFACT_COMMAND_VERSION as PRESENTATION_ARTIFACT_COMMAND_VERSION2,
   PRESENTATION_ARTIFACT_QUERY_MAX_NODES,
   PRESENTATION_ARTIFACT_QUERY_MAX_SLIDES,
   PRESENTATION_ARTIFACT_QUERY_MAX_TEXT_BYTES,
@@ -5926,19 +6044,20 @@ import {
 } from "@opengeni/contracts/presentation-artifact-commands";
 export {
   ArtifactWorkerClientError,
-  DOCUMENT_ARTIFACT_COMMAND_VERSION3 as DOCUMENT_ARTIFACT_COMMAND_VERSION,
+  DOCUMENT_ARTIFACT_COMMAND_VERSION2 as DOCUMENT_ARTIFACT_COMMAND_VERSION,
   EditableArtifactStorageConflictError,
   EditableArtifactSyncError,
   EditableArtifactSyncPool,
   EditableArtifactTransportError,
   IndexedDbEditableArtifactStorage,
   MemoryEditableArtifactStorage,
-  PRESENTATION_ARTIFACT_COMMAND_VERSION3 as PRESENTATION_ARTIFACT_COMMAND_VERSION,
+  PRESENTATION_ARTIFACT_COMMAND_VERSION2 as PRESENTATION_ARTIFACT_COMMAND_VERSION,
   PRESENTATION_ARTIFACT_QUERY_MAX_NODES,
   PRESENTATION_ARTIFACT_QUERY_MAX_SLIDES,
   PRESENTATION_ARTIFACT_QUERY_MAX_TEXT_BYTES,
   PRESENTATION_ARTIFACT_QUERY_RESPONSE_MAX_BYTES,
-  SPREADSHEET_ARTIFACT_COMMAND_VERSION3 as SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION2 as SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  classifyEditableArtifactOpenFailure,
   createBrowserEditableArtifactSession,
   createBrowserEditableArtifactWorkerKernel,
   createEditableArtifactHttpLiveTransport,