@opengeni/sdk 0.46.0 → 0.52.1

package/dist/editable-artifacts-worker.js

@@ -0,0 +1,1708 @@
+import {
+  ArtifactWorkerProtocolError,
+  decodeArtifactWorkerRpcMessage,
+  decodeAuthorPendingMetadata,
+  decodeCommittedMetadata,
+  decodeInitialize,
+  decodePendingListMetadata,
+  decodeReconcileMetadata,
+  decodeSnapshotMetadata,
+  encodeArtifactWorkerRpcMessage,
+  encodeErrorPayload,
+  encodePendingListMetadata,
+  encodeProjectionResponse,
+  encodeStateResponse,
+  requireMatchingHash,
+  sha256Hex,
+  transferListForArtifactWorkerRpcMessage
+} from "./chunk-VWE2QIVO.js";
+
+// src/editable-artifacts/worker/kernel-adapter.ts
+import {
+  EDITABLE_ARTIFACT_COMMAND_MAX_BYTES,
+  EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
+  EDITABLE_ARTIFACT_INTENT_VERSION,
+  EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION
+} from "@opengeni/contracts/editable-artifacts";
+import { MAX_COMMITTED_TRANSACTION_BYTES } from "@opengeni/contracts/editable-artifact-committed-transaction";
+var ArtifactWorkerPendingProjectionError = class extends Error {
+  code;
+  constructor(code, message = "pending transaction cannot project over confirmed state") {
+    super(message);
+    this.name = "ArtifactWorkerPendingProjectionError";
+    this.code = requireErrorCode(code, "pending projection code");
+  }
+};
+var MAX_BUILD_IDENTITY_BYTES = 512;
+var MAX_CAPABILITIES_BYTES = 8 * 1024;
+var MAX_FRONTIER_BYTES = 8 + 2 + 2 + 4 + 1024 * 16 + 8;
+var WASM_MAX_CELLS_PER_BATCH = 5e5;
+var WASM_MAX_COMMAND_BYTES = 8 * 1024 * 1024;
+var WASM_MAX_SNAPSHOT_BYTES = EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES;
+var SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/u;
+var loadBrowserWasmKernelAdapter = async (input) => {
+  const rawWasm = await import(
+    /* @vite-ignore */
+    input.wasmGlueUrl
+  );
+  const wasm = validateWasmModule(rawWasm, input.modality);
+  if (wasm.default) await wasm.default({ module_or_path: input.wasmBinaryUrl });
+  const buildIdentity = decodeUtf8(
+    requireBoundedBytes(wasm.buildIdentity(), "WASM build identity", MAX_BUILD_IDENTITY_BYTES),
+    "WASM build identity"
+  );
+  if (buildIdentity.length === 0) {
+    throw adapterError("incompatible_wasm_build", "WASM build identity is empty");
+  }
+  const capabilities = decodeCapabilities(
+    requireBoundedBytes(wasm.capabilities(), "WASM capabilities", MAX_CAPABILITIES_BYTES)
+  );
+  assertRequestedLimits(input, capabilities);
+  const profile = capabilityProfile(input.modality, capabilities);
+  const adapter = {
+    modality: input.modality,
+    protocolVersion: capabilities.editableArtifactIntentVersion,
+    kernelVersion: buildIdentity,
+    modelSchemaVersion: profile.modelSchemaVersion,
+    commandVersion: profile.commandVersion,
+    maximumSnapshotBytes: profile.maximumSnapshotBytes,
+    maximumCommandBytes: profile.maximumCommandBytes,
+    maximumIntentBytes: capabilities.maxIntentBytes,
+    maximumCommittedTransactionBytes: capabilities.maxCommittedTransactionBytes,
+    maximumQueryBytes: profile.maximumQueryBytes,
+    maximumQueryResponseBytes: profile.maximumQueryResponseBytes,
+    canonicalizeSnapshot(snapshotBytes) {
+      return requireOwnedOutput(
+        wasm.canonicalizeSnapshot(snapshotBytes),
+        `canonical ${input.modality} snapshot`,
+        input.maximumSnapshotBytes
+      );
+    },
+    open(snapshotBytes) {
+      if (wasm.modality === "spreadsheet") {
+        return wrapWasmCollaborationSession(wasm.open(snapshotBytes), input);
+      }
+      return wrapWasmModalitySession(wasm.open(snapshotBytes), input);
+    }
+  };
+  return Object.freeze(adapter);
+};
+function wrapWasmCollaborationSession(session, limits) {
+  requireSessionAbi(session);
+  let disposed = false;
+  const requireOpen = () => {
+    if (disposed || session.isClosed?.() === true) {
+      throw adapterError("session_closed", "artifact collaboration session is closed");
+    }
+  };
+  return {
+    modality: "spreadsheet",
+    applyCommitted(committedTransactionBytes) {
+      requireOpen();
+      requireInputBytes(
+        committedTransactionBytes,
+        "committed transaction",
+        limits.maximumCommittedTransactionBytes
+      );
+      session.applyCommitted(committedTransactionBytes);
+    },
+    applyPending(intentBytes) {
+      requireOpen();
+      requireInputBytes(intentBytes, "pending intent", limits.maximumIntentBytes);
+      const frontier = requireOwnedOutput(
+        session.frontier(),
+        "causal frontier",
+        MAX_FRONTIER_BYTES
+      );
+      try {
+        requireOwnedOutput(
+          session.authorTransaction(intentBytes, frontier),
+          "speculative committed transaction",
+          limits.maximumCommittedTransactionBytes
+        );
+      } catch (error) {
+        const projectionCode = classifyProjectionFailure(error);
+        if (projectionCode !== null) {
+          throw new ArtifactWorkerPendingProjectionError(projectionCode);
+        }
+        throw error;
+      }
+    },
+    applyCommands() {
+      throw adapterError(
+        "unsupported_modality",
+        "spreadsheet session does not apply serialized commands"
+      );
+    },
+    nativeRevision() {
+      throw adapterError("unsupported_modality", "spreadsheet session has no native revision");
+    },
+    fork() {
+      requireOpen();
+      return wrapWasmCollaborationSession(session.fork(), limits);
+    },
+    async stateHash() {
+      requireOpen();
+      const result = session.stateHash();
+      if (!SHA256_PATTERN.test(result)) {
+        throw adapterError("invalid_state_hash", "WASM kernel returned an invalid state hash");
+      }
+      return result;
+    },
+    snapshot() {
+      requireOpen();
+      return requireOwnedOutput(
+        session.snapshot(),
+        "collaboration snapshot",
+        limits.maximumSnapshotBytes
+      );
+    },
+    query(queryBytes) {
+      requireOpen();
+      requireInputBytes(queryBytes, "kernel query", limits.maximumQueryBytes);
+      return requireOwnedOutput(
+        session.query(queryBytes),
+        "kernel projection",
+        limits.maximumQueryResponseBytes
+      );
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      try {
+        session.dispose?.();
+      } finally {
+        try {
+          session.close?.();
+        } finally {
+          session.free?.();
+        }
+      }
+    }
+  };
+}
+function wrapWasmModalitySession(session, limits) {
+  requireModalitySessionAbi(session);
+  let disposed = false;
+  const requireOpen = () => {
+    if (disposed || session.isClosed?.() === true) {
+      throw adapterError("session_closed", `artifact ${limits.modality} session is closed`);
+    }
+  };
+  return {
+    modality: limits.modality,
+    applyCommitted() {
+      throw adapterError(
+        "unsupported_modality",
+        "serialized session requires decoded OGAST replay"
+      );
+    },
+    applyPending() {
+      throw adapterError("unsupported_modality", "serialized session requires exact command bytes");
+    },
+    applyCommands(commandBytes) {
+      requireOpen();
+      requireInputBytes(commandBytes, `${limits.modality} command`, limits.maximumCommandBytes);
+      return requireOwnedOutput(
+        session.applyCommands(commandBytes),
+        `${limits.modality} native receipt`,
+        limits.maximumCommittedTransactionBytes
+      );
+    },
+    nativeRevision() {
+      requireOpen();
+      const revision = session.revision();
+      if (revision < 0n || revision > BigInt(Number.MAX_SAFE_INTEGER)) {
+        throw adapterError("invalid_revision", "WASM kernel returned an unsafe native revision");
+      }
+      return Number(revision);
+    },
+    fork() {
+      requireOpen();
+      return wrapWasmModalitySession(session.fork(), limits);
+    },
+    async stateHash() {
+      requireOpen();
+      const result = session.stateHash();
+      if (!SHA256_PATTERN.test(result)) {
+        throw adapterError("invalid_state_hash", "WASM kernel returned an invalid state hash");
+      }
+      return result;
+    },
+    snapshot() {
+      requireOpen();
+      return requireOwnedOutput(
+        session.snapshot(),
+        `${limits.modality} snapshot`,
+        limits.maximumSnapshotBytes
+      );
+    },
+    query(queryBytes) {
+      requireOpen();
+      requireInputBytes(queryBytes, `${limits.modality} query`, limits.maximumQueryBytes);
+      return requireOwnedOutput(
+        session.query(queryBytes),
+        `${limits.modality} projection`,
+        limits.maximumQueryResponseBytes
+      );
+    },
+    dispose() {
+      if (disposed) return;
+      disposed = true;
+      try {
+        session.dispose?.();
+      } finally {
+        try {
+          session.close?.();
+        } finally {
+          session.free?.();
+        }
+      }
+    }
+  };
+}
+function requireModalitySessionAbi(session) {
+  if (!isObject(session) || typeof session.applyCommands !== "function" || typeof session.snapshot !== "function" || typeof session.revision !== "function" || typeof session.fork !== "function" || typeof session.stateHash !== "function" || typeof session.query !== "function") {
+    session?.dispose?.();
+    session?.close?.();
+    session?.free?.();
+    throw adapterError(
+      "incompatible_wasm_build",
+      "WASM modality session lacks the required stateful ABI"
+    );
+  }
+}
+function requireSessionAbi(session) {
+  if (!isObject(session) || typeof session.authorTransaction !== "function" || typeof session.applyCommitted !== "function" || typeof session.snapshot !== "function" || typeof session.frontier !== "function" || typeof session.fork !== "function" || typeof session.stateHash !== "function" || typeof session.revision !== "function" || typeof session.query !== "function") {
+    session?.dispose?.();
+    session?.close?.();
+    session?.free?.();
+    throw adapterError(
+      "incompatible_wasm_build",
+      "WASM collaboration session lacks the required stateful ABI"
+    );
+  }
+}
+function validateWasmModule(input, modality) {
+  if (!isObject(input)) throw adapterError("invalid_wasm_module", "WASM glue module is invalid");
+  const capabilities = callable(input, "capabilities");
+  const buildIdentity = callable(input, "buildIdentity");
+  const initializer = optionalCallable(input, "default");
+  const base = {
+    capabilities,
+    buildIdentity,
+    ...initializer ? { default: initializer } : {}
+  };
+  const canonicalizeName = modality === "spreadsheet" ? "canonicalizeCollaborationSnapshot" : modality === "document" ? "canonicalizeDocumentSnapshot" : "canonicalizePresentationSnapshot";
+  const sessionName = modality === "spreadsheet" ? "ArtifactCollaborationSession" : modality === "document" ? "ArtifactDocumentSession" : "ArtifactPresentationSession";
+  const canonicalizeSnapshot = callable(input, canonicalizeName);
+  const sessionClass = data(input, sessionName);
+  if (!isObject(sessionClass)) {
+    throw adapterError("invalid_wasm_module", `WASM glue has no ${sessionName} export`);
+  }
+  const open = callable(sessionClass, "open");
+  if (modality === "spreadsheet") {
+    return {
+      ...base,
+      modality,
+      canonicalizeSnapshot,
+      open
+    };
+  }
+  return {
+    ...base,
+    modality,
+    canonicalizeSnapshot,
+    open
+  };
+}
+function decodeCapabilities(bytes) {
+  let value;
+  try {
+    const text = decodeUtf8(bytes, "WASM capabilities");
+    value = JSON.parse(text);
+    if (JSON.stringify(value) !== text) {
+      throw new TypeError("capabilities JSON is not canonical");
+    }
+  } catch (error) {
+    throw new ArtifactWorkerProtocolError(
+      "incompatible_wasm_build",
+      "WASM capabilities are not canonical UTF-8 JSON",
+      { cause: error }
+    );
+  }
+  if (!isPlainRecord(value)) {
+    throw adapterError("incompatible_wasm_build", "WASM capabilities must be a plain record");
+  }
+  const expectedKeys = [
+    "abiVersion",
+    "buildIdentityFormat",
+    "canonicalStateHash",
+    "collaboration",
+    "collaborationSnapshotVersion",
+    "commandSchemaVersion",
+    "committedTransactionVersion",
+    "document",
+    "documentCommandVersion",
+    "documentQueryResponseVersion",
+    "documentQueryVersion",
+    "documentReceiptVersion",
+    "documentSnapshotVersion",
+    "documentStatefulSessions",
+    "editableArtifactIntentVersion",
+    "kernelSnapshotVersion",
+    "maxCellsPerBatch",
+    "maxCommandBytes",
+    "maxCommands",
+    "maxCommittedTransactionBytes",
+    "maxDocumentCommandBytes",
+    "maxDocumentCommands",
+    "maxDocumentQueryBytes",
+    "maxDocumentQueryResponseBytes",
+    "maxDocumentSnapshotBytes",
+    "maxIntentBytes",
+    "maxMetadataScannedCells",
+    "maxMetadataSheets",
+    "maxPresentationCommandBytes",
+    "maxPresentationQueryBytes",
+    "maxPresentationResponseBytes",
+    "maxPresentationSnapshotBytes",
+    "maxQueryBytes",
+    "maxQueryResponseBytes",
+    "maxSnapshotBytes",
+    "maxSpreadsheetCommandBytes",
+    "maxTextLayoutFontBundleBytes",
+    "maxTextLayoutRequestBytes",
+    "maxTextLayoutResponseBytes",
+    "maxViewportArea",
+    "maxViewportCells",
+    "presentation",
+    "presentationCommandVersion",
+    "presentationQueryResponseVersion",
+    "presentationQueryVersion",
+    "presentationSnapshotVersion",
+    "presentationStatefulSessions",
+    "queryResponseVersion",
+    "queryVersion",
+    "receiptSchemaVersion",
+    "retainedRenderPatchVersion",
+    "retainedRenderTileVersion",
+    "safeRust",
+    "sessionForks",
+    "spreadsheetCommandVersion",
+    "statefulSessions",
+    "textLayout",
+    "textLayoutFontBundleVersion",
+    "textLayoutRequestVersion",
+    "textLayoutResponseVersion",
+    "textLayoutStatefulSessions",
+    "transport",
+    "workbookMetadataQueries"
+  ];
+  const keys = Object.keys(value).sort();
+  if (keys.length !== expectedKeys.length || keys.some((key, index) => key !== expectedKeys[index])) {
+    throw adapterError(
+      "incompatible_wasm_build",
+      "WASM collaboration capabilities have unknown or missing fields"
+    );
+  }
+  const normalized = {
+    abiVersion: positiveInteger(value.abiVersion, "abiVersion"),
+    buildIdentityFormat: value.buildIdentityFormat,
+    canonicalStateHash: value.canonicalStateHash,
+    collaboration: strictBoolean(value.collaboration, "collaboration"),
+    collaborationSnapshotVersion: positiveInteger(
+      value.collaborationSnapshotVersion,
+      "collaborationSnapshotVersion"
+    ),
+    commandSchemaVersion: positiveInteger(value.commandSchemaVersion, "commandSchemaVersion"),
+    committedTransactionVersion: positiveInteger(
+      value.committedTransactionVersion,
+      "committedTransactionVersion"
+    ),
+    document: strictBoolean(value.document, "document"),
+    documentCommandVersion: positiveInteger(value.documentCommandVersion, "documentCommandVersion"),
+    documentQueryResponseVersion: positiveInteger(
+      value.documentQueryResponseVersion,
+      "documentQueryResponseVersion"
+    ),
+    documentQueryVersion: positiveInteger(value.documentQueryVersion, "documentQueryVersion"),
+    documentReceiptVersion: positiveInteger(value.documentReceiptVersion, "documentReceiptVersion"),
+    documentSnapshotVersion: positiveInteger(
+      value.documentSnapshotVersion,
+      "documentSnapshotVersion"
+    ),
+    documentStatefulSessions: strictBoolean(
+      value.documentStatefulSessions,
+      "documentStatefulSessions"
+    ),
+    editableArtifactIntentVersion: positiveInteger(
+      value.editableArtifactIntentVersion,
+      "editableArtifactIntentVersion"
+    ),
+    kernelSnapshotVersion: positiveInteger(value.kernelSnapshotVersion, "kernelSnapshotVersion"),
+    spreadsheetCommandVersion: positiveInteger(
+      value.spreadsheetCommandVersion,
+      "spreadsheetCommandVersion"
+    ),
+    maxCellsPerBatch: positiveInteger(value.maxCellsPerBatch, "maxCellsPerBatch"),
+    maxCommands: positiveInteger(value.maxCommands, "maxCommands"),
+    maxSnapshotBytes: positiveInteger(value.maxSnapshotBytes, "maxSnapshotBytes"),
+    maxCommandBytes: positiveInteger(value.maxCommandBytes, "maxCommandBytes"),
+    maxSpreadsheetCommandBytes: positiveInteger(
+      value.maxSpreadsheetCommandBytes,
+      "maxSpreadsheetCommandBytes"
+    ),
+    maxIntentBytes: positiveInteger(value.maxIntentBytes, "maxIntentBytes"),
+    maxCommittedTransactionBytes: positiveInteger(
+      value.maxCommittedTransactionBytes,
+      "maxCommittedTransactionBytes"
+    ),
+    maxDocumentCommandBytes: positiveInteger(
+      value.maxDocumentCommandBytes,
+      "maxDocumentCommandBytes"
+    ),
+    maxDocumentCommands: positiveInteger(value.maxDocumentCommands, "maxDocumentCommands"),
+    maxDocumentQueryBytes: positiveInteger(value.maxDocumentQueryBytes, "maxDocumentQueryBytes"),
+    maxDocumentQueryResponseBytes: positiveInteger(
+      value.maxDocumentQueryResponseBytes,
+      "maxDocumentQueryResponseBytes"
+    ),
+    maxDocumentSnapshotBytes: positiveInteger(
+      value.maxDocumentSnapshotBytes,
+      "maxDocumentSnapshotBytes"
+    ),
+    maxMetadataScannedCells: positiveInteger(
+      value.maxMetadataScannedCells,
+      "maxMetadataScannedCells"
+    ),
+    maxQueryBytes: positiveInteger(value.maxQueryBytes, "maxQueryBytes"),
+    maxQueryResponseBytes: positiveInteger(value.maxQueryResponseBytes, "maxQueryResponseBytes"),
+    maxViewportArea: positiveInteger(value.maxViewportArea, "maxViewportArea"),
+    maxViewportCells: positiveInteger(value.maxViewportCells, "maxViewportCells"),
+    maxMetadataSheets: positiveInteger(value.maxMetadataSheets, "maxMetadataSheets"),
+    maxPresentationCommandBytes: positiveInteger(
+      value.maxPresentationCommandBytes,
+      "maxPresentationCommandBytes"
+    ),
+    maxPresentationQueryBytes: positiveInteger(
+      value.maxPresentationQueryBytes,
+      "maxPresentationQueryBytes"
+    ),
+    maxPresentationResponseBytes: positiveInteger(
+      value.maxPresentationResponseBytes,
+      "maxPresentationResponseBytes"
+    ),
+    maxPresentationSnapshotBytes: positiveInteger(
+      value.maxPresentationSnapshotBytes,
+      "maxPresentationSnapshotBytes"
+    ),
+    maxTextLayoutFontBundleBytes: positiveInteger(
+      value.maxTextLayoutFontBundleBytes,
+      "maxTextLayoutFontBundleBytes"
+    ),
+    maxTextLayoutRequestBytes: positiveInteger(
+      value.maxTextLayoutRequestBytes,
+      "maxTextLayoutRequestBytes"
+    ),
+    maxTextLayoutResponseBytes: positiveInteger(
+      value.maxTextLayoutResponseBytes,
+      "maxTextLayoutResponseBytes"
+    ),
+    queryResponseVersion: positiveInteger(value.queryResponseVersion, "queryResponseVersion"),
+    queryVersion: positiveInteger(value.queryVersion, "queryVersion"),
+    receiptSchemaVersion: positiveInteger(value.receiptSchemaVersion, "receiptSchemaVersion"),
+    retainedRenderPatchVersion: positiveInteger(
+      value.retainedRenderPatchVersion,
+      "retainedRenderPatchVersion"
+    ),
+    retainedRenderTileVersion: positiveInteger(
+      value.retainedRenderTileVersion,
+      "retainedRenderTileVersion"
+    ),
+    presentation: strictBoolean(value.presentation, "presentation"),
+    presentationCommandVersion: positiveInteger(
+      value.presentationCommandVersion,
+      "presentationCommandVersion"
+    ),
+    presentationQueryResponseVersion: positiveInteger(
+      value.presentationQueryResponseVersion,
+      "presentationQueryResponseVersion"
+    ),
+    presentationQueryVersion: positiveInteger(
+      value.presentationQueryVersion,
+      "presentationQueryVersion"
+    ),
+    presentationSnapshotVersion: positiveInteger(
+      value.presentationSnapshotVersion,
+      "presentationSnapshotVersion"
+    ),
+    presentationStatefulSessions: strictBoolean(
+      value.presentationStatefulSessions,
+      "presentationStatefulSessions"
+    ),
+    safeRust: strictBoolean(value.safeRust, "safeRust"),
+    statefulSessions: strictBoolean(value.statefulSessions, "statefulSessions"),
+    textLayout: strictBoolean(value.textLayout, "textLayout"),
+    textLayoutFontBundleVersion: positiveInteger(
+      value.textLayoutFontBundleVersion,
+      "textLayoutFontBundleVersion"
+    ),
+    textLayoutRequestVersion: positiveInteger(
+      value.textLayoutRequestVersion,
+      "textLayoutRequestVersion"
+    ),
+    textLayoutResponseVersion: positiveInteger(
+      value.textLayoutResponseVersion,
+      "textLayoutResponseVersion"
+    ),
+    textLayoutStatefulSessions: strictBoolean(
+      value.textLayoutStatefulSessions,
+      "textLayoutStatefulSessions"
+    ),
+    sessionForks: strictBoolean(value.sessionForks, "sessionForks"),
+    transport: value.transport,
+    workbookMetadataQueries: strictBoolean(
+      value.workbookMetadataQueries,
+      "workbookMetadataQueries"
+    )
+  };
+  if (normalized.abiVersion !== 1 || normalized.buildIdentityFormat !== "utf8" || normalized.canonicalStateHash !== "sha256:canonical-snapshot" || normalized.editableArtifactIntentVersion !== EDITABLE_ARTIFACT_INTENT_VERSION || normalized.spreadsheetCommandVersion !== SPREADSHEET_ARTIFACT_COMMAND_VERSION || normalized.collaborationSnapshotVersion !== 1 || normalized.commandSchemaVersion !== 1 || normalized.committedTransactionVersion !== 1 || normalized.documentCommandVersion !== 1 || normalized.documentQueryResponseVersion !== 1 || normalized.documentQueryVersion !== 1 || normalized.documentReceiptVersion !== 1 || normalized.documentSnapshotVersion !== 1 || normalized.documentStatefulSessions !== normalized.document || normalized.kernelSnapshotVersion !== 1 || normalized.maxCellsPerBatch !== WASM_MAX_CELLS_PER_BATCH || normalized.maxCommandBytes !== WASM_MAX_COMMAND_BYTES || normalized.maxSpreadsheetCommandBytes !== EDITABLE_ARTIFACT_COMMAND_MAX_BYTES || normalized.maxCommands !== 1e4 || normalized.maxIntentBytes !== EDITABLE_ARTIFACT_INTENT_MAX_BYTES || normalized.maxCommittedTransactionBytes !== MAX_COMMITTED_TRANSACTION_BYTES || normalized.maxDocumentCommandBytes !== WASM_MAX_COMMAND_BYTES || normalized.maxDocumentCommands !== 4096 || normalized.maxDocumentQueryBytes !== 256 || normalized.maxDocumentQueryResponseBytes !== 8 * 1024 * 1024 || normalized.maxDocumentSnapshotBytes !== WASM_MAX_SNAPSHOT_BYTES || normalized.maxMetadataScannedCells !== 4e6 || normalized.maxQueryBytes !== 68 || normalized.maxQueryResponseBytes !== 8 * 1024 * 1024 || normalized.maxViewportArea !== 1048576 || normalized.maxViewportCells !== 262144 || normalized.maxMetadataSheets !== 1e4 || normalized.maxPresentationCommandBytes !== 4 * 1024 * 1024 || normalized.maxPresentationQueryBytes !== 96 || normalized.maxPresentationResponseBytes !== 8 * 1024 * 1024 || normalized.maxPresentationSnapshotBytes !== WASM_MAX_SNAPSHOT_BYTES || normalized.maxTextLayoutFontBundleBytes !== 48 * 1024 * 1024 || normalized.maxTextLayoutRequestBytes !== 4 * 1024 * 1024 || normalized.maxTextLayoutResponseBytes !== 32 * 1024 * 1024 || normalized.maxSnapshotBytes !== WASM_MAX_SNAPSHOT_BYTES || normalized.queryResponseVersion !== 1 || normalized.queryVersion !== 1 || normalized.receiptSchemaVersion !== 1 || normalized.retainedRenderPatchVersion !== 1 || normalized.retainedRenderTileVersion !== 1 || normalized.presentationCommandVersion !== 1 || normalized.presentationQueryResponseVersion !== 1 || normalized.presentationQueryVersion !== 1 || normalized.presentationSnapshotVersion !== 1 || normalized.presentationStatefulSessions !== normalized.presentation || normalized.safeRust !== true || normalized.statefulSessions !== true || normalized.textLayoutFontBundleVersion !== 1 || normalized.textLayoutRequestVersion !== 1 || normalized.textLayoutResponseVersion !== 1 || normalized.textLayoutStatefulSessions !== normalized.textLayout || normalized.sessionForks !== true || normalized.transport !== "bounded-uint8array" || normalized.workbookMetadataQueries !== normalized.collaboration) {
+    throw adapterError(
+      "incompatible_wasm_build",
+      "WASM capabilities do not match the SDK protocol"
+    );
+  }
+  return Object.freeze(normalized);
+}
+function assertRequestedLimits(input, capabilities) {
+  const profile = capabilityProfile(input.modality, capabilities);
+  const pairs = [
+    ["maximumSnapshotBytes", input.maximumSnapshotBytes, profile.maximumSnapshotBytes],
+    ["maximumCommandBytes", input.maximumCommandBytes, profile.maximumCommandBytes],
+    ["maximumIntentBytes", input.maximumIntentBytes, capabilities.maxIntentBytes],
+    [
+      "maximumCommittedTransactionBytes",
+      input.maximumCommittedTransactionBytes,
+      capabilities.maxCommittedTransactionBytes
+    ],
+    ["maximumQueryBytes", input.maximumQueryBytes, profile.maximumQueryBytes],
+    [
+      "maximumQueryResponseBytes",
+      input.maximumQueryResponseBytes,
+      profile.maximumQueryResponseBytes
+    ]
+  ];
+  for (const [label, requested, advertised] of pairs) {
+    if (requested > advertised) {
+      throw adapterError(
+        "incompatible_wasm_build",
+        `${label} exceeds the loaded WASM build capability`
+      );
+    }
+  }
+}
+function capabilityProfile(modality, capabilities) {
+  if (modality === "spreadsheet") {
+    if (!capabilities.collaboration || !capabilities.workbookMetadataQueries) {
+      throw adapterError(
+        "incompatible_wasm_build",
+        "WASM module does not provide the spreadsheet collaboration ABI"
+      );
+    }
+    return {
+      modelSchemaVersion: capabilities.collaborationSnapshotVersion,
+      commandVersion: capabilities.spreadsheetCommandVersion,
+      maximumSnapshotBytes: capabilities.maxSnapshotBytes,
+      maximumCommandBytes: capabilities.maxSpreadsheetCommandBytes,
+      maximumQueryBytes: capabilities.maxQueryBytes,
+      maximumQueryResponseBytes: capabilities.maxQueryResponseBytes
+    };
+  }
+  if (modality === "document") {
+    if (!capabilities.document || !capabilities.documentStatefulSessions) {
+      throw adapterError(
+        "incompatible_wasm_build",
+        "WASM module does not provide the document ABI"
+      );
+    }
+    return {
+      modelSchemaVersion: capabilities.documentSnapshotVersion,
+      commandVersion: capabilities.documentCommandVersion,
+      maximumSnapshotBytes: capabilities.maxDocumentSnapshotBytes,
+      maximumCommandBytes: capabilities.maxDocumentCommandBytes,
+      maximumQueryBytes: capabilities.maxDocumentQueryBytes,
+      maximumQueryResponseBytes: capabilities.maxDocumentQueryResponseBytes
+    };
+  }
+  if (!capabilities.presentation || !capabilities.presentationStatefulSessions) {
+    throw adapterError(
+      "incompatible_wasm_build",
+      "WASM module does not provide the presentation ABI"
+    );
+  }
+  return {
+    modelSchemaVersion: capabilities.presentationSnapshotVersion,
+    commandVersion: capabilities.presentationCommandVersion,
+    maximumSnapshotBytes: capabilities.maxPresentationSnapshotBytes,
+    maximumCommandBytes: capabilities.maxPresentationCommandBytes,
+    maximumQueryBytes: capabilities.maxPresentationQueryBytes,
+    maximumQueryResponseBytes: capabilities.maxPresentationResponseBytes
+  };
+}
+function classifyProjectionFailure(error) {
+  const message = error instanceof Error ? error.message : "";
+  const match = /^\[([A-Z][A-Z0-9_]{0,127})\]/u.exec(message);
+  if (!match) return null;
+  switch (match[1]) {
+    case "ARTIFACT_COLLABORATION_REJECTED":
+      return "structural_conflict";
+    case "ARTIFACT_PROJECTION_REJECTED":
+      return "projection_conflict";
+    default:
+      return null;
+  }
+}
+function requireInputBytes(value, label, maximumBytes) {
+  if (!(value instanceof Uint8Array) || value.byteLength === 0) {
+    throw adapterError("invalid_kernel_input", `${label} must be non-empty bytes`);
+  }
+  if (value.byteLength > maximumBytes) {
+    throw adapterError("limit_exceeded", `${label} exceeds its byte limit`);
+  }
+  return value;
+}
+function requireBoundedBytes(value, label, maximumBytes) {
+  if (!(value instanceof Uint8Array) || value.byteLength === 0) {
+    throw adapterError("invalid_kernel_output", `${label} must be non-empty bytes`);
+  }
+  if (value.byteLength > maximumBytes) {
+    throw adapterError("limit_exceeded", `${label} exceeds its byte limit`);
+  }
+  return value;
+}
+function requireOwnedOutput(value, label, maximumBytes) {
+  const bytes = requireBoundedBytes(value, label, maximumBytes);
+  if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+    return bytes;
+  }
+  return bytes.slice();
+}
+function decodeUtf8(bytes, label) {
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch (error) {
+    throw new ArtifactWorkerProtocolError("incompatible_wasm_build", `${label} is not UTF-8`, {
+      cause: error
+    });
+  }
+}
+function callable(record, key) {
+  const value = data(record, key);
+  if (typeof value !== "function") {
+    throw adapterError("invalid_wasm_module", `${key} must be a function`);
+  }
+  return value;
+}
+function optionalCallable(record, key) {
+  const value = data(record, key, false);
+  if (value === void 0) return void 0;
+  if (typeof value !== "function") {
+    throw adapterError("invalid_wasm_module", `${key} must be a function`);
+  }
+  return value;
+}
+function data(record, key, required = true) {
+  const descriptor = Object.getOwnPropertyDescriptor(record, key);
+  if (descriptor) return "value" in descriptor ? descriptor.value : Reflect.get(record, key);
+  if (required) throw adapterError("invalid_wasm_module", `module is missing ${key}`);
+  return void 0;
+}
+function isObject(value) {
+  return value !== null && (typeof value === "object" || typeof value === "function");
+}
+function isPlainRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.getPrototypeOf(value) === Object.prototype;
+}
+function adapterError(code, message) {
+  return new ArtifactWorkerProtocolError(code, message);
+}
+function requireErrorCode(value, label) {
+  if (typeof value !== "string" || !/^[a-z][a-z0-9_]{0,127}$/u.test(value)) {
+    throw adapterError("invalid_wasm_module", `${label} is invalid`);
+  }
+  return value;
+}
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw adapterError("incompatible_wasm_build", `${label} must be a positive safe integer`);
+  }
+  return value;
+}
+function strictBoolean(value, label) {
+  if (typeof value !== "boolean") {
+    throw adapterError("incompatible_wasm_build", `${label} must be a boolean`);
+  }
+  return value;
+}
+
+// src/editable-artifacts/worker/runtime.ts
+import {
+  EDITABLE_ARTIFACT_INTENT_MAX_BYTES as EDITABLE_ARTIFACT_INTENT_MAX_BYTES2,
+  EDITABLE_ARTIFACT_INTENT_VERSION as EDITABLE_ARTIFACT_INTENT_VERSION2,
+  assertCanonicalSpreadsheetArtifactCommandBytes,
+  decodeEditableArtifactMutationIntent,
+  hashEditableArtifactMutationIntent
+} from "@opengeni/contracts/editable-artifacts";
+import { decodeCommittedTransactionSummary } from "@opengeni/contracts/editable-artifact-committed-transaction";
+import { editableArtifactCodecFor } from "@opengeni/contracts/editable-artifact-codec-registry";
+import { decodeEditableArtifactSerializedCommit } from "@opengeni/contracts/editable-artifact-serialized-commit";
+var MAX_KNOWN_REQUESTS = 64;
+var MAX_QUEUED_REQUEST_BYTES = 192 * 1024 * 1024;
+var MAX_PENDING_AGGREGATE_BYTES = 64 * 1024 * 1024;
+var ArtifactWorkerRuntime = class {
+  endpoint;
+  loadAdapter;
+  rpcLimits;
+  onProtocolError;
+  cancelled = /* @__PURE__ */ new Set();
+  knownRequests = /* @__PURE__ */ new Map();
+  queuedRequestBytes = 0;
+  queue = Promise.resolve();
+  generation = null;
+  initialization = null;
+  adapter = null;
+  confirmed = null;
+  speculative = null;
+  installed = null;
+  pendingKeys = Object.freeze([]);
+  blockedPending = Object.freeze([]);
+  disposed = false;
+  onMessage = (event) => {
+    if (this.disposed) return;
+    let frame;
+    try {
+      frame = decodeArtifactWorkerRpcMessage(event.data, this.rpcLimits);
+    } catch (error) {
+      const failure = asProtocolError(error);
+      this.reportProtocolError(failure);
+      return;
+    }
+    if (frame.kind === 8 /* Cancel */) {
+      if (frame.flags === 0 && frame.metadata.byteLength === 0 && frame.segments.length === 0 && this.knownRequests.get(frame.requestId)?.generation === frame.generation) {
+        this.cancelled.add(frame.requestId);
+      }
+      return;
+    }
+    if (frame.flags !== 0) {
+      this.reportProtocolError(runtimeError("noncanonical", "unknown RPC flags are set"));
+      return;
+    }
+    if (this.knownRequests.has(frame.requestId)) {
+      this.reportProtocolError(runtimeError("duplicate_request", "RPC request id is duplicated"));
+      return;
+    }
+    const requestBytes = retainedFrameBytes(frame);
+    if (this.knownRequests.size >= MAX_KNOWN_REQUESTS || this.queuedRequestBytes + requestBytes > MAX_QUEUED_REQUEST_BYTES) {
+      this.respondError(
+        frame.requestId,
+        runtimeError("request_limit", "artifact Worker request queue is full"),
+        frame.generation
+      );
+      return;
+    }
+    this.knownRequests.set(frame.requestId, { bytes: requestBytes, generation: frame.generation });
+    this.queuedRequestBytes += requestBytes;
+    this.queue = this.queue.then(() => this.dispatch(frame)).catch((error) => this.reportProtocolError(asProtocolError(error)));
+  };
+  constructor(options) {
+    this.endpoint = options.endpoint;
+    this.loadAdapter = options.loadAdapter;
+    this.rpcLimits = options.rpcLimits;
+    this.onProtocolError = options.onProtocolError;
+    this.endpoint.addEventListener("message", this.onMessage);
+  }
+  async dispose() {
+    if (this.disposed) return;
+    this.disposed = true;
+    this.endpoint.removeEventListener("message", this.onMessage);
+    await this.queue.catch(() => {
+    });
+    this.releaseState();
+    this.disposeAdapter(this.adapter);
+    this.adapter = null;
+    this.cancelled.clear();
+    this.knownRequests.clear();
+    this.queuedRequestBytes = 0;
+  }
+  async dispatch(frame) {
+    try {
+      if (frame.kind === 1 /* Initialize */) {
+        await this.initialize(frame);
+        return;
+      }
+      this.requireInitialized(frame.generation);
+      this.throwIfCancelled(frame.requestId);
+      switch (frame.kind) {
+        case 2 /* Reset */:
+          this.requireNoPayload(frame);
+          this.releaseState();
+          this.respond(frame.requestId);
+          return;
+        case 3 /* LoadSnapshot */:
+          await this.loadSnapshot(frame);
+          return;
+        case 4 /* ApplyRecovered */:
+          await this.applyRecovered(frame);
+          return;
+        case 5 /* ReconcileCommitted */:
+          await this.reconcileCommitted(frame);
+          return;
+        case 6 /* ReplacePending */:
+          await this.replacePending(frame);
+          return;
+        case 7 /* AuthorPending */:
+          await this.authorPending(frame);
+          return;
+        case 10 /* QuerySpreadsheet */:
+          this.queryArtifact(frame);
+          return;
+        case 9 /* Dispose */:
+          this.requireNoPayload(frame);
+          this.releaseState();
+          this.disposeAdapter(this.adapter);
+          this.adapter = null;
+          this.respond(frame.requestId);
+          return;
+        default:
+          throw runtimeError("unknown_request", `worker cannot execute RPC kind ${frame.kind}`);
+      }
+    } catch (error) {
+      this.respondError(frame.requestId, error, frame.generation);
+    } finally {
+      this.cancelled.delete(frame.requestId);
+      const retainedBytes = this.knownRequests.get(frame.requestId)?.bytes ?? 0;
+      this.knownRequests.delete(frame.requestId);
+      this.queuedRequestBytes -= retainedBytes;
+    }
+  }
+  async initialize(frame) {
+    if (this.generation !== null || this.adapter !== null) {
+      throw runtimeError("already_initialized", "artifact Worker is already initialized");
+    }
+    if (frame.segments.length !== 0)
+      throw runtimeError("invalid_segment", "initialize has no segments");
+    const initialization = decodeInitialize(frame.metadata);
+    this.throwIfCancelled(frame.requestId);
+    let adapter = null;
+    try {
+      adapter = await this.loadAdapter(initialization);
+      this.throwIfCancelled(frame.requestId);
+    } catch (error) {
+      this.disposeAdapter(adapter);
+      throw error;
+    }
+    assertAdapterCompatibility(adapter, initialization);
+    this.generation = frame.generation;
+    this.initialization = initialization;
+    this.adapter = adapter;
+    this.respond(frame.requestId);
+  }
+  async loadSnapshot(frame) {
+    const initialization = this.requireInitialization();
+    const adapter = this.requireAdapter();
+    if (frame.segments.length !== 1)
+      throw runtimeError("invalid_segment", "snapshot requires one segment");
+    const ownedBytes = requireBytesWithin(
+      frame.segments[0],
+      initialization.maximumSnapshotBytes,
+      "snapshot"
+    );
+    const snapshot = decodeSnapshotMetadata(frame.metadata, ownedBytes);
+    if (snapshot.modality !== initialization.modality || snapshot.modality !== adapter.modality || snapshot.modality === "spreadsheet" && snapshot.protocolVersion !== adapter.protocolVersion || snapshot.kernelVersion !== adapter.kernelVersion || snapshot.modelSchemaVersion !== adapter.modelSchemaVersion) {
+      throw runtimeError(
+        "unsupported_protocol",
+        "snapshot protocol/kernel/schema is incompatible with the loaded collaboration kernel"
+      );
+    }
+    const digest = await sha256Hex(ownedBytes);
+    this.throwIfCancelled(frame.requestId);
+    requireMatchingHash(digest, snapshot.digest, "snapshot digest");
+    const canonical = requireBytesWithin(
+      adapter.canonicalizeSnapshot(ownedBytes),
+      initialization.maximumSnapshotBytes,
+      "canonical snapshot"
+    );
+    if (!bytesEqual(canonical, ownedBytes)) {
+      throw runtimeError(
+        "noncanonical_snapshot",
+        "server snapshot bytes are not canonical; refusing to persist a different model"
+      );
+    }
+    const nextConfirmed = adapter.open(canonical);
+    let nextSpeculative = null;
+    let stateHash;
+    try {
+      stateHash = await nextConfirmed.stateHash();
+      this.throwIfCancelled(frame.requestId);
+      requireMatchingHash(stateHash, snapshot.stateHash, "snapshot state");
+      if (snapshot.modality !== "spreadsheet" && nextConfirmed.nativeRevision() !== snapshot.nativeRevision) {
+        throw runtimeError(
+          "kernel_diverged",
+          "serialized snapshot native revision does not match the WASM session"
+        );
+      }
+      nextSpeculative = nextConfirmed.fork();
+      this.throwIfCancelled(frame.requestId);
+    } catch (error) {
+      this.disposeSession(nextConfirmed);
+      this.disposeSession(nextSpeculative);
+      throw error;
+    }
+    if (!nextSpeculative) throw runtimeError("kernel_failed", "kernel fork was not created");
+    this.installSessions(
+      nextConfirmed,
+      nextSpeculative,
+      snapshot.modality === "spreadsheet" ? {
+        artifactId: snapshot.artifactId,
+        modality: "spreadsheet",
+        sequence: snapshot.sequence,
+        protocolVersion: snapshot.protocolVersion,
+        kernelVersion: snapshot.kernelVersion,
+        modelSchemaVersion: snapshot.modelSchemaVersion,
+        stateHash,
+        causalFrontier: snapshot.causalFrontier
+      } : {
+        artifactId: snapshot.artifactId,
+        modality: snapshot.modality,
+        sequence: snapshot.sequence,
+        protocolVersion: adapter.protocolVersion,
+        kernelVersion: snapshot.kernelVersion,
+        modelSchemaVersion: snapshot.modelSchemaVersion,
+        stateHash,
+        nativeRevision: snapshot.nativeRevision
+      },
+      Object.freeze([]),
+      Object.freeze([])
+    );
+    this.respond(frame.requestId, encodeStateResponse(stateHash, digest));
+  }
+  async applyRecovered(frame) {
+    const initialization = this.requireInitialization();
+    if (frame.segments.length !== 1) {
+      throw runtimeError("invalid_segment", "recovered transaction requires one operation segment");
+    }
+    const committedTransactionBytes = requireBytesWithin(
+      frame.segments[0],
+      initialization.maximumCommittedTransactionBytes,
+      "committed transaction"
+    );
+    const transaction = decodeCommittedMetadata(frame.metadata, committedTransactionBytes);
+    const result = await this.buildCommittedCandidate(transaction, [], frame.requestId);
+    this.installCommittedCandidate(result, transaction, []);
+    this.respond(frame.requestId, encodeStateResponse(result.stateHash));
+  }
+  async reconcileCommitted(frame) {
+    const initialization = this.requireInitialization();
+    const decoded = decodeReconcileMetadata(
+      frame.metadata,
+      frame.segments,
+      initialization.maximumPendingTransactions
+    );
+    requireBytesWithin(
+      decoded.committed.committedTransactionBytes,
+      initialization.maximumCommittedTransactionBytes,
+      "committed transaction"
+    );
+    await this.validatePending(decoded.pending);
+    const result = await this.buildCommittedCandidate(
+      decoded.committed,
+      decoded.pending,
+      frame.requestId
+    );
+    this.installCommittedCandidate(result, decoded.committed, decoded.pending);
+    this.respond(
+      frame.requestId,
+      encodeProjectionResponse(result.blockedPending, result.stateHash)
+    );
+  }
+  async replacePending(frame) {
+    const initialization = this.requireInitialization();
+    const pending = decodePendingListMetadata(
+      frame.metadata,
+      frame.segments,
+      initialization.maximumPendingTransactions
+    );
+    await this.validatePending(pending);
+    const keys = pending.map(pendingKey);
+    if (arraysEqual(keys, this.pendingKeys)) {
+      this.respond(frame.requestId, encodeProjectionResponse(this.blockedPending));
+      return;
+    }
+    const candidate2 = this.requireConfirmed().fork();
+    let blockedPending;
+    try {
+      blockedPending = this.applyPending(candidate2, pending, frame.requestId);
+      this.throwIfCancelled(frame.requestId);
+    } catch (error) {
+      this.disposeSession(candidate2);
+      throw error;
+    }
+    const previous = this.speculative;
+    this.speculative = candidate2;
+    this.pendingKeys = Object.freeze(keys);
+    this.blockedPending = blockedPending;
+    this.disposeSession(previous);
+    this.respond(frame.requestId, encodeProjectionResponse(blockedPending));
+  }
+  async authorPending(frame) {
+    const initialization = this.requireInitialization();
+    const adapter = this.requireAdapter();
+    if (frame.segments.length !== 1)
+      throw runtimeError("invalid_segment", "author requires one command segment");
+    const commandBytes = requireBytesWithin(
+      frame.segments[0],
+      initialization.maximumCommandBytes,
+      "pending command"
+    );
+    const input = decodeAuthorPendingMetadata(frame.metadata, commandBytes);
+    if (input.modality !== initialization.modality || input.modality !== adapter.modality || input.protocolVersion !== adapter.protocolVersion || input.kernelVersion !== adapter.kernelVersion || input.modelSchemaVersion !== adapter.modelSchemaVersion || input.commandVersion !== adapter.commandVersion) {
+      throw runtimeError(
+        "unsupported_protocol",
+        "pending authoring versions are incompatible with the loaded kernel"
+      );
+    }
+    if (this.installed && input.artifactId !== this.installed.artifactId) {
+      throw runtimeError("artifact_mismatch", "pending transaction belongs to another artifact");
+    }
+    try {
+      if (input.modality === "spreadsheet") {
+        assertCanonicalSpreadsheetArtifactCommandBytes(commandBytes);
+      } else {
+        editableArtifactCodecFor({
+          durableModality: input.modality,
+          modelSchemaVersion: input.modelSchemaVersion,
+          commandProtocolVersion: input.commandVersion
+        }).command.assertCanonical(commandBytes);
+      }
+    } catch (error) {
+      throw runtimeError(
+        "noncanonical_command",
+        `pending ${input.modality} command must be canonical before it receives an identity: ${error instanceof Error ? error.message : "invalid command"}`
+      );
+    }
+    const canonicalCommand = commandBytes;
+    const authored = authorCanonicalPendingIntent(input, canonicalCommand);
+    const intentBytes = requireBytesWithin(
+      authored.bytes,
+      EDITABLE_ARTIFACT_INTENT_MAX_BYTES2,
+      "OGATX001 intent"
+    );
+    this.throwIfCancelled(frame.requestId);
+    const commonPending = {
+      artifactId: input.artifactId,
+      clientTransactionId: input.clientTransactionId,
+      requestHash: authored.requestHash,
+      protocolVersion: input.protocolVersion,
+      modelSchemaVersion: input.modelSchemaVersion,
+      commandVersion: input.commandVersion,
+      replicaId: input.replicaId,
+      replicaCounter: input.replicaCounter,
+      previousLocalTransactionId: input.previousLocalTransactionId,
+      observedHeadSequence: input.observedHeadSequence,
+      commandBytes: canonicalCommand,
+      intentBytes,
+      createdAt: input.createdAt
+    };
+    let pending;
+    if (input.modality === "spreadsheet") {
+      pending = Object.freeze({
+        ...commonPending,
+        modality: "spreadsheet",
+        causalBase: input.causalBase ?? [],
+        selectiveUndoTargets: input.selectiveUndoTargets ?? []
+      });
+    } else {
+      const installed = this.requireInstalled();
+      if (installed.modality !== input.modality) {
+        throw runtimeError("modality_mismatch", "pending modality does not match installed state");
+      }
+      const expectedHeadSequence = installed.sequence + this.pendingKeys.length;
+      if (input.observedHeadSequence !== expectedHeadSequence) {
+        throw runtimeError(
+          "serialized_head_conflict",
+          "serialized pending command was not authored over the speculative head"
+        );
+      }
+      pending = Object.freeze({
+        ...commonPending,
+        modality: input.modality,
+        observedNativeRevision: this.requireSpeculative().nativeRevision()
+      });
+    }
+    const metadata = encodePendingListMetadata([pending]);
+    const command = transferableOwnedBuffer(canonicalCommand);
+    const intent = transferableOwnedBuffer(intentBytes);
+    this.respond(frame.requestId, metadata, [command, intent]);
+  }
+  queryArtifact(frame) {
+    if (frame.metadata.byteLength !== 0 || frame.segments.length !== 1) {
+      throw runtimeError("invalid_segment", "artifact query requires one byte segment");
+    }
+    const initialization = this.requireInitialization();
+    const queryBytes = requireBytesWithin(
+      frame.segments[0],
+      initialization.maximumQueryBytes,
+      `${initialization.modality} query`
+    );
+    const result = requireBytesWithin(
+      this.requireSpeculative().query(queryBytes),
+      initialization.maximumQueryResponseBytes,
+      `${initialization.modality} projection`
+    );
+    this.throwIfCancelled(frame.requestId);
+    this.respond(frame.requestId, void 0, [transferableOwnedBuffer(result)]);
+  }
+  async buildCommittedCandidate(transaction, remainingPending, requestId) {
+    const installed = this.requireInstalled();
+    if (transaction.artifactId !== installed.artifactId) {
+      throw runtimeError("artifact_mismatch", "committed transaction belongs to another artifact");
+    }
+    if (transaction.modality !== installed.modality) {
+      throw runtimeError("modality_mismatch", "committed transaction modality is incompatible");
+    }
+    if (transaction.modality === "spreadsheet" && transaction.protocolVersion !== installed.protocolVersion)
+      throw runtimeError("unsupported_protocol", "committed transaction protocol is incompatible");
+    if (transaction.startSequence !== installed.sequence + 1) {
+      throw runtimeError("invalid_sequence", "committed transaction is not contiguous");
+    }
+    assertCommittedEnvelopeMatchesOuter(transaction);
+    if (transaction.modality === "spreadsheet" && installed.modality === "spreadsheet") {
+      requireFrontierAdvance(installed.causalFrontier, transaction.causalFrontier);
+    } else if (transaction.modality !== "spreadsheet" && installed.modality !== "spreadsheet") {
+      if (transaction.priorNativeRevision !== installed.nativeRevision) {
+        throw runtimeError("invalid_revision", "serialized commit prior revision is not current");
+      }
+    }
+    requireMatchingHash(installed.stateHash, transaction.priorStateHash, "transaction prior state");
+    const nextConfirmed = this.requireConfirmed().fork();
+    let nextSpeculative = null;
+    try {
+      if (transaction.modality === "spreadsheet") {
+        nextConfirmed.applyCommitted(transaction.committedTransactionBytes);
+      } else {
+        const summary = decodeEditableArtifactSerializedCommit(
+          transaction.committedTransactionBytes,
+          transaction.modality
+        );
+        const intent = decodeEditableArtifactMutationIntent(summary.intentBytes);
+        const nativeReceipt = nextConfirmed.applyCommands(intent.commandBytes);
+        if (!bytesEqual(nativeReceipt, summary.nativeReceiptBytes)) {
+          throw runtimeError(
+            "kernel_diverged",
+            "WASM native receipt differs from the exact durable OGAST receipt"
+          );
+        }
+        if (nextConfirmed.nativeRevision() !== transaction.nativeRevision) {
+          throw runtimeError(
+            "kernel_diverged",
+            "WASM native revision differs from the exact durable OGAST revision"
+          );
+        }
+      }
+      const stateHash = await nextConfirmed.stateHash();
+      this.throwIfCancelled(requestId);
+      requireMatchingHash(stateHash, transaction.stateHash, "committed state");
+      nextSpeculative = nextConfirmed.fork();
+      const blockedPending = this.applyPending(
+        nextSpeculative,
+        remainingPending,
+        requestId,
+        transaction.endSequence
+      );
+      this.throwIfCancelled(requestId);
+      return {
+        confirmed: nextConfirmed,
+        speculative: nextSpeculative,
+        stateHash,
+        blockedPending
+      };
+    } catch (error) {
+      this.disposeSession(nextConfirmed);
+      this.disposeSession(nextSpeculative);
+      throw error;
+    }
+  }
+  installCommittedCandidate(candidate2, transaction, pending) {
+    const installed = this.requireInstalled();
+    this.installSessions(
+      candidate2.confirmed,
+      candidate2.speculative,
+      transaction.modality === "spreadsheet" ? {
+        ...installed,
+        modality: "spreadsheet",
+        sequence: transaction.endSequence,
+        stateHash: candidate2.stateHash,
+        causalFrontier: transaction.causalFrontier
+      } : {
+        ...installed,
+        modality: transaction.modality,
+        sequence: transaction.endSequence,
+        stateHash: candidate2.stateHash,
+        nativeRevision: transaction.nativeRevision
+      },
+      Object.freeze(pending.map(pendingKey)),
+      candidate2.blockedPending
+    );
+  }
+  applyPending(session, pending, requestId, baseSequence = this.requireInstalled().sequence) {
+    const blocked = [];
+    const blockedIds = /* @__PURE__ */ new Set();
+    for (const transaction of pending) {
+      this.throwIfCancelled(requestId);
+      if (transaction.previousLocalTransactionId !== null && blockedIds.has(transaction.previousLocalTransactionId)) {
+        blockedIds.add(transaction.clientTransactionId);
+        blocked.push(
+          Object.freeze({
+            clientTransactionId: transaction.clientTransactionId,
+            code: "blocked_predecessor"
+          })
+        );
+        continue;
+      }
+      try {
+        if (transaction.modality === "spreadsheet") {
+          session.applyPending(transaction.intentBytes);
+        } else {
+          if (transaction.observedHeadSequence !== baseSequence || transaction.observedNativeRevision !== session.nativeRevision()) {
+            throw new ArtifactWorkerPendingProjectionError(
+              "serialized_head_conflict",
+              "serialized pending transaction is stale"
+            );
+          }
+          session.applyCommands(transaction.commandBytes);
+          baseSequence += 1;
+        }
+      } catch (error) {
+        if (!(error instanceof ArtifactWorkerPendingProjectionError)) throw error;
+        blockedIds.add(transaction.clientTransactionId);
+        blocked.push(
+          Object.freeze({ clientTransactionId: transaction.clientTransactionId, code: error.code })
+        );
+      }
+    }
+    return Object.freeze(blocked);
+  }
+  async validatePending(pending) {
+    const initialization = this.requireInitialization();
+    const installed = this.requireInstalled();
+    const adapter = this.requireAdapter();
+    const ids = /* @__PURE__ */ new Set();
+    let aggregateBytes = 0;
+    for (const transaction of pending) {
+      if (transaction.artifactId !== installed.artifactId) {
+        throw runtimeError("artifact_mismatch", "pending transaction belongs to another artifact");
+      }
+      if (transaction.modality !== installed.modality) {
+        throw runtimeError("modality_mismatch", "pending transaction modality is incompatible");
+      }
+      if (transaction.protocolVersion !== installed.protocolVersion || transaction.modelSchemaVersion !== installed.modelSchemaVersion || transaction.commandVersion !== adapter.commandVersion) {
+        throw runtimeError(
+          "unsupported_protocol",
+          "pending transaction versions are incompatible with confirmed state"
+        );
+      }
+      if (ids.has(transaction.clientTransactionId)) {
+        throw runtimeError("duplicate_transaction", "pending transaction id is duplicated");
+      }
+      ids.add(transaction.clientTransactionId);
+      requireBytesWithin(
+        transaction.commandBytes,
+        initialization.maximumCommandBytes,
+        "pending command"
+      );
+      requireBytesWithin(
+        transaction.intentBytes,
+        initialization.maximumIntentBytes,
+        "pending intent"
+      );
+      try {
+        if (transaction.modality === "spreadsheet") {
+          assertCanonicalSpreadsheetArtifactCommandBytes(transaction.commandBytes);
+        } else {
+          editableArtifactCodecFor({
+            durableModality: transaction.modality,
+            modelSchemaVersion: transaction.modelSchemaVersion,
+            commandProtocolVersion: transaction.commandVersion
+          }).command.assertCanonical(transaction.commandBytes);
+        }
+      } catch (error) {
+        throw new ArtifactWorkerProtocolError(
+          "noncanonical_command",
+          `pending transaction contains noncanonical ${transaction.modality} command bytes`,
+          { cause: error }
+        );
+      }
+      verifyCanonicalPendingIntent(transaction);
+      aggregateBytes += transaction.commandBytes.byteLength + transaction.intentBytes.byteLength;
+      if (!Number.isSafeInteger(aggregateBytes) || aggregateBytes > MAX_PENDING_AGGREGATE_BYTES) {
+        throw runtimeError("limit_exceeded", "pending commands exceed their aggregate byte limit");
+      }
+    }
+  }
+  installSessions(confirmed, speculative, installed, pendingKeys, blockedPending) {
+    const previousConfirmed = this.confirmed;
+    const previousSpeculative = this.speculative;
+    this.confirmed = confirmed;
+    this.speculative = speculative;
+    this.installed = Object.freeze(installed);
+    this.pendingKeys = pendingKeys;
+    this.blockedPending = blockedPending;
+    this.disposeSession(previousConfirmed);
+    this.disposeSession(previousSpeculative);
+  }
+  releaseState() {
+    const confirmed = this.confirmed;
+    const speculative = this.speculative;
+    this.confirmed = null;
+    this.speculative = null;
+    this.installed = null;
+    this.pendingKeys = Object.freeze([]);
+    this.blockedPending = Object.freeze([]);
+    this.disposeSession(confirmed);
+    this.disposeSession(speculative);
+  }
+  disposeSession(session) {
+    if (!session) return;
+    try {
+      session.dispose();
+    } catch (error) {
+      this.reportProtocolError(asProtocolError(error));
+    }
+  }
+  disposeAdapter(adapter) {
+    if (!adapter?.dispose) return;
+    try {
+      adapter.dispose();
+    } catch (error) {
+      this.reportProtocolError(asProtocolError(error));
+    }
+  }
+  reportProtocolError(error) {
+    try {
+      this.onProtocolError?.(error);
+    } catch {
+    }
+  }
+  requireNoPayload(frame) {
+    if (frame.metadata.byteLength !== 0 || frame.segments.length !== 0) {
+      throw runtimeError("unexpected_payload", "RPC operation must not contain a payload");
+    }
+  }
+  requireInitialized(generation) {
+    if (this.generation === null || this.adapter === null || this.initialization === null) {
+      throw runtimeError("not_initialized", "artifact Worker is not initialized");
+    }
+    if (generation !== this.generation) {
+      throw runtimeError("stale_generation", "RPC belongs to a retired Worker generation");
+    }
+  }
+  requireInitialization() {
+    if (!this.initialization)
+      throw runtimeError("not_initialized", "artifact Worker is not initialized");
+    return this.initialization;
+  }
+  requireAdapter() {
+    if (!this.adapter) throw runtimeError("not_initialized", "artifact Worker is not initialized");
+    return this.adapter;
+  }
+  requireConfirmed() {
+    if (!this.confirmed)
+      throw runtimeError("snapshot_required", "artifact Worker has no confirmed state");
+    return this.confirmed;
+  }
+  requireSpeculative() {
+    if (!this.speculative) {
+      throw runtimeError("snapshot_required", "artifact Worker has no speculative state");
+    }
+    return this.speculative;
+  }
+  requireInstalled() {
+    if (!this.installed)
+      throw runtimeError("snapshot_required", "artifact Worker has no installed snapshot");
+    return this.installed;
+  }
+  throwIfCancelled(requestId) {
+    if (this.cancelled.has(requestId))
+      throw runtimeError("cancelled", "artifact Worker request was cancelled");
+  }
+  respond(requestId, metadata, segments) {
+    if (this.generation === null || this.cancelled.has(requestId)) return;
+    const response = encodeArtifactWorkerRpcMessage({
+      kind: 128 /* Response */,
+      generation: this.generation,
+      requestId,
+      ...metadata ? { metadata } : {},
+      ...segments ? { segments } : {},
+      ...this.rpcLimits ? { limits: this.rpcLimits } : {}
+    });
+    this.endpoint.postMessage(response, transferListForArtifactWorkerRpcMessage(response));
+  }
+  respondError(requestId, error, generation = this.generation) {
+    if (generation === null || this.cancelled.has(requestId)) return;
+    const failure = asWorkerFailure(error);
+    const response = encodeArtifactWorkerRpcMessage({
+      kind: 129 /* Error */,
+      generation,
+      requestId,
+      metadata: encodeErrorPayload(failure),
+      ...this.rpcLimits ? { limits: this.rpcLimits } : {}
+    });
+    this.endpoint.postMessage(response, transferListForArtifactWorkerRpcMessage(response));
+  }
+};
+function authorCanonicalPendingIntent(input, canonicalCommand) {
+  try {
+    return hashEditableArtifactMutationIntent(canonicalMutationIntent(input, canonicalCommand));
+  } catch (error) {
+    throw new ArtifactWorkerProtocolError(
+      "invalid_intent",
+      "pending transaction cannot be represented by canonical OGATX001",
+      { cause: error }
+    );
+  }
+}
+function transferableOwnedBuffer(bytes) {
+  if (bytes.buffer instanceof ArrayBuffer && bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+    return bytes.buffer;
+  }
+  return bytes.slice().buffer;
+}
+function verifyCanonicalPendingIntent(transaction) {
+  let expected;
+  try {
+    expected = hashEditableArtifactMutationIntent(
+      canonicalMutationIntent(transaction, transaction.commandBytes)
+    );
+  } catch (error) {
+    throw new ArtifactWorkerProtocolError(
+      "intent_mismatch",
+      "pending transaction metadata is not valid canonical OGATX001 input",
+      { cause: error }
+    );
+  }
+  if (expected.requestHash !== transaction.requestHash || !bytesEqual(expected.bytes, transaction.intentBytes)) {
+    throw runtimeError(
+      "intent_mismatch",
+      "pending transaction bytes do not bind its exact metadata and command"
+    );
+  }
+}
+function assertAdapterCompatibility(adapter, initialization) {
+  if (adapter.modality !== initialization.modality) {
+    throw runtimeError("modality_mismatch", "loaded kernel modality does not match initialization");
+  }
+  if (adapter.kernelVersion !== initialization.kernelVersion || adapter.protocolVersion !== initialization.protocolVersion || adapter.modelSchemaVersion !== initialization.modelSchemaVersion || adapter.commandVersion !== initialization.commandVersion) {
+    throw runtimeError(
+      "runtime_identity_mismatch",
+      "loaded kernel build/protocol/model identity does not match its package"
+    );
+  }
+  const limits = [
+    [adapter.maximumSnapshotBytes, initialization.maximumSnapshotBytes, "snapshot"],
+    [adapter.maximumCommandBytes, initialization.maximumCommandBytes, "command"],
+    [adapter.maximumIntentBytes, initialization.maximumIntentBytes, "intent"],
+    [
+      adapter.maximumCommittedTransactionBytes,
+      initialization.maximumCommittedTransactionBytes,
+      "committed transaction"
+    ],
+    [adapter.maximumQueryBytes, initialization.maximumQueryBytes, "query"],
+    [adapter.maximumQueryResponseBytes, initialization.maximumQueryResponseBytes, "query response"]
+  ];
+  for (const [advertised, requested, label] of limits) {
+    if (advertised < requested) {
+      throw runtimeError(
+        "unsupported_protocol",
+        `loaded collaboration kernel ${label} limit is below the requested Worker limit`
+      );
+    }
+  }
+}
+function assertCommittedEnvelopeMatchesOuter(transaction) {
+  if (transaction.modality !== "spreadsheet") {
+    let summary2;
+    try {
+      summary2 = decodeEditableArtifactSerializedCommit(
+        transaction.committedTransactionBytes,
+        transaction.modality
+      );
+    } catch (error) {
+      throw new ArtifactWorkerProtocolError(
+        "invalid_committed_transaction",
+        "committed transaction is not canonical OGAST001",
+        { cause: error }
+      );
+    }
+    if (summary2.commitProtocolVersion !== transaction.commitProtocolVersion || summary2.transactionId !== transaction.transactionId || summary2.requestHash !== transaction.requestHash || summary2.parentHeadSequence + 1 !== transaction.startSequence || summary2.resultHeadSequence !== transaction.endSequence || summary2.priorNativeRevision !== transaction.priorNativeRevision || summary2.nativeReceipt.revision !== transaction.nativeRevision || summary2.priorStateHash !== transaction.priorStateHash || summary2.stateHash !== transaction.stateHash) {
+      throw runtimeError(
+        "committed_metadata_mismatch",
+        "outer committed metadata disagrees with its exact OGAST001 envelope"
+      );
+    }
+    return;
+  }
+  let summary;
+  try {
+    summary = decodeCommittedTransactionSummary(transaction.committedTransactionBytes);
+  } catch (error) {
+    throw new ArtifactWorkerProtocolError(
+      "invalid_committed_transaction",
+      "committed transaction is not canonical OGACO001",
+      { cause: error }
+    );
+  }
+  if (summary.operationProtocolVersion !== transaction.protocolVersion || summary.transactionId !== transaction.transactionId || summary.priorStateHash !== transaction.priorStateHash || summary.stateHash !== transaction.stateHash || !frontiersEqual(summary.resultingCausalFrontier, transaction.causalFrontier)) {
+    throw runtimeError(
+      "committed_metadata_mismatch",
+      "outer committed metadata disagrees with its exact OGACO001 envelope"
+    );
+  }
+}
+function frontiersEqual(left, right) {
+  return left.length === right.length && left.every(
+    (entry, index) => entry.replicaId === right[index]?.replicaId && entry.counter === right[index]?.counter
+  );
+}
+function canonicalMutationIntent(input, commandBytes) {
+  return {
+    envelopeVersion: EDITABLE_ARTIFACT_INTENT_VERSION2,
+    protocolVersion: input.protocolVersion,
+    modelSchemaVersion: input.modelSchemaVersion,
+    commandProtocolVersion: input.commandVersion,
+    artifactId: input.artifactId,
+    clientTransactionId: input.clientTransactionId,
+    replicaId: input.replicaId,
+    replicaCounter: input.replicaCounter,
+    previousLocalTransactionId: input.previousLocalTransactionId,
+    observedHeadSequence: input.observedHeadSequence,
+    causalBase: input.modality === "spreadsheet" ? input.causalBase ?? [] : [],
+    selectiveUndoOperationIds: input.modality === "spreadsheet" ? input.selectiveUndoTargets ?? [] : [],
+    commandBytes
+  };
+}
+function retainedFrameBytes(frame) {
+  let bytes = frame.metadata.byteLength;
+  for (const segment of frame.segments) bytes += segment.byteLength;
+  if (!Number.isSafeInteger(bytes)) {
+    throw runtimeError("size_overflow", "artifact Worker request byte count overflowed");
+  }
+  return bytes;
+}
+function requireBytesWithin(bytes, maximum, label) {
+  if (!(bytes instanceof Uint8Array) || bytes.byteLength === 0) {
+    throw runtimeError("invalid_bytes", `${label} must be non-empty bytes`);
+  }
+  if (bytes.byteLength > maximum)
+    throw runtimeError("limit_exceeded", `${label} exceeds its byte limit`);
+  return bytes;
+}
+function pendingKey(transaction) {
+  return `${transaction.clientTransactionId}\0${transaction.requestHash}`;
+}
+function arraysEqual(left, right) {
+  return left.length === right.length && left.every((value, index) => value === right[index]);
+}
+function bytesEqual(left, right) {
+  if (left.byteLength !== right.byteLength) return false;
+  for (let index = 0; index < left.byteLength; index += 1) {
+    if (left[index] !== right[index]) return false;
+  }
+  return true;
+}
+function requireFrontierAdvance(previous, next) {
+  const nextByReplica = new Map(next.map((entry) => [entry.replicaId, entry.counter]));
+  for (const entry of previous) {
+    if ((nextByReplica.get(entry.replicaId) ?? -1) < entry.counter) {
+      throw runtimeError("invalid_frontier", "committed causal frontier regresses");
+    }
+  }
+}
+function asWorkerFailure(error) {
+  if (error instanceof ArtifactWorkerProtocolError) {
+    return {
+      code: normalizeErrorCode(error.code),
+      message: sanitizeErrorMessage(error.message),
+      retryable: false
+    };
+  }
+  if (error instanceof Error) {
+    return {
+      code: "kernel_failed",
+      message: sanitizeErrorMessage(error.message || "artifact kernel failed"),
+      retryable: false
+    };
+  }
+  return { code: "kernel_failed", message: "artifact kernel failed", retryable: false };
+}
+function asProtocolError(error) {
+  if (error instanceof ArtifactWorkerProtocolError) return error;
+  return new ArtifactWorkerProtocolError(
+    "runtime_failed",
+    error instanceof Error ? error.message : "artifact Worker runtime failed",
+    { cause: error }
+  );
+}
+function normalizeErrorCode(value) {
+  return /^[a-z][a-z0-9_]{0,127}$/.test(value) ? value : "kernel_failed";
+}
+function sanitizeErrorMessage(value) {
+  let output = "";
+  for (let index = 0; index < value.length && output.length < 2e3; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const following = value.charCodeAt(index + 1);
+      if (following >= 56320 && following <= 57343) {
+        output += value[index] + value[index + 1];
+        index += 1;
+      } else {
+        output += "\uFFFD";
+      }
+    } else if (code >= 56320 && code <= 57343) {
+      output += "\uFFFD";
+    } else {
+      output += value[index];
+    }
+  }
+  return output || "artifact kernel failed";
+}
+function runtimeError(code, message) {
+  return new ArtifactWorkerProtocolError(code, message);
+}
+
+// src/editable-artifacts/worker/browser-entry.ts
+function installBrowserArtifactWorkerEntry(scope) {
+  return new ArtifactWorkerRuntime({ endpoint: scope, loadAdapter: loadBrowserWasmKernelAdapter });
+}
+var candidate = globalThis;
+if (candidate.document === void 0 && typeof candidate.addEventListener === "function" && typeof candidate.removeEventListener === "function" && typeof candidate.postMessage === "function") {
+  installBrowserArtifactWorkerEntry({
+    addEventListener(type, listener) {
+      candidate.addEventListener(type, listener);
+    },
+    removeEventListener(type, listener) {
+      candidate.removeEventListener(type, listener);
+    },
+    postMessage(message, transfer) {
+      candidate.postMessage(
+        message,
+        transfer
+      );
+    }
+  });
+}
+export {
+  installBrowserArtifactWorkerEntry
+};
+//# sourceMappingURL=editable-artifacts-worker.js.map