@opengeni/core 0.21.10 → 0.24.1

package/dist/chunk-NYPMQ7NO.js

@@ -0,0 +1,2270 @@
+import {
+  EDITABLE_ARTIFACT_MAX_COMMITTED_TRANSACTION_BYTES,
+  assertIsoTimestamp,
+  assertNonnegativeSafeInteger,
+  assertPositiveSafeInteger,
+  editableArtifactActorKey,
+  editableArtifactCausalFrontier,
+  editableArtifactClientTransactionId,
+  editableArtifactId,
+  editableArtifactOutboxId,
+  editableArtifactRequestHash,
+  editableArtifactScope,
+  editableArtifactSnapshotId,
+  editableArtifactStateHash,
+  editableArtifactTransactionId,
+  validateEditableArtifactActor
+} from "./chunk-JJU6I5XD.js";
+
+// src/editable-artifact-live/application.ts
+import { EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES } from "@opengeni/contracts/editable-artifacts";
+var EditableArtifactCompatibilityError = class extends Error {
+  code = "unsupported_protocol";
+  constructor(message = "Editable artifact runtime is incompatible") {
+    super(message);
+    this.name = "EditableArtifactCompatibilityError";
+  }
+};
+var EditableArtifactApplication = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async createArtifact(input) {
+    const scope = editableArtifactScope(input.scope);
+    validateEditableArtifactActor(input.actor);
+    const result = await this.dependencies.domain.createArtifact({
+      scope,
+      actor: Object.freeze({ ...input.actor }),
+      request: {
+        idempotencyKey: editableArtifactClientTransactionId(input.idempotencyKey),
+        modality: input.modality,
+        title: input.title
+      },
+      ...input.signal ? { signal: input.signal } : {}
+    });
+    return result.artifact;
+  }
+  async importArtifact(input) {
+    const scope = editableArtifactScope(input.scope);
+    validateEditableArtifactActor(input.actor);
+    const result = await this.dependencies.domain.importArtifact({
+      scope,
+      actor: Object.freeze({ ...input.actor }),
+      request: {
+        idempotencyKey: editableArtifactClientTransactionId(input.idempotencyKey),
+        modality: input.modality,
+        title: input.title,
+        originalImport: input.originalImport,
+        snapshot: input.snapshot
+      },
+      ...input.signal ? { signal: input.signal } : {}
+    });
+    return result.artifact;
+  }
+  async readArtifact(input) {
+    const scope = editableArtifactScope(input.scope);
+    const artifactId = editableArtifactId(input.artifactId);
+    validateEditableArtifactActor(input.actor);
+    return await this.dependencies.domain.getArtifact({
+      scope,
+      artifactId,
+      actor: Object.freeze({ ...input.actor })
+    });
+  }
+  async mintLiveTicket(input) {
+    const artifact = await this.readArtifact(input);
+    await this.dependencies.compatibility.assertCompatible({
+      artifact,
+      protocolVersion: positiveInteger(input.protocolVersion, "protocolVersion"),
+      kernelVersion: boundedVersion(input.kernelVersion, "kernelVersion"),
+      modelSchemaVersion: positiveInteger(input.modelSchemaVersion, "modelSchemaVersion")
+    });
+    return await this.dependencies.live.mintTicket({
+      scope: artifact.scope,
+      artifactId: artifact.id,
+      modality: artifact.modality,
+      actor: input.actor,
+      allowEdit: input.allowEdit
+    });
+  }
+  openLive(input) {
+    return this.dependencies.live.openLive(input);
+  }
+};
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError(`${label} must be a positive safe integer`);
+  }
+  return value;
+}
+function boundedVersion(value, label) {
+  const bytes = new TextEncoder().encode(value).byteLength;
+  if (bytes < 1 || bytes > EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES || value.trim() !== value) {
+    throw new TypeError(`${label} is malformed`);
+  }
+  return value;
+}
+
+// src/editable-artifact-live/errors.ts
+import {
+  EditableArtifactLiveError
+} from "@opengeni/contracts/editable-artifact-live";
+
+// src/editable-artifact-live/outbox-dispatcher.ts
+var textEncoder = new TextEncoder();
+var EDITABLE_ARTIFACT_HINT_MAX_BYTES = 16 * 1024;
+var EDITABLE_ARTIFACT_HINT_SUBJECT_PREFIX = "editable_artifacts.v1";
+var DEFAULTS = Object.freeze({
+  batchSize: 32,
+  concurrency: 8,
+  leaseDurationMs: 3e4,
+  leaseRenewIntervalMs: 1e4,
+  pollIntervalMs: 500,
+  publishTimeoutMs: 5e3,
+  retryBaseMs: 500,
+  retryMaxMs: 6e4,
+  retryJitterRatio: 0.2,
+  claimBackoffBaseMs: 500,
+  claimBackoffMaxMs: 3e4,
+  maxHintBytes: EDITABLE_ARTIFACT_HINT_MAX_BYTES
+});
+var EditableArtifactLiveOutboxDispatcher = class {
+  constructor(dependencies, options) {
+    this.dependencies = dependencies;
+    this.options = normalizeOptions(options);
+  }
+  options;
+  activeDispatch = null;
+  /**
+   * Long-running resilient loop. Abort stops new claims; an already-claimed
+   * bounded batch drains before this promise resolves.
+   */
+  async run(signal) {
+    let consecutiveClaimFailures = 0;
+    while (!signal.aborted) {
+      const summary = await this.dispatchOnce();
+      if (summary.claimFailed) consecutiveClaimFailures += 1;
+      else consecutiveClaimFailures = 0;
+      if (signal.aborted) break;
+      const delay = summary.claimFailed ? exponentialDelay(
+        consecutiveClaimFailures,
+        this.options.claimBackoffBaseMs,
+        this.options.claimBackoffMaxMs,
+        this.options.retryJitterRatio,
+        this.dependencies.random
+      ) : summary.claimed === 0 ? this.options.pollIntervalMs : 0;
+      if (delay > 0 && !await sleepUntilNextPoll(this.dependencies.scheduler, delay, signal)) {
+        break;
+      }
+    }
+    await this.drain();
+  }
+  /** Concurrent callers share one bounded claim/dispatch pass. */
+  dispatchOnce() {
+    if (this.activeDispatch) return this.activeDispatch;
+    const dispatch = this.dispatchBatch();
+    this.activeDispatch = dispatch;
+    void dispatch.then(
+      () => {
+        if (this.activeDispatch === dispatch) this.activeDispatch = null;
+      },
+      () => {
+        if (this.activeDispatch === dispatch) this.activeDispatch = null;
+      }
+    );
+    return dispatch;
+  }
+  async drain() {
+    await this.activeDispatch;
+  }
+  async dispatchBatch() {
+    const summary = mutableSummary();
+    let records;
+    try {
+      records = await this.dependencies.store.claimLiveOutbox({
+        owner: this.options.owner,
+        leaseDurationMs: this.options.leaseDurationMs,
+        limit: this.options.batchSize
+      });
+      if (!Array.isArray(records) || records.length > this.options.batchSize) {
+        throw new TypeError("Outbox store returned an invalid claim batch");
+      }
+    } catch (error) {
+      summary.claimFailed = true;
+      this.metric("claim_failed");
+      this.warn("Editable artifact outbox claim failed", "claim_failed", error);
+      return freezeSummary(summary);
+    }
+    summary.claimed = records.length;
+    if (records.length > 0) this.metric("claimed", records.length);
+    let cursor = 0;
+    const worker = async () => {
+      for (; ; ) {
+        const index = cursor;
+        cursor += 1;
+        const record = records[index];
+        if (!record) return;
+        await this.dispatchRecord(record, summary);
+      }
+    };
+    await Promise.all(
+      Array.from(
+        { length: Math.min(records.length, this.options.concurrency) },
+        async () => await worker()
+      )
+    );
+    return freezeSummary(summary);
+  }
+  async dispatchRecord(record, summary) {
+    let outboxId;
+    try {
+      outboxId = validateClaimedRecord(record, this.options.owner);
+    } catch (error) {
+      await this.deadLetter(record, "invalid_hint", summary, error);
+      return;
+    }
+    let encoded;
+    try {
+      encoded = encodeEditableArtifactBrokerHint(record, this.options.maxHintBytes);
+    } catch (error) {
+      await this.deadLetter(
+        record,
+        error instanceof EditableArtifactHintEncodingError && error.code === "oversized_hint" ? "oversized_hint" : "invalid_hint",
+        summary,
+        error
+      );
+      return;
+    }
+    const publishAbort = new AbortController();
+    const renewalAbort = new AbortController();
+    let leaseLost = false;
+    const renewal = this.renewWhilePublishing(record, renewalAbort.signal, publishAbort, () => {
+      leaseLost = true;
+    }).catch((error) => {
+      leaseLost = true;
+      publishAbort.abort();
+      this.warn("Editable artifact outbox renewal loop failed", "lease_lost", error);
+    });
+    let publishError = null;
+    let timedOut = false;
+    const startedAt = this.dependencies.clock.now().getTime();
+    try {
+      await withTimeout(
+        this.dependencies.broker.publish({
+          subject: encoded.subject,
+          payload: encoded.payload.slice(),
+          signal: publishAbort.signal
+        }),
+        this.options.publishTimeoutMs,
+        this.dependencies.scheduler,
+        publishAbort,
+        () => {
+          timedOut = true;
+        }
+      );
+    } catch (error) {
+      publishError = error;
+    } finally {
+      renewalAbort.abort();
+      await renewal;
+      this.observePublish(timedOut ? "timed_out" : publishError ? "failed" : "acked", startedAt);
+    }
+    if (leaseLost) {
+      summary.leaseLost += 1;
+      this.metric("lease_lost");
+      return;
+    }
+    if (publishError) {
+      const errorCode = timedOut ? "publish_timeout" : brokerErrorCode(publishError);
+      await this.retry(record, errorCode, summary, publishError);
+      return;
+    }
+    try {
+      await this.dependencies.store.renewLiveOutbox({
+        outboxId,
+        owner: this.options.owner,
+        attemptCount: record.attemptCount,
+        leaseDurationMs: this.options.leaseDurationMs
+      });
+    } catch (error) {
+      summary.leaseLost += 1;
+      this.metric("lease_lost");
+      this.warn("Editable artifact outbox lease was lost after broker ACK", "lease_lost", error);
+      return;
+    }
+    try {
+      await this.dependencies.store.markLiveOutboxPublished({
+        outboxId,
+        owner: this.options.owner,
+        attemptCount: record.attemptCount
+      });
+      summary.published += 1;
+      this.metric("published");
+    } catch (error) {
+      summary.markFailed += 1;
+      this.metric("mark_failed");
+      this.warn("Editable artifact outbox publish mark failed", "mark_failed", error);
+    }
+  }
+  async renewWhilePublishing(record, signal, publishAbort, onLeaseLost) {
+    for (; ; ) {
+      if (!await sleepUntilNextPoll(
+        this.dependencies.scheduler,
+        this.options.leaseRenewIntervalMs,
+        signal
+      )) {
+        return;
+      }
+      try {
+        await this.dependencies.store.renewLiveOutbox({
+          outboxId: editableArtifactOutboxId(record.outboxId),
+          owner: this.options.owner,
+          attemptCount: record.attemptCount,
+          leaseDurationMs: this.options.leaseDurationMs
+        });
+      } catch (error) {
+        onLeaseLost();
+        publishAbort.abort();
+        this.warn("Editable artifact outbox lease renewal failed", "lease_lost", error);
+        return;
+      }
+    }
+  }
+  async retry(record, errorCode, summary, error) {
+    const retryDelayMs = exponentialDelay(
+      record.attemptCount,
+      this.options.retryBaseMs,
+      this.options.retryMaxMs,
+      this.options.retryJitterRatio,
+      this.dependencies.random
+    );
+    try {
+      await this.dependencies.store.retryLiveOutbox({
+        outboxId: editableArtifactOutboxId(record.outboxId),
+        owner: this.options.owner,
+        attemptCount: record.attemptCount,
+        retryDelayMs,
+        errorCode
+      });
+      summary.retried += 1;
+      this.metric("retried");
+    } catch (retryError) {
+      this.metric("retry_store_failed");
+      this.warn(
+        "Editable artifact outbox retry persistence failed",
+        "retry_store_failed",
+        retryError
+      );
+    }
+    this.warn("Editable artifact hint publish failed", errorCode, error);
+  }
+  async deadLetter(record, errorCode, summary, error) {
+    try {
+      await this.dependencies.store.deadLetterLiveOutbox({
+        outboxId: editableArtifactOutboxId(record.outboxId),
+        owner: this.options.owner,
+        attemptCount: record.attemptCount,
+        errorCode
+      });
+      summary.deadLettered += 1;
+      this.metric("dead_lettered");
+    } catch (deadLetterError) {
+      this.metric("dead_letter_store_failed");
+      this.warn(
+        "Editable artifact outbox dead-letter persistence failed",
+        "dead_letter_store_failed",
+        deadLetterError
+      );
+    }
+    this.warn("Editable artifact outbox contains an undeliverable hint", errorCode, error);
+  }
+  metric(outcome, count = 1) {
+    try {
+      this.dependencies.metrics?.increment(outcome, count);
+    } catch {
+    }
+  }
+  observePublish(outcome, startedAt) {
+    let elapsed = 0;
+    const now = this.dependencies.clock.now().getTime();
+    if (Number.isFinite(now) && Number.isFinite(startedAt)) elapsed = Math.max(0, now - startedAt);
+    try {
+      this.dependencies.metrics?.observePublishSeconds(outcome, elapsed / 1e3);
+    } catch {
+    }
+  }
+  warn(message, code, error) {
+    try {
+      this.dependencies.logger?.warn(message, {
+        code,
+        errorClass: error instanceof Error ? error.name : "UnknownError"
+      });
+    } catch {
+    }
+  }
+};
+var EditableArtifactHintEncodingError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "EditableArtifactHintEncodingError";
+  }
+};
+function encodeEditableArtifactBrokerHint(record, maxBytes = EDITABLE_ARTIFACT_HINT_MAX_BYTES) {
+  assertPositiveSafeInteger(maxBytes, "maximum broker hint bytes");
+  let hint;
+  try {
+    const event = record.event;
+    const scope = editableArtifactScope(event.scope);
+    const artifactId = editableArtifactId(event.artifactId);
+    const stateHash = editableArtifactStateHash(event.stateHash);
+    if (event.schemaVersion !== 1) throw new TypeError("Unsupported artifact hint schema");
+    if (event.kind === "transaction_committed") {
+      assertPositiveSafeInteger(event.sequenceEnd, "hint head sequence");
+      const common = {
+        kind: "head_advanced",
+        schemaVersion: 1,
+        scope,
+        artifactId,
+        modality: event.modality,
+        headSequence: event.sequenceEnd,
+        stateHash
+      };
+      if (event.modality === "spreadsheet") {
+        assertPositiveSafeInteger(
+          event.operationProtocolVersion,
+          "hint operation protocol version"
+        );
+        hint = Object.freeze({
+          ...common,
+          modality: "spreadsheet",
+          operationProtocolVersion: event.operationProtocolVersion
+        });
+      } else {
+        assertPositiveSafeInteger(event.commitProtocolVersion, "hint commit protocol version");
+        hint = Object.freeze({
+          ...common,
+          modality: event.modality,
+          commitProtocolVersion: event.commitProtocolVersion
+        });
+      }
+    } else if (event.kind === "snapshot_published") {
+      assertNonnegativeSafeInteger(event.coveredHeadSequence, "snapshot hint head sequence");
+      const common = {
+        kind: "snapshot_available",
+        schemaVersion: 1,
+        scope,
+        artifactId,
+        modality: event.modality,
+        headSequence: event.coveredHeadSequence,
+        stateHash,
+        snapshotId: editableArtifactSnapshotId(event.snapshotId)
+      };
+      if (event.modality === "spreadsheet") {
+        assertPositiveSafeInteger(
+          event.operationProtocolVersion,
+          "hint operation protocol version"
+        );
+        hint = Object.freeze({
+          ...common,
+          modality: "spreadsheet",
+          operationProtocolVersion: event.operationProtocolVersion
+        });
+      } else {
+        hint = Object.freeze({ ...common, modality: event.modality });
+      }
+    } else {
+      throw new TypeError("Unknown editable artifact outbox event");
+    }
+    const payload = textEncoder.encode(JSON.stringify(hint));
+    if (payload.byteLength > maxBytes) {
+      throw new EditableArtifactHintEncodingError(
+        "oversized_hint",
+        "Editable artifact broker hint exceeds its byte limit"
+      );
+    }
+    return Object.freeze({
+      subject: editableArtifactLiveHintSubject(scope, artifactId),
+      payload,
+      hint
+    });
+  } catch (error) {
+    if (error instanceof EditableArtifactHintEncodingError) throw error;
+    throw new EditableArtifactHintEncodingError(
+      "invalid_hint",
+      "Editable artifact outbox event cannot be projected to a broker hint"
+    );
+  }
+}
+function editableArtifactLiveHintSubject(scope, artifactIdInput) {
+  const normalized = editableArtifactScope(scope);
+  const artifactId = editableArtifactId(artifactIdInput);
+  const subject = [
+    EDITABLE_ARTIFACT_HINT_SUBJECT_PREFIX,
+    base64Url(textEncoder.encode(normalized.accountId)),
+    base64Url(textEncoder.encode(normalized.workspaceId)),
+    artifactId
+  ].join(".");
+  if (textEncoder.encode(subject).byteLength > 1024) {
+    throw new EditableArtifactHintEncodingError(
+      "invalid_hint",
+      "Editable artifact hint subject exceeds its byte limit"
+    );
+  }
+  return subject;
+}
+function decodeEditableArtifactBrokerHint(payload, expected, maxBytes = EDITABLE_ARTIFACT_HINT_MAX_BYTES) {
+  if (!(payload instanceof Uint8Array) || payload.byteLength < 2 || payload.byteLength > maxBytes) {
+    throw new EditableArtifactHintEncodingError(
+      "oversized_hint",
+      "Editable artifact broker hint exceeds its byte limit"
+    );
+  }
+  try {
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(payload);
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+      throw new TypeError("hint must be an object");
+    }
+    const record = value;
+    if (JSON.stringify(record) !== text) throw new TypeError("hint must be canonical JSON");
+    const kind = record.kind;
+    const modality = record.modality;
+    if (modality !== "spreadsheet" && modality !== "document" && modality !== "presentation") {
+      throw new TypeError("hint modality invalid");
+    }
+    const keys = Object.keys(record);
+    const expectedKeys = kind === "head_advanced" ? modality === "spreadsheet" ? [
+      "kind",
+      "schemaVersion",
+      "scope",
+      "artifactId",
+      "modality",
+      "headSequence",
+      "stateHash",
+      "operationProtocolVersion"
+    ] : [
+      "kind",
+      "schemaVersion",
+      "scope",
+      "artifactId",
+      "modality",
+      "headSequence",
+      "stateHash",
+      "commitProtocolVersion"
+    ] : modality === "spreadsheet" ? [
+      "kind",
+      "schemaVersion",
+      "scope",
+      "artifactId",
+      "modality",
+      "headSequence",
+      "stateHash",
+      "snapshotId",
+      "operationProtocolVersion"
+    ] : [
+      "kind",
+      "schemaVersion",
+      "scope",
+      "artifactId",
+      "modality",
+      "headSequence",
+      "stateHash",
+      "snapshotId"
+    ];
+    if (keys.length !== expectedKeys.length || keys.some((key, index) => key !== expectedKeys[index])) {
+      throw new TypeError("hint fields invalid");
+    }
+    if (record.schemaVersion !== 1) throw new TypeError("hint schema invalid");
+    const scope = editableArtifactScope(record.scope);
+    const artifactId = editableArtifactId(record.artifactId);
+    if (scope.accountId !== expected.scope.accountId || scope.workspaceId !== expected.scope.workspaceId || artifactId !== editableArtifactId(expected.artifactId)) {
+      throw new TypeError("hint authority mismatch");
+    }
+    assertNonnegativeSafeInteger(record.headSequence, "hint head sequence");
+    if (modality === "spreadsheet") {
+      assertPositiveSafeInteger(
+        record.operationProtocolVersion,
+        "hint operation protocol version"
+      );
+    } else if (kind === "head_advanced") {
+      assertPositiveSafeInteger(
+        record.commitProtocolVersion,
+        "hint commit protocol version"
+      );
+    }
+    editableArtifactStateHash(record.stateHash);
+    if (kind === "head_advanced") return Object.freeze(record);
+    if (kind === "snapshot_available") {
+      editableArtifactSnapshotId(record.snapshotId);
+      return Object.freeze(record);
+    }
+    throw new TypeError("hint kind invalid");
+  } catch (error) {
+    if (error instanceof EditableArtifactHintEncodingError) throw error;
+    throw new EditableArtifactHintEncodingError(
+      "invalid_hint",
+      "Editable artifact broker hint is invalid"
+    );
+  }
+}
+var MathEditableArtifactOutboxRandom = class {
+  unit() {
+    return Math.random();
+  }
+};
+function validateClaimedRecord(record, owner) {
+  const outboxId = editableArtifactOutboxId(record.outboxId);
+  if (record.state !== "publishing") throw new TypeError("Claimed outbox row is not publishing");
+  if (record.leaseOwner !== owner) throw new TypeError("Claimed outbox row has another owner");
+  assertPositiveSafeInteger(record.attemptCount, "outbox attempt count");
+  if (record.leaseExpiresAt === null) throw new TypeError("Claimed outbox row has no lease expiry");
+  return outboxId;
+}
+function normalizeOptions(options) {
+  const owner = boundedOwner(options.owner);
+  const normalized = {
+    owner,
+    batchSize: options.batchSize ?? DEFAULTS.batchSize,
+    concurrency: options.concurrency ?? DEFAULTS.concurrency,
+    leaseDurationMs: options.leaseDurationMs ?? DEFAULTS.leaseDurationMs,
+    leaseRenewIntervalMs: options.leaseRenewIntervalMs ?? DEFAULTS.leaseRenewIntervalMs,
+    pollIntervalMs: options.pollIntervalMs ?? DEFAULTS.pollIntervalMs,
+    publishTimeoutMs: options.publishTimeoutMs ?? DEFAULTS.publishTimeoutMs,
+    retryBaseMs: options.retryBaseMs ?? DEFAULTS.retryBaseMs,
+    retryMaxMs: options.retryMaxMs ?? DEFAULTS.retryMaxMs,
+    retryJitterRatio: options.retryJitterRatio ?? DEFAULTS.retryJitterRatio,
+    claimBackoffBaseMs: options.claimBackoffBaseMs ?? DEFAULTS.claimBackoffBaseMs,
+    claimBackoffMaxMs: options.claimBackoffMaxMs ?? DEFAULTS.claimBackoffMaxMs,
+    maxHintBytes: options.maxHintBytes ?? DEFAULTS.maxHintBytes
+  };
+  for (const [label, value] of Object.entries(normalized)) {
+    if (label === "owner" || label === "retryJitterRatio") continue;
+    if (typeof value !== "number") throw new TypeError(`${label} must be numeric`);
+    assertPositiveSafeInteger(value, label);
+  }
+  if (normalized.batchSize > 256) throw new TypeError("outbox batch size exceeds 256");
+  if (normalized.concurrency > normalized.batchSize)
+    throw new TypeError("outbox concurrency exceeds batch size");
+  if (normalized.leaseDurationMs < 5e3 || normalized.leaseDurationMs > 3e5)
+    throw new TypeError("outbox lease duration must be 5-300 seconds");
+  if (normalized.leaseRenewIntervalMs * 2 >= normalized.leaseDurationMs)
+    throw new TypeError("outbox lease renewal interval must be less than half the lease");
+  if (normalized.publishTimeoutMs >= normalized.leaseDurationMs)
+    throw new TypeError("outbox publish timeout must be shorter than the lease");
+  if (normalized.retryBaseMs > normalized.retryMaxMs)
+    throw new TypeError("outbox retry base exceeds retry maximum");
+  if (normalized.claimBackoffBaseMs > normalized.claimBackoffMaxMs)
+    throw new TypeError("outbox claim backoff base exceeds its maximum");
+  if (!Number.isFinite(normalized.retryJitterRatio) || normalized.retryJitterRatio < 0 || normalized.retryJitterRatio > 1) {
+    throw new TypeError("outbox retry jitter ratio must be between zero and one");
+  }
+  if (normalized.maxHintBytes > EDITABLE_ARTIFACT_HINT_MAX_BYTES)
+    throw new TypeError("outbox hint byte limit exceeds the protocol maximum");
+  return Object.freeze(normalized);
+}
+function boundedOwner(value) {
+  const bytes = textEncoder.encode(value).byteLength;
+  if (bytes < 1 || bytes > 200 || value.trim() !== value || !/^[A-Za-z0-9._:-]+$/u.test(value)) {
+    throw new TypeError("outbox owner is malformed");
+  }
+  return value;
+}
+function exponentialDelay(attempt, base, maximum, jitterRatio, random) {
+  const exponent = Math.min(30, Math.max(0, attempt - 1));
+  const withoutJitter = Math.min(maximum, base * 2 ** exponent);
+  const sample = random.unit();
+  const unit = Number.isFinite(sample) && sample >= 0 && sample < 1 ? sample : 0.5;
+  const jitter = Math.floor(withoutJitter * jitterRatio * unit);
+  return Math.min(maximum, withoutJitter + jitter);
+}
+async function withTimeout(operation, timeoutMs, scheduler, operationAbort, onTimeout) {
+  const timeoutAbort = new AbortController();
+  try {
+    await Promise.race([
+      operation,
+      scheduler.sleep(timeoutMs, timeoutAbort.signal).then(() => {
+        onTimeout();
+        operationAbort.abort();
+        throw new Error("Editable artifact broker publish timed out");
+      })
+    ]);
+  } finally {
+    timeoutAbort.abort();
+  }
+}
+async function sleepUntilNextPoll(scheduler, milliseconds, signal) {
+  try {
+    await scheduler.sleep(milliseconds, signal);
+    return true;
+  } catch (error) {
+    if (signal.aborted) return false;
+    throw error;
+  }
+}
+function brokerErrorCode(error) {
+  if (typeof error === "object" && error !== null && "code" in error && error.code === "broker_backpressure") {
+    return "broker_backpressure";
+  }
+  return "broker_unavailable";
+}
+function mutableSummary() {
+  return {
+    claimed: 0,
+    published: 0,
+    retried: 0,
+    deadLettered: 0,
+    leaseLost: 0,
+    markFailed: 0,
+    claimFailed: false
+  };
+}
+function freezeSummary(summary) {
+  return Object.freeze({ ...summary });
+}
+function base64Url(bytes) {
+  let binary = "";
+  for (const byte of bytes) binary += String.fromCharCode(byte);
+  return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+}
+
+// src/editable-artifact-live/server.ts
+import {
+  EDITABLE_ARTIFACT_COMMAND_MAX_BYTES,
+  EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
+  EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES as EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES2,
+  EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES
+} from "@opengeni/contracts/editable-artifacts";
+import { decodeCommittedTransactionSummary } from "@opengeni/contracts/editable-artifact-committed-transaction";
+import { decodeEditableArtifactSerializedCommit } from "@opengeni/contracts/editable-artifact-serialized-commit";
+
+// src/editable-artifact-live/types.ts
+var EDITABLE_ARTIFACT_LIVE_PROTOCOL_VERSION = 1;
+
+// src/editable-artifact-live/ticket.ts
+var DEFAULT_TTL_MS = 3e4;
+var MAX_TTL_MS = 6e4;
+var MAX_TOKEN_BYTES = 4096;
+var EditableArtifactLiveTicketAuthority = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+    this.ttlMs = dependencies.ttlMs ?? DEFAULT_TTL_MS;
+    if (!Number.isSafeInteger(this.ttlMs) || this.ttlMs < 1e3 || this.ttlMs > MAX_TTL_MS) {
+      throw new TypeError(`ticket ttl must be 1000-${MAX_TTL_MS} milliseconds`);
+    }
+    this.protocolVersion = dependencies.protocolVersion ?? EDITABLE_ARTIFACT_LIVE_PROTOCOL_VERSION;
+    if (!Number.isSafeInteger(this.protocolVersion) || this.protocolVersion < 1) {
+      throw new TypeError("protocol version must be a positive safe integer");
+    }
+  }
+  ttlMs;
+  protocolVersion;
+  async mint(input) {
+    const scope = editableArtifactScope(input.scope);
+    const artifactId = editableArtifactId(input.artifactId);
+    const modality = assertModality(input.modality);
+    validateEditableArtifactActor(input.actor);
+    if (typeof input.allowEdit !== "boolean") {
+      throw new TypeError("ticket allowEdit must be boolean");
+    }
+    const actor = Object.freeze({ ...input.actor });
+    const decision = await this.dependencies.authorization.authorize({
+      scope,
+      artifactId,
+      actor,
+      permission: "read"
+    });
+    if (!decision.allowed) {
+      throw new EditableArtifactLiveError(
+        "permission_changed",
+        "Editable artifact read permission denied"
+      );
+    }
+    const token = this.dependencies.tokens.randomOpaqueToken();
+    assertToken(token);
+    const tokenDigest = await this.dependencies.tokens.digestOpaqueToken(token);
+    assertDigest(tokenDigest);
+    const issuedAtDate = this.dependencies.clock.now();
+    if (!Number.isFinite(issuedAtDate.getTime()))
+      throw new TypeError("clock returned an invalid date");
+    const issuedAt = issuedAtDate.toISOString();
+    const expiresAt = new Date(issuedAtDate.getTime() + this.ttlMs).toISOString();
+    const record = Object.freeze({
+      tokenDigest,
+      scope,
+      artifactId,
+      modality,
+      actor,
+      allowEdit: input.allowEdit,
+      protocolVersion: this.protocolVersion,
+      issuedAt,
+      expiresAt
+    });
+    await this.dependencies.tickets.put(record);
+    return Object.freeze({
+      artifactId,
+      modality,
+      replicaId: actor.replicaId,
+      token,
+      expiresAt,
+      protocolVersion: this.protocolVersion
+    });
+  }
+  async consume(input) {
+    assertToken(input.token);
+    const artifactId = editableArtifactId(input.artifactId);
+    const digest = await this.dependencies.tokens.digestOpaqueToken(input.token);
+    assertDigest(digest);
+    const record = await this.dependencies.tickets.consume(digest);
+    if (!record) {
+      throw new EditableArtifactLiveError(
+        "ticket_replayed",
+        "Live ticket is invalid or was already consumed"
+      );
+    }
+    validateTicketRecord(record);
+    if (Date.parse(record.expiresAt) <= this.dependencies.clock.now().getTime()) {
+      throw new EditableArtifactLiveError("ticket_expired", "Live ticket has expired", {
+        retryable: true
+      });
+    }
+    if (record.artifactId !== artifactId) {
+      throw new EditableArtifactLiveError("invalid_ticket", "Live ticket scope does not match");
+    }
+    if (record.protocolVersion !== input.protocolVersion || input.protocolVersion !== this.protocolVersion) {
+      throw new EditableArtifactLiveError(
+        "protocol_mismatch",
+        "Editable artifact live protocol is unsupported"
+      );
+    }
+    return Object.freeze({
+      ...record,
+      scope: editableArtifactScope(record.scope),
+      actor: Object.freeze({ ...record.actor })
+    });
+  }
+};
+var InMemoryEditableArtifactLiveTicketStore = class {
+  records = /* @__PURE__ */ new Map();
+  async put(record) {
+    if (this.records.has(record.tokenDigest)) throw new Error("Live ticket digest collision");
+    this.records.set(record.tokenDigest, record);
+  }
+  async consume(tokenDigest) {
+    const record = this.records.get(tokenDigest) ?? null;
+    if (record) this.records.delete(tokenDigest);
+    return record;
+  }
+};
+var WebCryptoEditableArtifactLiveTokens = class {
+  randomOpaqueToken() {
+    const bytes = crypto.getRandomValues(new Uint8Array(32));
+    let binary = "";
+    for (const byte of bytes) binary += String.fromCharCode(byte);
+    return btoa(binary).replaceAll("+", "-").replaceAll("/", "_").replace(/=+$/u, "");
+  }
+  async digestOpaqueToken(token) {
+    const digest = new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(token))
+    );
+    return `sha256:${[...digest].map((byte) => byte.toString(16).padStart(2, "0")).join("")}`;
+  }
+};
+function validateTicketRecord(record) {
+  assertDigest(record.tokenDigest);
+  editableArtifactScope(record.scope);
+  editableArtifactId(record.artifactId);
+  assertModality(record.modality);
+  validateEditableArtifactActor(record.actor);
+  if (typeof record.allowEdit !== "boolean") {
+    throw new TypeError("ticket allowEdit is invalid");
+  }
+  assertIsoTimestamp(record.issuedAt, "ticket issuedAt");
+  assertIsoTimestamp(record.expiresAt, "ticket expiresAt");
+}
+function assertModality(value) {
+  if (value !== "document" && value !== "spreadsheet" && value !== "presentation") {
+    throw new TypeError("ticket modality is invalid");
+  }
+  return value;
+}
+function assertToken(token) {
+  const bytes = new TextEncoder().encode(token).byteLength;
+  if (bytes < 32 || bytes > MAX_TOKEN_BYTES || !/^[A-Za-z0-9._~-]+$/u.test(token)) {
+    throw new EditableArtifactLiveError("invalid_ticket", "Live ticket is malformed");
+  }
+}
+function assertDigest(value) {
+  if (!/^sha256:[0-9a-f]{64}$/u.test(value)) throw new TypeError("ticket digest is malformed");
+}
+
+// src/editable-artifact-live/server.ts
+var textEncoder2 = new TextEncoder();
+var strictDecoder = new TextDecoder("utf-8", { fatal: true });
+var DEFAULT_MAX_CLIENT_FRAME_BYTES = 5 * 1024 * 1024 + 64 * 1024;
+var DEFAULT_MAX_OUTBOUND_FRAME_BYTES = 8 * 1024 * 1024 + 64 * 1024;
+var DEFAULT_MAX_SNAPSHOT_BYTES = EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES;
+var DEFAULT_SNAPSHOT_CHUNK_BYTES = 256 * 1024;
+var DEFAULT_MAX_IN_FLIGHT_TRANSACTIONS = 256;
+var DEFAULT_MAX_IN_FLIGHT_BYTES = 32 * 1024 * 1024;
+var DEFAULT_REPLAY_PAGE_TRANSACTIONS = 256;
+var DEFAULT_REPLAY_PAGE_BYTES = 32 * 1024 * 1024;
+var DEFAULT_MAX_SOCKET_BUFFERED_BYTES = 16 * 1024 * 1024;
+var DEFAULT_MAX_INBOUND_QUEUE_FRAMES = 64;
+var DEFAULT_MAX_INBOUND_QUEUE_BYTES = 12 * 1024 * 1024;
+var DEFAULT_RECONCILE_INTERVAL_MS = 5e3;
+var DEFAULT_REAUTHORIZE_INTERVAL_MS = 15e3;
+var DEFAULT_ACK_TIMEOUT_MS = 3e4;
+var DEFAULT_SEND_TIMEOUT_MS = 1e4;
+var MAX_IDENTIFIER_BYTES = 512;
+var MAX_CAUSAL_ACTORS = 1024;
+var EditableArtifactLiveServer = class {
+  constructor(dependencies, options = {}) {
+    this.dependencies = dependencies;
+    this.options = normalizeOptions2(options);
+    this.ticketAuthority = new EditableArtifactLiveTicketAuthority({
+      authorization: dependencies.authorization,
+      tickets: dependencies.tickets,
+      tokens: dependencies.tokens,
+      clock: dependencies.clock,
+      protocolVersion: this.options.protocolVersion,
+      ...this.options.ticketTtlMs === void 0 ? {} : { ttlMs: this.options.ticketTtlMs }
+    });
+  }
+  options;
+  ticketAuthority;
+  mintTicket(input) {
+    return this.ticketAuthority.mint(input);
+  }
+  async openLive(input) {
+    const artifactId = editableArtifactId(input.artifactId);
+    const ticket = await this.ticketAuthority.consume({
+      token: input.token,
+      artifactId,
+      protocolVersion: input.protocolVersion
+    });
+    validateResume(input.resume, ticket.modality);
+    const streamEpoch = `live_${this.dependencies.tokens.randomOpaqueToken()}`;
+    boundedString(streamEpoch, "stream epoch", MAX_IDENTIFIER_BYTES);
+    const session = new EditableArtifactLiveSessionImpl({
+      dependencies: this.dependencies,
+      options: this.options,
+      ticket,
+      streamEpoch,
+      resume: input.resume,
+      sink: input.sink,
+      ...input.signal === void 0 ? {} : { parentSignal: input.signal }
+    });
+    await session.start();
+    return session;
+  }
+};
+var EditableArtifactLiveSessionImpl = class {
+  artifactId;
+  modality;
+  streamEpoch;
+  closed;
+  dependencies;
+  options;
+  ticket;
+  resume;
+  sink;
+  abort = new AbortController();
+  boundaries = /* @__PURE__ */ new Map();
+  inFlight = /* @__PURE__ */ new Map();
+  resolveClosed;
+  workTail = Promise.resolve();
+  releaseHints = null;
+  releaseInvalidations = null;
+  detachParent = null;
+  maintenance = null;
+  closedValue = null;
+  bootstrapping = true;
+  reconcileRequested = false;
+  reconcileScheduled = false;
+  reauthorizationRequested = false;
+  reauthorizationScheduled = false;
+  sentSequence = 0;
+  sentStateHash = null;
+  ackedSequence = 0;
+  ackedStateHash = null;
+  targetHead = 0;
+  inFlightBytes = 0;
+  oldestInFlightAt = 0;
+  writable = false;
+  authorizationRevision = 0;
+  queuedInboundFrames = 0;
+  queuedInboundBytes = 0;
+  constructor(input) {
+    this.dependencies = input.dependencies;
+    this.options = input.options;
+    this.ticket = input.ticket;
+    this.artifactId = input.ticket.artifactId;
+    this.modality = input.ticket.modality;
+    this.streamEpoch = input.streamEpoch;
+    this.resume = input.resume;
+    this.sink = input.sink;
+    this.closed = new Promise((resolve) => {
+      this.resolveClosed = resolve;
+    });
+    if (input.parentSignal) {
+      const close = () => void this.close("closed");
+      if (input.parentSignal.aborted) close();
+      else {
+        input.parentSignal.addEventListener("abort", close, { once: true });
+        this.detachParent = () => input.parentSignal.removeEventListener("abort", close);
+      }
+    }
+  }
+  async start() {
+    try {
+      this.assertOpen();
+      this.authorizationRevision = await this.requireRead();
+      this.assertOpen();
+      const releaseHints = await this.dependencies.hints.subscribe({
+        scope: this.ticket.scope,
+        artifactId: this.artifactId,
+        onHint: () => this.requestReconcile(),
+        onReconnect: () => this.requestReconcile()
+      });
+      if (this.closedValue) {
+        safeRelease(releaseHints);
+        this.assertOpen();
+      }
+      this.releaseHints = releaseHints;
+      const releaseInvalidations = await this.dependencies.invalidations.subscribe({
+        scope: this.ticket.scope,
+        artifactId: this.artifactId,
+        actor: this.ticket.actor,
+        onInvalidated: () => this.requestReauthorization()
+      });
+      if (this.closedValue) {
+        safeRelease(releaseInvalidations);
+        this.assertOpen();
+      }
+      this.releaseInvalidations = releaseInvalidations;
+      this.authorizationRevision = Math.max(this.authorizationRevision, await this.requireRead());
+      this.assertOpen();
+      let editDecision = await this.checkPermission("edit");
+      if (editDecision.revision > this.authorizationRevision) {
+        this.authorizationRevision = editDecision.revision;
+        await this.requireRead();
+      } else if (editDecision.revision < this.authorizationRevision) {
+        editDecision = await this.checkPermission("edit");
+      }
+      this.writable = editDecision.revision === this.authorizationRevision && editDecision.allowed;
+      this.assertOpen();
+      const bootstrap = await this.dependencies.read.readBootstrap({
+        scope: this.ticket.scope,
+        artifactId: this.artifactId,
+        resume: this.resume,
+        protocolVersion: this.options.protocolVersion
+      });
+      this.assertOpen();
+      validateBootstrap(bootstrap, this.artifactId, this.modality, this.resume, this.options);
+      this.targetHead = bootstrap.headSequence;
+      await this.send({
+        type: "open",
+        protocolVersion: this.options.protocolVersion,
+        artifactId: this.artifactId,
+        streamEpoch: this.streamEpoch,
+        modality: this.modality,
+        writable: this.writable,
+        headSequence: bootstrap.headSequence,
+        minimumReplaySequence: bootstrap.minimumReplaySequence,
+        maxClientFrameBytes: this.options.maxClientFrameBytes,
+        maxCommandBytes: Math.min(
+          EDITABLE_ARTIFACT_COMMAND_MAX_BYTES,
+          Math.max(0, this.options.maxClientFrameBytes - 64 * 1024)
+        ),
+        maxIntentBytes: Math.min(
+          EDITABLE_ARTIFACT_INTENT_MAX_BYTES,
+          Math.max(0, this.options.maxClientFrameBytes - 64 * 1024)
+        ),
+        maxCommittedTransactionBytes: Math.min(
+          EDITABLE_ARTIFACT_MAX_COMMITTED_TRANSACTION_BYTES,
+          Math.max(0, this.options.maxOutboundFrameBytes - 64 * 1024)
+        ),
+        maxSnapshotBytes: this.options.maxSnapshotBytes,
+        maxInFlightTransactions: this.options.maxInFlightTransactions,
+        maxInFlightBytes: this.options.maxInFlightBytes
+      });
+      await this.applyBootstrap(bootstrap);
+      await this.reconcileFromDurableHead();
+      await this.sendBarrier();
+      this.bootstrapping = false;
+      if (this.reconcileRequested) this.requestReconcile();
+      this.maintenance = this.runMaintenance().catch((error) => {
+        if (!this.abort.signal.aborted) void this.fail(error);
+      });
+    } catch (error) {
+      await this.fail(error);
+      throw error;
+    }
+  }
+  receive(bytes) {
+    if (this.closedValue)
+      return Promise.reject(new EditableArtifactLiveError("closed", "Live session is closed"));
+    if (!(bytes instanceof Uint8Array)) {
+      return Promise.reject(new TypeError("Live frame must be Uint8Array"));
+    }
+    if (bytes.byteLength > this.options.maxClientFrameBytes) {
+      const error = new EditableArtifactLiveError(
+        "oversized_frame",
+        "Client live frame exceeds the byte limit"
+      );
+      void this.fail(error);
+      return Promise.reject(error);
+    }
+    let frame;
+    try {
+      frame = decodeClientFrame(
+        bytes,
+        this.artifactId,
+        this.streamEpoch,
+        this.options.protocolVersion
+      );
+    } catch (error) {
+      const failure = error instanceof EditableArtifactLiveError ? error : new EditableArtifactLiveError("invalid_frame", "Client live frame is malformed", {
+        cause: error
+      });
+      void this.fail(failure);
+      return Promise.reject(failure);
+    }
+    return this.enqueueInbound(bytes.byteLength, async () => {
+      await this.applyAcknowledgement(frame);
+    });
+  }
+  acknowledge(frame) {
+    if (this.closedValue) {
+      return Promise.reject(new EditableArtifactLiveError("closed", "Live session is closed"));
+    }
+    let normalized;
+    try {
+      normalized = validateAppliedFrame(
+        frame,
+        this.artifactId,
+        this.streamEpoch,
+        this.options.protocolVersion
+      );
+    } catch (error) {
+      const failure = error instanceof EditableArtifactLiveError ? error : new EditableArtifactLiveError("invalid_frame", "Client live ACK is malformed", {
+        cause: error
+      });
+      void this.fail(failure);
+      return Promise.reject(failure);
+    }
+    return this.enqueueInbound(256, async () => {
+      await this.applyAcknowledgement(normalized);
+    });
+  }
+  submitIntent(input) {
+    if (this.closedValue) {
+      return Promise.reject(new EditableArtifactLiveError("closed", "Live session is closed"));
+    }
+    if (input.protocolVersion !== this.options.protocolVersion) {
+      const error = new EditableArtifactLiveError(
+        "protocol_mismatch",
+        "Mutation protocol mismatch"
+      );
+      void this.fail(error);
+      return Promise.reject(error);
+    }
+    let inputArtifactId;
+    try {
+      inputArtifactId = editableArtifactId(input.artifactId);
+    } catch (cause) {
+      const error = new EditableArtifactLiveError(
+        "invalid_frame",
+        "Mutation artifact id is malformed",
+        { cause }
+      );
+      void this.fail(error);
+      return Promise.reject(error);
+    }
+    if (inputArtifactId !== this.artifactId) {
+      const error = new EditableArtifactLiveError("invalid_frame", "Mutation artifact mismatch");
+      void this.fail(error);
+      return Promise.reject(error);
+    }
+    if (input.streamEpoch !== this.streamEpoch) {
+      const error = new EditableArtifactLiveError(
+        "stale_epoch",
+        "Mutation belongs to a stale stream epoch"
+      );
+      void this.fail(error);
+      return Promise.reject(error);
+    }
+    try {
+      editableArtifactRequestHash(input.requestHash);
+    } catch (cause) {
+      const error = new EditableArtifactLiveError(
+        "invalid_frame",
+        "Mutation request hash is malformed",
+        { cause }
+      );
+      return Promise.reject(error);
+    }
+    if (!(input.intentBytes instanceof Uint8Array) || input.intentBytes.byteLength === 0 || input.intentBytes.byteLength > this.options.maxClientFrameBytes) {
+      const error = new EditableArtifactLiveError(
+        "oversized_frame",
+        "Mutation intent exceeds the byte limit"
+      );
+      void this.fail(error);
+      return Promise.reject(error);
+    }
+    return this.enqueueInbound(
+      input.intentBytes.byteLength,
+      () => this.applyMutation(input),
+      false
+    );
+  }
+  reconcileNow() {
+    return this.enqueue(() => this.reconcileFromDurableHead());
+  }
+  reauthorizeNow() {
+    return this.enqueue(() => this.reauthorize());
+  }
+  async close(reason = "closed") {
+    if (this.closedValue) return;
+    const close = closeValue(reason);
+    this.closedValue = close;
+    this.abort.abort();
+    safeRelease(this.releaseHints);
+    this.releaseHints = null;
+    safeRelease(this.releaseInvalidations);
+    this.releaseInvalidations = null;
+    safeRelease(this.detachParent);
+    this.detachParent = null;
+    try {
+      this.sink.close(close);
+    } catch {
+    }
+    this.resolveClosed(close);
+  }
+  assertOpen() {
+    if (this.closedValue) {
+      throw new EditableArtifactLiveError("closed", "Live session is closed");
+    }
+  }
+  enqueue(task) {
+    const result = this.workTail.then(async () => {
+      if (this.closedValue) {
+        throw new EditableArtifactLiveError("closed", "Live session is closed");
+      }
+      return await task();
+    });
+    this.workTail = result.then(
+      () => void 0,
+      (error) => this.fail(error)
+    );
+    return result;
+  }
+  enqueueInbound(bytes, task, fatal = true) {
+    if (this.queuedInboundFrames + 1 > this.options.maxInboundQueueFrames || this.queuedInboundBytes + bytes > this.options.maxInboundQueueBytes) {
+      const error = new EditableArtifactLiveError(
+        "slow_client",
+        "Live inbound work queue is full",
+        { requiresSnapshot: true }
+      );
+      void this.fail(error);
+      return Promise.reject(error);
+    }
+    this.queuedInboundFrames += 1;
+    this.queuedInboundBytes += bytes;
+    const run = async () => {
+      try {
+        return await task();
+      } finally {
+        this.queuedInboundFrames -= 1;
+        this.queuedInboundBytes -= bytes;
+      }
+    };
+    if (fatal) return this.enqueue(run);
+    const result = this.workTail.then(async () => {
+      if (this.closedValue) {
+        throw new EditableArtifactLiveError("closed", "Live session is closed");
+      }
+      return await run();
+    });
+    this.workTail = result.then(
+      () => void 0,
+      () => void 0
+    );
+    return result;
+  }
+  requestReconcile() {
+    if (this.closedValue) return;
+    this.reconcileRequested = true;
+    if (this.bootstrapping || this.reconcileScheduled) return;
+    this.reconcileScheduled = true;
+    void this.enqueue(async () => {
+      try {
+        while (this.reconcileRequested && !this.closedValue) {
+          this.reconcileRequested = false;
+          await this.reconcileFromDurableHead();
+        }
+      } finally {
+        this.reconcileScheduled = false;
+        if (this.reconcileRequested && !this.closedValue) this.requestReconcile();
+      }
+    }).catch(() => void 0);
+  }
+  requestReauthorization() {
+    if (this.closedValue) return;
+    this.reauthorizationRequested = true;
+    if (this.reauthorizationScheduled) return;
+    this.reauthorizationScheduled = true;
+    void this.enqueue(async () => {
+      try {
+        while (this.reauthorizationRequested && !this.closedValue) {
+          this.reauthorizationRequested = false;
+          await this.reauthorize();
+        }
+      } finally {
+        this.reauthorizationScheduled = false;
+        if (this.reauthorizationRequested && !this.closedValue) {
+          this.requestReauthorization();
+        }
+      }
+    }).catch(() => void 0);
+  }
+  async applyBootstrap(bootstrap) {
+    if (bootstrap.resumeAccepted) {
+      this.sentSequence = bootstrap.resumeSequence;
+      this.ackedSequence = bootstrap.resumeSequence;
+      this.sentStateHash = bootstrap.resumeStateHash;
+      this.ackedStateHash = bootstrap.resumeStateHash;
+      this.boundaries.set(bootstrap.resumeSequence, bootstrap.resumeStateHash);
+    } else if (bootstrap.snapshot) {
+      await this.sendSnapshot(bootstrap.snapshot);
+      this.sentSequence = bootstrap.snapshot.sequence;
+      this.sentStateHash = bootstrap.snapshot.stateHash;
+      this.boundaries.set(bootstrap.snapshot.sequence, bootstrap.snapshot.stateHash);
+      if (bootstrap.snapshot.sequence === 0) {
+        this.ackedStateHash = bootstrap.snapshot.stateHash;
+      }
+    } else {
+      await this.requireResync("retention_gap", bootstrap.headSequence);
+      return;
+    }
+    if (this.sentSequence + 1 < bootstrap.minimumReplaySequence) {
+      await this.requireResync("retention_gap", bootstrap.headSequence);
+      return;
+    }
+    await this.pumpThrough(bootstrap.headSequence);
+    if (!this.closedValue && this.sentSequence === bootstrap.headSequence && this.sentStateHash !== bootstrap.stateHash) {
+      await this.requireResync("durable_gap", bootstrap.headSequence);
+    }
+  }
+  async sendSnapshot(snapshot) {
+    if (snapshot.bytes.byteLength > this.options.maxSnapshotBytes) {
+      await this.requireResync("oversized_frame", snapshot.sequence);
+      return;
+    }
+    const snapshotBytes = snapshot.bytes;
+    if (snapshot.modality !== this.modality) {
+      throw new EditableArtifactLiveError(
+        "durable_gap",
+        "Snapshot modality differs from its durable ticket",
+        { requiresSnapshot: true }
+      );
+    }
+    const causalFrontier = snapshot.modality === "spreadsheet" ? validateFrontier(snapshot.causalFrontier, "snapshot causal frontier") : null;
+    const totalBytes = snapshotBytes.byteLength;
+    if (totalBytes === 0)
+      throw new EditableArtifactLiveError("durable_gap", "Snapshot is empty", {
+        requiresSnapshot: true
+      });
+    for (let offset = 0; offset < totalBytes; offset += this.options.snapshotChunkBytes) {
+      const bytes = snapshotBytes.slice(
+        offset,
+        Math.min(offset + this.options.snapshotChunkBytes, totalBytes)
+      );
+      const common = {
+        type: "snapshot",
+        protocolVersion: this.options.protocolVersion,
+        artifactId: this.artifactId,
+        streamEpoch: this.streamEpoch,
+        sequence: snapshot.sequence,
+        stateHash: snapshot.stateHash,
+        digest: snapshot.digest,
+        kernelVersion: snapshot.kernelVersion,
+        modelSchemaVersion: snapshot.modelSchemaVersion,
+        offset,
+        totalBytes,
+        final: offset + bytes.byteLength === totalBytes,
+        bytes
+      };
+      await this.send(
+        snapshot.modality === "spreadsheet" ? { ...common, modality: snapshot.modality, causalFrontier } : {
+          ...common,
+          modality: snapshot.modality,
+          nativeRevision: snapshot.nativeRevision
+        }
+      );
+    }
+  }
+  async reconcileFromDurableHead() {
+    if (this.closedValue) return;
+    const head = await this.dependencies.read.readHead(this.ticket.scope, this.artifactId);
+    validateHead(head, this.modality);
+    if (head.headSequence < this.sentSequence) {
+      await this.requireResync("durable_gap", head.headSequence);
+      return;
+    }
+    this.targetHead = head.headSequence;
+    if (this.sentSequence + 1 < head.minimumReplaySequence) {
+      await this.requireResync("retention_gap", head.headSequence);
+      return;
+    }
+    await this.pumpThrough(head.headSequence);
+    if (!this.closedValue && this.sentSequence === head.headSequence && this.sentStateHash !== head.stateHash) {
+      await this.requireResync("durable_gap", head.headSequence);
+      return;
+    }
+    if (!this.closedValue) {
+      await this.send({
+        type: "watermark",
+        protocolVersion: this.options.protocolVersion,
+        artifactId: this.artifactId,
+        streamEpoch: this.streamEpoch,
+        headSequence: head.headSequence
+      });
+    }
+  }
+  async pumpThrough(through) {
+    assertNonnegativeSafeInteger(through, "target head sequence");
+    while (!this.closedValue && this.sentSequence < through) {
+      if (this.inFlight.size >= this.options.maxInFlightTransactions) return;
+      const page = await this.dependencies.read.readTransactions({
+        scope: this.ticket.scope,
+        artifactId: this.artifactId,
+        after: this.sentSequence,
+        through,
+        maxCount: this.options.replayPageTransactions,
+        maxBytes: this.options.replayPageBytes
+      });
+      validatePage(
+        page,
+        this.sentSequence,
+        through,
+        this.options.replayPageTransactions,
+        this.options.replayPageBytes
+      );
+      if (this.sentSequence + 1 < page.minimumReplaySequence) {
+        await this.requireResync("retention_gap", page.headSequence);
+        return;
+      }
+      if (page.transactions.length === 0) {
+        await this.requireResync("durable_gap", page.headSequence);
+        return;
+      }
+      let progressed = false;
+      for (const transaction of page.transactions) {
+        validateTransaction(
+          transaction,
+          this.artifactId,
+          this.modality,
+          Math.min(
+            this.options.replayPageBytes,
+            Math.max(0, this.options.maxOutboundFrameBytes - 64 * 1024)
+          )
+        );
+        if (transaction.endSequence > through) {
+          await this.requireResync("durable_gap", page.headSequence);
+          return;
+        }
+        if (transaction.startSequence !== this.sentSequence + 1) {
+          await this.requireResync("durable_gap", page.headSequence);
+          return;
+        }
+        if (this.sentStateHash && transaction.priorStateHash !== this.sentStateHash) {
+          await this.requireResync("durable_gap", page.headSequence);
+          return;
+        }
+        const ownedTransaction = ownTransaction(transaction);
+        const frameBytes = estimateFrameBytes({
+          type: "transaction",
+          protocolVersion: this.options.protocolVersion,
+          artifactId: this.artifactId,
+          streamEpoch: this.streamEpoch,
+          transaction: ownedTransaction
+        });
+        if (frameBytes > this.options.maxOutboundFrameBytes || frameBytes > this.options.maxInFlightBytes) {
+          await this.requireResync("oversized_frame", page.headSequence);
+          return;
+        }
+        if (this.inFlight.size >= this.options.maxInFlightTransactions || this.inFlightBytes + frameBytes > this.options.maxInFlightBytes) {
+          return;
+        }
+        await this.send({
+          type: "transaction",
+          protocolVersion: this.options.protocolVersion,
+          artifactId: this.artifactId,
+          streamEpoch: this.streamEpoch,
+          transaction: ownedTransaction
+        });
+        this.sentSequence = ownedTransaction.endSequence;
+        this.sentStateHash = ownedTransaction.stateHash;
+        this.boundaries.set(ownedTransaction.endSequence, ownedTransaction.stateHash);
+        const sentAt = this.dependencies.clock.now().getTime();
+        this.inFlight.set(ownedTransaction.endSequence, {
+          bytes: frameBytes,
+          stateHash: ownedTransaction.stateHash,
+          sentAt
+        });
+        this.inFlightBytes += frameBytes;
+        if (this.oldestInFlightAt === 0) this.oldestInFlightAt = sentAt;
+        progressed = true;
+        if (this.sentSequence >= through) break;
+      }
+      if (!progressed) return;
+    }
+  }
+  async applyAcknowledgement(frame) {
+    if (frame.sequence < this.ackedSequence || frame.sequence > this.sentSequence) {
+      await this.requireResync("invalid_ack", this.targetHead);
+      return;
+    }
+    const expected = frame.sequence === this.ackedSequence ? this.ackedStateHash : this.boundaries.get(frame.sequence);
+    if (!expected || expected !== frame.stateHash) {
+      await this.requireResync("invalid_ack", this.targetHead);
+      return;
+    }
+    if (frame.sequence > this.ackedSequence) {
+      await this.dependencies.read.acknowledgeReplica({
+        scope: this.ticket.scope,
+        artifactId: this.artifactId,
+        replicaId: this.ticket.actor.replicaId,
+        actorKey: editableArtifactActorKey(this.ticket.actor),
+        streamEpoch: this.streamEpoch,
+        sequence: frame.sequence,
+        stateHash: frame.stateHash
+      });
+      this.ackedSequence = frame.sequence;
+      this.ackedStateHash = frame.stateHash;
+      for (const [sequence, inFlight] of this.inFlight) {
+        if (sequence <= frame.sequence) {
+          this.inFlight.delete(sequence);
+          this.inFlightBytes -= inFlight.bytes;
+        }
+      }
+      for (const sequence of this.boundaries.keys()) {
+        if (sequence < frame.sequence) this.boundaries.delete(sequence);
+      }
+      this.oldestInFlightAt = this.inFlight.size === 0 ? 0 : Math.min(...[...this.inFlight.values()].map((value) => value.sentAt));
+    }
+    await this.send({
+      type: "applied",
+      protocolVersion: this.options.protocolVersion,
+      artifactId: this.artifactId,
+      streamEpoch: this.streamEpoch,
+      sequence: frame.sequence,
+      stateHash: frame.stateHash
+    });
+    await this.reconcileFromDurableHead();
+  }
+  async applyMutation(frame) {
+    await this.reauthorize();
+    if (this.closedValue) {
+      throw new EditableArtifactLiveError(
+        "permission_changed",
+        "Editable artifact read permission changed"
+      );
+    }
+    if (!this.writable) {
+      throw new EditableArtifactLiveError(
+        "permission_changed",
+        "Editable artifact edit permission denied"
+      );
+    }
+    let result;
+    try {
+      result = await this.dependencies.domain.applyTransaction({
+        scope: this.ticket.scope,
+        artifactId: this.artifactId,
+        actor: this.ticket.actor,
+        request: {
+          intentBytes: frame.intentBytes.slice(),
+          requestHash: frame.requestHash
+        }
+      });
+    } catch (error) {
+      await this.reauthorize();
+      throw error;
+    }
+    const transaction = await this.dependencies.read.readCommittedTransaction({
+      scope: this.ticket.scope,
+      artifactId: this.artifactId,
+      transactionId: result.receipt.serverTransactionId
+    });
+    if (!transaction || result.receipt.modality !== this.modality || transaction.modality !== this.modality || transaction.startSequence !== result.receipt.sequenceStart || transaction.endSequence !== result.receipt.sequenceEnd || transaction.transactionId !== result.receipt.serverTransactionId || result.receipt.requestHash !== frame.requestHash || transaction.requestHash !== result.receipt.requestHash || transaction.stateHash !== result.receipt.stateHash) {
+      await this.requireResync("durable_gap", this.targetHead);
+      throw new EditableArtifactLiveError(
+        "durable_gap",
+        "Committed mutation is unavailable from durable replay",
+        { requiresSnapshot: true }
+      );
+    }
+    validateTransaction(
+      transaction,
+      this.artifactId,
+      this.modality,
+      Math.min(
+        this.options.replayPageBytes,
+        Math.max(0, this.options.maxOutboundFrameBytes - 64 * 1024)
+      )
+    );
+    const ownedTransaction = ownTransaction(transaction);
+    await this.reconcileFromDurableHead();
+    return Object.freeze({
+      clientTransactionId: result.receipt.clientTransactionId,
+      requestHash: result.receipt.requestHash,
+      transaction: ownedTransaction
+    });
+  }
+  async reauthorize() {
+    let readDecision = await this.checkPermission("read");
+    let editDecision = await this.checkPermission("edit");
+    const targetRevision = Math.max(
+      this.authorizationRevision,
+      readDecision.revision,
+      editDecision.revision
+    );
+    if (readDecision.revision < targetRevision) {
+      readDecision = await this.checkPermission("read");
+    }
+    if (editDecision.revision < targetRevision) {
+      editDecision = await this.checkPermission("edit");
+    }
+    const coherentRevision = Math.max(targetRevision, readDecision.revision, editDecision.revision);
+    if (readDecision.revision !== coherentRevision) {
+      await this.close("permission_changed");
+      return;
+    }
+    if (!readDecision.allowed) {
+      await this.close("permission_changed");
+      return;
+    }
+    const nextWritable = editDecision.revision === coherentRevision && editDecision.allowed;
+    const revisionChanged = coherentRevision !== this.authorizationRevision;
+    this.authorizationRevision = coherentRevision;
+    if (nextWritable !== this.writable || revisionChanged) {
+      this.writable = nextWritable;
+      await this.sendAuthorization();
+    }
+  }
+  async sendAuthorization() {
+    await this.send({
+      type: "authorizationChanged",
+      protocolVersion: this.options.protocolVersion,
+      artifactId: this.artifactId,
+      streamEpoch: this.streamEpoch,
+      writable: this.writable
+    });
+  }
+  async requireRead() {
+    const decision = await this.checkPermission("read");
+    if (!decision.allowed || decision.revision < this.authorizationRevision) {
+      throw new EditableArtifactLiveError(
+        "permission_changed",
+        "Editable artifact read permission denied"
+      );
+    }
+    return decision.revision;
+  }
+  async checkPermission(permission) {
+    const decision = await this.dependencies.authorization.authorize({
+      scope: this.ticket.scope,
+      artifactId: this.artifactId,
+      actor: this.ticket.actor,
+      permission
+    });
+    if (permission === "edit" && !this.ticket.allowEdit) {
+      return Object.freeze({ ...decision, allowed: false });
+    }
+    return decision;
+  }
+  async sendBarrier() {
+    if (!this.sentStateHash)
+      throw new EditableArtifactLiveError("durable_gap", "Bootstrap has no state boundary");
+    await this.send({
+      type: "barrier",
+      protocolVersion: this.options.protocolVersion,
+      artifactId: this.artifactId,
+      streamEpoch: this.streamEpoch,
+      sequence: this.sentSequence,
+      stateHash: this.sentStateHash
+    });
+  }
+  async send(frame) {
+    if (this.closedValue) return;
+    const bytes = estimateFrameBytes(frame);
+    if (bytes > this.options.maxOutboundFrameBytes) {
+      throw new EditableArtifactLiveError(
+        "oversized_frame",
+        "Server live frame exceeds the byte limit",
+        { requiresSnapshot: true }
+      );
+    }
+    const buffered = this.sink.bufferedBytes();
+    if (!Number.isSafeInteger(buffered) || buffered < 0 || buffered + bytes > this.options.maxSocketBufferedBytes) {
+      throw new EditableArtifactLiveError("slow_client", "Live socket send buffer is full", {
+        retryable: true,
+        requiresSnapshot: true
+      });
+    }
+    const timeout = new AbortController();
+    try {
+      await Promise.race([
+        this.sink.send(frame),
+        this.dependencies.scheduler.sleep(this.options.sendTimeoutMs, timeout.signal).then(() => {
+          throw new EditableArtifactLiveError("slow_client", "Live socket write timed out", {
+            retryable: true,
+            requiresSnapshot: true
+          });
+        })
+      ]);
+    } finally {
+      timeout.abort();
+    }
+  }
+  async requireResync(reason, headSequence) {
+    if (this.closedValue) return;
+    try {
+      await this.send({
+        type: "resyncRequired",
+        protocolVersion: this.options.protocolVersion,
+        artifactId: this.artifactId,
+        streamEpoch: this.streamEpoch,
+        reason,
+        headSequence
+      });
+    } catch {
+    }
+    await this.close(reason);
+  }
+  async runMaintenance() {
+    let nextReconcile = this.dependencies.clock.now().getTime() + this.options.reconcileIntervalMs;
+    let nextAuthorization = this.dependencies.clock.now().getTime() + this.options.reauthorizeIntervalMs;
+    const tick = Math.max(
+      10,
+      Math.min(
+        this.options.reconcileIntervalMs,
+        this.options.reauthorizeIntervalMs,
+        this.options.ackTimeoutMs
+      )
+    );
+    while (!this.abort.signal.aborted) {
+      await this.dependencies.scheduler.sleep(tick, this.abort.signal);
+      if (this.abort.signal.aborted || this.closedValue) return;
+      const now = this.dependencies.clock.now().getTime();
+      if (this.oldestInFlightAt !== 0 && now - this.oldestInFlightAt >= this.options.ackTimeoutMs) {
+        await this.enqueue(() => this.requireResync("slow_client", this.targetHead));
+        return;
+      }
+      if (now >= nextAuthorization) {
+        await this.reauthorizeNow();
+        nextAuthorization = now + this.options.reauthorizeIntervalMs;
+      }
+      if (this.closedValue) return;
+      if (now >= nextReconcile) {
+        await this.reconcileNow();
+        nextReconcile = now + this.options.reconcileIntervalMs;
+      }
+    }
+  }
+  async fail(error) {
+    if (this.closedValue) return;
+    if (error instanceof EditableArtifactLiveError) {
+      if (error.requiresSnapshot && ["durable_gap", "retention_gap", "invalid_ack", "slow_client", "oversized_frame"].includes(
+        error.code
+      )) {
+        await this.requireResync(
+          error.code,
+          this.targetHead
+        );
+        return;
+      }
+      await this.close(error.code === "invalid_ticket" ? "transport_error" : error.code);
+      return;
+    }
+    await this.close("transport_error");
+  }
+};
+function decodeClientFrame(bytes, artifactId, streamEpoch, protocolVersion) {
+  let value;
+  try {
+    value = JSON.parse(strictDecoder.decode(bytes));
+  } catch (cause) {
+    throw new EditableArtifactLiveError(
+      "invalid_frame",
+      "Client live frame is not valid UTF-8 JSON",
+      { cause }
+    );
+  }
+  const frame = plainRecord(value, "client frame");
+  const type = requiredString(frame, "type", 32);
+  const actualProtocol = requiredSafeInteger(frame, "protocolVersion");
+  const actualArtifact = editableArtifactId(requiredString(frame, "artifactId", 64));
+  const actualEpoch = requiredString(frame, "streamEpoch", MAX_IDENTIFIER_BYTES);
+  if (actualProtocol !== protocolVersion)
+    throw new EditableArtifactLiveError("protocol_mismatch", "Client frame protocol mismatch");
+  if (actualArtifact !== artifactId)
+    throw new EditableArtifactLiveError("invalid_frame", "Client frame artifact mismatch");
+  if (actualEpoch !== streamEpoch)
+    throw new EditableArtifactLiveError(
+      "stale_epoch",
+      "Client frame belongs to a stale stream epoch"
+    );
+  if (type === "applied") {
+    rejectUnknown(frame, [
+      "type",
+      "protocolVersion",
+      "artifactId",
+      "streamEpoch",
+      "sequence",
+      "stateHash"
+    ]);
+    return validateAppliedFrame(
+      Object.freeze({
+        type,
+        protocolVersion,
+        artifactId,
+        streamEpoch,
+        sequence: requiredSafeInteger(frame, "sequence"),
+        stateHash: editableArtifactStateHash(requiredString(frame, "stateHash", 80))
+      }),
+      artifactId,
+      streamEpoch,
+      protocolVersion
+    );
+  }
+  throw new EditableArtifactLiveError("invalid_frame", `Unknown client live frame: ${type}`);
+}
+function validateAppliedFrame(frame, artifactId, streamEpoch, protocolVersion) {
+  if (frame.type !== "applied") {
+    throw new EditableArtifactLiveError("invalid_frame", "Client frame is not an apply ACK");
+  }
+  if (frame.protocolVersion !== protocolVersion) {
+    throw new EditableArtifactLiveError("protocol_mismatch", "Client frame protocol mismatch");
+  }
+  if (editableArtifactId(frame.artifactId) !== artifactId) {
+    throw new EditableArtifactLiveError("invalid_frame", "Client frame artifact mismatch");
+  }
+  boundedString(frame.streamEpoch, "stream epoch", MAX_IDENTIFIER_BYTES);
+  if (frame.streamEpoch !== streamEpoch) {
+    throw new EditableArtifactLiveError(
+      "stale_epoch",
+      "Client frame belongs to a stale stream epoch"
+    );
+  }
+  assertNonnegativeSafeInteger(frame.sequence, "applied sequence");
+  return Object.freeze({
+    type: "applied",
+    protocolVersion,
+    artifactId,
+    streamEpoch,
+    sequence: frame.sequence,
+    stateHash: editableArtifactStateHash(frame.stateHash)
+  });
+}
+function validateResume(resume, durableModality) {
+  const resumeModality = resume.modality ?? "spreadsheet";
+  if (resumeModality !== durableModality) {
+    throw new EditableArtifactLiveError(
+      "invalid_frame",
+      "Resume modality differs from the durable artifact"
+    );
+  }
+  if (resume.localCursor !== null) assertNonnegativeSafeInteger(resume.localCursor, "local cursor");
+  if (resume.localStateHash !== null) editableArtifactStateHash(resume.localStateHash);
+  if (resumeModality === "spreadsheet") {
+    if (!("localCausalFrontier" in resume)) {
+      throw new TypeError("spreadsheet resume requires a causal frontier");
+    }
+    validateFrontier(resume.localCausalFrontier, "local causal frontier");
+  } else if ("localNativeRevision" in resume && resume.localNativeRevision !== null) {
+    assertNonnegativeSafeInteger(resume.localNativeRevision, "local native revision");
+  } else if (!("localNativeRevision" in resume)) {
+    throw new TypeError("serialized resume requires a native revision");
+  }
+  if (typeof resume.requireSnapshot !== "boolean")
+    throw new TypeError("requireSnapshot must be boolean");
+  if (resume.localCursor === null !== (resume.localStateHash === null)) {
+    throw new TypeError("resume cursor and state hash must both be null or present");
+  }
+  if (resumeModality !== "spreadsheet" && "localNativeRevision" in resume && resume.localCursor === null !== (resume.localNativeRevision === null)) {
+    throw new TypeError(
+      "serialized resume cursor and native revision must both be null or present"
+    );
+  }
+}
+function validateBootstrap(bootstrap, artifactId, durableModality, resume, options) {
+  validateHead(bootstrap, durableModality);
+  assertNonnegativeSafeInteger(bootstrap.resumeSequence, "bootstrap resume sequence");
+  editableArtifactStateHash(bootstrap.resumeStateHash);
+  if (typeof bootstrap.resumeAccepted !== "boolean")
+    throw new TypeError("resumeAccepted must be boolean");
+  if (bootstrap.resumeSequence > bootstrap.headSequence)
+    throw new TypeError("bootstrap resume is beyond head");
+  if (bootstrap.resumeAccepted && (resume.requireSnapshot || resume.localCursor === null || resume.localStateHash === null || bootstrap.resumeSequence !== resume.localCursor || bootstrap.resumeStateHash !== resume.localStateHash)) {
+    throw new TypeError("bootstrap accepted a different or unverified resume boundary");
+  }
+  if (bootstrap.snapshot) {
+    const snapshot = bootstrap.snapshot;
+    if (snapshot.modality !== durableModality) throw new TypeError("snapshot modality mismatch");
+    if (snapshot.artifactId !== artifactId) throw new TypeError("snapshot artifact mismatch");
+    assertNonnegativeSafeInteger(snapshot.sequence, "snapshot sequence");
+    if (snapshot.sequence > bootstrap.headSequence) throw new TypeError("snapshot is beyond head");
+    editableArtifactStateHash(snapshot.stateHash);
+    if (snapshot.modality === "spreadsheet") {
+      validateFrontier(snapshot.causalFrontier, "snapshot causal frontier");
+      assertPositiveSafeInteger(
+        snapshot.operationProtocolVersion,
+        "snapshot operation protocol version"
+      );
+    } else {
+      assertNonnegativeSafeInteger(snapshot.nativeRevision, "snapshot native revision");
+    }
+    if (!/^sha256:[0-9a-f]{64}$/u.test(snapshot.digest))
+      throw new TypeError("snapshot digest is malformed");
+    assertPositiveSafeInteger(snapshot.modelSchemaVersion, "snapshot model schema version");
+    boundedString(
+      snapshot.kernelVersion,
+      "snapshot kernel version",
+      EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES2
+    );
+    if (!(snapshot.bytes instanceof Uint8Array) || snapshot.bytes.byteLength > options.maxSnapshotBytes) {
+      throw new EditableArtifactLiveError("oversized_frame", "Snapshot bytes exceed live limit", {
+        requiresSnapshot: true
+      });
+    }
+  }
+}
+function validateHead(head, durableModality) {
+  if (head.modality !== durableModality) throw new TypeError("durable live head modality mismatch");
+  assertNonnegativeSafeInteger(head.headSequence, "head sequence");
+  assertNonnegativeSafeInteger(head.minimumReplaySequence, "minimum replay sequence");
+  if (head.minimumReplaySequence > head.headSequence + 1)
+    throw new TypeError("minimum replay sequence is beyond head");
+  editableArtifactStateHash(head.stateHash);
+  if (head.modality === "spreadsheet") {
+    validateFrontier(head.causalFrontier, "head causal frontier");
+  } else {
+    assertNonnegativeSafeInteger(head.nativeRevision, "head native revision");
+  }
+}
+function validatePage(page, after, through, maxCount, maxBytes) {
+  if (!Array.isArray(page.transactions)) throw new TypeError("transaction page is malformed");
+  assertNonnegativeSafeInteger(page.headSequence, "page head sequence");
+  assertNonnegativeSafeInteger(page.minimumReplaySequence, "page minimum replay sequence");
+  if (page.headSequence < through || after > through)
+    throw new TypeError("transaction page does not cover requested target");
+  if (page.transactions.length > maxCount) {
+    throw new EditableArtifactLiveError(
+      "oversized_frame",
+      "Durable transaction page exceeds the count limit",
+      { requiresSnapshot: true }
+    );
+  }
+  let bytes = 0;
+  for (const transaction of page.transactions) {
+    bytes += transaction.committedTransactionBytes.byteLength;
+    if (!Number.isSafeInteger(bytes) || bytes > maxBytes) {
+      throw new EditableArtifactLiveError(
+        "oversized_frame",
+        "Durable transaction page exceeds the byte limit",
+        { requiresSnapshot: true }
+      );
+    }
+  }
+}
+function validateTransaction(transaction, artifactId, durableModality, maxBytes) {
+  if (transaction.artifactId !== artifactId) throw new TypeError("transaction artifact mismatch");
+  if (transaction.modality !== durableModality)
+    throw new TypeError("transaction modality differs from the durable artifact");
+  editableArtifactTransactionId(transaction.transactionId);
+  assertPositiveSafeInteger(transaction.startSequence, "transaction start sequence");
+  assertPositiveSafeInteger(transaction.endSequence, "transaction end sequence");
+  if (transaction.endSequence < transaction.startSequence)
+    throw new TypeError("transaction sequence interval is inverted");
+  editableArtifactRequestHash(transaction.requestHash);
+  editableArtifactStateHash(transaction.priorStateHash);
+  editableArtifactStateHash(transaction.stateHash);
+  if (transaction.modality === "spreadsheet") {
+    assertPositiveSafeInteger(
+      transaction.operationProtocolVersion,
+      "transaction operation protocol version"
+    );
+    validateFrontier(transaction.causalFrontier, "transaction causal frontier");
+  } else {
+    assertPositiveSafeInteger(
+      transaction.commitProtocolVersion,
+      "transaction commit protocol version"
+    );
+    assertNonnegativeSafeInteger(
+      transaction.priorNativeRevision,
+      "transaction prior native revision"
+    );
+    assertNonnegativeSafeInteger(transaction.nativeRevision, "transaction native revision");
+  }
+  if (!(transaction.committedTransactionBytes instanceof Uint8Array) || transaction.committedTransactionBytes.byteLength === 0 || transaction.committedTransactionBytes.byteLength > maxBytes) {
+    throw new EditableArtifactLiveError(
+      "oversized_frame",
+      "Canonical transaction bytes exceed live limit",
+      { requiresSnapshot: true }
+    );
+  }
+  try {
+    if (transaction.modality === "spreadsheet") {
+      const summary = decodeCommittedTransactionSummary(transaction.committedTransactionBytes);
+      if (summary.transactionId !== transaction.transactionId || summary.priorStateHash !== transaction.priorStateHash || summary.stateHash !== transaction.stateHash || summary.operationProtocolVersion !== transaction.operationProtocolVersion || !sameFrontier(summary.resultingCausalFrontier, transaction.causalFrontier)) {
+        throw new TypeError("spreadsheet transaction projection mismatch");
+      }
+    } else {
+      const summary = decodeEditableArtifactSerializedCommit(
+        transaction.committedTransactionBytes,
+        transaction.modality
+      );
+      if (summary.transactionId !== transaction.transactionId || summary.requestHash !== transaction.requestHash || summary.parentHeadSequence !== transaction.startSequence - 1 || summary.resultHeadSequence !== transaction.endSequence || summary.priorStateHash !== transaction.priorStateHash || summary.stateHash !== transaction.stateHash || summary.priorNativeRevision !== transaction.priorNativeRevision || summary.nativeReceipt.revision !== transaction.nativeRevision || summary.commitProtocolVersion !== transaction.commitProtocolVersion) {
+        throw new TypeError("serialized transaction projection mismatch");
+      }
+    }
+  } catch (cause) {
+    throw new EditableArtifactLiveError(
+      "durable_gap",
+      "Canonical transaction bytes disagree with durable live metadata",
+      { requiresSnapshot: true, cause }
+    );
+  }
+}
+function estimateFrameBytes(frame) {
+  if (frame.type === "snapshot") {
+    const { bytes, ...metadata } = frame;
+    return textEncoder2.encode(JSON.stringify(metadata)).byteLength + bytes.byteLength + 128;
+  }
+  if (frame.type === "transaction") {
+    const { committedTransactionBytes, ...transaction } = frame.transaction;
+    return textEncoder2.encode(JSON.stringify({ ...frame, transaction })).byteLength + committedTransactionBytes.byteLength + 128;
+  }
+  return textEncoder2.encode(JSON.stringify(frame)).byteLength;
+}
+function validateFrontier(frontier, label) {
+  if (!Array.isArray(frontier) || frontier.length > MAX_CAUSAL_ACTORS) {
+    throw new EditableArtifactLiveError(
+      "oversized_frame",
+      `${label} exceeds ${MAX_CAUSAL_ACTORS} actors`,
+      { requiresSnapshot: true }
+    );
+  }
+  const normalized = editableArtifactCausalFrontier(frontier);
+  if (normalized.length > MAX_CAUSAL_ACTORS) {
+    throw new EditableArtifactLiveError(
+      "oversized_frame",
+      `${label} exceeds ${MAX_CAUSAL_ACTORS} actors`,
+      { requiresSnapshot: true }
+    );
+  }
+  return normalized;
+}
+function sameFrontier(left, right) {
+  return left.length === right.length && left.every(
+    (entry, index) => entry.replicaId === right[index]?.replicaId && entry.counter === right[index]?.counter
+  );
+}
+function ownTransaction(transaction) {
+  return transaction.modality === "spreadsheet" ? Object.freeze({
+    ...transaction,
+    causalFrontier: validateFrontier(transaction.causalFrontier, "transaction causal frontier"),
+    committedTransactionBytes: transaction.committedTransactionBytes.slice()
+  }) : Object.freeze({
+    ...transaction,
+    committedTransactionBytes: transaction.committedTransactionBytes.slice()
+  });
+}
+function plainRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) {
+    throw new EditableArtifactLiveError("invalid_frame", `${label} must be an object`);
+  }
+  const prototype = Object.getPrototypeOf(value);
+  if (prototype !== Object.prototype && prototype !== null) {
+    throw new EditableArtifactLiveError("invalid_frame", `${label} must be a plain object`);
+  }
+  return value;
+}
+function requiredString(record, key, maxBytes) {
+  const value = record[key];
+  if (typeof value !== "string")
+    throw new EditableArtifactLiveError("invalid_frame", `${key} must be a string`);
+  boundedString(value, key, maxBytes);
+  return value;
+}
+function requiredSafeInteger(record, key) {
+  const value = record[key];
+  if (!Number.isSafeInteger(value))
+    throw new EditableArtifactLiveError("invalid_frame", `${key} must be a safe integer`);
+  return value;
+}
+function rejectUnknown(record, allowed) {
+  const allowedSet = new Set(allowed);
+  const unknown = Object.keys(record).find((key) => !allowedSet.has(key));
+  if (unknown)
+    throw new EditableArtifactLiveError(
+      "invalid_frame",
+      `Unknown client frame property: ${unknown}`
+    );
+}
+function boundedString(value, label, maxBytes) {
+  const bytes = textEncoder2.encode(value).byteLength;
+  if (bytes < 1 || bytes > maxBytes || value.trim() !== value)
+    throw new TypeError(`${label} is malformed`);
+}
+function normalizeOptions2(options) {
+  const normalized = {
+    protocolVersion: options.protocolVersion ?? EDITABLE_ARTIFACT_LIVE_PROTOCOL_VERSION,
+    maxClientFrameBytes: options.maxClientFrameBytes ?? DEFAULT_MAX_CLIENT_FRAME_BYTES,
+    maxOutboundFrameBytes: options.maxOutboundFrameBytes ?? DEFAULT_MAX_OUTBOUND_FRAME_BYTES,
+    maxSnapshotBytes: options.maxSnapshotBytes ?? DEFAULT_MAX_SNAPSHOT_BYTES,
+    snapshotChunkBytes: options.snapshotChunkBytes ?? DEFAULT_SNAPSHOT_CHUNK_BYTES,
+    maxInFlightTransactions: options.maxInFlightTransactions ?? DEFAULT_MAX_IN_FLIGHT_TRANSACTIONS,
+    maxInFlightBytes: options.maxInFlightBytes ?? DEFAULT_MAX_IN_FLIGHT_BYTES,
+    replayPageTransactions: options.replayPageTransactions ?? DEFAULT_REPLAY_PAGE_TRANSACTIONS,
+    replayPageBytes: options.replayPageBytes ?? DEFAULT_REPLAY_PAGE_BYTES,
+    maxSocketBufferedBytes: options.maxSocketBufferedBytes ?? DEFAULT_MAX_SOCKET_BUFFERED_BYTES,
+    maxInboundQueueFrames: options.maxInboundQueueFrames ?? DEFAULT_MAX_INBOUND_QUEUE_FRAMES,
+    maxInboundQueueBytes: options.maxInboundQueueBytes ?? DEFAULT_MAX_INBOUND_QUEUE_BYTES,
+    reconcileIntervalMs: options.reconcileIntervalMs ?? DEFAULT_RECONCILE_INTERVAL_MS,
+    reauthorizeIntervalMs: options.reauthorizeIntervalMs ?? DEFAULT_REAUTHORIZE_INTERVAL_MS,
+    ackTimeoutMs: options.ackTimeoutMs ?? DEFAULT_ACK_TIMEOUT_MS,
+    sendTimeoutMs: options.sendTimeoutMs ?? DEFAULT_SEND_TIMEOUT_MS,
+    ...options.ticketTtlMs === void 0 ? {} : { ticketTtlMs: options.ticketTtlMs }
+  };
+  for (const [label, value] of Object.entries(normalized)) {
+    if (label === "ticketTtlMs") continue;
+    assertPositiveSafeInteger(value, label);
+  }
+  if (normalized.maxSnapshotBytes > EDITABLE_ARTIFACT_PRODUCT_MAX_SNAPSHOT_BYTES) {
+    throw new TypeError("maxSnapshotBytes exceeds the browser-compatible product limit");
+  }
+  if (normalized.snapshotChunkBytes + 1024 > normalized.maxOutboundFrameBytes) {
+    throw new TypeError("snapshot chunk exceeds maximum outbound frame");
+  }
+  if (normalized.replayPageBytes < normalized.maxOutboundFrameBytes) {
+    throw new TypeError("replay page bytes must cover one maximum outbound frame");
+  }
+  return Object.freeze(normalized);
+}
+function closeValue(reason) {
+  return Object.freeze({
+    reason,
+    retryable: ["ticket_expired", "permission_changed", "slow_client", "transport_error"].includes(
+      reason
+    ),
+    requiresSnapshot: [
+      "invalid_ack",
+      "retention_gap",
+      "durable_gap",
+      "slow_client",
+      "oversized_frame"
+    ].includes(reason)
+  });
+}
+function safeRelease(release) {
+  try {
+    release?.();
+  } catch {
+  }
+}
+var SystemEditableArtifactLiveClock = class {
+  now() {
+    return /* @__PURE__ */ new Date();
+  }
+};
+var SystemEditableArtifactLiveScheduler = class {
+  sleep(milliseconds, signal) {
+    return new Promise((resolve, reject) => {
+      if (signal.aborted) {
+        reject(signal.reason ?? new Error("aborted"));
+        return;
+      }
+      const timer = setTimeout(resolve, milliseconds);
+      signal.addEventListener(
+        "abort",
+        () => {
+          clearTimeout(timer);
+          reject(signal.reason ?? new Error("aborted"));
+        },
+        { once: true }
+      );
+    });
+  }
+};
+
+// src/editable-artifact-live/wire.ts
+import {
+  EDITABLE_ARTIFACT_LIVE_WIRE_VERSION,
+  decodeEditableArtifactLiveClientWireFrame as decodeContractClientFrame,
+  decodeEditableArtifactLiveServerWireFrame,
+  encodeEditableArtifactLiveAppliedWireFrame as encodeContractAppliedFrame,
+  encodeEditableArtifactLiveMutationWireFrame as encodeContractMutationFrame,
+  encodeEditableArtifactLiveOpenWireFrame as encodeContractOpenFrame,
+  encodeEditableArtifactLiveServerWireFrame as encodeContractServerFrame,
+  inspectEditableArtifactLiveWireEnvelope
+} from "@opengeni/contracts/editable-artifact-live";
+function decodeEditableArtifactLiveClientWireFrame(bytes) {
+  return decodeContractClientFrame(bytes);
+}
+function encodeEditableArtifactLiveOpenWireFrame(frame) {
+  return encodeContractOpenFrame(frame);
+}
+function encodeEditableArtifactLiveAppliedWireFrame(frame) {
+  return encodeContractAppliedFrame(frame);
+}
+function encodeEditableArtifactLiveMutationWireFrame(frame) {
+  return encodeContractMutationFrame(frame);
+}
+function encodeEditableArtifactLiveServerWireFrame(frame) {
+  if (frame.type === "transaction" && frame.transaction.modality === "spreadsheet") {
+    const { operationProtocolVersion, modality: _modality, ...transaction } = frame.transaction;
+    return encodeContractServerFrame({
+      ...frame,
+      transaction: {
+        ...transaction,
+        protocolVersion: operationProtocolVersion
+      }
+    });
+  }
+  return encodeContractServerFrame(frame);
+}
+
+export {
+  EditableArtifactCompatibilityError,
+  EditableArtifactApplication,
+  EditableArtifactLiveError,
+  EDITABLE_ARTIFACT_HINT_MAX_BYTES,
+  EDITABLE_ARTIFACT_HINT_SUBJECT_PREFIX,
+  EditableArtifactLiveOutboxDispatcher,
+  EditableArtifactHintEncodingError,
+  encodeEditableArtifactBrokerHint,
+  editableArtifactLiveHintSubject,
+  decodeEditableArtifactBrokerHint,
+  MathEditableArtifactOutboxRandom,
+  EDITABLE_ARTIFACT_LIVE_PROTOCOL_VERSION,
+  EditableArtifactLiveTicketAuthority,
+  InMemoryEditableArtifactLiveTicketStore,
+  WebCryptoEditableArtifactLiveTokens,
+  EditableArtifactLiveServer,
+  SystemEditableArtifactLiveClock,
+  SystemEditableArtifactLiveScheduler,
+  EDITABLE_ARTIFACT_LIVE_WIRE_VERSION,
+  decodeEditableArtifactLiveServerWireFrame,
+  inspectEditableArtifactLiveWireEnvelope,
+  decodeEditableArtifactLiveClientWireFrame,
+  encodeEditableArtifactLiveOpenWireFrame,
+  encodeEditableArtifactLiveAppliedWireFrame,
+  encodeEditableArtifactLiveMutationWireFrame,
+  encodeEditableArtifactLiveServerWireFrame
+};
+//# sourceMappingURL=chunk-NYPMQ7NO.js.map