@opengeni/contracts 0.40.0 → 0.50.0

package/dist/editable-artifact-live.js

@@ -0,0 +1,907 @@
+import {
+  EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
+  hashEditableArtifactMutationIntentBytes
+} from "./chunk-TZ6YEYN4.js";
+import "./chunk-YRKRZ6OF.js";
+import "./chunk-JBCIY7QD.js";
+import "./chunk-RIY7GYQS.js";
+import "./chunk-CADSX6UN.js";
+import "./chunk-D2HKF2EF.js";
+import "./chunk-MYBZRDTY.js";
+import "./chunk-LSB7GRLG.js";
+import "./chunk-BVGIYW7D.js";
+
+// src/editable-artifact-live.ts
+var MAGIC = new TextEncoder().encode("OGALV001");
+var HEADER_BYTES = 20;
+var MAX_METADATA_BYTES = 64 * 1024;
+var MAX_TOKEN_BYTES = 4096;
+var MAX_IDENTIFIER_BYTES = 512;
+var MAX_CAUSAL_ACTORS = 1024;
+var textEncoder = new TextEncoder();
+var strictDecoder = new TextDecoder("utf-8", { fatal: true });
+var CLIENT_OPEN = 1;
+var CLIENT_APPLIED = 2;
+var CLIENT_MUTATION = 3;
+var SERVER_OPEN = 64;
+var SERVER_SNAPSHOT = 65;
+var SERVER_TRANSACTION = 66;
+var SERVER_BARRIER = 67;
+var SERVER_WATERMARK = 68;
+var SERVER_RESYNC_REQUIRED = 69;
+var SERVER_APPLIED = 70;
+var SERVER_AUTHORIZATION_CHANGED = 71;
+var SERVER_MUTATION_ACCEPTED = 72;
+var SERVER_MUTATION_REJECTED = 73;
+var RESYNC_REASONS = /* @__PURE__ */ new Set([
+  "retention_gap",
+  "durable_gap",
+  "invalid_ack",
+  "slow_client",
+  "oversized_frame"
+]);
+var MUTATION_REJECTION_CODES = /* @__PURE__ */ new Set([
+  "invalid_request",
+  "forbidden",
+  "conflict",
+  "unsupported",
+  "unavailable"
+]);
+var EDITABLE_ARTIFACT_LIVE_WIRE_VERSION = 1;
+var EditableArtifactLiveError = class extends Error {
+  constructor(code, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.code = code;
+    this.options = options;
+    this.name = "EditableArtifactLiveError";
+  }
+  get retryable() {
+    return this.options.retryable ?? false;
+  }
+  get requiresSnapshot() {
+    return this.options.requiresSnapshot ?? false;
+  }
+};
+function decodeEditableArtifactLiveClientWireFrame(bytes) {
+  const decoded = decodeEnvelope(bytes);
+  if (decoded.kind === CLIENT_OPEN) return decodeOpen(decoded.metadata, decoded.payload);
+  if (decoded.kind === CLIENT_APPLIED) return decodeApplied(decoded.metadata, decoded.payload);
+  if (decoded.kind === CLIENT_MUTATION) return decodeMutation(decoded.metadata, decoded.payload);
+  throw invalidFrame("Unknown editable artifact client frame kind");
+}
+function encodeEditableArtifactLiveOpenWireFrame(frame) {
+  const artifactId = editableArtifactId(frame.artifactId);
+  const protocolVersion = positiveInteger(frame.protocolVersion, "protocolVersion");
+  const token = boundedToken(frame.token);
+  const resume = normalizeResume(frame.resume);
+  if (resume.modality === "document" || resume.modality === "presentation") {
+    return encodeEnvelope(
+      CLIENT_OPEN,
+      {
+        type: "open",
+        protocolVersion,
+        artifactId,
+        token,
+        modality: resume.modality,
+        localCursor: resume.localCursor,
+        localStateHash: resume.localStateHash,
+        localNativeRevision: resume.localNativeRevision,
+        requireSnapshot: resume.requireSnapshot
+      },
+      EMPTY_BYTES
+    );
+  }
+  if (!("localCausalFrontier" in resume)) {
+    throw invalidFrame("spreadsheet resume requires a causal frontier");
+  }
+  return encodeEnvelope(
+    CLIENT_OPEN,
+    {
+      type: "open",
+      protocolVersion,
+      artifactId,
+      token,
+      localCursor: resume.localCursor,
+      localStateHash: resume.localStateHash,
+      localCausalFrontier: resume.localCausalFrontier,
+      requireSnapshot: resume.requireSnapshot
+    },
+    EMPTY_BYTES
+  );
+}
+function encodeEditableArtifactLiveAppliedWireFrame(frame) {
+  return encodeEnvelope(
+    CLIENT_APPLIED,
+    {
+      type: "applied",
+      protocolVersion: positiveInteger(frame.protocolVersion, "protocolVersion"),
+      artifactId: editableArtifactId(frame.artifactId),
+      streamEpoch: boundedString(frame.streamEpoch, "streamEpoch", MAX_IDENTIFIER_BYTES),
+      sequence: nonnegativeInteger(frame.sequence, "sequence"),
+      stateHash: editableArtifactStateHash(frame.stateHash)
+    },
+    EMPTY_BYTES
+  );
+}
+function encodeEditableArtifactLiveMutationWireFrame(frame) {
+  const intentBytes = ownPayload(frame.intentBytes, EDITABLE_ARTIFACT_INTENT_MAX_BYTES, false);
+  const requestHash = editableArtifactRequestHash(frame.requestHash);
+  if (hashEditableArtifactMutationIntentBytes(intentBytes) !== requestHash) {
+    throw invalidFrame("Mutation request hash does not match exact OGATX bytes");
+  }
+  return encodeEnvelope(
+    CLIENT_MUTATION,
+    {
+      type: "mutation",
+      protocolVersion: positiveInteger(frame.protocolVersion, "protocolVersion"),
+      artifactId: editableArtifactId(frame.artifactId),
+      streamEpoch: boundedString(frame.streamEpoch, "streamEpoch", MAX_IDENTIFIER_BYTES),
+      requestHash
+    },
+    intentBytes
+  );
+}
+function encodeEditableArtifactLiveServerWireFrame(frame) {
+  switch (frame.type) {
+    case "open": {
+      const { modality, ...metadata } = frame;
+      return encodeEnvelope(
+        SERVER_OPEN,
+        modality === "document" || modality === "presentation" ? {
+          type: metadata.type,
+          protocolVersion: metadata.protocolVersion,
+          artifactId: metadata.artifactId,
+          streamEpoch: metadata.streamEpoch,
+          modality,
+          writable: metadata.writable,
+          headSequence: metadata.headSequence,
+          minimumReplaySequence: metadata.minimumReplaySequence,
+          maxClientFrameBytes: metadata.maxClientFrameBytes,
+          maxCommandBytes: metadata.maxCommandBytes,
+          maxIntentBytes: metadata.maxIntentBytes,
+          maxCommittedTransactionBytes: metadata.maxCommittedTransactionBytes,
+          maxSnapshotBytes: metadata.maxSnapshotBytes,
+          maxInFlightTransactions: metadata.maxInFlightTransactions,
+          maxInFlightBytes: metadata.maxInFlightBytes
+        } : metadata,
+        EMPTY_BYTES
+      );
+    }
+    case "snapshot": {
+      const { bytes, modality, ...metadata } = frame;
+      if ((modality === "document" || modality === "presentation") && !("nativeRevision" in metadata)) {
+        throw invalidFrame("serialized snapshot requires a native revision");
+      }
+      if (modality !== "document" && modality !== "presentation" && !("causalFrontier" in metadata)) {
+        throw invalidFrame("spreadsheet snapshot requires a causal frontier");
+      }
+      return encodeEnvelope(
+        SERVER_SNAPSHOT,
+        modality === "document" || modality === "presentation" ? {
+          type: metadata.type,
+          protocolVersion: metadata.protocolVersion,
+          artifactId: metadata.artifactId,
+          streamEpoch: metadata.streamEpoch,
+          modality,
+          sequence: metadata.sequence,
+          stateHash: metadata.stateHash,
+          nativeRevision: metadata.nativeRevision,
+          digest: metadata.digest,
+          kernelVersion: metadata.kernelVersion,
+          modelSchemaVersion: metadata.modelSchemaVersion,
+          offset: metadata.offset,
+          totalBytes: metadata.totalBytes,
+          final: metadata.final
+        } : {
+          type: metadata.type,
+          protocolVersion: metadata.protocolVersion,
+          artifactId: metadata.artifactId,
+          streamEpoch: metadata.streamEpoch,
+          sequence: metadata.sequence,
+          stateHash: metadata.stateHash,
+          causalFrontier: metadata.causalFrontier,
+          digest: metadata.digest,
+          kernelVersion: metadata.kernelVersion,
+          modelSchemaVersion: metadata.modelSchemaVersion,
+          offset: metadata.offset,
+          totalBytes: metadata.totalBytes,
+          final: metadata.final
+        },
+        bytes
+      );
+    }
+    case "transaction": {
+      const { committedTransactionBytes, ...transaction } = frame.transaction;
+      const serializedTransaction = transaction;
+      const transactionMetadata = transaction.modality === void 0 || transaction.modality === "spreadsheet" ? {
+        artifactId: transaction.artifactId,
+        transactionId: transaction.transactionId,
+        requestHash: transaction.requestHash,
+        startSequence: transaction.startSequence,
+        endSequence: transaction.endSequence,
+        priorStateHash: transaction.priorStateHash,
+        stateHash: transaction.stateHash,
+        causalFrontier: transaction.causalFrontier,
+        protocolVersion: transaction.protocolVersion
+      } : {
+        artifactId: serializedTransaction.artifactId,
+        modality: serializedTransaction.modality,
+        transactionId: serializedTransaction.transactionId,
+        requestHash: serializedTransaction.requestHash,
+        startSequence: serializedTransaction.startSequence,
+        endSequence: serializedTransaction.endSequence,
+        priorStateHash: serializedTransaction.priorStateHash,
+        stateHash: serializedTransaction.stateHash,
+        priorNativeRevision: serializedTransaction.priorNativeRevision,
+        nativeRevision: serializedTransaction.nativeRevision,
+        commitProtocolVersion: serializedTransaction.commitProtocolVersion
+      };
+      return encodeEnvelope(
+        SERVER_TRANSACTION,
+        { ...frame, transaction: transactionMetadata },
+        committedTransactionBytes
+      );
+    }
+    case "barrier":
+      return encodeEnvelope(SERVER_BARRIER, { ...frame }, EMPTY_BYTES);
+    case "watermark":
+      return encodeEnvelope(SERVER_WATERMARK, { ...frame }, EMPTY_BYTES);
+    case "resyncRequired":
+      return encodeEnvelope(SERVER_RESYNC_REQUIRED, { ...frame }, EMPTY_BYTES);
+    case "applied":
+      return encodeEnvelope(SERVER_APPLIED, { ...frame }, EMPTY_BYTES);
+    case "authorizationChanged":
+      return encodeEnvelope(SERVER_AUTHORIZATION_CHANGED, { ...frame }, EMPTY_BYTES);
+    case "mutationAccepted":
+      return encodeEnvelope(SERVER_MUTATION_ACCEPTED, { ...frame }, EMPTY_BYTES);
+    case "mutationRejected":
+      return encodeEnvelope(SERVER_MUTATION_REJECTED, { ...frame }, EMPTY_BYTES);
+  }
+}
+function decodeEditableArtifactLiveServerWireFrame(bytes) {
+  const decoded = decodeEnvelope(bytes);
+  const metadata = decoded.metadata;
+  switch (decoded.kind) {
+    case SERVER_OPEN: {
+      requireNoPayload(decoded.payload);
+      const modality = serverModality(metadata);
+      requireServerKeys(metadata, "open", [
+        ...modality === "spreadsheet" ? [] : ["modality"],
+        "writable",
+        "headSequence",
+        "minimumReplaySequence",
+        "maxClientFrameBytes",
+        "maxCommandBytes",
+        "maxIntentBytes",
+        "maxCommittedTransactionBytes",
+        "maxSnapshotBytes",
+        "maxInFlightTransactions",
+        "maxInFlightBytes"
+      ]);
+      const common = {
+        ...serverIdentity(metadata, "open"),
+        writable: requiredBoolean(metadata.writable, "writable"),
+        headSequence: nonnegativeInteger(metadata.headSequence, "headSequence"),
+        minimumReplaySequence: nonnegativeInteger(
+          metadata.minimumReplaySequence,
+          "minimumReplaySequence"
+        ),
+        maxClientFrameBytes: positiveInteger(metadata.maxClientFrameBytes, "maxClientFrameBytes"),
+        maxCommandBytes: nonnegativeInteger(metadata.maxCommandBytes, "maxCommandBytes"),
+        maxIntentBytes: nonnegativeInteger(metadata.maxIntentBytes, "maxIntentBytes"),
+        maxCommittedTransactionBytes: nonnegativeInteger(
+          metadata.maxCommittedTransactionBytes,
+          "maxCommittedTransactionBytes"
+        ),
+        maxSnapshotBytes: positiveInteger(metadata.maxSnapshotBytes, "maxSnapshotBytes"),
+        maxInFlightTransactions: positiveInteger(
+          metadata.maxInFlightTransactions,
+          "maxInFlightTransactions"
+        ),
+        maxInFlightBytes: positiveInteger(metadata.maxInFlightBytes, "maxInFlightBytes")
+      };
+      return Object.freeze(modality === "spreadsheet" ? common : { ...common, modality });
+    }
+    case SERVER_SNAPSHOT: {
+      const modality = serverModality(metadata);
+      requireServerKeys(metadata, "snapshot", [
+        ...modality === "spreadsheet" ? [] : ["modality"],
+        "sequence",
+        "stateHash",
+        modality === "spreadsheet" ? "causalFrontier" : "nativeRevision",
+        "digest",
+        "kernelVersion",
+        "modelSchemaVersion",
+        "offset",
+        "totalBytes",
+        "final"
+      ]);
+      const offset = nonnegativeInteger(metadata.offset, "offset");
+      const totalBytes = positiveInteger(metadata.totalBytes, "totalBytes");
+      const final = requiredBoolean(metadata.final, "final");
+      if (decoded.payload.byteLength === 0 || offset + decoded.payload.byteLength > totalBytes) {
+        throw invalidFrame("snapshot chunk bounds are invalid");
+      }
+      if (final !== (offset + decoded.payload.byteLength === totalBytes)) {
+        throw invalidFrame("snapshot final flag does not match its byte boundary");
+      }
+      const common = {
+        ...serverIdentity(metadata, "snapshot"),
+        sequence: nonnegativeInteger(metadata.sequence, "sequence"),
+        stateHash: editableArtifactStateHash(requiredString(metadata.stateHash, "stateHash")),
+        digest: editableArtifactContentHash(requiredString(metadata.digest, "digest")),
+        kernelVersion: boundedString(
+          requiredString(metadata.kernelVersion, "kernelVersion"),
+          "kernelVersion",
+          MAX_IDENTIFIER_BYTES
+        ),
+        modelSchemaVersion: positiveInteger(metadata.modelSchemaVersion, "modelSchemaVersion"),
+        offset,
+        totalBytes,
+        final,
+        bytes: decoded.payload
+      };
+      return Object.freeze(
+        modality === "spreadsheet" ? {
+          ...common,
+          causalFrontier: requiredFrontier(metadata.causalFrontier)
+        } : {
+          ...common,
+          modality,
+          nativeRevision: nonnegativeInteger(metadata.nativeRevision, "nativeRevision")
+        }
+      );
+    }
+    case SERVER_TRANSACTION: {
+      requireServerKeys(metadata, "transaction", ["transaction"]);
+      const transaction = requiredRecord(metadata.transaction, "transaction");
+      const modality = transactionModality(transaction);
+      requireExactKeys(
+        transaction,
+        modality === "spreadsheet" ? [
+          "artifactId",
+          "transactionId",
+          "requestHash",
+          "startSequence",
+          "endSequence",
+          "priorStateHash",
+          "stateHash",
+          "causalFrontier",
+          "protocolVersion"
+        ] : [
+          "artifactId",
+          "modality",
+          "transactionId",
+          "requestHash",
+          "startSequence",
+          "endSequence",
+          "priorStateHash",
+          "stateHash",
+          "priorNativeRevision",
+          "nativeRevision",
+          "commitProtocolVersion"
+        ]
+      );
+      if (decoded.payload.byteLength === 0) {
+        throw invalidFrame("transaction payload must not be empty");
+      }
+      const startSequence = positiveInteger(transaction.startSequence, "startSequence");
+      const endSequence = positiveInteger(transaction.endSequence, "endSequence");
+      if (endSequence < startSequence)
+        throw invalidFrame("transaction sequence interval is inverted");
+      const common = {
+        ...serverIdentity(metadata, "transaction"),
+        transaction: {
+          artifactId: editableArtifactId(requiredString(transaction.artifactId, "artifactId")),
+          transactionId: editableArtifactTransactionId(
+            requiredString(transaction.transactionId, "transactionId")
+          ),
+          requestHash: editableArtifactRequestHash(
+            requiredString(transaction.requestHash, "requestHash")
+          ),
+          startSequence,
+          endSequence,
+          priorStateHash: editableArtifactStateHash(
+            requiredString(transaction.priorStateHash, "priorStateHash")
+          ),
+          stateHash: editableArtifactStateHash(requiredString(transaction.stateHash, "stateHash")),
+          committedTransactionBytes: decoded.payload
+        }
+      };
+      return Object.freeze({
+        ...common,
+        transaction: Object.freeze(
+          modality === "spreadsheet" ? {
+            ...common.transaction,
+            causalFrontier: requiredFrontier(transaction.causalFrontier),
+            protocolVersion: positiveInteger(transaction.protocolVersion, "protocolVersion")
+          } : {
+            ...common.transaction,
+            modality,
+            priorNativeRevision: nonnegativeInteger(
+              transaction.priorNativeRevision,
+              "priorNativeRevision"
+            ),
+            nativeRevision: nonnegativeInteger(transaction.nativeRevision, "nativeRevision"),
+            commitProtocolVersion: positiveInteger(
+              transaction.commitProtocolVersion,
+              "commitProtocolVersion"
+            )
+          }
+        )
+      });
+    }
+    case SERVER_BARRIER:
+    case SERVER_APPLIED: {
+      const type = decoded.kind === SERVER_BARRIER ? "barrier" : "applied";
+      requireNoPayload(decoded.payload);
+      requireServerKeys(metadata, type, ["sequence", "stateHash"]);
+      return Object.freeze({
+        ...serverIdentity(metadata, type),
+        sequence: nonnegativeInteger(metadata.sequence, "sequence"),
+        stateHash: editableArtifactStateHash(requiredString(metadata.stateHash, "stateHash"))
+      });
+    }
+    case SERVER_WATERMARK: {
+      requireNoPayload(decoded.payload);
+      requireServerKeys(metadata, "watermark", ["headSequence"]);
+      return Object.freeze({
+        ...serverIdentity(metadata, "watermark"),
+        headSequence: nonnegativeInteger(metadata.headSequence, "headSequence")
+      });
+    }
+    case SERVER_RESYNC_REQUIRED: {
+      requireNoPayload(decoded.payload);
+      requireServerKeys(metadata, "resyncRequired", ["reason", "headSequence"]);
+      const reason = requiredString(metadata.reason, "reason");
+      if (!RESYNC_REASONS.has(reason)) throw invalidFrame("resync reason is invalid");
+      return Object.freeze({
+        ...serverIdentity(metadata, "resyncRequired"),
+        reason,
+        headSequence: nonnegativeInteger(metadata.headSequence, "headSequence")
+      });
+    }
+    case SERVER_AUTHORIZATION_CHANGED: {
+      requireNoPayload(decoded.payload);
+      requireServerKeys(metadata, "authorizationChanged", ["writable"]);
+      return Object.freeze({
+        ...serverIdentity(metadata, "authorizationChanged"),
+        writable: requiredBoolean(metadata.writable, "writable")
+      });
+    }
+    case SERVER_MUTATION_ACCEPTED: {
+      requireNoPayload(decoded.payload);
+      requireServerKeys(metadata, "mutationAccepted", [
+        "requestHash",
+        "clientTransactionId",
+        "transactionId",
+        "startSequence",
+        "endSequence",
+        "stateHash"
+      ]);
+      const startSequence = positiveInteger(metadata.startSequence, "startSequence");
+      const endSequence = positiveInteger(metadata.endSequence, "endSequence");
+      if (endSequence < startSequence) throw invalidFrame("accepted sequence interval is inverted");
+      return Object.freeze({
+        ...serverIdentity(metadata, "mutationAccepted"),
+        requestHash: editableArtifactRequestHash(
+          requiredString(metadata.requestHash, "requestHash")
+        ),
+        clientTransactionId: editableArtifactClientTransactionId(
+          requiredString(metadata.clientTransactionId, "clientTransactionId")
+        ),
+        transactionId: editableArtifactTransactionId(
+          requiredString(metadata.transactionId, "transactionId")
+        ),
+        startSequence,
+        endSequence,
+        stateHash: editableArtifactStateHash(requiredString(metadata.stateHash, "stateHash"))
+      });
+    }
+    case SERVER_MUTATION_REJECTED: {
+      requireNoPayload(decoded.payload);
+      requireServerKeys(metadata, "mutationRejected", ["requestHash", "code", "retryable"]);
+      const code = requiredString(metadata.code, "code");
+      if (!MUTATION_REJECTION_CODES.has(code)) {
+        throw invalidFrame("mutation rejection code is invalid");
+      }
+      return Object.freeze({
+        ...serverIdentity(metadata, "mutationRejected"),
+        requestHash: editableArtifactRequestHash(
+          requiredString(metadata.requestHash, "requestHash")
+        ),
+        code,
+        retryable: requiredBoolean(metadata.retryable, "retryable")
+      });
+    }
+    default:
+      throw invalidFrame("Unknown editable artifact server frame kind");
+  }
+}
+function inspectEditableArtifactLiveWireEnvelope(bytes) {
+  return decodeEnvelope(bytes);
+}
+function decodeOpen(metadata, payload) {
+  requireNoPayload(payload);
+  const modality = clientOpenModality(metadata);
+  requireExactKeys(
+    metadata,
+    modality === "spreadsheet" ? [
+      "type",
+      "protocolVersion",
+      "artifactId",
+      "token",
+      "localCursor",
+      "localStateHash",
+      "localCausalFrontier",
+      "requireSnapshot"
+    ] : [
+      "type",
+      "protocolVersion",
+      "artifactId",
+      "token",
+      "modality",
+      "localCursor",
+      "localStateHash",
+      "localNativeRevision",
+      "requireSnapshot"
+    ]
+  );
+  requireLiteral(metadata.type, "open", "type");
+  return Object.freeze({
+    type: "open",
+    protocolVersion: positiveInteger(metadata.protocolVersion, "protocolVersion"),
+    artifactId: editableArtifactId(requiredString(metadata.artifactId, "artifactId")),
+    token: boundedToken(requiredString(metadata.token, "token")),
+    resume: normalizeResume(
+      modality === "spreadsheet" ? {
+        modality,
+        localCursor: nullableNonnegativeInteger(metadata.localCursor, "localCursor"),
+        localStateHash: metadata.localStateHash === null ? null : editableArtifactStateHash(
+          requiredString(metadata.localStateHash, "localStateHash")
+        ),
+        localCausalFrontier: requiredFrontier(metadata.localCausalFrontier),
+        requireSnapshot: requiredBoolean(metadata.requireSnapshot, "requireSnapshot")
+      } : {
+        modality,
+        localCursor: nullableNonnegativeInteger(metadata.localCursor, "localCursor"),
+        localStateHash: metadata.localStateHash === null ? null : editableArtifactStateHash(
+          requiredString(metadata.localStateHash, "localStateHash")
+        ),
+        localNativeRevision: nullableNonnegativeInteger(
+          metadata.localNativeRevision,
+          "localNativeRevision"
+        ),
+        requireSnapshot: requiredBoolean(metadata.requireSnapshot, "requireSnapshot")
+      }
+    )
+  });
+}
+function decodeApplied(metadata, payload) {
+  requireNoPayload(payload);
+  requireExactKeys(metadata, [
+    "type",
+    "protocolVersion",
+    "artifactId",
+    "streamEpoch",
+    "sequence",
+    "stateHash"
+  ]);
+  requireLiteral(metadata.type, "applied", "type");
+  return Object.freeze({
+    type: "applied",
+    protocolVersion: positiveInteger(metadata.protocolVersion, "protocolVersion"),
+    artifactId: editableArtifactId(requiredString(metadata.artifactId, "artifactId")),
+    streamEpoch: boundedString(
+      requiredString(metadata.streamEpoch, "streamEpoch"),
+      "streamEpoch",
+      MAX_IDENTIFIER_BYTES
+    ),
+    sequence: nonnegativeInteger(metadata.sequence, "sequence"),
+    stateHash: editableArtifactStateHash(requiredString(metadata.stateHash, "stateHash"))
+  });
+}
+function decodeMutation(metadata, payload) {
+  requireExactKeys(metadata, [
+    "type",
+    "protocolVersion",
+    "artifactId",
+    "streamEpoch",
+    "requestHash"
+  ]);
+  requireLiteral(metadata.type, "mutation", "type");
+  const requestHash = editableArtifactRequestHash(
+    requiredString(metadata.requestHash, "requestHash")
+  );
+  const intentBytes = ownPayload(payload, EDITABLE_ARTIFACT_INTENT_MAX_BYTES, false);
+  try {
+    if (hashEditableArtifactMutationIntentBytes(intentBytes) !== requestHash) {
+      throw new TypeError("request hash mismatch");
+    }
+  } catch (cause) {
+    throw invalidFrame("Mutation request hash does not match exact OGATX bytes", cause);
+  }
+  return Object.freeze({
+    type: "mutation",
+    protocolVersion: positiveInteger(metadata.protocolVersion, "protocolVersion"),
+    artifactId: editableArtifactId(requiredString(metadata.artifactId, "artifactId")),
+    streamEpoch: boundedString(
+      requiredString(metadata.streamEpoch, "streamEpoch"),
+      "streamEpoch",
+      MAX_IDENTIFIER_BYTES
+    ),
+    requestHash,
+    intentBytes
+  });
+}
+function encodeEnvelope(kind, metadata, rawPayload) {
+  if (!Number.isInteger(kind) || kind < 1 || kind > 255) throw new TypeError("wire kind invalid");
+  const metadataBytes = textEncoder.encode(JSON.stringify(metadata));
+  if (metadataBytes.byteLength < 2 || metadataBytes.byteLength > MAX_METADATA_BYTES) {
+    throw new RangeError("Editable artifact wire metadata exceeds bound");
+  }
+  const payload = ownPayload(rawPayload, 128 * 1024 * 1024, true);
+  const total = HEADER_BYTES + metadataBytes.byteLength + payload.byteLength;
+  if (!Number.isSafeInteger(total)) throw new RangeError("Editable artifact wire frame too large");
+  const output = new Uint8Array(total);
+  output.set(MAGIC, 0);
+  const view = new DataView(output.buffer);
+  view.setUint8(8, EDITABLE_ARTIFACT_LIVE_WIRE_VERSION);
+  view.setUint8(9, kind);
+  view.setUint16(10, 0, true);
+  view.setUint32(12, metadataBytes.byteLength, true);
+  view.setUint32(16, payload.byteLength, true);
+  output.set(metadataBytes, HEADER_BYTES);
+  output.set(payload, HEADER_BYTES + metadataBytes.byteLength);
+  return output;
+}
+function decodeEnvelope(bytes) {
+  if (!(bytes instanceof Uint8Array) || bytes.byteLength < HEADER_BYTES) {
+    throw invalidFrame("Editable artifact wire frame is truncated");
+  }
+  for (let index = 0; index < MAGIC.byteLength; index += 1) {
+    if (bytes[index] !== MAGIC[index]) throw invalidFrame("Editable artifact wire magic mismatch");
+  }
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  if (view.getUint8(8) !== EDITABLE_ARTIFACT_LIVE_WIRE_VERSION) {
+    throw new EditableArtifactLiveError("protocol_mismatch", "Live wire version unsupported");
+  }
+  const kind = view.getUint8(9);
+  if (view.getUint16(10, true) !== 0) throw invalidFrame("Editable artifact wire flags invalid");
+  const metadataLength = view.getUint32(12, true);
+  const payloadLength = view.getUint32(16, true);
+  if (metadataLength < 2 || metadataLength > MAX_METADATA_BYTES) {
+    throw invalidFrame("Editable artifact wire metadata exceeds bound");
+  }
+  const expected = HEADER_BYTES + metadataLength + payloadLength;
+  if (expected !== bytes.byteLength) throw invalidFrame("Editable artifact wire length mismatch");
+  const metadataBytes = bytes.subarray(HEADER_BYTES, HEADER_BYTES + metadataLength);
+  let metadataText;
+  let value;
+  try {
+    metadataText = strictDecoder.decode(metadataBytes);
+    value = JSON.parse(metadataText);
+  } catch (cause) {
+    throw invalidFrame("Editable artifact wire metadata is not UTF-8 JSON", cause);
+  }
+  const metadata = requiredRecord(value, "metadata");
+  if (JSON.stringify(metadata) !== metadataText) {
+    throw invalidFrame("Editable artifact wire metadata is not canonical JSON");
+  }
+  return Object.freeze({
+    kind,
+    metadata: Object.freeze(metadata),
+    payload: bytes.slice(HEADER_BYTES + metadataLength)
+  });
+}
+function normalizeResume(resume) {
+  if (!resume || typeof resume !== "object") throw invalidFrame("resume must be an object");
+  const localCursor = nullableNonnegativeInteger(resume.localCursor, "localCursor");
+  const localStateHash = resume.localStateHash === null ? null : editableArtifactStateHash(resume.localStateHash);
+  const requireSnapshot = requiredBoolean(resume.requireSnapshot, "requireSnapshot");
+  if (localCursor === null !== (localStateHash === null)) {
+    throw invalidFrame("resume cursor and state hash must both be null or both be present");
+  }
+  const modality = resume.modality ?? "spreadsheet";
+  if (modality === "spreadsheet") {
+    if (!("localCausalFrontier" in resume)) {
+      throw invalidFrame("spreadsheet resume requires a causal frontier");
+    }
+    return Object.freeze({
+      localCursor,
+      localStateHash,
+      localCausalFrontier: requiredFrontier(resume.localCausalFrontier),
+      requireSnapshot
+    });
+  }
+  editableArtifactLiveModality(modality);
+  if (!("localNativeRevision" in resume)) {
+    throw invalidFrame("serialized resume requires a native revision");
+  }
+  const localNativeRevision = nullableNonnegativeInteger(
+    resume.localNativeRevision,
+    "localNativeRevision"
+  );
+  if (localCursor === null !== (localNativeRevision === null)) {
+    throw invalidFrame(
+      "serialized resume cursor and native revision must both be null or both be present"
+    );
+  }
+  return Object.freeze({
+    modality,
+    localCursor,
+    localStateHash,
+    localNativeRevision,
+    requireSnapshot
+  });
+}
+function requiredFrontier(value) {
+  if (!Array.isArray(value) || value.length > MAX_CAUSAL_ACTORS) {
+    throw invalidFrame("causal frontier exceeds bound");
+  }
+  return editableArtifactCausalFrontier(value);
+}
+function editableArtifactLiveModality(value) {
+  if (value !== "document" && value !== "spreadsheet" && value !== "presentation") {
+    throw invalidFrame("editable artifact modality is invalid");
+  }
+  return value;
+}
+function clientOpenModality(metadata) {
+  return metadata.modality === void 0 ? "spreadsheet" : editableArtifactLiveModality(metadata.modality);
+}
+function serverModality(metadata) {
+  return metadata.modality === void 0 ? "spreadsheet" : editableArtifactLiveModality(metadata.modality);
+}
+function transactionModality(transaction) {
+  return transaction.modality === void 0 ? "spreadsheet" : editableArtifactLiveModality(transaction.modality);
+}
+function requireExactKeys(record, expected) {
+  const keys = Object.keys(record);
+  if (keys.length !== expected.length || keys.some((key, index) => key !== expected[index])) {
+    throw invalidFrame("Editable artifact wire metadata fields are invalid or out of order");
+  }
+}
+function requireServerKeys(metadata, type, trailing) {
+  requireExactKeys(metadata, ["type", "protocolVersion", "artifactId", "streamEpoch", ...trailing]);
+  requireLiteral(metadata.type, type, "type");
+}
+function serverIdentity(metadata, type) {
+  return Object.freeze({
+    type,
+    protocolVersion: positiveInteger(metadata.protocolVersion, "protocolVersion"),
+    artifactId: editableArtifactId(requiredString(metadata.artifactId, "artifactId")),
+    streamEpoch: boundedString(
+      requiredString(metadata.streamEpoch, "streamEpoch"),
+      "streamEpoch",
+      MAX_IDENTIFIER_BYTES
+    )
+  });
+}
+function requiredRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw invalidFrame(`${label} must be an object`);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw invalidFrame(`${label} must be a plain object`);
+  }
+  return value;
+}
+function requiredString(value, label) {
+  if (typeof value !== "string") throw invalidFrame(`${label} must be a string`);
+  return value;
+}
+function requiredBoolean(value, label) {
+  if (typeof value !== "boolean") throw invalidFrame(`${label} must be boolean`);
+  return value;
+}
+function requireLiteral(value, expected, label) {
+  if (value !== expected) throw invalidFrame(`${label} must equal ${expected}`);
+}
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw invalidFrame(`${label} must be a positive safe integer`);
+  }
+  return value;
+}
+function nonnegativeInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw invalidFrame(`${label} must be a nonnegative safe integer`);
+  }
+  return value;
+}
+function nullableNonnegativeInteger(value, label) {
+  return value === null ? null : nonnegativeInteger(value, label);
+}
+function boundedString(value, label, maxBytes) {
+  const bytes = textEncoder.encode(value).byteLength;
+  if (bytes < 1 || bytes > maxBytes || value.trim() !== value) {
+    throw invalidFrame(`${label} is malformed`);
+  }
+  return value;
+}
+function boundedToken(value) {
+  const token = boundedString(value, "token", MAX_TOKEN_BYTES);
+  if (!/^[A-Za-z0-9._~-]+$/u.test(token)) throw invalidFrame("token is malformed");
+  return token;
+}
+function editableArtifactId(value) {
+  return stableId(value, "artifact id");
+}
+function editableArtifactTransactionId(value) {
+  return stableId(value, "server transaction id");
+}
+function editableArtifactClientTransactionId(value) {
+  if (!/^[A-Za-z0-9._:-]{1,200}$/u.test(value)) {
+    throw invalidFrame("clientTransactionId is malformed");
+  }
+  return value;
+}
+function editableArtifactRequestHash(value) {
+  return sha256Text(value, "request hash");
+}
+function editableArtifactStateHash(value) {
+  return sha256Text(value, "state hash");
+}
+function editableArtifactContentHash(value) {
+  return sha256Text(value, "content hash");
+}
+function stableId(value, label) {
+  if (!/^[0-9a-f]{32}$/u.test(value) || /^0{32}$/u.test(value)) {
+    throw invalidFrame(`${label} is malformed`);
+  }
+  return value;
+}
+function sha256Text(value, label) {
+  if (!/^sha256:[0-9a-f]{64}$/u.test(value)) {
+    throw invalidFrame(`${label} is malformed`);
+  }
+  return value;
+}
+function editableArtifactCausalFrontier(entries) {
+  const seen = /* @__PURE__ */ new Set();
+  const normalized = entries.map((entry, index) => {
+    const record = requiredRecord(entry, `causal frontier entry ${index}`);
+    requireExactKeys(record, ["replicaId", "counter"]);
+    const replicaId = requiredString(record.replicaId, "causal replicaId");
+    if (!/^[0-9a-f]{16}$/u.test(replicaId) || /^0{16}$/u.test(replicaId)) {
+      throw invalidFrame("causal replicaId is malformed");
+    }
+    const counter = positiveInteger(record.counter, "causal counter");
+    if (seen.has(replicaId)) throw invalidFrame("duplicate causal replicaId");
+    seen.add(replicaId);
+    return Object.freeze({ replicaId, counter });
+  });
+  normalized.sort(
+    (left, right) => left.replicaId < right.replicaId ? -1 : left.replicaId > right.replicaId ? 1 : 0
+  );
+  return Object.freeze(normalized);
+}
+function ownPayload(value, maxBytes, allowEmpty) {
+  if (!(value instanceof Uint8Array) || !allowEmpty && value.byteLength === 0 || value.byteLength > maxBytes) {
+    throw invalidFrame("Editable artifact wire payload exceeds bound");
+  }
+  return value.slice();
+}
+function requireNoPayload(payload) {
+  if (payload.byteLength !== 0) throw invalidFrame("Frame kind must not carry a binary payload");
+}
+function invalidFrame(message, cause) {
+  return new EditableArtifactLiveError("invalid_frame", message, {
+    ...cause ? { cause } : {}
+  });
+}
+var EMPTY_BYTES = new Uint8Array(0);
+export {
+  EDITABLE_ARTIFACT_LIVE_WIRE_VERSION,
+  EditableArtifactLiveError,
+  decodeEditableArtifactLiveClientWireFrame,
+  decodeEditableArtifactLiveServerWireFrame,
+  encodeEditableArtifactLiveAppliedWireFrame,
+  encodeEditableArtifactLiveMutationWireFrame,
+  encodeEditableArtifactLiveOpenWireFrame,
+  encodeEditableArtifactLiveServerWireFrame,
+  inspectEditableArtifactLiveWireEnvelope
+};
+//# sourceMappingURL=editable-artifact-live.js.map