@opengeni/core 0.21.10 → 0.24.1

package/dist/chunk-6WKPWE5S.js

@@ -0,0 +1,2380 @@
+import {
+  EditableArtifactDomainError,
+  EditableArtifactIdempotencyConflictError,
+  EditableArtifactNotFoundError,
+  EditableArtifactOutboxLeaseConflictError,
+  EditableArtifactSnapshotVerificationError,
+  EditableArtifactStaleBaseError,
+  MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES,
+  assertBoundedArtifactTitle,
+  assertBoundedKernelVersion,
+  assertIsoTimestamp,
+  assertNonnegativeSafeInteger,
+  assertPositiveSafeInteger,
+  causalFrontiersEqual,
+  editableArtifactActorKey,
+  editableArtifactCausalFrontier,
+  editableArtifactClientTransactionId,
+  editableArtifactContentHash,
+  editableArtifactId,
+  editableArtifactOperationId,
+  editableArtifactOutboxId,
+  editableArtifactReceiptId,
+  editableArtifactRequestHash,
+  editableArtifactScope,
+  editableArtifactSnapshotId,
+  editableArtifactStateHash,
+  validateEditableArtifactActor
+} from "./chunk-JJU6I5XD.js";
+
+// src/domain/editable-artifacts/durable-export.ts
+import { createHash } from "crypto";
+var EDITABLE_ARTIFACT_EXPORT_MAX_DOWNLOAD_BYTES = 512 * 1024 * 1024;
+var EDITABLE_ARTIFACT_EXPORT_MAX_OPTIONS_BYTES = 256 * 1024;
+var EditableArtifactDurableExportError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "EditableArtifactDurableExportError";
+  }
+};
+var MAX_AUTHORIZATION_RETRIES = 4;
+var PORTABLE_ID = /^[0-9a-f]{32}$/u;
+var IDEMPOTENCY_KEY = /^[A-Za-z0-9._:-]{1,200}$/u;
+var SHA256 = /^sha256:[0-9a-f]{64}$/u;
+var PROFILE_TEXT = /^[\x21-\x7e]+$/u;
+var EditableArtifactDurableExportService = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async pinVersion(input) {
+    const context = normalizeContext(input);
+    const idempotencyKey = portableIdempotencyKey(input.idempotencyKey);
+    const name = versionName(input.name);
+    const snapshot = await this.dependencies.exactSnapshots.ensure({
+      ...context,
+      ...input.signal ? { signal: input.signal } : {}
+    });
+    if (snapshot.scope.accountId !== context.scope.accountId || snapshot.scope.workspaceId !== context.scope.workspaceId || snapshot.artifactId !== context.artifactId) {
+      throw new EditableArtifactDurableExportError("unavailable");
+    }
+    const requestHash = hashPublicRequest("pin-version", [idempotencyKey, name]);
+    const authorityKey = editableArtifactActorKey(context.actor);
+    const receiptId = stableId(this.dependencies.ids.next("receipt"), "receipt id");
+    const versionId = stableId(this.dependencies.ids.next("version"), "version id");
+    for (let attempt = 0; attempt < MAX_AUTHORIZATION_RETRIES; attempt += 1) {
+      const revision = await this.requireExportPermission(context);
+      const result = await this.dependencies.store.pinVersion({
+        ...context,
+        expectedAuthorizationRevision: revision,
+        authorityKey,
+        receiptId,
+        versionId,
+        idempotencyKey,
+        requestHash,
+        name,
+        snapshot
+      });
+      if (result.kind === "result") {
+        return Object.freeze({ version: result.version, replayed: result.replayed });
+      }
+    }
+    throw new EditableArtifactDurableExportError("conflict");
+  }
+  async enqueueMaterialization(input) {
+    const context = normalizeContext(input);
+    const idempotencyKey = portableIdempotencyKey(input.idempotencyKey);
+    const versionId = stableId(input.versionId, "version id");
+    const format = materializationFormat(input.format);
+    const options = exactOptions(input.options ?? Object.freeze({}));
+    const version = await this.getVersion(context, versionId);
+    const profile = await this.dependencies.profiles.resolve({
+      modality: version.modality,
+      format,
+      options
+    });
+    if (!profile) throw new EditableArtifactDurableExportError("unsupported_format");
+    validateProfile(profile, version.modality, format);
+    const requestHash = hashPublicRequest("materialize", [
+      idempotencyKey,
+      versionId,
+      format,
+      canonicalJson(options)
+    ]);
+    const authorityKey = editableArtifactActorKey(context.actor);
+    const receiptId = stableId(this.dependencies.ids.next("receipt"), "receipt id");
+    const jobId = stableId(this.dependencies.ids.next("materialization_job"), "job id");
+    for (let attempt = 0; attempt < MAX_AUTHORIZATION_RETRIES; attempt += 1) {
+      const revision = await this.requireExportPermission(context);
+      const result = await this.dependencies.store.enqueueMaterialization({
+        ...context,
+        expectedAuthorizationRevision: revision,
+        authorityKey,
+        receiptId,
+        jobId,
+        idempotencyKey,
+        requestHash,
+        versionId,
+        profile
+      });
+      if (result.kind === "result") {
+        return Object.freeze({ job: result.job, replayed: result.replayed });
+      }
+    }
+    throw new EditableArtifactDurableExportError("conflict");
+  }
+  async getMaterialization(input) {
+    const context = normalizeContext(input);
+    const jobId = stableId(input.jobId, "job id");
+    for (let attempt = 0; attempt < MAX_AUTHORIZATION_RETRIES; attempt += 1) {
+      const revision = await this.requireExportPermission(context);
+      const result = await this.dependencies.store.readMaterialization({
+        ...context,
+        expectedAuthorizationRevision: revision,
+        jobId
+      });
+      if (result.kind === "authorization_stale") continue;
+      if (!result.job) throw new EditableArtifactDurableExportError("not_found");
+      return result.job;
+    }
+    throw new EditableArtifactDurableExportError("conflict");
+  }
+  async openMaterializationDownload(input) {
+    const context = normalizeContext(input);
+    const jobId = stableId(input.jobId, "job id");
+    for (let attempt = 0; attempt < MAX_AUTHORIZATION_RETRIES; attempt += 1) {
+      const revision = await this.requireExportPermission(context);
+      const result = await this.dependencies.store.readMaterializationDownload({
+        ...context,
+        expectedAuthorizationRevision: revision,
+        jobId
+      });
+      if (result.kind === "authorization_stale") continue;
+      if (!result.job) throw new EditableArtifactDurableExportError("not_found");
+      const materialization = result.job.result;
+      if (result.job.state !== "succeeded" || !materialization || !result.objectReference) {
+        throw new EditableArtifactDurableExportError("not_ready");
+      }
+      let object;
+      try {
+        object = await this.dependencies.materializationObjects.open({
+          opaqueReference: result.objectReference,
+          maxBytes: EDITABLE_ARTIFACT_EXPORT_MAX_DOWNLOAD_BYTES,
+          expectedByteSize: materialization.byteSize,
+          ...input.signal ? { signal: input.signal } : {}
+        });
+      } catch {
+        throw new EditableArtifactDurableExportError("unavailable");
+      }
+      if (object.contentType !== void 0 && object.contentType !== materialization.mimeType) {
+        await object.close();
+        throw new EditableArtifactDurableExportError("unavailable");
+      }
+      return Object.freeze({
+        artifactId: context.artifactId,
+        jobId,
+        format: result.job.format,
+        byteSize: materialization.byteSize,
+        contentHash: materialization.contentHash,
+        mimeType: materialization.mimeType,
+        chunks: (chunkInput = {}) => object.chunks(chunkInput.signal ? { signal: chunkInput.signal } : {}),
+        assertUnchanged: async (signal) => await object.assertUnchanged(signal),
+        close: async () => await object.close()
+      });
+    }
+    throw new EditableArtifactDurableExportError("conflict");
+  }
+  async getVersion(context, versionId) {
+    for (let attempt = 0; attempt < MAX_AUTHORIZATION_RETRIES; attempt += 1) {
+      const revision = await this.requireExportPermission(context);
+      const result = await this.dependencies.store.readVersion({
+        ...context,
+        expectedAuthorizationRevision: revision,
+        versionId
+      });
+      if (result.kind === "authorization_stale") continue;
+      if (!result.version) throw new EditableArtifactDurableExportError("not_found");
+      return result.version;
+    }
+    throw new EditableArtifactDurableExportError("conflict");
+  }
+  async requireExportPermission(context) {
+    const decision = await this.dependencies.authorization.authorize({
+      ...context,
+      permission: "export"
+    });
+    if (!decision.allowed) throw new EditableArtifactDurableExportError("forbidden");
+    if (!Number.isSafeInteger(decision.revision) || decision.revision < 1) {
+      throw new EditableArtifactDurableExportError("unavailable");
+    }
+    return decision.revision;
+  }
+};
+function editableArtifactMaterializationMimeType(format) {
+  switch (format) {
+    case "xlsx":
+      return "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet";
+    case "pptx":
+      return "application/vnd.openxmlformats-officedocument.presentationml.presentation";
+    case "docx":
+      return "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
+    case "pdf":
+      return "application/pdf";
+    case "png":
+      return "image/png";
+    case "webp":
+      return "image/webp";
+  }
+}
+function editableArtifactFormatMatchesModality(modality, format) {
+  return modality === "spreadsheet" && ["xlsx", "pdf", "png", "webp"].includes(format) || modality === "presentation" && ["pptx", "pdf", "png", "webp"].includes(format) || modality === "document" && ["docx", "pdf", "png", "webp"].includes(format);
+}
+function normalizeContext(input) {
+  const scope = editableArtifactScope(input.scope);
+  const artifactId = editableArtifactId(input.artifactId);
+  validateEditableArtifactActor(input.actor);
+  return Object.freeze({
+    scope,
+    artifactId,
+    actor: Object.freeze({ ...input.actor })
+  });
+}
+function stableId(value, _label) {
+  if (!PORTABLE_ID.test(value) || /^0+$/u.test(value)) {
+    throw new EditableArtifactDurableExportError("invalid_request");
+  }
+  return value;
+}
+function portableIdempotencyKey(value) {
+  if (!IDEMPOTENCY_KEY.test(value)) {
+    throw new EditableArtifactDurableExportError("invalid_request");
+  }
+  return value;
+}
+function versionName(value) {
+  if (typeof value !== "string" || value.trim() !== value || /[\u0000-\u001f\u007f]/u.test(value) || new TextEncoder().encode(value).byteLength < 1 || new TextEncoder().encode(value).byteLength > 256 || !wellFormedText(value)) {
+    throw new EditableArtifactDurableExportError("invalid_request");
+  }
+  return value;
+}
+function materializationFormat(value) {
+  if (!["xlsx", "pptx", "docx", "pdf", "png", "webp"].includes(value)) {
+    throw new EditableArtifactDurableExportError("invalid_request");
+  }
+  return value;
+}
+function exactOptions(value) {
+  if (!plainRecord(value)) throw new EditableArtifactDurableExportError("invalid_request");
+  const canonical = canonicalJson(value);
+  if (new TextEncoder().encode(canonical).byteLength > EDITABLE_ARTIFACT_EXPORT_MAX_OPTIONS_BYTES) {
+    throw new EditableArtifactDurableExportError("invalid_request");
+  }
+  return Object.freeze({ ...value });
+}
+function canonicalJson(value) {
+  const keys = Object.keys(value).sort(compareCodeUnits);
+  const normalized = {};
+  for (const key of keys) {
+    if (!wellFormedText(key) || !jsonValue(value[key])) {
+      throw new EditableArtifactDurableExportError("invalid_request");
+    }
+    normalized[key] = value[key];
+  }
+  const encoded = JSON.stringify(normalized);
+  if (encoded === void 0) throw new EditableArtifactDurableExportError("invalid_request");
+  return encoded;
+}
+function validateProfile(profile, modality, format) {
+  if (!plainRecord(profile) || profile.modality !== modality || profile.format !== format || !editableArtifactFormatMatchesModality(modality, format) || !boundedProfileText(profile.codecId, 128) || !boundedProfileText(profile.codecVersion, 128) || !boundedProfileText(profile.kernelVersion, 512) || !SHA256.test(profile.fontRegistryHash) || !SHA256.test(profile.policyHash) || profile.normalizedOptions.trim() !== profile.normalizedOptions || new TextEncoder().encode(profile.normalizedOptions).byteLength > EDITABLE_ARTIFACT_EXPORT_MAX_OPTIONS_BYTES) {
+    throw new EditableArtifactDurableExportError("unavailable");
+  }
+  let decoded;
+  try {
+    decoded = JSON.parse(profile.normalizedOptions);
+  } catch {
+    throw new EditableArtifactDurableExportError("unavailable");
+  }
+  if (!plainRecord(decoded) || canonicalJson(decoded) !== profile.normalizedOptions) {
+    throw new EditableArtifactDurableExportError("unavailable");
+  }
+}
+function boundedProfileText(value, maximumBytes) {
+  return typeof value === "string" && PROFILE_TEXT.test(value) && new TextEncoder().encode(value).byteLength <= maximumBytes;
+}
+function hashPublicRequest(kind, fields) {
+  const digest = createHash("sha256");
+  digest.update("OpenGeni editable artifact durable export\0v1\0", "utf8");
+  digest.update(kind, "utf8");
+  digest.update("\0", "utf8");
+  for (const field of fields) {
+    const bytes = Buffer.from(field, "utf8");
+    const length = Buffer.allocUnsafe(4);
+    length.writeUInt32BE(bytes.byteLength);
+    digest.update(length);
+    digest.update(bytes);
+  }
+  return `sha256:${digest.digest("hex")}`;
+}
+function plainRecord(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const prototype = Object.getPrototypeOf(value);
+  return prototype === Object.prototype || prototype === null;
+}
+function jsonValue(value, depth = 0) {
+  if (depth > 32) return false;
+  if (value === null || typeof value === "boolean" || typeof value === "string") {
+    return typeof value !== "string" || wellFormedText(value);
+  }
+  if (typeof value === "number") return Number.isFinite(value);
+  if (Array.isArray(value))
+    return value.length <= 1e4 && value.every((item) => jsonValue(item, depth + 1));
+  if (!plainRecord(value) || Object.keys(value).length > 1e4) return false;
+  return Object.entries(value).every(
+    ([key, item]) => wellFormedText(key) && jsonValue(item, depth + 1)
+  );
+}
+function wellFormedText(value) {
+  if (value.includes("\0")) return false;
+  for (let index = 0; index < value.length; index += 1) {
+    const unit = value.charCodeAt(index);
+    if (unit >= 55296 && unit <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!Number.isFinite(next) || next < 56320 || next > 57343) return false;
+      index += 1;
+    } else if (unit >= 56320 && unit <= 57343) {
+      return false;
+    }
+  }
+  return true;
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function validateEditableArtifactPinnedVersion(version) {
+  const scope = editableArtifactScope(version.scope);
+  const artifactId = editableArtifactId(version.artifactId);
+  const id = stableId(version.id, "version id");
+  const snapshotId = editableArtifactSnapshotId(version.snapshotId);
+  if (!Number.isSafeInteger(version.headSequence) || version.headSequence < 0) {
+    throw new EditableArtifactDurableExportError("unavailable");
+  }
+  const stateHash = editableArtifactStateHash(version.stateHash);
+  versionName(version.name);
+  assertIsoTimestamp(version.createdAt, "version creation time");
+  if (version.pinned !== true || !wellFormedText(version.createdBySubjectId)) {
+    throw new EditableArtifactDurableExportError("unavailable");
+  }
+  if (version.modality === "spreadsheet" && (!Array.isArray(version.causalFrontier) || version.nativeRevision !== null) || version.modality !== "spreadsheet" && (version.causalFrontier !== null || !Number.isSafeInteger(version.nativeRevision) || version.nativeRevision < 0)) {
+    throw new EditableArtifactDurableExportError("unavailable");
+  }
+  return Object.freeze({
+    ...version,
+    scope,
+    artifactId,
+    id,
+    snapshotId,
+    stateHash,
+    causalFrontier: version.causalFrontier === null ? null : Object.freeze(version.causalFrontier.map((entry) => Object.freeze({ ...entry })))
+  });
+}
+function validateEditableArtifactMaterializationJob(job) {
+  const scope = editableArtifactScope(job.scope);
+  const artifactId = editableArtifactId(job.artifactId);
+  const id = stableId(job.id, "job id");
+  const versionId = stableId(job.versionId, "version id");
+  const inputSnapshotId = stableId(job.inputSnapshotId, "snapshot id");
+  const stateHash = editableArtifactStateHash(job.stateHash);
+  const format = materializationFormat(job.format);
+  if (!Number.isSafeInteger(job.targetHeadSequence) || job.targetHeadSequence < 0 || !Number.isSafeInteger(job.attemptCount) || job.attemptCount < 0 || !["pending", "running", "succeeded", "failed"].includes(job.state)) {
+    throw new EditableArtifactDurableExportError("unavailable");
+  }
+  assertIsoTimestamp(job.createdAt, "job creation time");
+  if (job.startedAt !== null) assertIsoTimestamp(job.startedAt, "job start time");
+  if (job.completedAt !== null) assertIsoTimestamp(job.completedAt, "job completion time");
+  let result = null;
+  if (job.result) {
+    result = Object.freeze({
+      ...job.result,
+      id: stableId(job.result.id, "result id"),
+      contentHash: editableArtifactContentHash(job.result.contentHash),
+      mimeType: editableArtifactMaterializationMimeType(format)
+    });
+    if (job.result.mimeType !== result.mimeType || !Number.isSafeInteger(job.result.byteSize) || job.result.byteSize < 1 || job.result.byteSize > EDITABLE_ARTIFACT_EXPORT_MAX_DOWNLOAD_BYTES) {
+      throw new EditableArtifactDurableExportError("unavailable");
+    }
+    assertIsoTimestamp(job.result.verifiedAt, "result verification time");
+    assertIsoTimestamp(job.result.createdAt, "result creation time");
+  }
+  if (job.state === "succeeded" !== (result !== null)) {
+    throw new EditableArtifactDurableExportError("unavailable");
+  }
+  return Object.freeze({
+    ...job,
+    scope,
+    artifactId,
+    id,
+    versionId,
+    inputSnapshotId,
+    stateHash,
+    format,
+    result
+  });
+}
+
+// src/domain/editable-artifacts/agent-application.ts
+import { createHash as createHash2 } from "crypto";
+import {
+  COMMITTED_TRANSACTION_PROTOCOL_VERSION,
+  EDITABLE_ARTIFACT_MODEL_SCHEMA_VERSION
+} from "@opengeni/contracts/editable-artifact-versions";
+import {
+  DOCUMENT_ARTIFACT_COMMAND_VERSION,
+  EDITABLE_ARTIFACT_INTENT_VERSION,
+  PRESENTATION_ARTIFACT_COMMAND_VERSION,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  decodeEditableArtifactMutationIntent,
+  decodeDocumentArtifactQueryResponse,
+  decodePresentationArtifactQueryResponse,
+  decodeSpreadsheetArtifactKernelProjection,
+  encodeDocumentArtifactCommandBatch,
+  encodeDocumentArtifactQuery,
+  encodePresentationArtifactCommandBatch,
+  encodePresentationArtifactQuery,
+  encodeSpreadsheetArtifactCommandBatch,
+  encodeSpreadsheetArtifactKernelQuery,
+  hashEditableArtifactMutationIntent
+} from "@opengeni/contracts/editable-artifacts";
+var EditableArtifactOfficeImportError = class extends Error {
+  constructor(code) {
+    super(code);
+    this.code = code;
+    this.name = "EditableArtifactOfficeImportError";
+  }
+};
+var EditableArtifactAgentApplication = class {
+  constructor(dependencies) {
+    this.dependencies = dependencies;
+  }
+  async list(input) {
+    const context = agentContext(input);
+    const limit = boundedLimit(input.limit ?? 64);
+    const ids = await this.dependencies.associations.listArtifactIds({
+      scope: context.scope,
+      sessionId: context.sessionId,
+      limit
+    });
+    const artifacts = [];
+    for (const artifactId of ids) {
+      try {
+        const artifact = await this.dependencies.domain.getArtifact({
+          scope: context.scope,
+          actor: context.actor,
+          artifactId
+        });
+        artifacts.push(projectArtifact(artifact));
+      } catch (error) {
+        if (error instanceof EditableArtifactNotFoundError || error instanceof EditableArtifactDomainError && error.code === "forbidden") {
+          continue;
+        }
+        throw error;
+      }
+    }
+    return Object.freeze(artifacts);
+  }
+  async create(input) {
+    const context = agentContext(input);
+    const result = await this.dependencies.domain.createArtifact({
+      scope: context.scope,
+      actor: context.actor,
+      request: {
+        idempotencyKey: editableArtifactClientTransactionId(input.idempotencyKey),
+        modality: input.modality,
+        title: input.title
+      },
+      ...input.signal ? { signal: input.signal } : {}
+    });
+    await this.touch(context, result.artifact.id);
+    return projectArtifact(result.artifact);
+  }
+  async import(input) {
+    const context = agentContext(input);
+    const prepared = await this.dependencies.officeImports.prepare({
+      scope: context.scope,
+      actor: context.actor,
+      fileId: input.fileId,
+      modality: input.modality,
+      ...input.signal ? { signal: input.signal } : {}
+    });
+    const result = await this.dependencies.domain.importArtifact({
+      scope: context.scope,
+      actor: context.actor,
+      request: {
+        idempotencyKey: editableArtifactClientTransactionId(input.idempotencyKey),
+        modality: input.modality,
+        title: input.title,
+        originalImport: prepared.originalImport,
+        snapshot: prepared.snapshot
+      },
+      ...input.signal ? { signal: input.signal } : {}
+    });
+    await this.touch(context, result.artifact.id);
+    return projectArtifact(result.artifact);
+  }
+  async get(input) {
+    const context = agentContext(input);
+    const artifact = await this.dependencies.domain.getArtifact({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId: editableArtifactId(input.artifactId)
+    });
+    await this.touch(context, artifact.id);
+    return projectArtifact(artifact);
+  }
+  async inspect(input) {
+    const context = agentContext(input);
+    const artifactId = editableArtifactId(input.artifactId);
+    const state = await this.dependencies.domain.readCurrentKernelState({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId
+    });
+    if (state.modality !== input.request.modality)
+      throw new TypeError("Artifact modality mismatch");
+    const queryBytes = encodeQuery(input.request);
+    const responseBytes = await this.dependencies.inspector.query({ state, queryBytes });
+    const projection = decodeQueryResponse(input.request.modality, responseBytes);
+    await this.touch(context, artifactId);
+    return Object.freeze({ artifact: projectArtifact(state.artifact), projection });
+  }
+  async apply(input) {
+    const context = agentContext(input);
+    const artifactId = editableArtifactId(input.artifactId);
+    const commandBytes = encodeCommands(input.batch);
+    const clientTransactionId = editableArtifactClientTransactionId(input.clientTransactionId);
+    const expectedHeadSequence = boundedHeadSequence(input.expectedHeadSequence);
+    const expectedStateHash = editableArtifactStateHash(input.expectedStateHash);
+    const artifact = await this.dependencies.domain.getArtifact({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId
+    });
+    if (artifact.modality !== input.batch.modality)
+      throw new TypeError("Artifact modality mismatch");
+    if (artifact.headSequence !== expectedHeadSequence || artifact.stateHash !== expectedStateHash) {
+      const existing = await this.dependencies.domain.findTransactionReceipt({
+        scope: context.scope,
+        actor: context.actor,
+        artifactId,
+        clientTransactionId
+      });
+      if (existing) {
+        if (!receiptMatchesAgentMutation(
+          existing,
+          expectedHeadSequence,
+          expectedStateHash,
+          commandBytes
+        )) {
+          throw new EditableArtifactIdempotencyConflictError();
+        }
+        await this.touch(context, artifactId);
+        return Object.freeze({
+          artifact: projectArtifact(artifact),
+          transaction: projectReceipt(existing, true)
+        });
+      }
+      throw new EditableArtifactStaleBaseError();
+    }
+    const authored = hashEditableArtifactMutationIntent({
+      envelopeVersion: EDITABLE_ARTIFACT_INTENT_VERSION,
+      protocolVersion: COMMITTED_TRANSACTION_PROTOCOL_VERSION,
+      modelSchemaVersion: EDITABLE_ARTIFACT_MODEL_SCHEMA_VERSION,
+      commandProtocolVersion: commandProtocolVersion(input.batch.modality),
+      artifactId,
+      clientTransactionId,
+      replicaId: context.actor.replicaId,
+      replicaCounter: 1,
+      previousLocalTransactionId: null,
+      observedHeadSequence: expectedHeadSequence,
+      causalBase: artifact.modality === "spreadsheet" ? artifact.causalFrontier : [],
+      selectiveUndoOperationIds: [],
+      commandBytes
+    });
+    let applied;
+    try {
+      applied = await this.dependencies.domain.applyTransaction({
+        scope: context.scope,
+        actor: context.actor,
+        artifactId,
+        request: {
+          intentBytes: authored.bytes,
+          requestHash: editableArtifactRequestHash(authored.requestHash),
+          expectedHead: Object.freeze({
+            sequence: expectedHeadSequence,
+            stateHash: expectedStateHash
+          })
+        }
+      });
+    } catch (error) {
+      if (!(error instanceof EditableArtifactIdempotencyConflictError)) throw error;
+      const receipt = await this.dependencies.domain.findTransactionReceipt({
+        scope: context.scope,
+        actor: context.actor,
+        artifactId,
+        clientTransactionId
+      });
+      if (!receipt || !receiptMatchesAgentMutation(receipt, expectedHeadSequence, expectedStateHash, commandBytes)) {
+        throw error;
+      }
+      applied = Object.freeze({ receipt, replayed: true });
+    }
+    const current = await this.dependencies.domain.getArtifact({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId
+    });
+    await this.touch(context, artifactId);
+    return Object.freeze({
+      artifact: projectArtifact(current),
+      transaction: projectReceipt(applied.receipt, applied.replayed)
+    });
+  }
+  async startExport(input) {
+    const context = agentContext(input);
+    const artifactId = editableArtifactId(input.artifactId);
+    const artifact = await this.dependencies.domain.getArtifact({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId
+    });
+    const version = await this.dependencies.exports.pinVersion({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId,
+      idempotencyKey: exportChildIdempotencyKey(input.idempotencyKey, "version"),
+      name: `Export ${artifact.title}`,
+      ...input.signal ? { signal: input.signal } : {}
+    });
+    const materialization = await this.dependencies.exports.enqueueMaterialization({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId,
+      idempotencyKey: exportChildIdempotencyKey(input.idempotencyKey, "materialization"),
+      versionId: version.version.id,
+      format: input.format,
+      ...input.options ? { options: input.options } : {}
+    });
+    const current = await this.dependencies.domain.getArtifact({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId
+    });
+    await this.touch(context, artifactId);
+    return Object.freeze({
+      artifact: projectArtifact(current),
+      versionId: version.version.id,
+      jobId: materialization.job.id,
+      sourceHeadSequence: materialization.job.targetHeadSequence,
+      sourceStateHash: materialization.job.stateHash,
+      state: materialization.job.state
+    });
+  }
+  async exportStatus(input) {
+    const context = agentContext(input);
+    const artifactId = editableArtifactId(input.artifactId);
+    const artifact = await this.dependencies.domain.getArtifact({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId
+    });
+    const job = await this.dependencies.exports.getMaterialization({
+      scope: context.scope,
+      actor: context.actor,
+      artifactId,
+      jobId: input.jobId
+    });
+    if (job.versionId !== input.versionId) throw new TypeError("Export version mismatch");
+    const file = job.state === "succeeded" && job.result ? await this.dependencies.workspaceFiles.ensureMaterializationFile({
+      scope: context.scope,
+      actor: context.actor,
+      artifact,
+      versionId: job.versionId,
+      jobId: job.id,
+      filename: defaultExportFilename(artifact.title, job.format),
+      sourceHeadSequence: job.targetHeadSequence,
+      sourceStateHash: job.stateHash,
+      ...input.signal ? { signal: input.signal } : {}
+    }) : null;
+    await this.touch(context, artifactId);
+    return Object.freeze({
+      artifact: projectArtifact(artifact),
+      versionId: job.versionId,
+      jobId: job.id,
+      sourceHeadSequence: job.targetHeadSequence,
+      sourceStateHash: job.stateHash,
+      state: job.state,
+      errorCode: job.errorCode,
+      file
+    });
+  }
+  async touch(context, artifactId) {
+    await this.dependencies.associations.touch({
+      scope: context.scope,
+      sessionId: context.sessionId,
+      artifactId
+    });
+  }
+};
+function agentContext(input) {
+  const scope = editableArtifactScope(input.scope);
+  validateEditableArtifactActor(input.actor);
+  if (input.actor.kind !== "agent" || input.actor.sessionId !== input.sessionId) {
+    throw new TypeError("Artifact agent context is not bound to its attempt session");
+  }
+  return Object.freeze({
+    scope,
+    actor: Object.freeze({ ...input.actor }),
+    sessionId: boundedSessionId(input.sessionId)
+  });
+}
+function encodeCommands(batch) {
+  if (batch.modality === "spreadsheet") {
+    return encodeSpreadsheetArtifactCommandBatch({ version: 1, commands: batch.commands });
+  }
+  if (batch.modality === "document") {
+    return encodeDocumentArtifactCommandBatch({ version: 1, commands: batch.commands });
+  }
+  return encodePresentationArtifactCommandBatch({ version: 1, commands: batch.commands });
+}
+function encodeQuery(request) {
+  if (request.modality === "spreadsheet") {
+    return encodeSpreadsheetArtifactKernelQuery(request.query);
+  }
+  if (request.modality === "document") return encodeDocumentArtifactQuery(request.query);
+  return encodePresentationArtifactQuery(request.query);
+}
+function decodeQueryResponse(modality, bytes) {
+  if (modality === "spreadsheet") return decodeSpreadsheetArtifactKernelProjection(bytes);
+  if (modality === "document") return decodeDocumentArtifactQueryResponse(bytes);
+  return decodePresentationArtifactQueryResponse(bytes);
+}
+function commandProtocolVersion(modality) {
+  if (modality === "spreadsheet") return SPREADSHEET_ARTIFACT_COMMAND_VERSION;
+  if (modality === "document") return DOCUMENT_ARTIFACT_COMMAND_VERSION;
+  return PRESENTATION_ARTIFACT_COMMAND_VERSION;
+}
+function projectArtifact(artifact) {
+  return Object.freeze({
+    id: artifact.id,
+    modality: artifact.modality,
+    title: artifact.title,
+    lifecycle: artifact.lifecycle,
+    headSequence: artifact.headSequence,
+    stateHash: artifact.stateHash,
+    createdAt: artifact.createdAt,
+    updatedAt: artifact.updatedAt
+  });
+}
+function projectReceipt(receipt, replayed) {
+  return Object.freeze({
+    id: receipt.serverTransactionId,
+    clientTransactionId: receipt.clientTransactionId,
+    sequenceStart: receipt.sequenceStart,
+    sequenceEnd: receipt.sequenceEnd,
+    stateHash: receipt.stateHash,
+    committedAt: receipt.committedAt,
+    replayed
+  });
+}
+function receiptMatchesAgentMutation(receipt, expectedHeadSequence, expectedStateHash, commandBytes) {
+  const intent = decodeEditableArtifactMutationIntent(receipt.intentBytes);
+  return intent.observedHeadSequence === expectedHeadSequence && receipt.priorStateHash === expectedStateHash && sameBytes(commandBytes, intent.commandBytes);
+}
+function sameBytes(left, right) {
+  if (left.byteLength !== right.byteLength) return false;
+  for (let index = 0; index < left.byteLength; index += 1) {
+    if (left[index] !== right[index]) return false;
+  }
+  return true;
+}
+function boundedSessionId(value) {
+  if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u.test(value)) {
+    throw new TypeError("Artifact session id is invalid");
+  }
+  return value;
+}
+function boundedLimit(value) {
+  if (!Number.isSafeInteger(value) || value < 1 || value > 64) {
+    throw new TypeError("Artifact list limit must be between 1 and 64");
+  }
+  return value;
+}
+function boundedHeadSequence(value) {
+  if (!Number.isSafeInteger(value) || value < 0) {
+    throw new TypeError("Artifact expected head sequence must be a nonnegative safe integer");
+  }
+  return value;
+}
+function defaultExportFilename(title, format) {
+  const stem = title.normalize("NFKC").replace(/[\\/:*?"<>|\u0000-\u001f\u007f]+/gu, "-").replace(/\s+/gu, " ").trim().slice(0, 180);
+  return `${stem || "artifact"}.${format}`;
+}
+function exportChildIdempotencyKey(value, operation) {
+  const digest = createHash2("sha256").update("opengeni:editable-artifact-export:v1\0", "utf8").update(operation, "utf8").update("\0", "utf8").update(value, "utf8").digest("hex");
+  return `artifact-export:${operation}:${digest}`;
+}
+
+// src/domain/editable-artifacts/durable-export-postgres.ts
+import {
+  EditableArtifactDurableExportPersistenceError
+} from "@opengeni/db/editable-artifact-durable-export";
+function editableArtifactDurableExportStorePortFromPostgres(store) {
+  return Object.freeze({
+    async pinVersion(input) {
+      try {
+        const result = await store.pinVersion(persistedPinRequest(input));
+        if (result.kind === "authorization_stale") return result;
+        return Object.freeze({
+          kind: "result",
+          version: versionFromPersisted(result.value.version),
+          replayed: result.value.replayed
+        });
+      } catch (error) {
+        throw mapPersistenceError(error);
+      }
+    },
+    async enqueueMaterialization(input) {
+      try {
+        const result = await store.enqueueMaterialization(persistedEnqueueRequest(input));
+        if (result.kind === "authorization_stale") return result;
+        return Object.freeze({
+          kind: "result",
+          job: jobFromPersisted(result.value.job),
+          replayed: result.value.replayed
+        });
+      } catch (error) {
+        throw mapPersistenceError(error);
+      }
+    },
+    async readVersion(input) {
+      try {
+        const result = await store.readVersion(input);
+        if (result.kind === "authorization_stale") return result;
+        return Object.freeze({
+          kind: "result",
+          version: result.value ? versionFromPersisted(result.value) : null
+        });
+      } catch (error) {
+        throw mapPersistenceError(error);
+      }
+    },
+    async readMaterialization(input) {
+      try {
+        const result = await store.readMaterialization(input);
+        if (result.kind === "authorization_stale") return result;
+        return Object.freeze({
+          kind: "result",
+          job: result.value ? jobFromPersisted(result.value) : null
+        });
+      } catch (error) {
+        throw mapPersistenceError(error);
+      }
+    },
+    async readMaterializationDownload(input) {
+      try {
+        const result = await store.readMaterializationDownload(input);
+        if (result.kind === "authorization_stale") return result;
+        return Object.freeze({
+          kind: "result",
+          job: result.value.job ? jobFromPersisted(result.value.job) : null,
+          objectReference: result.value.objectReference
+        });
+      } catch (error) {
+        throw mapPersistenceError(error);
+      }
+    }
+  });
+}
+function persistedPinRequest(input) {
+  const snapshot = input.snapshot;
+  return {
+    ...input,
+    snapshot: {
+      modality: snapshot.modality,
+      snapshotId: snapshot.snapshotId,
+      coveredHeadSequence: snapshot.coveredHeadSequence,
+      stateHash: snapshot.stateHash,
+      coveredCausalFrontier: snapshot.modality === "spreadsheet" ? snapshot.coveredCausalFrontier : null,
+      nativeRevision: snapshot.modality === "spreadsheet" ? null : snapshot.nativeRevision
+    }
+  };
+}
+function persistedEnqueueRequest(input) {
+  return { ...input };
+}
+function versionFromPersisted(value) {
+  return validateEditableArtifactPinnedVersion(value);
+}
+function jobFromPersisted(value) {
+  return validateEditableArtifactMaterializationJob(value);
+}
+function mapPersistenceError(error) {
+  if (!(error instanceof EditableArtifactDurableExportPersistenceError)) return error;
+  switch (error.code) {
+    case "not_found":
+      return new EditableArtifactDurableExportError("not_found");
+    case "idempotency_conflict":
+    case "snapshot_conflict":
+      return new EditableArtifactDurableExportError("conflict");
+    case "unsupported_format":
+      return new EditableArtifactDurableExportError("unsupported_format");
+    case "database_contract_violation":
+      return new EditableArtifactDurableExportError("unavailable");
+  }
+}
+
+// src/domain/editable-artifacts/in-memory.ts
+import { decodeCommittedTransactionSummary } from "@opengeni/contracts/editable-artifact-committed-transaction";
+import { decodeEditableArtifactSerializedCommit } from "@opengeni/contracts/editable-artifact-serialized-commit";
+var InMemoryEditableArtifactStore = class {
+  constructor(now = () => /* @__PURE__ */ new Date()) {
+    this.now = now;
+  }
+  aggregates = /* @__PURE__ */ new Map();
+  creationReceipts = /* @__PURE__ */ new Map();
+  scopeCreateAuthorizationRevisions = /* @__PURE__ */ new Map();
+  exclusiveTail = Promise.resolve();
+  async findArtifactCreation(scopeInput, operationKind, authorityKey, idempotencyKeyInput) {
+    const scope = editableArtifactScope(scopeInput);
+    const idempotencyKey = editableArtifactClientTransactionId(idempotencyKeyInput);
+    const key = creationReceiptKey(scope, operationKind, authorityKey, idempotencyKey);
+    return this.exclusive(async () => {
+      const receipt = this.creationReceipts.get(key);
+      if (!receipt) return null;
+      const aggregate = this.aggregates.get(aggregateKey(scope, receipt.artifactId));
+      const snapshot = aggregate?.snapshots.get(receipt.genesisSnapshotId);
+      if (!aggregate || !snapshot) {
+        throw new Error("Artifact creation receipt is corrupt");
+      }
+      return Object.freeze({
+        artifact: cloneArtifact(aggregate.artifact),
+        genesisSnapshot: cloneSnapshot(snapshot),
+        creationReceipt: cloneCreationReceipt(receipt),
+        replayed: true
+      });
+    });
+  }
+  async createArtifact(input) {
+    const scope = editableArtifactScope(input.scope);
+    const artifactId = editableArtifactId(input.artifactId);
+    const receiptId = editableArtifactReceiptId(input.receiptId);
+    const idempotencyKey = editableArtifactClientTransactionId(input.idempotencyKey);
+    const requestHash = editableArtifactRequestHash(input.requestHash);
+    if (input.operationKind !== "create" && input.operationKind !== "import") {
+      throw new TypeError("Unknown editable artifact origin operation");
+    }
+    if (input.operationKind === "import" !== Boolean(input.originalImport)) {
+      throw new TypeError("Editable artifact import source does not match its origin operation");
+    }
+    assertBoundedArtifactTitle(input.title);
+    assertPositiveSafeInteger(
+      input.expectedScopeAuthorizationRevision,
+      "expected scope create authorization revision"
+    );
+    assertPositiveSafeInteger(
+      input.initialArtifactAuthorizationRevision,
+      "initial artifact authorization revision"
+    );
+    const genesisSnapshot = cloneSnapshot(input.genesisSnapshot);
+    const outbox = cloneOutbox(input.outbox);
+    assertGenesisCreateRequest(scope, artifactId, input.operationKind, genesisSnapshot, outbox);
+    if (!["spreadsheet", "presentation", "document"].includes(input.modality)) {
+      throw new TypeError("Unknown editable artifact modality");
+    }
+    if (genesisSnapshot.modality !== input.modality) {
+      throw new TypeError("Genesis snapshot modality does not match artifact modality");
+    }
+    const creationKey = creationReceiptKey(
+      scope,
+      input.operationKind,
+      input.authorityKey,
+      idempotencyKey
+    );
+    return this.exclusive(async () => {
+      const prior = this.creationReceipts.get(creationKey);
+      if (prior) {
+        if (prior.requestHash !== requestHash) {
+          throw new EditableArtifactIdempotencyConflictError();
+        }
+        const replay = this.aggregates.get(aggregateKey(scope, prior.artifactId));
+        if (!replay) throw new Error("Artifact creation receipt is corrupt");
+        const replaySnapshot = replay.snapshots.get(prior.genesisSnapshotId);
+        if (!replaySnapshot) {
+          throw new Error("Artifact creation receipt has no genesis snapshot");
+        }
+        return Object.freeze({
+          kind: "result",
+          value: Object.freeze({
+            artifact: cloneArtifact(replay.artifact),
+            genesisSnapshot: cloneSnapshot(replaySnapshot),
+            creationReceipt: cloneCreationReceipt(prior),
+            replayed: true
+          })
+        });
+      }
+      const scopeKey = authorizationScopeKey(scope);
+      const currentScopeRevision = this.scopeCreateAuthorizationRevisions.get(scopeKey) ?? 1;
+      if (currentScopeRevision !== input.expectedScopeAuthorizationRevision) {
+        return Object.freeze({ kind: "authorization_stale" });
+      }
+      const key = aggregateKey(scope, artifactId);
+      if (this.aggregates.has(key)) {
+        throw new Error("Editable artifact identity already exists");
+      }
+      const commonArtifact = {
+        scope,
+        id: artifactId,
+        title: input.title,
+        lifecycle: "active",
+        authorizationRevision: input.initialArtifactAuthorizationRevision,
+        headSequence: 0,
+        stateHash: genesisSnapshot.stateHash,
+        currentSnapshotId: genesisSnapshot.snapshotId,
+        createdAt: genesisSnapshot.publishedAt,
+        updatedAt: genesisSnapshot.publishedAt
+      };
+      const artifact = input.modality === "spreadsheet" ? {
+        ...commonArtifact,
+        modality: "spreadsheet",
+        causalFrontier: editableArtifactCausalFrontier(
+          genesisSnapshot.modality === "spreadsheet" ? genesisSnapshot.coveredCausalFrontier : []
+        )
+      } : { ...commonArtifact, modality: input.modality };
+      const creationReceipt = Object.freeze({
+        receiptId,
+        scope,
+        artifactId,
+        operationKind: input.operationKind,
+        authorityKey: input.authorityKey,
+        idempotencyKey,
+        requestHash,
+        genesisSnapshotId: genesisSnapshot.snapshotId,
+        createdAt: genesisSnapshot.publishedAt
+      });
+      this.aggregates.set(key, emptyAggregate(artifact, genesisSnapshot, outbox));
+      this.creationReceipts.set(creationKey, creationReceipt);
+      return Object.freeze({
+        kind: "result",
+        value: Object.freeze({
+          artifact: cloneArtifact(artifact),
+          genesisSnapshot: cloneSnapshot(genesisSnapshot),
+          creationReceipt: cloneCreationReceipt(creationReceipt),
+          replayed: false
+        })
+      });
+    });
+  }
+  async readScopeCreateAuthorizationRevision(scope) {
+    const key = authorizationScopeKey(editableArtifactScope(scope));
+    return this.exclusive(async () => {
+      const revision = this.scopeCreateAuthorizationRevisions.get(key) ?? 1;
+      this.scopeCreateAuthorizationRevisions.set(key, revision);
+      return revision;
+    });
+  }
+  async advanceScopeCreateAuthorizationRevision(scope, expectedRevision, nextRevision) {
+    assertPositiveSafeInteger(expectedRevision, "expected scope create authorization revision");
+    assertPositiveSafeInteger(nextRevision, "next scope create authorization revision");
+    if (nextRevision <= expectedRevision) {
+      throw new TypeError(
+        "Next scope create authorization revision must exceed the expected revision"
+      );
+    }
+    const key = authorizationScopeKey(editableArtifactScope(scope));
+    return this.exclusive(async () => {
+      const current = this.scopeCreateAuthorizationRevisions.get(key) ?? 1;
+      if (current !== expectedRevision) {
+        return Object.freeze({
+          applied: false,
+          authorizationRevision: current
+        });
+      }
+      this.scopeCreateAuthorizationRevisions.set(key, nextRevision);
+      return Object.freeze({
+        applied: true,
+        authorizationRevision: nextRevision
+      });
+    });
+  }
+  async seedArtifact(input) {
+    const scope = editableArtifactScope(input.scope);
+    const artifactId = editableArtifactId(input.artifactId);
+    assertBoundedArtifactTitle(input.title);
+    const stateHash = editableArtifactStateHash(input.stateHash);
+    const createdAt = input.createdAt ?? (/* @__PURE__ */ new Date(0)).toISOString();
+    assertIsoTimestamp(createdAt, "artifact creation timestamp");
+    if (!["spreadsheet", "presentation", "document"].includes(input.modality)) {
+      throw new TypeError("Unknown editable artifact modality");
+    }
+    const lifecycle = input.lifecycle ?? "active";
+    if (lifecycle !== "active" && lifecycle !== "archived") {
+      throw new TypeError("Unknown editable artifact lifecycle state");
+    }
+    const authorizationRevision = input.authorizationRevision ?? 1;
+    assertPositiveSafeInteger(authorizationRevision, "artifact authorization revision");
+    const title = input.title;
+    const modality = input.modality;
+    const nativeRevision = input.nativeRevision ?? 0;
+    assertNonnegativeSafeInteger(nativeRevision, "artifact native revision");
+    return this.exclusive(async () => {
+      const key = aggregateKey(scope, artifactId);
+      if (this.aggregates.has(key)) throw new Error("Editable artifact is already seeded");
+      const commonArtifact = {
+        scope,
+        id: artifactId,
+        title,
+        lifecycle,
+        authorizationRevision,
+        headSequence: 0,
+        stateHash,
+        currentSnapshotId: null,
+        createdAt,
+        updatedAt: createdAt
+      };
+      const artifact = modality === "spreadsheet" ? {
+        ...commonArtifact,
+        modality: "spreadsheet",
+        causalFrontier: editableArtifactCausalFrontier([])
+      } : { ...commonArtifact, modality };
+      this.aggregates.set(key, {
+        artifact,
+        receipts: /* @__PURE__ */ new Map(),
+        transactions: /* @__PURE__ */ new Map(),
+        committedTransactions: /* @__PURE__ */ new Map(),
+        operations: /* @__PURE__ */ new Map(),
+        undoClaims: /* @__PURE__ */ new Map(),
+        snapshots: /* @__PURE__ */ new Map(),
+        checkpoints: /* @__PURE__ */ new Map([[0, checkpointAtGenesis(artifact, nativeRevision)]]),
+        outbox: /* @__PURE__ */ new Map()
+      });
+      return cloneArtifact(artifact);
+    });
+  }
+  async getArtifact(scope, artifactId) {
+    const key = aggregateKey(editableArtifactScope(scope), editableArtifactId(artifactId));
+    return this.exclusive(async () => {
+      const aggregate = this.aggregates.get(key);
+      return aggregate ? cloneArtifact(aggregate.artifact) : null;
+    });
+  }
+  async readArtifactAtAuthorizationRevision(scope, artifactId, expectedAuthorizationRevision) {
+    assertPositiveSafeInteger(
+      expectedAuthorizationRevision,
+      "expected artifact authorization revision"
+    );
+    const key = aggregateKey(editableArtifactScope(scope), editableArtifactId(artifactId));
+    return this.exclusive(async () => {
+      const aggregate = this.aggregates.get(key);
+      if (!aggregate) {
+        return Object.freeze({ kind: "result", artifact: null });
+      }
+      if (aggregate.artifact.authorizationRevision !== expectedAuthorizationRevision) {
+        return Object.freeze({ kind: "authorization_stale" });
+      }
+      return Object.freeze({
+        kind: "result",
+        artifact: cloneArtifact(aggregate.artifact)
+      });
+    });
+  }
+  /** Test/admin seam modeling the local policy invalidation transaction. */
+  async advanceAuthorizationRevision(scope, artifactId, expectedRevision, nextRevision) {
+    assertPositiveSafeInteger(expectedRevision, "expected artifact authorization revision");
+    assertPositiveSafeInteger(nextRevision, "next artifact authorization revision");
+    if (nextRevision <= expectedRevision) {
+      throw new TypeError("Next artifact authorization revision must exceed the expected revision");
+    }
+    const key = aggregateKey(editableArtifactScope(scope), editableArtifactId(artifactId));
+    return this.exclusive(async () => {
+      const aggregate = this.aggregates.get(key);
+      if (!aggregate) throw new EditableArtifactNotFoundError();
+      if (aggregate.artifact.authorizationRevision !== expectedRevision) {
+        return Object.freeze({
+          applied: false,
+          authorizationRevision: aggregate.artifact.authorizationRevision
+        });
+      }
+      const updatedAt = authoritativeNow(this.now).toISOString();
+      aggregate.artifact = {
+        ...aggregate.artifact,
+        authorizationRevision: nextRevision,
+        updatedAt: laterIsoTimestamp(aggregate.artifact.updatedAt, updatedAt)
+      };
+      return Object.freeze({
+        applied: true,
+        authorizationRevision: nextRevision
+      });
+    });
+  }
+  async readTransactionBasis(scope, artifactId, request) {
+    const normalizedScope = editableArtifactScope(scope);
+    const normalizedArtifactId = editableArtifactId(artifactId);
+    const key = aggregateKey(normalizedScope, normalizedArtifactId);
+    return this.exclusive(async () => {
+      const aggregate = this.aggregates.get(key);
+      if (!aggregate) throw new EditableArtifactNotFoundError();
+      const priorReceipt = aggregate.receipts.get(
+        receiptKey(request.actorKey, request.clientTransactionId)
+      );
+      if (priorReceipt) {
+        return Object.freeze({
+          kind: "existing",
+          receipt: cloneReceipt(priorReceipt)
+        });
+      }
+      const predecessor = request.previousLocalTransactionId ? aggregate.receipts.get(receiptKey(request.actorKey, request.previousLocalTransactionId)) : void 0;
+      const undoTargets = Object.freeze(
+        request.selectiveUndoOperationIds.map(
+          (operationId) => Object.freeze({
+            operationId,
+            operation: aggregate.operations.has(operationId) ? cloneOperation(aggregate.operations.get(operationId)) : null,
+            claimedBy: aggregate.undoClaims.get(operationId) ?? null
+          })
+        )
+      );
+      const kernelState = kernelStateFromAggregate(aggregate);
+      return Object.freeze({
+        kind: "basis",
+        artifact: kernelState.artifact,
+        predecessor: predecessor ? cloneReceipt(predecessor) : null,
+        undoTargets,
+        kernelState
+      });
+    });
+  }
+  async readCurrentKernelState(scope, artifactId, expectedAuthorizationRevision) {
+    const normalizedScope = editableArtifactScope(scope);
+    const normalizedArtifactId = editableArtifactId(artifactId);
+    const key = aggregateKey(normalizedScope, normalizedArtifactId);
+    return this.exclusive(async () => {
+      const aggregate = this.aggregates.get(key);
+      if (!aggregate) throw new EditableArtifactNotFoundError();
+      if (aggregate.artifact.authorizationRevision !== expectedAuthorizationRevision) {
+        return Object.freeze({ kind: "authorization_stale" });
+      }
+      return Object.freeze({ kind: "basis", state: kernelStateFromAggregate(aggregate) });
+    });
+  }
+  async tryCommitAppliedTransaction(request) {
+    const scope = editableArtifactScope(request.scope);
+    const artifactId = editableArtifactId(request.artifactId);
+    const key = aggregateKey(scope, artifactId);
+    return this.exclusive(async () => {
+      const aggregate = this.aggregates.get(key);
+      if (!aggregate) throw new EditableArtifactNotFoundError();
+      const prior = aggregate.receipts.get(
+        receiptKey(request.actorKey, request.clientTransactionId)
+      );
+      if (prior) {
+        if (prior.requestHash !== request.requestHash) {
+          throw new EditableArtifactIdempotencyConflictError();
+        }
+        return Object.freeze({
+          kind: "replayed",
+          receipt: cloneReceipt(prior)
+        });
+      }
+      const artifact = aggregate.artifact;
+      if (artifact.lifecycle !== request.expectedLifecycle || artifact.authorizationRevision !== request.expectedAuthorizationRevision || artifact.headSequence !== request.expectedHeadSequence) {
+        return Object.freeze({ kind: "stale" });
+      }
+      if (!sameExpectedPredecessor(aggregate, request.expectedPredecessor)) {
+        return Object.freeze({ kind: "stale" });
+      }
+      if (request.expectedUnclaimedUndoTargets.some(
+        (operationId) => aggregate.undoClaims.has(operationId)
+      )) {
+        return Object.freeze({ kind: "stale" });
+      }
+      const working = cloneAggregate(aggregate);
+      commitAppliedTransaction(working, request);
+      this.aggregates.set(key, working);
+      return Object.freeze({
+        kind: "committed",
+        receipt: cloneReceipt(request.receipt)
+      });
+    });
+  }
+  async withSnapshotPublicationLock(scope, artifactId, callback) {
+    const key = aggregateKey(editableArtifactScope(scope), editableArtifactId(artifactId));
+    return this.exclusive(async () => {
+      const aggregate = this.aggregates.get(key);
+      if (!aggregate) throw new EditableArtifactNotFoundError();
+      const working = cloneAggregate(aggregate);
+      const unitOfWork = new InMemoryEditableArtifactSnapshotUnitOfWork(working);
+      try {
+        const result = await callback(unitOfWork);
+        this.aggregates.set(key, cloneAggregate(working));
+        return result;
+      } finally {
+        unitOfWork.close();
+      }
+    });
+  }
+  async claimLiveOutbox(request) {
+    assertLeaseRequest(request);
+    const owner = request.owner;
+    const leaseDurationMs = request.leaseDurationMs;
+    const limit = request.limit;
+    return this.exclusive(async () => {
+      const nowMs = authoritativeNow(this.now).getTime();
+      const eligible = [...this.aggregates.values()].flatMap(
+        (aggregate) => [...aggregate.outbox.values()].map((record) => ({
+          aggregate,
+          record
+        }))
+      ).filter(({ record }) => {
+        if (record.state === "pending") {
+          return new Date(record.nextAttemptAt).getTime() <= nowMs;
+        }
+        if (record.state !== "publishing" || !record.leaseExpiresAt) return false;
+        return new Date(record.leaseExpiresAt).getTime() <= nowMs;
+      }).sort(
+        (left, right) => compareText(left.record.createdAt, right.record.createdAt) || compareText(left.record.outboxId, right.record.outboxId)
+      ).slice(0, limit);
+      const leaseExpiresAt = new Date(nowMs + leaseDurationMs).toISOString();
+      return Object.freeze(
+        eligible.map(({ aggregate, record }) => {
+          if (record.attemptCount >= Number.MAX_SAFE_INTEGER) {
+            throw new Error("Editable artifact outbox attempt counter exhausted");
+          }
+          const claimed = {
+            ...record,
+            state: "publishing",
+            attemptCount: record.attemptCount + 1,
+            leaseOwner: owner,
+            leaseExpiresAt
+          };
+          aggregate.outbox.set(record.outboxId, claimed);
+          return cloneOutbox(claimed);
+        })
+      );
+    });
+  }
+  async markLiveOutboxPublished(input) {
+    const outboxId = editableArtifactOutboxId(input.outboxId);
+    const owner = assertLeaseOwner(input.owner);
+    assertPositiveSafeInteger(input.attemptCount, "outbox attempt count");
+    await this.exclusive(async () => {
+      const publishedAt = authoritativeNow(this.now);
+      const publishedAtMs = publishedAt.getTime();
+      const publishedAtIso = publishedAt.toISOString();
+      const located = this.findOutbox(outboxId);
+      if (!located) throw new EditableArtifactOutboxLeaseConflictError();
+      const record = located.record;
+      if (record.state === "published") {
+        if (record.attemptCount === input.attemptCount) return;
+        throw new EditableArtifactOutboxLeaseConflictError();
+      }
+      if (record.state !== "publishing" || record.leaseOwner !== owner || record.attemptCount !== input.attemptCount || !record.leaseExpiresAt || publishedAtMs >= new Date(record.leaseExpiresAt).getTime()) {
+        throw new EditableArtifactOutboxLeaseConflictError();
+      }
+      located.aggregate.outbox.set(outboxId, {
+        ...record,
+        state: "published",
+        leaseOwner: null,
+        leaseExpiresAt: null,
+        publishedAt: publishedAtIso
+      });
+    });
+  }
+  async releaseLiveOutbox(input) {
+    const outboxId = editableArtifactOutboxId(input.outboxId);
+    const owner = assertLeaseOwner(input.owner);
+    assertPositiveSafeInteger(input.attemptCount, "outbox attempt count");
+    await this.exclusive(async () => {
+      const releasedAt = authoritativeNow(this.now).toISOString();
+      const located = this.findOutbox(outboxId);
+      if (!located) throw new EditableArtifactOutboxLeaseConflictError();
+      if ((located.record.state === "published" || located.record.state === "pending" && located.record.leaseOwner === null && located.record.leaseExpiresAt === null) && located.record.attemptCount === input.attemptCount) {
+        return;
+      }
+      if (located.record.state !== "publishing" || located.record.leaseOwner !== owner || located.record.attemptCount !== input.attemptCount) {
+        throw new EditableArtifactOutboxLeaseConflictError();
+      }
+      located.aggregate.outbox.set(outboxId, {
+        ...located.record,
+        state: "pending",
+        leaseOwner: null,
+        leaseExpiresAt: null,
+        nextAttemptAt: releasedAt
+      });
+    });
+  }
+  async renewLiveOutbox(input) {
+    const outboxId = editableArtifactOutboxId(input.outboxId);
+    const owner = assertLeaseOwner(input.owner);
+    assertPositiveSafeInteger(input.attemptCount, "outbox attempt count");
+    assertLeaseDuration(input.leaseDurationMs);
+    await this.exclusive(async () => {
+      const nowMs = authoritativeNow(this.now).getTime();
+      const located = this.findOutbox(outboxId);
+      if (!located) throw new EditableArtifactOutboxLeaseConflictError();
+      assertActiveOutboxLease(located.record, owner, input.attemptCount, nowMs);
+      located.aggregate.outbox.set(outboxId, {
+        ...located.record,
+        leaseExpiresAt: new Date(nowMs + input.leaseDurationMs).toISOString()
+      });
+    });
+  }
+  async retryLiveOutbox(input) {
+    const outboxId = editableArtifactOutboxId(input.outboxId);
+    const owner = assertLeaseOwner(input.owner);
+    assertPositiveSafeInteger(input.attemptCount, "outbox attempt count");
+    assertRetryDelay(input.retryDelayMs);
+    assertRetryErrorCode(input.errorCode);
+    await this.exclusive(async () => {
+      const nowMs = authoritativeNow(this.now).getTime();
+      const located = this.findOutbox(outboxId);
+      if (!located) throw new EditableArtifactOutboxLeaseConflictError();
+      const record = located.record;
+      if (record.state === "pending" && record.attemptCount === input.attemptCount && record.leaseOwner === null && record.leaseExpiresAt === null && record.lastErrorCode === input.errorCode) {
+        return;
+      }
+      assertActiveOutboxLease(record, owner, input.attemptCount, nowMs);
+      located.aggregate.outbox.set(outboxId, {
+        ...record,
+        state: "pending",
+        leaseOwner: null,
+        leaseExpiresAt: null,
+        nextAttemptAt: new Date(nowMs + input.retryDelayMs).toISOString(),
+        lastErrorCode: input.errorCode
+      });
+    });
+  }
+  async deadLetterLiveOutbox(input) {
+    const outboxId = editableArtifactOutboxId(input.outboxId);
+    const owner = assertLeaseOwner(input.owner);
+    assertPositiveSafeInteger(input.attemptCount, "outbox attempt count");
+    assertDeadLetterErrorCode(input.errorCode);
+    await this.exclusive(async () => {
+      const now = authoritativeNow(this.now);
+      const nowMs = now.getTime();
+      const located = this.findOutbox(outboxId);
+      if (!located) throw new EditableArtifactOutboxLeaseConflictError();
+      const record = located.record;
+      if (record.state === "dead_lettered" && record.attemptCount === input.attemptCount && record.leaseOwner === null && record.leaseExpiresAt === null && record.lastErrorCode === input.errorCode) {
+        return;
+      }
+      assertActiveOutboxLease(record, owner, input.attemptCount, nowMs);
+      located.aggregate.outbox.set(outboxId, {
+        ...record,
+        state: "dead_lettered",
+        leaseOwner: null,
+        leaseExpiresAt: null,
+        lastErrorCode: input.errorCode,
+        deadLetteredAt: now.toISOString()
+      });
+    });
+  }
+  async listReceipts(scope, artifactId) {
+    return this.inspectAggregate(
+      scope,
+      artifactId,
+      (aggregate) => Object.freeze(
+        [...aggregate.transactions.values()].sort((left, right) => left.sequenceStart - right.sequenceStart).map(cloneReceipt)
+      )
+    );
+  }
+  async listOperations(scope, artifactId) {
+    return this.inspectAggregate(
+      scope,
+      artifactId,
+      (aggregate) => Object.freeze(
+        [...aggregate.operations.values()].sort((left, right) => left.sequence - right.sequence).map(cloneOperation)
+      )
+    );
+  }
+  async listCommittedTransactions(scope, artifactId) {
+    return this.inspectAggregate(
+      scope,
+      artifactId,
+      (aggregate) => Object.freeze(
+        [...aggregate.committedTransactions.values()].sort((left, right) => left.sequenceStart - right.sequenceStart).map(cloneCommittedTransaction)
+      )
+    );
+  }
+  async listSnapshots(scope, artifactId) {
+    return this.inspectAggregate(
+      scope,
+      artifactId,
+      (aggregate) => Object.freeze(
+        [...aggregate.snapshots.values()].sort((left, right) => left.coveredHeadSequence - right.coveredHeadSequence).map(cloneSnapshot)
+      )
+    );
+  }
+  async listOutbox() {
+    return this.exclusive(
+      async () => Object.freeze(
+        [...this.aggregates.values()].flatMap((aggregate) => [...aggregate.outbox.values()]).sort(
+          (left, right) => compareText(left.createdAt, right.createdAt) || compareText(left.outboxId, right.outboxId)
+        ).map(cloneOutbox)
+      )
+    );
+  }
+  async inspectAggregate(scope, artifactId, inspect) {
+    const key = aggregateKey(editableArtifactScope(scope), editableArtifactId(artifactId));
+    return this.exclusive(async () => {
+      const aggregate = this.aggregates.get(key);
+      if (!aggregate) throw new EditableArtifactNotFoundError();
+      return inspect(aggregate);
+    });
+  }
+  findOutbox(outboxId) {
+    for (const aggregate of this.aggregates.values()) {
+      const record = aggregate.outbox.get(outboxId);
+      if (record) return { aggregate, record };
+    }
+    return void 0;
+  }
+  async exclusive(operation) {
+    const prior = this.exclusiveTail;
+    let release;
+    this.exclusiveTail = new Promise((resolve) => {
+      release = resolve;
+    });
+    await prior;
+    try {
+      return await operation();
+    } finally {
+      release();
+    }
+  }
+};
+function commitAppliedTransaction(aggregate, input) {
+  const artifact = aggregate.artifact;
+  if (input.expectedHeadSequence !== artifact.headSequence) {
+    throw new Error("In-memory artifact head changed before its CAS commit");
+  }
+  if (input.receipt.modality !== artifact.modality || input.committedTransaction.modality !== artifact.modality || input.receipt.sequenceStart !== artifact.headSequence + 1) {
+    throw new Error("Committed transaction modality or interval is invalid");
+  }
+  if (input.receipt.serverTransactionId !== input.serverTransactionId || input.operations.some(
+    (operation, index) => operation.serverTransactionId !== input.serverTransactionId || operation.sequence !== input.receipt.sequenceStart + index
+  )) {
+    throw new Error("Committed operations are not bound to the transaction interval");
+  }
+  const committed = input.committedTransaction;
+  if (committed.serverTransactionId !== input.serverTransactionId || committed.scope.accountId !== artifact.scope.accountId || committed.scope.workspaceId !== artifact.scope.workspaceId || committed.artifactId !== artifact.id || committed.requestHash !== input.receipt.requestHash || committed.sequenceStart !== input.receipt.sequenceStart || committed.sequenceEnd !== input.receipt.sequenceEnd || committed.priorStateHash !== artifact.stateHash || committed.stateHash !== input.receipt.stateHash || !(committed.committedTransactionBytes instanceof Uint8Array) || committed.committedTransactionBytes.byteLength < 1) {
+    throw new Error("Canonical committed transaction disagrees with its receipt");
+  }
+  if (input.outbox.event.kind !== "transaction_committed" || input.outbox.event.modality !== artifact.modality || input.outbox.event.serverTransactionId !== input.serverTransactionId || input.outbox.event.sequenceStart !== input.receipt.sequenceStart || input.outbox.event.sequenceEnd !== input.receipt.sequenceEnd || input.outbox.event.stateHash !== input.receipt.stateHash) {
+    throw new Error("Transaction outbox projection is inconsistent");
+  }
+  if (artifact.modality === "spreadsheet") {
+    if (input.receipt.modality !== "spreadsheet" || committed.modality !== "spreadsheet" || input.outbox.event.modality !== "spreadsheet" || input.operations.length !== input.receipt.operationCount || input.receipt.sequenceEnd !== artifact.headSequence + input.operations.length || committed.operationIds.length !== input.operations.length || committed.operationIds.some(
+      (operationId, index) => operationId !== input.operations[index]?.operationId
+    ) || !causalFrontiersEqual(
+      committed.resultingCausalFrontier,
+      input.receipt.resultingCausalFrontier
+    ) || input.outbox.event.operationProtocolVersion !== input.receipt.operationProtocolVersion) {
+      throw new Error("Spreadsheet commit disagrees with its CRDT receipt");
+    }
+    const summary = decodeCommittedTransactionSummary(committed.committedTransactionBytes);
+    if (summary.transactionId !== input.serverTransactionId || summary.priorStateHash !== committed.priorStateHash || summary.stateHash !== committed.stateHash || summary.operationIds.length !== committed.operationIds.length) {
+      throw new Error("Spreadsheet OGACO metadata disagrees with its record");
+    }
+  } else {
+    if (input.receipt.modality !== artifact.modality || committed.modality !== artifact.modality || input.outbox.event.modality !== artifact.modality || input.operations.length !== 0 || input.receipt.sequenceEnd !== input.receipt.sequenceStart || committed.sequenceEnd !== committed.sequenceStart || input.receipt.commitProtocolVersion !== committed.commitProtocolVersion || input.receipt.priorNativeRevision !== committed.priorNativeRevision || input.receipt.nativeRevision !== committed.nativeRevision || input.receipt.commandCount !== committed.commandCount || input.outbox.event.commitProtocolVersion !== input.receipt.commitProtocolVersion) {
+      throw new Error("Serialized commit disagrees with its authoritative receipt");
+    }
+    const summary = decodeEditableArtifactSerializedCommit(
+      committed.committedTransactionBytes,
+      artifact.modality
+    );
+    if (summary.transactionId !== input.serverTransactionId || summary.parentHeadSequence !== artifact.headSequence || summary.resultHeadSequence !== input.receipt.sequenceEnd || summary.priorNativeRevision !== committed.priorNativeRevision || summary.nativeReceipt.revision !== committed.nativeRevision || summary.nativeReceipt.commandCount !== committed.commandCount || summary.priorStateHash !== artifact.stateHash || summary.stateHash !== input.receipt.stateHash || summary.requestHash !== input.receipt.requestHash || !sameBytes2(summary.intentBytes, input.receipt.intentBytes) || !sameBytes2(summary.nativeReceiptBytes, committed.nativeReceiptBytes)) {
+      throw new Error("Serialized OGAST metadata disagrees with its record");
+    }
+  }
+  const idempotencyKey = receiptKey(input.receipt.actorKey, input.receipt.clientTransactionId);
+  if (aggregate.receipts.has(idempotencyKey) || aggregate.transactions.has(input.serverTransactionId) || aggregate.committedTransactions.has(input.serverTransactionId) || aggregate.outbox.has(input.outbox.outboxId)) {
+    throw new Error("Duplicate transaction, receipt, or outbox identity");
+  }
+  for (const operation of input.operations) {
+    if (aggregate.operations.has(operation.operationId)) {
+      throw new Error(`Duplicate operation identity: ${operation.operationId}`);
+    }
+  }
+  if (input.receipt.modality === "spreadsheet") {
+    for (const target of input.receipt.selectiveUndoOperationIds) {
+      if (aggregate.undoClaims.has(target)) {
+        throw new Error(`Duplicate selective undo claim: ${target}`);
+      }
+      aggregate.undoClaims.set(target, input.serverTransactionId);
+    }
+  }
+  aggregate.receipts.set(idempotencyKey, cloneReceipt(input.receipt));
+  aggregate.transactions.set(input.serverTransactionId, cloneReceipt(input.receipt));
+  aggregate.committedTransactions.set(
+    input.serverTransactionId,
+    cloneCommittedTransaction(input.committedTransaction)
+  );
+  for (const operation of input.operations) {
+    aggregate.operations.set(operation.operationId, cloneOperation(operation));
+  }
+  aggregate.outbox.set(input.outbox.outboxId, cloneOutbox(input.outbox));
+  if (artifact.modality === "spreadsheet") {
+    if (input.receipt.modality !== "spreadsheet") {
+      throw new Error("Spreadsheet artifact received a serialized receipt");
+    }
+    aggregate.artifact = {
+      ...artifact,
+      headSequence: input.receipt.sequenceEnd,
+      causalFrontier: cloneFrontier(input.receipt.resultingCausalFrontier),
+      stateHash: input.receipt.stateHash,
+      updatedAt: laterIsoTimestamp(artifact.updatedAt, input.receipt.committedAt)
+    };
+    aggregate.checkpoints.set(input.receipt.sequenceEnd, {
+      modality: "spreadsheet",
+      headSequence: input.receipt.sequenceEnd,
+      causalFrontier: cloneFrontier(input.receipt.resultingCausalFrontier),
+      stateHash: input.receipt.stateHash
+    });
+  } else {
+    if (input.receipt.modality === "spreadsheet") {
+      throw new Error("Serialized artifact received a spreadsheet receipt");
+    }
+    aggregate.artifact = {
+      ...artifact,
+      headSequence: input.receipt.sequenceEnd,
+      stateHash: input.receipt.stateHash,
+      updatedAt: laterIsoTimestamp(artifact.updatedAt, input.receipt.committedAt)
+    };
+    aggregate.checkpoints.set(input.receipt.sequenceEnd, {
+      modality: artifact.modality,
+      headSequence: input.receipt.sequenceEnd,
+      nativeRevision: input.receipt.nativeRevision,
+      stateHash: input.receipt.stateHash
+    });
+  }
+}
+var InMemoryEditableArtifactSnapshotUnitOfWork = class {
+  constructor(aggregate) {
+    this.aggregate = aggregate;
+  }
+  committed = false;
+  closed = false;
+  artifact() {
+    this.assertOpen();
+    return cloneArtifact(this.aggregate.artifact);
+  }
+  async checkpoint(headSequence) {
+    this.assertOpen();
+    const checkpoint = this.aggregate.checkpoints.get(headSequence);
+    return checkpoint ? cloneCheckpoint(checkpoint) : null;
+  }
+  async findSnapshot(snapshotId) {
+    this.assertOpen();
+    const snapshot = this.aggregate.snapshots.get(snapshotId);
+    return snapshot ? cloneSnapshot(snapshot) : null;
+  }
+  async commitSnapshot(input) {
+    this.assertUncommitted();
+    if (input.authorizationPermission !== void 0 && input.authorizationPermission !== "manage" && input.authorizationPermission !== "read" && input.authorizationPermission !== "edit") {
+      throw new TypeError("Snapshot authorization permission is invalid");
+    }
+    const artifact = this.aggregate.artifact;
+    if (input.expectedCurrentSnapshotId !== artifact.currentSnapshotId) {
+      throw new Error("In-memory current snapshot changed inside its transaction lock");
+    }
+    if (input.expectedAuthorizationRevision !== artifact.authorizationRevision) {
+      throw new Error("In-memory artifact authorization changed before snapshot commit");
+    }
+    if (this.aggregate.snapshots.has(input.snapshot.snapshotId) || this.aggregate.outbox.has(input.outbox.outboxId)) {
+      throw new Error("Duplicate snapshot or outbox identity");
+    }
+    const checkpoint = this.aggregate.checkpoints.get(input.snapshot.coveredHeadSequence);
+    if (!checkpoint || checkpoint.modality !== artifact.modality || input.snapshot.modality !== artifact.modality || checkpoint.stateHash !== input.snapshot.stateHash || input.snapshot.modality === "spreadsheet" && (checkpoint.modality !== "spreadsheet" || !causalFrontiersEqual(
+      checkpoint.causalFrontier,
+      input.snapshot.coveredCausalFrontier
+    )) || input.snapshot.modality !== "spreadsheet" && (checkpoint.modality === "spreadsheet" || checkpoint.nativeRevision !== input.snapshot.nativeRevision)) {
+      throw new Error("Snapshot does not match an authoritative checkpoint");
+    }
+    this.aggregate.snapshots.set(input.snapshot.snapshotId, cloneSnapshot(input.snapshot));
+    this.aggregate.outbox.set(input.outbox.outboxId, cloneOutbox(input.outbox));
+    this.aggregate.artifact = {
+      ...artifact,
+      currentSnapshotId: input.snapshot.snapshotId,
+      updatedAt: laterIsoTimestamp(artifact.updatedAt, input.snapshot.publishedAt)
+    };
+    this.committed = true;
+    return Object.freeze({ kind: "committed" });
+  }
+  assertUncommitted() {
+    this.assertOpen();
+    if (this.committed) throw new Error("Artifact unit of work may commit exactly once");
+  }
+  close() {
+    this.closed = true;
+  }
+  assertOpen() {
+    if (this.closed) {
+      throw new Error("Artifact unit of work is no longer inside its lock");
+    }
+  }
+};
+var InMemoryEditableArtifactStableIdFactory = class {
+  nextCounter;
+  namespace;
+  constructor(namespace, initialCounter = 1n) {
+    this.namespace = typeof namespace === "bigint" ? namespace : BigInt(`0x${namespace.replace(/^0x/, "")}`);
+    if (this.namespace < 1n || this.namespace > 0xffffffffffffffffn) {
+      throw new TypeError("Stable id namespace must be a nonzero unsigned 64-bit integer");
+    }
+    if (initialCounter < 1n || initialCounter > 0xffffffffffffffffn) {
+      throw new TypeError("Stable id counter must be a nonzero unsigned 64-bit integer");
+    }
+    this.nextCounter = initialCounter;
+  }
+  next(_kind) {
+    if (this.nextCounter > 0xffffffffffffffffn) {
+      throw new Error("Stable id namespace exhausted");
+    }
+    const value = `${this.namespace.toString(16).padStart(16, "0")}${this.nextCounter.toString(16).padStart(16, "0")}`;
+    this.nextCounter += 1n;
+    return editableArtifactOperationId(value);
+  }
+};
+var SystemEditableArtifactClock = class {
+  now() {
+    return /* @__PURE__ */ new Date();
+  }
+};
+function aggregateKey(scope, artifactId) {
+  return JSON.stringify([scope.accountId, scope.workspaceId, artifactId]);
+}
+function authorizationScopeKey(scope) {
+  return JSON.stringify([scope.accountId, scope.workspaceId]);
+}
+function creationReceiptKey(scope, operationKind, authorityKey, idempotencyKey) {
+  return JSON.stringify([
+    scope.accountId,
+    scope.workspaceId,
+    operationKind,
+    authorityKey,
+    idempotencyKey
+  ]);
+}
+function emptyAggregate(artifact, genesisSnapshot, outbox) {
+  return {
+    artifact,
+    receipts: /* @__PURE__ */ new Map(),
+    transactions: /* @__PURE__ */ new Map(),
+    committedTransactions: /* @__PURE__ */ new Map(),
+    operations: /* @__PURE__ */ new Map(),
+    undoClaims: /* @__PURE__ */ new Map(),
+    snapshots: /* @__PURE__ */ new Map([[genesisSnapshot.snapshotId, cloneSnapshot(genesisSnapshot)]]),
+    checkpoints: /* @__PURE__ */ new Map([
+      [
+        0,
+        checkpointAtGenesis(
+          artifact,
+          genesisSnapshot.modality === "spreadsheet" ? 0 : genesisSnapshot.nativeRevision
+        )
+      ]
+    ]),
+    outbox: /* @__PURE__ */ new Map([[outbox.outboxId, cloneOutbox(outbox)]])
+  };
+}
+function assertGenesisCreateRequest(scope, artifactId, operationKind, snapshot, outbox) {
+  assertIsoTimestamp(snapshot.verifiedAt, "genesis snapshot verification time");
+  assertIsoTimestamp(snapshot.publishedAt, "genesis snapshot publication time");
+  if (snapshot.scope.accountId !== scope.accountId || snapshot.scope.workspaceId !== scope.workspaceId || snapshot.artifactId !== artifactId || snapshot.coveredHeadSequence !== 0 || operationKind === "create" && snapshot.modality === "spreadsheet" && snapshot.coveredCausalFrontier.length !== 0 || Date.parse(snapshot.verifiedAt) > Date.parse(snapshot.publishedAt)) {
+    throw new TypeError(
+      "Genesis snapshot is not the verified sequence-zero state for this artifact"
+    );
+  }
+  if (outbox.state !== "pending" || outbox.attemptCount !== 0 || outbox.leaseOwner !== null || outbox.leaseExpiresAt !== null || outbox.nextAttemptAt !== snapshot.publishedAt || outbox.lastErrorCode !== null || outbox.publishedAt !== null || outbox.deadLetteredAt !== null || outbox.createdAt !== snapshot.publishedAt || outbox.event.kind !== "snapshot_published" || outbox.event.scope.accountId !== scope.accountId || outbox.event.scope.workspaceId !== scope.workspaceId || outbox.event.artifactId !== artifactId || outbox.event.modality !== snapshot.modality || outbox.event.snapshotId !== snapshot.snapshotId || outbox.event.coveredHeadSequence !== 0 || outbox.event.stateHash !== snapshot.stateHash || snapshot.modality === "spreadsheet" && (outbox.event.modality !== "spreadsheet" || outbox.event.operationProtocolVersion !== snapshot.operationProtocolVersion) || outbox.event.publishedAt !== snapshot.publishedAt) {
+    throw new TypeError("Genesis snapshot outbox projection is inconsistent");
+  }
+}
+function receiptKey(actorKey, clientTransactionId) {
+  return JSON.stringify([actorKey, clientTransactionId]);
+}
+function sameExpectedPredecessor(aggregate, expected) {
+  if (expected === null) return true;
+  const actual = aggregate.receipts.get(
+    receiptKey(expected.actorKey, expected.clientTransactionId)
+  );
+  return actual !== void 0 && actual.receiptId === expected.receiptId && actual.serverTransactionId === expected.serverTransactionId && actual.replicaId === expected.replicaId && actual.replicaCounter === expected.replicaCounter;
+}
+function assertLeaseRequest(request) {
+  assertLeaseOwner(request.owner);
+  assertLeaseDuration(request.leaseDurationMs);
+  assertPositiveSafeInteger(request.limit, "outbox claim limit");
+  if (request.limit > 1e3) throw new TypeError("Outbox claim limit must not exceed 1000");
+}
+function assertLeaseDuration(value) {
+  assertPositiveSafeInteger(value, "outbox lease duration");
+  if (value > 24 * 60 * 60 * 1e3) {
+    throw new TypeError("Outbox lease duration must not exceed 24 hours");
+  }
+}
+function assertRetryDelay(value) {
+  assertPositiveSafeInteger(value, "outbox retry delay");
+  if (value > 24 * 60 * 60 * 1e3) {
+    throw new TypeError("Outbox retry delay must not exceed 24 hours");
+  }
+}
+function assertActiveOutboxLease(record, owner, attemptCount, nowMs) {
+  if (record.state !== "publishing" || record.leaseOwner !== owner || record.attemptCount !== attemptCount || !record.leaseExpiresAt || nowMs >= Date.parse(record.leaseExpiresAt)) {
+    throw new EditableArtifactOutboxLeaseConflictError();
+  }
+}
+function assertRetryErrorCode(value) {
+  if (value !== "broker_unavailable" && value !== "broker_backpressure" && value !== "publish_timeout") {
+    throw new TypeError("Outbox retry error code is invalid");
+  }
+}
+function assertDeadLetterErrorCode(value) {
+  if (value !== "invalid_hint" && value !== "oversized_hint") {
+    throw new TypeError("Outbox dead-letter error code is invalid");
+  }
+}
+function assertLeaseOwner(owner) {
+  if (owner.length < 1 || owner.length > 256) {
+    throw new TypeError("Outbox lease owner must contain 1-256 characters");
+  }
+  return owner;
+}
+function authoritativeNow(now) {
+  const value = now();
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw new TypeError("Editable artifact store clock returned an invalid date");
+  }
+  return new Date(value);
+}
+function laterIsoTimestamp(left, right) {
+  return Date.parse(left) >= Date.parse(right) ? left : right;
+}
+function cloneAggregate(aggregate) {
+  return {
+    artifact: cloneArtifact(aggregate.artifact),
+    receipts: new Map([...aggregate.receipts].map(([key, value]) => [key, cloneReceipt(value)])),
+    transactions: new Map(
+      [...aggregate.transactions].map(([key, value]) => [key, cloneReceipt(value)])
+    ),
+    committedTransactions: new Map(
+      [...aggregate.committedTransactions].map(([key, value]) => [
+        key,
+        cloneCommittedTransaction(value)
+      ])
+    ),
+    operations: new Map(
+      [...aggregate.operations].map(([key, value]) => [key, cloneOperation(value)])
+    ),
+    undoClaims: new Map(aggregate.undoClaims),
+    snapshots: new Map([...aggregate.snapshots].map(([key, value]) => [key, cloneSnapshot(value)])),
+    checkpoints: new Map(
+      [...aggregate.checkpoints].map(([key, value]) => [key, cloneCheckpoint(value)])
+    ),
+    outbox: new Map([...aggregate.outbox].map(([key, value]) => [key, cloneOutbox(value)]))
+  };
+}
+function kernelStateFromAggregate(aggregate) {
+  const snapshot = aggregate.artifact.currentSnapshotId ? aggregate.snapshots.get(aggregate.artifact.currentSnapshotId) ?? null : null;
+  const artifact = cloneArtifact(aggregate.artifact);
+  const covered = snapshot?.coveredHeadSequence ?? 0;
+  const coveredCheckpoint = aggregate.checkpoints.get(covered);
+  if (!coveredCheckpoint || coveredCheckpoint.modality !== artifact.modality) {
+    throw new Error("Artifact replay base has no matching checkpoint");
+  }
+  const tail = [...aggregate.committedTransactions.values()].filter((transaction) => transaction.sequenceEnd > covered).sort((left, right) => left.sequenceStart - right.sequenceStart).map(cloneCommittedTransaction);
+  const tailByteSize = tail.reduce(
+    (total, transaction) => total + transaction.committedTransactionBytes.byteLength,
+    0
+  );
+  const common = {
+    tailTransactionCount: tail.length,
+    tailByteSize
+  };
+  if (artifact.modality === "spreadsheet") {
+    return Object.freeze({
+      ...common,
+      modality: artifact.modality,
+      artifact,
+      snapshot: snapshot?.modality === "spreadsheet" ? cloneSnapshot(snapshot) : null,
+      committedTransactionTail: Object.freeze(
+        tail.map((transaction) => {
+          if (transaction.modality !== "spreadsheet") {
+            throw new Error("Spreadsheet artifact contains a cross-modality transaction");
+          }
+          return transaction;
+        })
+      )
+    });
+  }
+  return Object.freeze({
+    ...common,
+    modality: artifact.modality,
+    artifact,
+    snapshot: snapshot && snapshot.modality !== "spreadsheet" ? cloneSnapshot(snapshot) : null,
+    baseNativeRevision: coveredCheckpoint.modality === "spreadsheet" ? (() => {
+      throw new Error("Serialized artifact has a spreadsheet replay checkpoint");
+    })() : coveredCheckpoint.nativeRevision,
+    committedTransactionTail: Object.freeze(
+      tail.map((transaction) => {
+        if (transaction.modality !== artifact.modality) {
+          throw new Error("Serialized artifact contains a cross-modality transaction");
+        }
+        return transaction;
+      })
+    )
+  });
+}
+function cloneArtifact(artifact) {
+  if (artifact.modality !== "spreadsheet") {
+    return Object.freeze({
+      ...artifact,
+      scope: Object.freeze({ ...artifact.scope })
+    });
+  }
+  return Object.freeze({
+    ...artifact,
+    scope: Object.freeze({ ...artifact.scope }),
+    causalFrontier: cloneFrontier(artifact.causalFrontier)
+  });
+}
+function cloneCreationReceipt(receipt) {
+  return Object.freeze({
+    ...receipt,
+    scope: Object.freeze({ ...receipt.scope })
+  });
+}
+function cloneReceipt(receipt) {
+  if (receipt.modality !== "spreadsheet") {
+    return Object.freeze({
+      ...receipt,
+      scope: Object.freeze({ ...receipt.scope }),
+      intentBytes: receipt.intentBytes.slice()
+    });
+  }
+  return Object.freeze({
+    ...receipt,
+    scope: Object.freeze({ ...receipt.scope }),
+    intentBytes: receipt.intentBytes.slice(),
+    causalBase: cloneFrontier(receipt.causalBase),
+    resolvedCausalBase: cloneFrontier(receipt.resolvedCausalBase),
+    resultingCausalFrontier: cloneFrontier(receipt.resultingCausalFrontier),
+    selectiveUndoOperationIds: Object.freeze([...receipt.selectiveUndoOperationIds])
+  });
+}
+function cloneOperation(operation) {
+  return Object.freeze({
+    ...operation,
+    scope: Object.freeze({ ...operation.scope }),
+    dot: Object.freeze({ ...operation.dot })
+  });
+}
+function cloneCommittedTransaction(transaction) {
+  if (transaction.modality !== "spreadsheet") {
+    return Object.freeze({
+      ...transaction,
+      scope: Object.freeze({ ...transaction.scope }),
+      nativeReceiptBytes: transaction.nativeReceiptBytes.slice(),
+      committedTransactionBytes: transaction.committedTransactionBytes.slice()
+    });
+  }
+  return Object.freeze({
+    ...transaction,
+    scope: Object.freeze({ ...transaction.scope }),
+    dot: Object.freeze({ ...transaction.dot }),
+    resolvedCausalBase: cloneFrontier(transaction.resolvedCausalBase),
+    resultingCausalFrontier: cloneFrontier(transaction.resultingCausalFrontier),
+    operationIds: Object.freeze([...transaction.operationIds]),
+    committedTransactionBytes: transaction.committedTransactionBytes.slice()
+  });
+}
+function cloneSnapshot(snapshot) {
+  if (snapshot.modality !== "spreadsheet") {
+    return Object.freeze({
+      ...snapshot,
+      scope: Object.freeze({ ...snapshot.scope })
+    });
+  }
+  return Object.freeze({
+    ...snapshot,
+    scope: Object.freeze({ ...snapshot.scope }),
+    coveredCausalFrontier: cloneFrontier(snapshot.coveredCausalFrontier)
+  });
+}
+function cloneCheckpoint(checkpoint) {
+  if (checkpoint.modality !== "spreadsheet") {
+    return Object.freeze({ ...checkpoint });
+  }
+  return Object.freeze({
+    ...checkpoint,
+    causalFrontier: cloneFrontier(checkpoint.causalFrontier)
+  });
+}
+function checkpointAtGenesis(artifact, nativeRevision = 0) {
+  return artifact.modality === "spreadsheet" ? Object.freeze({
+    modality: "spreadsheet",
+    headSequence: 0,
+    causalFrontier: editableArtifactCausalFrontier([]),
+    stateHash: artifact.stateHash
+  }) : Object.freeze({
+    modality: artifact.modality,
+    headSequence: 0,
+    nativeRevision,
+    stateHash: artifact.stateHash
+  });
+}
+function sameBytes2(left, right) {
+  if (left.byteLength !== right.byteLength) return false;
+  let difference = 0;
+  for (let index = 0; index < left.byteLength; index += 1) {
+    difference |= left[index] ^ right[index];
+  }
+  return difference === 0;
+}
+function cloneOutbox(record) {
+  return Object.freeze({
+    ...record,
+    event: Object.freeze({
+      ...record.event,
+      scope: Object.freeze({ ...record.event.scope })
+    })
+  });
+}
+function cloneFrontier(frontier) {
+  return Object.freeze(frontier.map((entry) => Object.freeze({ ...entry })));
+}
+function compareText(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+
+// src/domain/editable-artifacts/postgres-adapters.ts
+function editableArtifactStorePortFromPostgres(store) {
+  return store;
+}
+function editableArtifactAuthorizationRevisionPortFromPostgres(store) {
+  return store;
+}
+function editableArtifactScopeAuthorizationRevisionPortFromPostgres(store) {
+  return store;
+}
+function editableArtifactLiveReadPortFromPostgres(store) {
+  return store;
+}
+function editableArtifactLiveTicketStorePortFromPostgres(store) {
+  return store;
+}
+
+// src/domain/editable-artifacts/snapshot-compaction.ts
+import { BoundedObjectWriteError } from "@opengeni/storage";
+var SNAPSHOT_MIME_TYPE = "application/vnd.opengeni.editable-artifact-snapshot";
+var EditableArtifactCompactionPipeline = class {
+  #dependencies;
+  constructor(dependencies) {
+    const maxSnapshotBytes = dependencies.maxSnapshotBytes ?? MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES;
+    if (!Number.isSafeInteger(maxSnapshotBytes) || maxSnapshotBytes <= 0 || maxSnapshotBytes > MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES) {
+      throw new TypeError("Compaction snapshot limit is invalid");
+    }
+    this.#dependencies = Object.freeze({ ...dependencies, maxSnapshotBytes });
+  }
+  async prepare(input) {
+    const scope = editableArtifactScope(input.scope);
+    const artifactId = editableArtifactId(input.artifactId);
+    const snapshotId = editableArtifactSnapshotId(input.snapshotId);
+    validateBasis(input.state, scope, artifactId);
+    throwIfCancelled(input.signal);
+    try {
+      const generated = await this.#dependencies.kernel.createCanonicalSnapshot({
+        state: input.state,
+        ...input.signal ? { signal: input.signal } : {}
+      });
+      validateGenerated(generated, input.state, scope, artifactId);
+      const stored = await this.#dependencies.objects.write({
+        chunks: generated.canonicalChunks,
+        contentType: SNAPSHOT_MIME_TYPE,
+        maxBytes: this.#dependencies.maxSnapshotBytes,
+        expectedByteSize: generated.canonicalByteSize,
+        expectedContentHash: generated.canonicalContentHash,
+        ...input.signal ? { signal: input.signal } : {}
+      });
+      const common = {
+        snapshotId,
+        blobReference: stored.opaqueReference,
+        byteSize: stored.byteSize,
+        contentHash: editableArtifactContentHash(stored.contentHash),
+        mimeType: SNAPSHOT_MIME_TYPE,
+        modality: generated.modality,
+        coveredHeadSequence: generated.coveredHeadSequence,
+        stateHash: generated.stateHash,
+        modelSchemaVersion: generated.modelSchemaVersion,
+        kernelVersion: generated.kernelVersion,
+        verifiedAt: canonicalTimestamp(this.#dependencies.now())
+      };
+      return generated.modality === "spreadsheet" ? Object.freeze({
+        ...common,
+        modality: generated.modality,
+        coveredCausalFrontier: generated.coveredCausalFrontier,
+        operationProtocolVersion: generated.operationProtocolVersion,
+        crdtStateVersion: generated.crdtStateVersion
+      }) : Object.freeze({
+        ...common,
+        modality: generated.modality,
+        nativeRevision: generated.nativeRevision
+      });
+    } catch (error) {
+      if (error instanceof EditableArtifactSnapshotVerificationError || error instanceof BoundedObjectWriteError) {
+        throw error;
+      }
+      if (input.signal?.aborted) {
+        throw new EditableArtifactSnapshotVerificationError("cancelled");
+      }
+      throw new EditableArtifactSnapshotVerificationError("kernel_rejected");
+    }
+  }
+};
+function validateBasis(state, scope, artifactId) {
+  if (state.artifact.scope.accountId !== scope.accountId || state.artifact.scope.workspaceId !== scope.workspaceId || state.artifact.id !== artifactId || state.artifact.modality !== state.modality) {
+    throw new EditableArtifactSnapshotVerificationError("identity_mismatch");
+  }
+  for (const value of [state.tailTransactionCount, state.tailByteSize]) {
+    if (!Number.isSafeInteger(value) || value < 0) {
+      throw new EditableArtifactSnapshotVerificationError("coverage_mismatch");
+    }
+  }
+}
+function validateGenerated(value, state, scope, artifactId) {
+  if (value.scope.accountId !== scope.accountId || value.scope.workspaceId !== scope.workspaceId || value.artifactId !== artifactId || value.modality !== state.modality) {
+    throw new EditableArtifactSnapshotVerificationError("identity_mismatch");
+  }
+  if (value.coveredHeadSequence !== state.artifact.headSequence || editableArtifactStateHash(value.stateHash) !== state.artifact.stateHash || value.modality === "spreadsheet" && (state.modality !== "spreadsheet" || !causalFrontiersEqual(
+    editableArtifactCausalFrontier(value.coveredCausalFrontier),
+    state.artifact.causalFrontier
+  )) || value.modality !== "spreadsheet" && (state.modality === "spreadsheet" || value.nativeRevision !== expectedNativeRevision(state))) {
+    throw new EditableArtifactSnapshotVerificationError("coverage_mismatch");
+  }
+  if (!Number.isSafeInteger(value.canonicalByteSize) || value.canonicalByteSize <= 0 || value.canonicalByteSize > MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES) {
+    throw new EditableArtifactSnapshotVerificationError("limit_exceeded");
+  }
+  editableArtifactContentHash(value.canonicalContentHash);
+  const versions = value.modality === "spreadsheet" ? [value.modelSchemaVersion, value.operationProtocolVersion, value.crdtStateVersion] : [value.modelSchemaVersion];
+  if (versions.some((version) => !Number.isSafeInteger(version) || version <= 0)) {
+    throw new EditableArtifactSnapshotVerificationError("version_mismatch");
+  }
+  try {
+    assertBoundedKernelVersion(value.kernelVersion);
+  } catch {
+    throw new EditableArtifactSnapshotVerificationError("version_mismatch");
+  }
+  if (!value.canonicalChunks || typeof value.canonicalChunks[Symbol.asyncIterator] !== "function") {
+    throw new EditableArtifactSnapshotVerificationError("kernel_rejected");
+  }
+}
+function expectedNativeRevision(state) {
+  return state.committedTransactionTail.at(-1)?.nativeRevision ?? state.snapshot?.nativeRevision ?? state.baseNativeRevision;
+}
+function canonicalTimestamp(value) {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw new TypeError("Compaction verification clock returned an invalid date");
+  }
+  return value.toISOString();
+}
+function throwIfCancelled(signal) {
+  if (signal?.aborted) throw new EditableArtifactSnapshotVerificationError("cancelled");
+}
+
+// src/domain/editable-artifacts/snapshot-verifier-genesis.ts
+import { BoundedObjectWriteError as BoundedObjectWriteError2 } from "@opengeni/storage";
+var SNAPSHOT_MIME_TYPE2 = "application/vnd.opengeni.editable-artifact-snapshot";
+var EditableArtifactGenesisPipeline = class {
+  #dependencies;
+  constructor(dependencies) {
+    const maxSnapshotBytes = dependencies.maxSnapshotBytes ?? MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES;
+    if (!Number.isSafeInteger(maxSnapshotBytes) || maxSnapshotBytes <= 0 || maxSnapshotBytes > MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES) {
+      throw new TypeError("Genesis snapshot limit is invalid");
+    }
+    this.#dependencies = Object.freeze({
+      kernel: dependencies.kernel,
+      objects: dependencies.objects,
+      now: dependencies.now,
+      maxSnapshotBytes
+    });
+  }
+  async prepare(input) {
+    const scope = editableArtifactScope(input.scope);
+    const artifactId = editableArtifactId(input.artifactId);
+    const snapshotId = editableArtifactSnapshotId(input.snapshotId);
+    if (!isModality(input.modality)) {
+      throw new TypeError("Genesis modality is invalid");
+    }
+    throwIfGenesisCancelled(input.signal);
+    try {
+      const generated = await this.#dependencies.kernel.createCanonicalEmptySnapshot({
+        scope,
+        artifactId,
+        modality: input.modality,
+        ...input.signal ? { signal: input.signal } : {}
+      });
+      validateGeneratedGenesis(generated, scope, artifactId, input.modality);
+      const stored = await this.#dependencies.objects.write({
+        chunks: generated.canonicalChunks,
+        contentType: SNAPSHOT_MIME_TYPE2,
+        maxBytes: this.#dependencies.maxSnapshotBytes,
+        expectedByteSize: generated.canonicalByteSize,
+        expectedContentHash: generated.canonicalContentHash,
+        ...input.signal ? { signal: input.signal } : {}
+      });
+      const verifiedAt = canonicalTimestamp2(this.#dependencies.now());
+      const common = {
+        snapshotId,
+        blobReference: stored.opaqueReference,
+        byteSize: stored.byteSize,
+        contentHash: editableArtifactContentHash(stored.contentHash),
+        mimeType: SNAPSHOT_MIME_TYPE2,
+        modality: generated.modality,
+        coveredHeadSequence: 0,
+        stateHash: generated.stateHash,
+        modelSchemaVersion: generated.modelSchemaVersion,
+        kernelVersion: generated.kernelVersion,
+        verifiedAt
+      };
+      return generated.modality === "spreadsheet" ? Object.freeze({
+        ...common,
+        modality: "spreadsheet",
+        coveredCausalFrontier: editableArtifactCausalFrontier([]),
+        operationProtocolVersion: generated.operationProtocolVersion,
+        crdtStateVersion: generated.crdtStateVersion
+      }) : Object.freeze({
+        ...common,
+        modality: generated.modality,
+        nativeRevision: generated.nativeRevision
+      });
+    } catch (error) {
+      if (error instanceof EditableArtifactSnapshotVerificationError || error instanceof BoundedObjectWriteError2) {
+        throw error;
+      }
+      if (input.signal?.aborted) {
+        throw new EditableArtifactSnapshotVerificationError("cancelled");
+      }
+      throw new EditableArtifactSnapshotVerificationError("kernel_rejected");
+    }
+  }
+};
+function validateGeneratedGenesis(value, scope, artifactId, modality) {
+  if (value.scope.accountId !== scope.accountId || value.scope.workspaceId !== scope.workspaceId || value.artifactId !== artifactId || value.modality !== modality) {
+    throw new EditableArtifactSnapshotVerificationError("identity_mismatch");
+  }
+  if (value.coveredHeadSequence !== 0 || (value.modality === "spreadsheet" ? editableArtifactCausalFrontier(value.coveredCausalFrontier).length !== 0 : value.nativeRevision !== 0)) {
+    throw new EditableArtifactSnapshotVerificationError("coverage_mismatch");
+  }
+  if (!Number.isSafeInteger(value.canonicalByteSize) || value.canonicalByteSize <= 0 || value.canonicalByteSize > MAX_EDITABLE_ARTIFACT_SNAPSHOT_BYTES) {
+    throw new EditableArtifactSnapshotVerificationError("limit_exceeded");
+  }
+  editableArtifactContentHash(value.canonicalContentHash);
+  editableArtifactStateHash(value.stateHash);
+  const versions = value.modality === "spreadsheet" ? [value.modelSchemaVersion, value.operationProtocolVersion, value.crdtStateVersion] : [value.modelSchemaVersion];
+  for (const version of versions) {
+    if (!Number.isSafeInteger(version) || version <= 0) {
+      throw new EditableArtifactSnapshotVerificationError("version_mismatch");
+    }
+  }
+  try {
+    assertBoundedKernelVersion(value.kernelVersion);
+  } catch {
+    throw new EditableArtifactSnapshotVerificationError("version_mismatch");
+  }
+  if (!value.canonicalChunks || typeof value.canonicalChunks[Symbol.asyncIterator] !== "function") {
+    throw new EditableArtifactSnapshotVerificationError("kernel_rejected");
+  }
+}
+function canonicalTimestamp2(value) {
+  if (!(value instanceof Date) || !Number.isFinite(value.getTime())) {
+    throw new TypeError("Genesis verification clock returned an invalid date");
+  }
+  return value.toISOString();
+}
+function isModality(value) {
+  return value === "spreadsheet" || value === "presentation" || value === "document";
+}
+function throwIfGenesisCancelled(signal) {
+  if (signal?.aborted) {
+    throw new EditableArtifactSnapshotVerificationError("cancelled");
+  }
+}
+
+// src/domain/editable-artifacts/snapshot-verifier-materialization.ts
+import { createHash as createHash3 } from "crypto";
+import { EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES } from "@opengeni/contracts/editable-artifacts";
+var SHA256_PATTERN = /^sha256:[0-9a-f]{64}$/;
+var FORMAT_PATTERN = /^[a-z0-9][a-z0-9.+_-]{0,63}$/;
+var VERSION_PATTERN = /^[\x21-\x7e]+$/;
+function editableArtifactMaterializationKey(input) {
+  for (const [label, value] of [
+    ["state hash", input.stateHash],
+    ["options hash", input.optionsHash],
+    ["font registry hash", input.fontRegistryHash],
+    ["policy hash", input.policyHash]
+  ]) {
+    if (!SHA256_PATTERN.test(value)) {
+      throw new TypeError(`${label} must be a canonical SHA-256 digest`);
+    }
+  }
+  if (!FORMAT_PATTERN.test(input.format)) {
+    throw new TypeError("materialization format is invalid");
+  }
+  if (!VERSION_PATTERN.test(input.codecVersion) || input.codecVersion.length > 128) {
+    throw new TypeError("codec version is invalid");
+  }
+  if (!VERSION_PATTERN.test(input.kernelVersion) || input.kernelVersion.length > EDITABLE_ARTIFACT_KERNEL_VERSION_MAX_BYTES) {
+    throw new TypeError("kernel version is invalid");
+  }
+  const fields = [
+    input.stateHash,
+    input.format,
+    input.optionsHash,
+    input.codecVersion,
+    input.kernelVersion,
+    input.fontRegistryHash,
+    input.policyHash
+  ];
+  const digest = createHash3("sha256");
+  digest.update("OpenGeni editable artifact materialization\0v1\0", "utf8");
+  for (const field of fields) {
+    const bytes = Buffer.from(field, "utf8");
+    const length = Buffer.allocUnsafe(4);
+    length.writeUInt32BE(bytes.byteLength);
+    digest.update(length);
+    digest.update(bytes);
+  }
+  return `materialization:v1:sha256:${digest.digest("hex")}`;
+}
+
+export {
+  EDITABLE_ARTIFACT_EXPORT_MAX_DOWNLOAD_BYTES,
+  EDITABLE_ARTIFACT_EXPORT_MAX_OPTIONS_BYTES,
+  EditableArtifactDurableExportError,
+  EditableArtifactDurableExportService,
+  editableArtifactMaterializationMimeType,
+  editableArtifactFormatMatchesModality,
+  validateEditableArtifactPinnedVersion,
+  validateEditableArtifactMaterializationJob,
+  EditableArtifactOfficeImportError,
+  EditableArtifactAgentApplication,
+  editableArtifactDurableExportStorePortFromPostgres,
+  InMemoryEditableArtifactStore,
+  InMemoryEditableArtifactStableIdFactory,
+  SystemEditableArtifactClock,
+  editableArtifactStorePortFromPostgres,
+  editableArtifactAuthorizationRevisionPortFromPostgres,
+  editableArtifactScopeAuthorizationRevisionPortFromPostgres,
+  editableArtifactLiveReadPortFromPostgres,
+  editableArtifactLiveTicketStorePortFromPostgres,
+  EditableArtifactCompactionPipeline,
+  EditableArtifactGenesisPipeline,
+  editableArtifactMaterializationKey
+};
+//# sourceMappingURL=chunk-6WKPWE5S.js.map