@opengeni/artifact-tool 0.2.2

package/dist/chunk-ZZXPEE4S.js

@@ -0,0 +1,2260 @@
+import {
+  SpreadsheetFile
+} from "./chunk-VOJHMSM3.js";
+import {
+  CompositeArtifactState,
+  requireCompositeState
+} from "./chunk-HTJBLBDE.js";
+import {
+  DOCUMENT_LOSS_PRESERVATION
+} from "./chunk-RBGQADXA.js";
+import {
+  NativeDocumentSession,
+  NativePresentationSession,
+  NativeSpreadsheetSession
+} from "./chunk-B2ZJRZDA.js";
+import {
+  Document,
+  DocumentBlockCollection,
+  DocumentCommentThread,
+  DocumentComments,
+  DocumentFile,
+  DocumentParagraph,
+  DocumentSection,
+  DocumentSections,
+  DocumentStory,
+  DocumentTable,
+  TrackedChanges
+} from "./chunk-66CT2ZRP.js";
+import {
+  LOSS_PRESERVATION
+} from "./chunk-J6N7IR44.js";
+import {
+  Workbook
+} from "./chunk-IYFXZQ34.js";
+import {
+  UnsupportedArtifactFeatureError
+} from "./chunk-O24KTEGP.js";
+import {
+  ArtifactRuntimeError
+} from "./chunk-N2IHNWBS.js";
+import {
+  Presentation,
+  PresentationChart,
+  PresentationChartCollection,
+  PresentationFile,
+  PresentationGroup,
+  PresentationGroupCollection,
+  PresentationImage,
+  PresentationImageCollection,
+  PresentationShape,
+  PresentationShapeCollection,
+  PresentationTable,
+  PresentationTableCollection,
+  PresentationText,
+  Slide,
+  SlideCollection,
+  colorValue,
+  presentationLossState,
+  setPresentationLossState
+} from "./chunk-PI2AZVGK.js";
+import {
+  decodeRasterBase64,
+  inspectRasterImage
+} from "./chunk-FGZM4FQ6.js";
+
+// src/production-sha256.ts
+var ROUND_CONSTANTS = Uint32Array.of(
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+);
+var INITIAL_STATE = Uint32Array.of(
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+);
+function sha256Bytes(input) {
+  const paddedLength = Math.ceil((input.byteLength + 9) / 64) * 64;
+  const padded = new Uint8Array(paddedLength);
+  padded.set(input);
+  padded[input.byteLength] = 128;
+  const bitLength = input.byteLength * 8;
+  const paddedView = new DataView(padded.buffer);
+  paddedView.setUint32(paddedLength - 8, Math.floor(bitLength / 4294967296), false);
+  paddedView.setUint32(paddedLength - 4, bitLength >>> 0, false);
+  const state = Uint32Array.from(INITIAL_STATE);
+  const schedule = new Uint32Array(64);
+  for (let offset = 0; offset < paddedLength; offset += 64) {
+    for (let index = 0; index < 16; index += 1) {
+      schedule[index] = paddedView.getUint32(offset + index * 4, false);
+    }
+    for (let index = 16; index < 64; index += 1) {
+      const previous15 = schedule[index - 15];
+      const previous2 = schedule[index - 2];
+      const sigma0 = (rotateRight(previous15, 7) ^ rotateRight(previous15, 18) ^ previous15 >>> 3) >>> 0;
+      const sigma1 = (rotateRight(previous2, 17) ^ rotateRight(previous2, 19) ^ previous2 >>> 10) >>> 0;
+      schedule[index] = schedule[index - 16] + sigma0 + schedule[index - 7] + sigma1 >>> 0;
+    }
+    let a = state[0];
+    let b = state[1];
+    let c = state[2];
+    let d = state[3];
+    let e = state[4];
+    let f = state[5];
+    let g = state[6];
+    let h = state[7];
+    for (let index = 0; index < 64; index += 1) {
+      const sum1 = (rotateRight(e, 6) ^ rotateRight(e, 11) ^ rotateRight(e, 25)) >>> 0;
+      const choose = (e & f ^ ~e & g) >>> 0;
+      const temporary1 = h + sum1 + choose + ROUND_CONSTANTS[index] + schedule[index] >>> 0;
+      const sum0 = (rotateRight(a, 2) ^ rotateRight(a, 13) ^ rotateRight(a, 22)) >>> 0;
+      const majority = (a & b ^ a & c ^ b & c) >>> 0;
+      const temporary2 = sum0 + majority >>> 0;
+      h = g;
+      g = f;
+      f = e;
+      e = d + temporary1 >>> 0;
+      d = c;
+      c = b;
+      b = a;
+      a = temporary1 + temporary2 >>> 0;
+    }
+    state[0] = state[0] + a >>> 0;
+    state[1] = state[1] + b >>> 0;
+    state[2] = state[2] + c >>> 0;
+    state[3] = state[3] + d >>> 0;
+    state[4] = state[4] + e >>> 0;
+    state[5] = state[5] + f >>> 0;
+    state[6] = state[6] + g >>> 0;
+    state[7] = state[7] + h >>> 0;
+  }
+  const output = new Uint8Array(32);
+  const outputView = new DataView(output.buffer);
+  for (let index = 0; index < state.length; index += 1) {
+    outputView.setUint32(index * 4, state[index], false);
+  }
+  return output;
+}
+function rotateRight(value, bits) {
+  return (value >>> bits | value << 32 - bits) >>> 0;
+}
+
+// src/production-native-codecs.ts
+var textEncoder = new TextEncoder();
+var DOCUMENT_COMMAND_MAX_BYTES = 64 * 1024 * 1024;
+var DOCUMENT_COMMAND_MAX_COUNT = 4096;
+var PRESENTATION_COMMAND_MAX_BYTES = 4 * 1024 * 1024;
+var PRESENTATION_COMMAND_MAX_COUNT = 1e4;
+var HEADER_BYTES = 24;
+var CHECKSUM_BYTES = 8;
+var EMU_PER_CSS_PIXEL = 9525;
+var PRESENTATION_MAX_COORDINATE_EMU = 9525e9;
+function encodeDocumentProjectionCommands(snapshot) {
+  const payload = new ByteWriter(DOCUMENT_COMMAND_MAX_BYTES - HEADER_BYTES - CHECKSUM_BYTES);
+  let commandCount = 0;
+  const command = (write) => {
+    commandCount += 1;
+    if (commandCount > DOCUMENT_COMMAND_MAX_COUNT) {
+      throw new RangeError("Document projection exceeds the native command-count limit");
+    }
+    write();
+  };
+  const firstSection = snapshot.sections[0];
+  if (!firstSection || firstSection.startBlockIndex !== 0) {
+    throw new Error("Document projection requires one initial section at body offset zero");
+  }
+  assertInitialDocumentSectionIds(firstSection, snapshot.idNamespace);
+  if (snapshot.evenAndOddHeaders !== void 0 || snapshot.trackRevisions !== void 0) {
+    command(() => {
+      payload.u8(0);
+      payload.u8(optionalOptionalBool(snapshot.evenAndOddHeaders));
+      payload.u8(optionalOptionalBool(snapshot.trackRevisions));
+    });
+  }
+  if (firstSection.titlePage !== void 0) {
+    command(() => {
+      payload.u8(9);
+      payload.documentId(firstSection.id, "sec");
+      payload.u8(optionalBool(firstSection.titlePage));
+    });
+  }
+  if (!isDefaultNativeDocumentPage(firstSection.page)) {
+    command(() => {
+      payload.u8(14);
+      payload.documentId(firstSection.id, "sec");
+      payload.pageWithExtras(firstSection.page);
+    });
+  }
+  const laterSections = /* @__PURE__ */ new Map();
+  for (const section of snapshot.sections.slice(1)) {
+    if (laterSections.has(section.startBlockIndex)) {
+      throw new Error("Document projection contains adjacent sections without a body block");
+    }
+    laterSections.set(section.startBlockIndex, section);
+  }
+  for (let index = 0; index <= snapshot.blocks.length; index += 1) {
+    const section = laterSections.get(index);
+    if (section) {
+      command(() => writeAddSection(payload, section));
+      if (hasNonDefaultDocumentPageExtras(section.page)) {
+        command(() => {
+          payload.u8(14);
+          payload.documentId(section.id, "sec");
+          payload.pageWithExtras(section.page);
+        });
+      }
+    }
+    const block = snapshot.blocks[index];
+    if (block) command(() => writeDocumentBlock(payload, block, { kind: "body" }));
+  }
+  if ([...laterSections.keys()].some((index) => index > snapshot.blocks.length)) {
+    throw new Error("Document section starts beyond the body block list");
+  }
+  for (const section of snapshot.sections) {
+    writeDocumentStoryCommands(
+      payload,
+      command,
+      section,
+      "header",
+      "default",
+      section.headers.default
+    );
+    writeDocumentStoryCommands(payload, command, section, "header", "first", section.headers.first);
+    writeDocumentStoryCommands(payload, command, section, "header", "even", section.headers.even);
+    writeDocumentStoryCommands(
+      payload,
+      command,
+      section,
+      "footer",
+      "default",
+      section.footers.default
+    );
+    writeDocumentStoryCommands(payload, command, section, "footer", "first", section.footers.first);
+    writeDocumentStoryCommands(payload, command, section, "footer", "even", section.footers.even);
+  }
+  for (const thread of snapshot.comments) {
+    const root = thread.replies[0];
+    if (!root) throw new Error(`Document comment ${thread.id} has no root reply`);
+    command(() => {
+      payload.u8(10);
+      payload.documentId(thread.id, "dc");
+      payload.documentId(thread.blockId, "p");
+      payload.u32(thread.start);
+      payload.u32(thread.end);
+      payload.bool(thread.resolved);
+      payload.commentReply(root);
+    });
+    for (const reply of thread.replies.slice(1)) {
+      command(() => {
+        payload.u8(11);
+        payload.documentId(thread.id, "dc");
+        payload.commentReply(reply);
+      });
+    }
+  }
+  for (const change of snapshot.changes) {
+    command(() => {
+      payload.u8(13);
+      payload.documentId(change.id, "chg");
+      payload.documentId(change.blockId, "p");
+      payload.u32(change.start);
+      payload.u32(change.end);
+      payload.u8(change.kind === "insert" ? 1 : 2);
+      payload.string(change.author);
+      payload.string(change.createdAt);
+    });
+  }
+  return envelope("OGADC001", commandCount, payload.finish(), DOCUMENT_COMMAND_MAX_BYTES);
+}
+function encodeDocumentIncrementalCommands(commands) {
+  const payload = new ByteWriter(DOCUMENT_COMMAND_MAX_BYTES - HEADER_BYTES - CHECKSUM_BYTES);
+  if (commands.length === 0 || commands.length > DOCUMENT_COMMAND_MAX_COUNT) {
+    throw new RangeError("Document incremental command count is outside its limit");
+  }
+  for (const command of commands) {
+    switch (command.kind) {
+      case "block.add":
+        writeDocumentBlock(payload, command.block, command.target);
+        break;
+      case "paragraph.edit":
+        payload.u8(2);
+        payload.documentId(command.id, "p");
+        payload.u32(command.start);
+        payload.u32(command.end);
+        payload.string(command.text);
+        payload.bool(command.style !== void 0);
+        if (command.style) payload.textStyle(command.style);
+        break;
+      case "paragraph.format":
+        payload.u8(3);
+        payload.documentId(command.id, "p");
+        payload.u32(command.format.start);
+        payload.u32(command.format.end);
+        payload.textStylePatch(command.format.style);
+        break;
+      case "paragraph.style":
+        payload.u8(4);
+        payload.documentId(command.id, "p");
+        payload.paragraphStyle(command.style);
+        break;
+      case "table.style":
+        payload.u8(6);
+        payload.documentId(command.id, "dt");
+        payload.tableStyle(command.style);
+        break;
+      case "document.flags":
+        payload.u8(0);
+        payload.u8(optionalOptionalBool(command.evenAndOddHeaders));
+        payload.u8(optionalOptionalBool(command.trackRevisions));
+        break;
+      case "section.add":
+        writeAddSection(payload, command.section);
+        if (hasNonDefaultDocumentPageExtras(command.section.page)) {
+          payload.u8(14);
+          payload.documentId(command.section.id, "sec");
+          payload.pageWithExtras(command.section.page);
+        }
+        break;
+      case "section.title":
+        payload.u8(9);
+        payload.documentId(command.id, "sec");
+        payload.u8(optionalBool(command.titlePage));
+        break;
+      case "comment.add": {
+        const root = command.comment.replies[0];
+        if (!root) throw new Error(`Document comment ${command.comment.id} has no root reply`);
+        payload.u8(10);
+        payload.documentId(command.comment.id, "dc");
+        payload.documentId(command.comment.blockId, "p");
+        payload.u32(command.comment.start);
+        payload.u32(command.comment.end);
+        payload.bool(command.comment.resolved);
+        payload.commentReply(root);
+        break;
+      }
+      case "comment.reply":
+        payload.u8(11);
+        payload.documentId(command.id, "dc");
+        payload.commentReply(command.reply);
+        break;
+      case "comment.resolved":
+        payload.u8(12);
+        payload.documentId(command.id, "dc");
+        payload.bool(command.resolved);
+        break;
+      case "tracked.add":
+        payload.u8(13);
+        payload.documentId(command.change.id, "chg");
+        payload.documentId(command.change.blockId, "p");
+        payload.u32(command.change.start);
+        payload.u32(command.change.end);
+        payload.u8(command.change.kind === "insert" ? 1 : 2);
+        payload.string(command.change.author);
+        payload.string(command.change.createdAt);
+        break;
+    }
+  }
+  const commandCount = commands.length + commands.filter(
+    (command) => command.kind === "section.add" && hasNonDefaultDocumentPageExtras(command.section.page)
+  ).length;
+  return envelope("OGADC001", commandCount, payload.finish(), DOCUMENT_COMMAND_MAX_BYTES);
+}
+function encodePresentationProjectionCommands(presentation, namespace) {
+  const hasCustomSlideSize = presentation.slideSize.width !== 1280 || presentation.slideSize.height !== 720;
+  if (hasCustomSlideSize) {
+    assertFinitePositive(presentation.slideSize.width, "presentation slide width");
+    assertFinitePositive(presentation.slideSize.height, "presentation slide height");
+  }
+  const payload = new ByteWriter(PRESENTATION_COMMAND_MAX_BYTES - HEADER_BYTES - CHECKSUM_BYTES);
+  let commandCount = 0;
+  const command = (write) => {
+    commandCount += 1;
+    if (commandCount > PRESENTATION_COMMAND_MAX_COUNT) {
+      throw new RangeError("Presentation projection exceeds the native command-count limit");
+    }
+    write();
+  };
+  if (hasCustomSlideSize) {
+    command(() => {
+      payload.u8(15);
+      payload.i64(presentationSizeEmu(presentation.slideSize.width, "presentation slide width"));
+      payload.i64(presentationSizeEmu(presentation.slideSize.height, "presentation slide height"));
+    });
+  }
+  let templateElementCounter = 0xffffffffffffffffn;
+  const nextTemplateElementId = () => {
+    if (templateElementCounter === 0n) {
+      throw new RangeError("Presentation template element id space is exhausted");
+    }
+    return `sh/${templateElementCounter--}`;
+  };
+  for (const master of presentation.masters.items) {
+    command(() => {
+      payload.u8(0);
+      payload.presentationId(master.id, namespace);
+      payload.string(master.name);
+      payload.fill(master.background);
+    });
+    for (const [index, template] of master.elements.entries()) {
+      const element = materializeTemplateElement(template);
+      writePresentationElement(
+        payload,
+        command,
+        element,
+        namespace,
+        { tag: 0, id: master.id },
+        void 0,
+        index,
+        nextTemplateElementId()
+      );
+    }
+  }
+  for (const layout of presentation.layouts.items) {
+    command(() => {
+      payload.u8(1);
+      payload.presentationId(layout.id, namespace);
+      payload.string(layout.name);
+      payload.optionalPresentationId(layout.masterId, namespace);
+      payload.fill(layout.background);
+    });
+    for (const [index, template] of layout.elements.entries()) {
+      const element = materializeTemplateElement(template);
+      writePresentationElement(
+        payload,
+        command,
+        element,
+        namespace,
+        { tag: 1, id: layout.id },
+        void 0,
+        index,
+        nextTemplateElementId()
+      );
+    }
+  }
+  for (const [slideIndex, slide] of presentation.slides.items.entries()) {
+    command(() => {
+      payload.u8(2);
+      payload.presentationId(slide.id, namespace);
+      payload.u32(slideIndex);
+      payload.string(slide.title);
+      payload.optionalPresentationId(slide.layout?.id, namespace);
+      payload.fill(slide.background.fill);
+    });
+    if (slide.notes.toString().length > 0) {
+      command(() => {
+        payload.u8(8);
+        payload.presentationId(slide.id, namespace);
+        payload.richText(slide.notes);
+      });
+    }
+    for (const [index, element] of slide.elements.entries()) {
+      writePresentationElement(
+        payload,
+        command,
+        element,
+        namespace,
+        { tag: 2, id: slide.id },
+        void 0,
+        index
+      );
+    }
+  }
+  return envelope("OGAPC001", commandCount, payload.finish(), PRESENTATION_COMMAND_MAX_BYTES);
+}
+function encodePresentationIncrementalCommands(commands, namespace) {
+  const payload = new ByteWriter(PRESENTATION_COMMAND_MAX_BYTES - HEADER_BYTES - CHECKSUM_BYTES);
+  let commandCount = 0;
+  const command = (write) => {
+    commandCount += 1;
+    if (commandCount > PRESENTATION_COMMAND_MAX_COUNT) {
+      throw new RangeError("Presentation incremental command count is outside its limit");
+    }
+    write();
+  };
+  for (const entry of commands) {
+    switch (entry.kind) {
+      case "slide.create":
+        command(() => {
+          payload.u8(2);
+          payload.presentationId(entry.slide.id, namespace);
+          payload.u32(entry.index);
+          payload.string(entry.slide.title);
+          payload.optionalPresentationId(entry.slide.layout?.id, namespace);
+          payload.fill(entry.slide.background.fill);
+        });
+        break;
+      case "slide.title":
+        command(() => {
+          payload.u8(6);
+          payload.presentationId(entry.id, namespace);
+          payload.string(entry.title);
+        });
+        break;
+      case "slide.layout":
+        command(() => {
+          payload.u8(7);
+          payload.presentationId(entry.id, namespace);
+          payload.optionalPresentationId(entry.layoutId, namespace);
+        });
+        break;
+      case "slide.notes":
+        command(() => {
+          payload.u8(8);
+          payload.presentationId(entry.id, namespace);
+          payload.richText(entry.notes);
+        });
+        break;
+      case "node.insert":
+        writePresentationElement(
+          payload,
+          command,
+          entry.element,
+          namespace,
+          { tag: 2, id: entry.slideId },
+          void 0,
+          entry.index
+        );
+        break;
+      case "node.update":
+        command(() => {
+          payload.u8(12);
+          payload.presentationId(entry.element.id, namespace);
+          payload.presentationRect(entry.element.position);
+        });
+        command(() => {
+          payload.u8(13);
+          payload.presentationId(entry.element.id, namespace);
+          payload.presentationTransform(
+            "rotation" in entry.element ? entry.element.rotation : 0,
+            "flipHorizontal" in entry.element ? entry.element.flipHorizontal : false,
+            "flipVertical" in entry.element ? entry.element.flipVertical : false
+          );
+        });
+        command(() => {
+          payload.u8(14);
+          payload.presentationId(entry.element.id, namespace);
+          payload.presentationNode(entry.element);
+        });
+        break;
+      case "presentation.size":
+        command(() => {
+          payload.u8(15);
+          payload.i64(presentationSizeEmu(entry.width, "presentation slide width"));
+          payload.i64(presentationSizeEmu(entry.height, "presentation slide height"));
+        });
+        break;
+    }
+  }
+  if (commandCount === 0) throw new RangeError("Presentation incremental command batch is empty");
+  return envelope("OGAPC001", commandCount, payload.finish(), PRESENTATION_COMMAND_MAX_BYTES);
+}
+function materializeTemplateElement(template) {
+  const scratch = Presentation.create();
+  const slide = scratch.slides.add();
+  switch (template.kind) {
+    case "shape":
+      return slide.shapes.add(template.config);
+    case "chart":
+      return slide.charts.add(template.type, template.config);
+    case "image":
+      return slide.images.add(template.config);
+    case "table":
+      return slide.tables.add(template.config);
+  }
+}
+function writeDocumentStoryCommands(writer, command, section, kind, variant, story) {
+  const expectedPrefix = kind === "header" ? "hdr" : "ftr";
+  writer.assertDocumentId(story.id, expectedPrefix);
+  for (const block of story.blocks) {
+    command(
+      () => writeDocumentBlock(writer, block, {
+        kind: "story",
+        sectionId: section.id,
+        storyKind: kind,
+        variant
+      })
+    );
+  }
+}
+function writeDocumentBlock(writer, block, target) {
+  if (block.kind === "paragraph") {
+    writer.u8(1);
+    writer.documentTarget(target);
+    writer.documentId(block.id, "p");
+    writer.textRuns(block.runs);
+    writer.paragraphStyle(block.style);
+    return;
+  }
+  if (block.kind === "table") {
+    writer.u8(5);
+    writer.documentTarget(target);
+    writer.documentId(block.id, "dt");
+    writer.u32(block.rows.length);
+    for (const row of block.rows) {
+      writer.u32(row.length);
+      for (const cell of row) writer.textRuns(cell);
+    }
+    writer.tableStyle(block.style);
+    return;
+  }
+  if (target.kind !== "body") {
+    throw new Error("Document story cannot contain a page break");
+  }
+  writer.u8(7);
+  writer.documentId(block.id, "pb");
+}
+function writeAddSection(writer, section) {
+  writer.u8(8);
+  writer.documentId(section.id, "sec");
+  writer.documentId(section.headers.default.id, "hdr");
+  writer.documentId(section.headers.first.id, "hdr");
+  writer.documentId(section.headers.even.id, "hdr");
+  writer.documentId(section.footers.default.id, "ftr");
+  writer.documentId(section.footers.first.id, "ftr");
+  writer.documentId(section.footers.even.id, "ftr");
+  writer.page(section.page);
+  writer.u8(optionalBool(section.titlePage));
+}
+function assertInitialDocumentSectionIds(section, namespace) {
+  const expected = [
+    [section.id, "sec", 1n],
+    [section.headers.default.id, "hdr", 2n],
+    [section.headers.first.id, "hdr", 3n],
+    [section.headers.even.id, "hdr", 4n],
+    [section.footers.default.id, "ftr", 5n],
+    [section.footers.first.id, "ftr", 6n],
+    [section.footers.even.id, "ftr", 7n]
+  ];
+  for (const [id, prefix, counter] of expected) {
+    const parsed = parseDocumentId(id, prefix);
+    if (parsed.namespace !== BigInt(`0x${namespace}`) || parsed.counter !== counter) {
+      throw new Error("Initial document structural ids do not match the native document allocator");
+    }
+  }
+}
+function isDefaultNativeDocumentPage(page) {
+  return page.widthPt === 612 && page.heightPt === 792 && page.marginTopPt === 72 && page.marginRightPt === 72 && page.marginBottomPt === 72 && page.marginLeftPt === 72 && !hasNonDefaultDocumentPageExtras(page);
+}
+function hasNonDefaultDocumentPageExtras(page) {
+  return (page.headerPt ?? 36) !== 36 || (page.footerPt ?? 36) !== 36 || (page.gutterPt ?? 0) !== 0;
+}
+function writePresentationElement(writer, command, element, namespace, owner, parentId, index, idOverride) {
+  const elementId = idOverride ?? element.id;
+  command(() => {
+    writer.u8(9);
+    writer.u8(owner.tag);
+    writer.presentationId(owner.id, namespace);
+    writer.optionalPresentationId(parentId, namespace);
+    writer.u32(index);
+    writer.presentationId(elementId, namespace);
+    writer.string(element.name);
+    writer.presentationRect(element.position);
+    writer.presentationTransform(
+      "rotation" in element ? element.rotation : 0,
+      "flipHorizontal" in element ? element.flipHorizontal : false,
+      "flipVertical" in element ? element.flipVertical : false
+    );
+    writer.presentationNode(element);
+  });
+  if (element instanceof PresentationGroup) {
+    for (const [childIndex, child] of element.children.entries()) {
+      writePresentationElement(writer, command, child, namespace, owner, elementId, childIndex);
+    }
+  }
+}
+function unsupportedPresentation(feature) {
+  throw new UnsupportedArtifactFeatureError("presentation", feature, "native Rust projection");
+}
+var ByteWriter = class {
+  constructor(maximum) {
+    this.maximum = maximum;
+  }
+  #bytes = [];
+  finish() {
+    return Uint8Array.from(this.#bytes);
+  }
+  bytes(value) {
+    if (this.#bytes.length + value.byteLength > this.maximum) {
+      throw new RangeError("Native projection command envelope exceeds its byte limit");
+    }
+    this.#bytes.push(...value);
+  }
+  u8(value) {
+    this.bytes(Uint8Array.of(value));
+  }
+  bool(value) {
+    this.u8(value ? 1 : 0);
+  }
+  u16(value) {
+    const bytes = new Uint8Array(2);
+    new DataView(bytes.buffer).setUint16(0, value, true);
+    this.bytes(bytes);
+  }
+  u32(value) {
+    if (!Number.isSafeInteger(value) || value < 0 || value > 4294967295) {
+      throw new RangeError("Native projection integer is outside u32");
+    }
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setUint32(0, value, true);
+    this.bytes(bytes);
+  }
+  i32(value) {
+    if (!Number.isSafeInteger(value) || value < -2147483648 || value > 2147483647) {
+      throw new RangeError("Native projection integer is outside i32");
+    }
+    const bytes = new Uint8Array(4);
+    new DataView(bytes.buffer).setInt32(0, value, true);
+    this.bytes(bytes);
+  }
+  u64(value) {
+    if (value < 0n || value > 0xffffffffffffffffn) {
+      throw new RangeError("Native projection integer is outside u64");
+    }
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setBigUint64(0, value, true);
+    this.bytes(bytes);
+  }
+  i64(value) {
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setBigInt64(0, value, true);
+    this.bytes(bytes);
+  }
+  f64(value) {
+    if (!Number.isFinite(value) || Object.is(value, -0)) {
+      throw new TypeError("Native projection numbers must be finite canonical doubles");
+    }
+    const bytes = new Uint8Array(8);
+    new DataView(bytes.buffer).setFloat64(0, value, true);
+    this.bytes(bytes);
+  }
+  string(value) {
+    const encoded = textEncoder.encode(value);
+    this.u32(encoded.byteLength);
+    this.bytes(encoded);
+  }
+  optionalString(value) {
+    this.bool(value !== void 0);
+    if (value !== void 0) this.string(value);
+  }
+  assertDocumentId(id, expectedPrefix) {
+    parseDocumentId(id, expectedPrefix);
+  }
+  documentId(id, expectedPrefix) {
+    const parsed = parseDocumentId(id, expectedPrefix);
+    this.u8(documentKindTag(expectedPrefix));
+    this.u64(parsed.namespace);
+    this.u64(parsed.counter);
+  }
+  documentTarget(target) {
+    if (target.kind === "body") {
+      this.u8(0);
+      return;
+    }
+    this.u8(1);
+    this.documentId(target.sectionId, "sec");
+    this.u8(target.storyKind === "header" ? 1 : 2);
+    this.u8(target.variant === "default" ? 1 : target.variant === "first" ? 2 : 3);
+  }
+  page(page) {
+    this.f64(page.widthPt);
+    this.f64(page.heightPt);
+    this.f64(page.marginTopPt);
+    this.f64(page.marginRightPt);
+    this.f64(page.marginBottomPt);
+    this.f64(page.marginLeftPt);
+  }
+  pageWithExtras(page) {
+    this.page(page);
+    this.f64(page.headerPt ?? 36);
+    this.f64(page.footerPt ?? 36);
+    this.f64(page.gutterPt ?? 0);
+  }
+  textRuns(runs) {
+    this.u32(runs.length);
+    for (const run of runs) {
+      this.string(run.text);
+      this.textStyle(run.style);
+    }
+  }
+  textStyle(style) {
+    const mask = Number(style.fontFamily !== void 0) | Number(style.fontSizePt !== void 0) << 1 | Number(style.color !== void 0) << 2 | Number(style.bold !== void 0) << 3 | Number(style.italic !== void 0) << 4 | Number(style.underline !== void 0) << 5 | Number(style.strike !== void 0) << 6;
+    this.u8(mask);
+    if (style.fontFamily !== void 0) this.string(style.fontFamily);
+    if (style.fontSizePt !== void 0) this.f64(style.fontSizePt);
+    if (style.color !== void 0) this.string(style.color);
+    for (const value of [style.bold, style.italic, style.underline, style.strike]) {
+      if (value !== void 0) this.bool(value);
+    }
+  }
+  textStylePatch(style) {
+    this.patchString(style.fontFamily);
+    this.patchF64(style.fontSizePt);
+    this.patchString(style.color);
+    this.patchBool(style.bold);
+    this.patchBool(style.italic);
+    this.patchBool(style.underline);
+    this.patchBool(style.strike);
+  }
+  patchString(value) {
+    this.u8(value === void 0 ? 0 : value === null ? 1 : 2);
+    if (typeof value === "string") this.string(value);
+  }
+  patchF64(value) {
+    this.u8(value === void 0 ? 0 : value === null ? 1 : 2);
+    if (typeof value === "number") this.f64(value);
+  }
+  patchBool(value) {
+    this.u8(value === void 0 ? 0 : value === null ? 1 : value ? 3 : 2);
+  }
+  paragraphStyle(style) {
+    const mask = Number(style.headingLevel !== void 0) | Number(style.alignment !== void 0) << 1 | Number(style.spaceBeforePt !== void 0) << 2 | Number(style.spaceAfterPt !== void 0) << 3 | Number(style.lineHeight !== void 0) << 4 | Number(style.keepNext !== void 0) << 5 | Number(style.pageBreakBefore !== void 0) << 6 | Number(style.list !== void 0) << 7;
+    this.u16(mask);
+    if (style.headingLevel !== void 0) this.u8(style.headingLevel);
+    if (style.alignment !== void 0) {
+      this.u8({ left: 1, center: 2, right: 3, justify: 4 }[style.alignment]);
+    }
+    for (const value of [style.spaceBeforePt, style.spaceAfterPt, style.lineHeight]) {
+      if (value !== void 0) this.f64(value);
+    }
+    for (const value of [style.keepNext, style.pageBreakBefore]) {
+      if (value !== void 0) this.bool(value);
+    }
+    if (style.list) {
+      this.u8(style.list.kind === "bullet" ? 1 : 2);
+      this.bool(style.list.level !== void 0);
+      if (style.list.level !== void 0) this.u8(style.list.level);
+      this.optionalString(style.list.instanceId);
+    }
+  }
+  tableStyle(style) {
+    const mask = Number(style.widthPt !== void 0) | Number(style.columnWidthsPt !== void 0) << 1 | Number(style.headerRows !== void 0) << 2 | Number(style.cellPaddingPt !== void 0) << 3 | Number(style.borderColor !== void 0) << 4 | Number(style.headerFill !== void 0) << 5 | Number(style.allowRowSplit !== void 0) << 6;
+    this.u8(mask);
+    if (style.widthPt !== void 0) this.f64(style.widthPt);
+    if (style.columnWidthsPt !== void 0) {
+      this.u32(style.columnWidthsPt.length);
+      for (const width of style.columnWidthsPt) this.f64(width);
+    }
+    if (style.headerRows !== void 0) this.u32(style.headerRows);
+    if (style.cellPaddingPt !== void 0) this.f64(style.cellPaddingPt);
+    if (style.borderColor !== void 0) this.string(style.borderColor);
+    if (style.headerFill !== void 0) this.string(style.headerFill);
+    if (style.allowRowSplit !== void 0) this.bool(style.allowRowSplit);
+  }
+  commentReply(reply) {
+    this.string(reply.author);
+    this.string(reply.text);
+    this.string(reply.createdAt);
+  }
+  presentationId(id, namespace) {
+    const counter = presentationCounter(id);
+    this.u64(counter);
+    this.u64(namespace);
+  }
+  optionalPresentationId(id, namespace) {
+    this.bool(id !== void 0);
+    if (id !== void 0) this.presentationId(id, namespace);
+  }
+  fill(fill) {
+    const value = colorValue(fill);
+    if (value === "none") {
+      this.u8(0);
+      return;
+    }
+    this.u8(1);
+    const rgb = Number.parseInt(value.slice(1), 16);
+    this.u32(rgb * 256 + 255 >>> 0);
+  }
+  line(line) {
+    this.fill(line.fill ?? "black");
+    this.i64(cssPixels(line.width ?? 1));
+    this.u8(line.style === "dash" ? 1 : line.style === "dot" ? 2 : 0);
+  }
+  presentationRect(position) {
+    this.i64(cssPixels(position.left));
+    this.i64(cssPixels(position.top));
+    this.i64(cssPixels(position.width));
+    this.i64(cssPixels(position.height));
+  }
+  presentationTransform(rotation, flipHorizontal, flipVertical) {
+    this.i32(Math.round(rotation * 6e4));
+    this.bool(flipHorizontal);
+    this.bool(flipVertical);
+  }
+  richText(text, fallbackStyle = {}) {
+    const style = { ...fallbackStyle, ...text.style };
+    this.u8(
+      style.verticalAlignment === "middle" ? 1 : style.verticalAlignment === "bottom" ? 2 : 0
+    );
+    this.u32(1);
+    this.u8(
+      style.alignment === "center" ? 1 : style.alignment === "right" ? 2 : style.alignment === "justify" ? 3 : 0
+    );
+    this.u32(1);
+    this.string(text.toString());
+    this.presentationTextStyle(style);
+  }
+  plainRichText(value, style = {}) {
+    this.u8(
+      style.verticalAlignment === "middle" ? 1 : style.verticalAlignment === "bottom" ? 2 : 0
+    );
+    this.u32(1);
+    this.u8(
+      style.alignment === "center" ? 1 : style.alignment === "right" ? 2 : style.alignment === "justify" ? 3 : 0
+    );
+    this.u32(1);
+    this.string(value);
+    this.presentationTextStyle(style);
+  }
+  presentationTextStyle(style) {
+    this.string(style.fontFamily ?? "Arial");
+    this.u32(Math.round((style.fontSize ?? 18) * 100));
+    const color = colorValue(style.color ?? "black");
+    const rgb = color === "none" ? 0 : Number.parseInt(color.slice(1), 16);
+    this.u32(rgb * 256 + (color === "none" ? 0 : 255) >>> 0);
+    this.bool(style.bold ?? false);
+    this.bool(style.italic ?? false);
+    this.bool(style.underline ?? false);
+    this.bool(false);
+  }
+  presentationNode(element) {
+    if (element instanceof PresentationShape) {
+      this.u8(0);
+      this.u8(
+        { textbox: 0, rect: 1, roundRect: 2, ellipse: 3, triangle: 4, rightArrow: 5, line: 6 }[element.geometry]
+      );
+      this.fill(element.fill);
+      this.line(element.line);
+      const hasText = element.text.toString().length > 0;
+      this.bool(hasText);
+      if (hasText) this.richText(element.text);
+      this.bool(element.placeholder !== void 0);
+      if (element.placeholder) {
+        this.string(element.placeholder.type);
+        this.bool(element.placeholder.index !== void 0);
+        if (element.placeholder.index !== void 0) this.u32(element.placeholder.index);
+      }
+      return;
+    }
+    if (element instanceof PresentationGroup) {
+      this.u8(1);
+      this.i64(cssPixels(element.childOffset.left));
+      this.i64(cssPixels(element.childOffset.top));
+      this.i64(cssPixels(element.childExtent.width));
+      this.i64(cssPixels(element.childExtent.height));
+      this.u32(0);
+      return;
+    }
+    if (element instanceof PresentationChart) {
+      this.u8(3);
+      this.u8(
+        { bar: 0, line: 1, area: 2, pie: 3, doughnut: 4, scatter: 5, bubble: 6, radar: 7 }[element.type]
+      );
+      this.plainRichText(element.title);
+      this.u32(element.series.items.length);
+      for (const series of element.series.items) {
+        this.string(series.name);
+        this.stringVector(series.categories.length > 0 ? series.categories : element.categories);
+        this.numberVector(series.values);
+        this.numberVector(series.xValues);
+        this.numberVector(series.bubbleSizes);
+      }
+      this.bool(element.hasLegend);
+      return;
+    }
+    if (element instanceof PresentationTable) {
+      this.u8(4);
+      this.u32(element.rows.length);
+      this.u32(element.rows[0]?.length ?? 0);
+      for (const row of element.rows) {
+        for (const cell of row) {
+          this.bool(cell !== null);
+          if (cell) {
+            this.richText(cell.text, element.textStyle);
+            this.fill(cell.fill);
+            this.u16(cell.rowSpan);
+            this.u16(cell.colSpan);
+          }
+        }
+      }
+      this.u32(element.columnWidths.length);
+      for (const width of element.columnWidths) this.i64(cssPixels(width));
+      this.u32(element.rowHeights.length);
+      for (const height of element.rowHeights) this.i64(cssPixels(height));
+      this.line(element.line);
+      return;
+    }
+    if (element instanceof PresentationImage) {
+      const source = element.sourceForSvg();
+      if (!source) {
+        unsupportedPresentation("prompt-only raster image scene nodes");
+      }
+      const match = /^data:([^;,]+);base64,([A-Za-z0-9+/]*={0,2})$/u.exec(source);
+      if (!match) throw new Error(`Presentation image ${element.id} has a non-canonical source`);
+      const bytes = decodeRasterBase64(match[2]);
+      const metadata = inspectRasterImage(bytes);
+      if (metadata.contentType !== match[1] || metadata.contentType !== element.contentType) {
+        throw new Error(`Presentation image ${element.id} MIME metadata diverged`);
+      }
+      this.u8(5);
+      this.bytes(sha256Bytes(bytes));
+      this.string(metadata.contentType);
+      this.string(element.alt);
+      this.u8(element.fit === "contain" ? 0 : 1);
+      this.u32(metadata.width);
+      this.u32(metadata.height);
+      return;
+    }
+    unsupportedPresentation("unknown scene node");
+  }
+  stringVector(values) {
+    this.u32(values.length);
+    for (const value of values) this.string(value);
+  }
+  numberVector(values) {
+    this.u32(values.length);
+    for (const value of values) this.f64(value);
+  }
+};
+function envelope(magic, count, payload, maximum) {
+  const output = new Uint8Array(HEADER_BYTES + payload.byteLength + CHECKSUM_BYTES);
+  if (output.byteLength > maximum) throw new RangeError(`${magic} envelope exceeds its byte limit`);
+  output.set(textEncoder.encode(magic), 0);
+  const view = new DataView(output.buffer);
+  view.setUint16(8, 1, true);
+  view.setUint32(12, count, true);
+  view.setBigUint64(16, BigInt(payload.byteLength), true);
+  output.set(payload, HEADER_BYTES);
+  view.setBigUint64(HEADER_BYTES + payload.byteLength, fnv1a64(output.subarray(0, -8)), true);
+  return output;
+}
+function parseDocumentId(id, expectedPrefix) {
+  const match = /^([a-z]{1,8})\/([0-9a-f]{16})([0-9a-f]{16})$/u.exec(id);
+  if (!match || match[1] !== expectedPrefix) {
+    throw new Error(`Document id ${id} is not a canonical ${expectedPrefix} id`);
+  }
+  const counter = BigInt(`0x${match[3]}`);
+  if (counter === 0n) throw new Error(`Document id ${id} uses the reserved zero counter`);
+  return { namespace: BigInt(`0x${match[2]}`), counter };
+}
+function documentKindTag(prefix) {
+  const tag = { p: 1, dt: 2, pb: 3, sec: 4, hdr: 5, ftr: 6, dc: 7, chg: 8 }[prefix];
+  if (!tag) throw new Error(`Unknown document id prefix: ${prefix}`);
+  return tag;
+}
+function presentationCounter(id) {
+  const match = /^[a-z]{2}\/([1-9][0-9]*)$/u.exec(id);
+  if (!match) throw new Error(`Presentation object id is not canonical: ${id}`);
+  const counter = BigInt(match[1]);
+  if (counter > 0xffffffffffffffffn) throw new RangeError("Presentation object id is exhausted");
+  return counter;
+}
+function optionalBool(value) {
+  return value === void 0 ? 0 : value ? 2 : 1;
+}
+function optionalOptionalBool(value) {
+  return value === void 0 ? 0 : value ? 3 : 2;
+}
+function cssPixels(value) {
+  if (!Number.isFinite(value) || Object.is(value, -0)) {
+    throw new TypeError("Presentation geometry must contain finite canonical numbers");
+  }
+  return BigInt(Math.round(value * EMU_PER_CSS_PIXEL));
+}
+function assertFinitePositive(value, label) {
+  if (!Number.isFinite(value) || value <= 0)
+    throw new TypeError(`${label} must be positive and finite`);
+}
+function presentationSizeEmu(value, label) {
+  assertFinitePositive(value, label);
+  const rounded = Math.round(value * EMU_PER_CSS_PIXEL);
+  if (!Number.isSafeInteger(rounded) || rounded <= 0 || rounded > PRESENTATION_MAX_COORDINATE_EMU) {
+    throw new RangeError(`${label} exceeds the native presentation-coordinate bound`);
+  }
+  return BigInt(rounded);
+}
+function fnv1a64(bytes) {
+  let hash = 0xcbf29ce484222325n;
+  for (const byte of bytes) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * 0x100000001b3n);
+  }
+  return hash;
+}
+
+// src/production-spreadsheet-native.ts
+import {
+  SPREADSHEET_ARTIFACT_PROJECTION_MAX_BYTES,
+  SPREADSHEET_ARTIFACT_VIEWPORT_MAX_CELLS,
+  decodeSpreadsheetMetadataKernelProjection,
+  decodeSpreadsheetViewportKernelProjection,
+  editableArtifactStableId,
+  encodeSpreadsheetMetadataKernelQuery,
+  encodeSpreadsheetViewportKernelQuery,
+  spreadsheetSheetId
+} from "@opengeni/contracts/editable-artifacts";
+var textEncoder2 = new TextEncoder();
+function reconcileSpreadsheetProjection(workbook, runtime, namespace) {
+  const snapshot = workbook.toJSON();
+  const session = NativeSpreadsheetSession.create(runtime, namespace);
+  const sheetIds = /* @__PURE__ */ new Map();
+  const generations = /* @__PURE__ */ new Map();
+  const author = new SpreadsheetProjectionAuthor(session, namespace);
+  try {
+    let previous = null;
+    let offset = 0;
+    const maximumCommands = Math.max(1, Math.min(session.capabilities.maxCommands, 1024));
+    while (offset < snapshot.worksheets.length) {
+      const chunk = snapshot.worksheets.slice(offset, offset + maximumCommands);
+      const commands = [];
+      for (let relativeIndex = 0; relativeIndex < chunk.length; relativeIndex += 1) {
+        const worksheet = chunk[relativeIndex];
+        const sheetId = nativeSheetId(namespace, worksheet.id);
+        sheetIds.set(worksheet.id, sheetId);
+        const after = relativeIndex === 0 ? previous : {
+          kind: "created-in-batch",
+          sheetId: sheetIds.get(chunk[relativeIndex - 1].id),
+          createCommandIndex: relativeIndex - 1
+        };
+        commands.push({ kind: "sheet.create", sheetId, name: worksheet.name, after });
+      }
+      author.author(commands);
+      const metadata = querySpreadsheetMetadata(session, sheetIds.size);
+      const metadataById = new Map(metadata.map((sheet) => [sheet.sheetId, sheet]));
+      for (let index = 0; index < chunk.length; index += 1) {
+        const worksheet = chunk[index];
+        const sheetId = sheetIds.get(worksheet.id);
+        const operationId = metadataById.get(sheetId)?.generationId;
+        if (!operationId) throw new Error("Native kernel omitted a sheet generation id");
+        const generation = Object.freeze({
+          kind: "generation",
+          sheetId,
+          creationOperationId: editableArtifactStableId(operationId)
+        });
+        generations.set(worksheet.id, generation);
+        previous = generation;
+      }
+      offset += chunk.length;
+    }
+    const batch = new SpreadsheetCommandBatcher(author, session);
+    for (const worksheet of snapshot.worksheets) {
+      const generation = generations.get(worksheet.id);
+      if (!generation) throw new Error(`Missing native generation for worksheet ${worksheet.id}`);
+      for (const command of cellCommands(worksheet, generation)) batch.add(command);
+    }
+    batch.finish();
+    return {
+      session,
+      data: {
+        sheetIds,
+        generations,
+        author,
+        metadata: null
+      }
+    };
+  } catch (cause) {
+    session.dispose();
+    throw cause;
+  }
+}
+var prepareSpreadsheetMutation = (mutation, state) => {
+  const data = spreadsheetData(state);
+  const root = state.rawRoot();
+  if (mutation.owner === root.worksheets && mutation.member === "add") {
+    const previousHostId = root.worksheets.items.at(-1)?.id;
+    const after = previousHostId ? data.generations.get(previousHostId) ?? null : null;
+    return {
+      commit(result) {
+        if (!isWorksheet(result)) throw new Error("Worksheet add did not return a worksheet");
+        const sheetId = nativeSheetId(state.namespace, result.id);
+        data.author.author([{ kind: "sheet.create", sheetId, name: result.name, after }]);
+        const operationId = querySpreadsheetMetadata(
+          state.native,
+          data.sheetIds.size + 1
+        ).find((sheet) => sheet.sheetId === sheetId)?.generationId;
+        if (!operationId) throw new Error("Native kernel omitted a sheet generation id");
+        data.sheetIds.set(result.id, sheetId);
+        data.generations.set(
+          result.id,
+          Object.freeze({
+            kind: "generation",
+            sheetId,
+            creationOperationId: editableArtifactStableId(operationId)
+          })
+        );
+        data.metadata = null;
+        return true;
+      }
+    };
+  }
+  if (isWorksheet(mutation.owner) && mutation.member === "name") {
+    const generation2 = requiredGeneration(data, mutation.owner.id);
+    const name = normalizedSheetName(mutation.arguments?.[0]);
+    return commitSpreadsheetCommands(data, [{ kind: "sheet.rename", sheet: generation2, name }]);
+  }
+  if (!isRange(mutation.owner)) return null;
+  const range = mutation.owner;
+  const generation = requiredGeneration(data, range.worksheet.id);
+  if (mutation.member === "values" || mutation.member === "formulas") {
+    return commitSpreadsheetCommands(data, [
+      rectangularWriteCommand(generation, range.address, mutation.arguments?.[0], mutation.member)
+    ]);
+  }
+  if (mutation.member === "writeValues") {
+    const matrix = rectangularMatrix(mutation.arguments?.[0], "spreadsheet values");
+    if (matrix.rows === 0 || matrix.columns === 0) return { commit: () => false };
+    return commitSpreadsheetCommands(data, [
+      rectangularWriteCommand(
+        generation,
+        { ...range.address, rowCount: matrix.rows, colCount: matrix.columns },
+        matrix.values,
+        "values"
+      )
+    ]);
+  }
+  if (mutation.member === "clear") {
+    const options = mutation.arguments?.[0];
+    if (options?.applyTo === "formats") {
+      return { commit: () => true };
+    }
+    return commitSpreadsheetCommands(data, [
+      {
+        kind: "range.clear",
+        sheet: generation,
+        range: {
+          start: { row: range.address.row, column: range.address.col },
+          end: {
+            row: range.address.row + range.address.rowCount - 1,
+            column: range.address.col + range.address.colCount - 1
+          }
+        }
+      }
+    ]);
+  }
+  return null;
+};
+function commitSpreadsheetCommands(data, commands) {
+  return {
+    commit() {
+      data.author.author(commands);
+      data.metadata = null;
+      return true;
+    }
+  };
+}
+function requiredGeneration(data, hostSheetId) {
+  const generation = data.generations.get(hostSheetId);
+  if (!generation) throw new Error(`Spreadsheet native generation is missing: ${hostSheetId}`);
+  return generation;
+}
+function rectangularWriteCommand(sheet, address, input, kind) {
+  const matrix = rectangularMatrix(input, `spreadsheet ${kind}`);
+  if (matrix.rows !== address.rowCount || matrix.columns !== address.colCount) {
+    throw new Error(
+      `Matrix shape ${matrix.rows}x${matrix.columns} does not match range ${address.rowCount}x${address.colCount}`
+    );
+  }
+  const cells = [];
+  for (const row of matrix.values) {
+    for (const value of row) {
+      cells.push(kind === "values" ? nativeInputValue(value) : nativeFormula(value));
+    }
+  }
+  return {
+    kind: "cells.set",
+    sheet,
+    anchor: { row: address.row, column: address.col },
+    rows: address.rowCount,
+    columns: address.colCount,
+    cells
+  };
+}
+function rectangularMatrix(input, label) {
+  if (!Array.isArray(input)) throw new TypeError(`${label} must be a matrix`);
+  const columns = input[0]?.length ?? 0;
+  if (!input.every((row) => Array.isArray(row) && row.length === columns)) {
+    throw new Error(`${label} must be rectangular`);
+  }
+  return { values: input, rows: input.length, columns };
+}
+function nativeInputValue(value) {
+  if (value instanceof Date) {
+    const milliseconds = Date.prototype.getTime.call(value);
+    if (!Number.isSafeInteger(milliseconds)) {
+      throw new TypeError("Spreadsheet cell dates must be valid ECMAScript instants");
+    }
+    return { date: new Date(milliseconds).toISOString() };
+  }
+  if (value === null || typeof value === "string" || typeof value === "boolean") return value;
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) throw new TypeError("Spreadsheet cell numbers must be finite");
+    return value;
+  }
+  throw new TypeError("Spreadsheet cell value is not supported by the native kernel");
+}
+function nativeFormula(value) {
+  if (value === null) return null;
+  if (typeof value !== "string")
+    throw new TypeError("Spreadsheet formulas must be strings or null");
+  const trimmed = value.trim();
+  if (trimmed.length === 0) return null;
+  return { formula: trimmed.startsWith("=") ? trimmed : `=${trimmed}`, cached: null };
+}
+function normalizedSheetName(value) {
+  if (typeof value !== "string") throw new TypeError("Worksheet name must be a string");
+  const name = value.trim();
+  if (!name || name.length > 31 || /[\\/?*[\]:]/u.test(name)) {
+    throw new Error(`Invalid worksheet name: ${value}`);
+  }
+  return name;
+}
+function installSpreadsheetProjection(workbook, state) {
+  Object.defineProperty(workbook, "valueAt", {
+    configurable: true,
+    writable: true,
+    value: (sheet, address) => {
+      if (state.inMutation) {
+        return Workbook.prototype.valueAt.call(workbook, sheet, address);
+      }
+      return readSpreadsheetMatrix(state, sheet.id, {
+        row: address.row,
+        col: address.col,
+        rowCount: 1,
+        colCount: 1
+      }).values[0][0];
+    }
+  });
+}
+function readSpreadsheetProperty(owner, member, state) {
+  if (state.inMutation) return { handled: false };
+  if (member === "values" && isRange(owner)) {
+    return {
+      handled: true,
+      value: readSpreadsheetMatrix(state, owner.worksheet.id, owner.address).values
+    };
+  }
+  if (member === "formulas" && isRange(owner)) {
+    return {
+      handled: true,
+      value: readSpreadsheetMatrix(state, owner.worksheet.id, owner.address).formulas
+    };
+  }
+  if (member === "name" && isWorksheet(owner)) {
+    const metadata = spreadsheetMetadata(state).get(owner.id);
+    if (!metadata) throw new Error(`Native worksheet is missing: ${owner.id}`);
+    return { handled: true, value: metadata.name };
+  }
+  return { handled: false };
+}
+function readSpreadsheetMatrix(state, hostSheetId, address) {
+  const data = spreadsheetData(state);
+  const nativeSheetIdValue = data.sheetIds.get(hostSheetId);
+  if (!nativeSheetIdValue) throw new Error(`Native worksheet mapping is missing: ${hostSheetId}`);
+  const cells = address.rowCount * address.colCount;
+  if (!Number.isSafeInteger(cells) || cells > SPREADSHEET_ARTIFACT_VIEWPORT_MAX_CELLS) {
+    throw new RangeError(
+      `Spreadsheet read exceeds the native viewport limit (${SPREADSHEET_ARTIFACT_VIEWPORT_MAX_CELLS} cells)`
+    );
+  }
+  const maxBytes = Math.min(
+    state.native.capabilities.maxQueryResponseBytes,
+    SPREADSHEET_ARTIFACT_PROJECTION_MAX_BYTES
+  );
+  const query = {
+    sheetId: nativeSheetIdValue,
+    startRow: address.row,
+    startColumn: address.col,
+    rowCount: address.rowCount,
+    columnCount: address.colCount,
+    maxCells: cells,
+    maxBytes
+  };
+  const projection = decodeSpreadsheetViewportKernelProjection(
+    state.native.query(encodeSpreadsheetViewportKernelQuery(query)),
+    query
+  );
+  const values = Array.from(
+    { length: address.rowCount },
+    () => Array(address.colCount).fill(null)
+  );
+  const formulas = Array.from(
+    { length: address.rowCount },
+    () => Array(address.colCount).fill(null)
+  );
+  for (const cell of projection.cells) {
+    const row = cell.row - address.row;
+    const column = cell.column - address.col;
+    values[row][column] = projectedCellValue(cell.value);
+    formulas[row][column] = cell.formula;
+  }
+  return { values, formulas };
+}
+function spreadsheetMetadata(state) {
+  const data = spreadsheetData(state);
+  if (data.metadata) return data.metadata;
+  const sheets = querySpreadsheetMetadata(
+    state.native,
+    data.sheetIds.size
+  );
+  const hostByNative = new Map([...data.sheetIds].map(([host, native]) => [native, host]));
+  const metadata = /* @__PURE__ */ new Map();
+  for (const sheet of sheets) {
+    const host = hostByNative.get(sheet.sheetId);
+    if (host) metadata.set(host, sheet);
+  }
+  data.metadata = metadata;
+  return metadata;
+}
+function querySpreadsheetMetadata(session, maxSheets) {
+  const query = {
+    maxSheets: Math.max(1, maxSheets),
+    maxBytes: Math.min(
+      session.capabilities.maxQueryResponseBytes,
+      SPREADSHEET_ARTIFACT_PROJECTION_MAX_BYTES
+    )
+  };
+  return decodeSpreadsheetMetadataKernelProjection(
+    session.query(encodeSpreadsheetMetadataKernelQuery(query)),
+    query
+  ).sheets;
+}
+function spreadsheetData(state) {
+  if (state.native.modality !== "spreadsheet")
+    throw new TypeError("Expected native spreadsheet session");
+  const data = state.nativeData;
+  if (!(data?.sheetIds instanceof Map) || !(data.generations instanceof Map) || !(data.author instanceof SpreadsheetProjectionAuthor)) {
+    throw new Error("Spreadsheet native mapping is unavailable");
+  }
+  return data;
+}
+var SpreadsheetProjectionAuthor = class {
+  #session;
+  #replicaId;
+  #artifactId;
+  #transactionCounter = 0;
+  #previousTransactionId = null;
+  constructor(session, namespace) {
+    this.#session = session;
+    this.#replicaId = u64Hex(namespace);
+    this.#artifactId = `${this.#replicaId}ffffffffffffffff`;
+  }
+  author(commands) {
+    if (commands.length === 0) return;
+    const counter = this.#transactionCounter + 1;
+    const clientTransactionId = `projection.${this.#replicaId}.${counter}`;
+    const revision = this.#session.revision();
+    if (revision > BigInt(Number.MAX_SAFE_INTEGER)) {
+      throw new RangeError("Native spreadsheet revision exceeds the JavaScript safe-integer range");
+    }
+    this.#session.authorCommands({
+      intent: {
+        artifactId: this.#artifactId,
+        clientTransactionId,
+        replicaId: this.#replicaId,
+        replicaCounter: counter,
+        previousLocalTransactionId: this.#previousTransactionId,
+        observedHeadSequence: Number(revision),
+        causalBase: this.#transactionCounter === 0 ? [] : [{ replicaId: this.#replicaId, counter: this.#transactionCounter }],
+        selectiveUndoOperationIds: []
+      },
+      commands: { version: 1, commands },
+      resolvedBaseBytes: this.#session.frontier()
+    });
+    this.#transactionCounter = counter;
+    this.#previousTransactionId = clientTransactionId;
+  }
+};
+var SpreadsheetCommandBatcher = class {
+  #author;
+  #maxCommands;
+  #maxCells;
+  #maxEstimatedBytes;
+  #commands = [];
+  #cells = 0;
+  #estimatedBytes = 0;
+  constructor(author, session) {
+    this.#author = author;
+    this.#maxCommands = Math.max(1, Math.min(session.capabilities.maxCommands, 1e3));
+    this.#maxCells = Math.max(1, Math.min(session.capabilities.maxCellsPerBatch, 1e5));
+    this.#maxEstimatedBytes = Math.max(
+      16384,
+      Math.min(session.capabilities.maxSpreadsheetCommandBytes - 4096, 2 * 1024 * 1024)
+    );
+  }
+  add(command) {
+    const cells = command.kind === "cells.set" ? command.cells.length : 0;
+    const estimatedBytes = estimateCommandBytes(command);
+    if (this.#commands.length > 0 && (this.#commands.length + 1 > this.#maxCommands || this.#cells + cells > this.#maxCells || this.#estimatedBytes + estimatedBytes > this.#maxEstimatedBytes)) {
+      this.flush();
+    }
+    this.#commands.push(command);
+    this.#cells += cells;
+    this.#estimatedBytes += estimatedBytes;
+    if (estimatedBytes > this.#maxEstimatedBytes) this.flush();
+  }
+  finish() {
+    this.flush();
+  }
+  flush() {
+    if (this.#commands.length === 0) return;
+    this.#author.author(this.#commands);
+    this.#commands = [];
+    this.#cells = 0;
+    this.#estimatedBytes = 0;
+  }
+};
+function* cellCommands(worksheet, generation) {
+  const cells = [...worksheet.cells].sort(
+    (left, right) => left.row - right.row || left.col - right.col
+  );
+  let index = 0;
+  while (index < cells.length) {
+    const first = cells[index];
+    const rowCells = [nativeCell(first)];
+    let nextColumn = first.col + 1;
+    index += 1;
+    while (index < cells.length && cells[index].row === first.row && cells[index].col === nextColumn && rowCells.length < 4096 && estimateCellsBytes(rowCells) < 512 * 1024) {
+      rowCells.push(nativeCell(cells[index]));
+      nextColumn += 1;
+      index += 1;
+    }
+    yield {
+      kind: "cells.set",
+      sheet: generation,
+      anchor: { row: first.row, column: first.col },
+      rows: 1,
+      columns: rowCells.length,
+      cells: rowCells
+    };
+  }
+}
+function nativeCell(cell) {
+  if (cell.formula !== null) return { formula: cell.formula, cached: null };
+  const value = cell.value;
+  if (typeof value === "object" && value !== null) {
+    if ("type" in value && value.type === "date") {
+      return { date: value.value };
+    }
+    throw new TypeError("Serialized spreadsheet cell value is not supported by the native kernel");
+  }
+  if (typeof value === "number" && !Number.isFinite(value)) {
+    throw new TypeError("Spreadsheet cell numbers must be finite");
+  }
+  return value;
+}
+function nativeSheetId(namespace, hostId) {
+  const match = /^ws\/(\d+)$/u.exec(hostId);
+  if (!match) throw new Error(`Worksheet id cannot be mapped to the native kernel: ${hostId}`);
+  const counter = BigInt(match[1]) + 1n;
+  if (counter <= 1n || counter > 0xffffffffffffffffn) {
+    throw new RangeError(`Worksheet id counter is outside the native range: ${hostId}`);
+  }
+  return spreadsheetSheetId(`${u64Hex(namespace)}${u64Hex(counter)}`);
+}
+function projectedCellValue(value) {
+  switch (value.kind) {
+    case "empty":
+      return null;
+    case "boolean":
+    case "number":
+    case "text":
+      return value.value;
+    case "date":
+      return new Date(value.value);
+    case "error": {
+      if (typeof value.value === "object") return value.value.custom;
+      const errors = {
+        null: "#NULL!",
+        divide_by_zero: "#DIV/0!",
+        value: "#VALUE!",
+        reference: "#REF!",
+        name: "#NAME?",
+        number: "#NUM!",
+        not_available: "#N/A",
+        spill: "#SPILL!",
+        calculation: "#CALC!"
+      };
+      const projected = errors[value.value];
+      if (!projected) throw new Error(`Unknown native formula error: ${value.value}`);
+      return projected;
+    }
+  }
+  throw new Error("Unknown native spreadsheet cell value");
+}
+function estimateCommandBytes(command) {
+  if (command.kind !== "cells.set") return 256;
+  return 256 + estimateCellsBytes(command.cells);
+}
+function estimateCellsBytes(cells) {
+  let bytes = cells.length * 16;
+  for (const cell of cells) {
+    if (typeof cell === "string") bytes += textEncoder2.encode(cell).byteLength;
+    else if (typeof cell === "object" && cell !== null) {
+      if ("formula" in cell) bytes += textEncoder2.encode(cell.formula).byteLength;
+      else if ("error" in cell) bytes += textEncoder2.encode(cell.error).byteLength;
+    }
+  }
+  return bytes;
+}
+function isRange(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const worksheet = Reflect.get(value, "worksheet");
+  const address = Reflect.get(value, "address");
+  return typeof worksheet === "object" && worksheet !== null && typeof Reflect.get(worksheet, "id") === "string" && typeof address === "object" && address !== null && Number.isInteger(Reflect.get(address, "row")) && Number.isInteger(Reflect.get(address, "col"));
+}
+function isWorksheet(value) {
+  return typeof value === "object" && value !== null && typeof Reflect.get(value, "id") === "string" && typeof Reflect.get(value, "name") === "string" && String(Reflect.get(value, "id")).startsWith("ws/") && typeof Reflect.get(value, "getRangeByIndexes") === "function";
+}
+function u64Hex(value) {
+  if (value <= 0n || value > 0xffffffffffffffffn) {
+    throw new RangeError("Artifact namespace must be a nonzero u64");
+  }
+  return value.toString(16).padStart(16, "0");
+}
+
+// src/production.ts
+var configuredRuntime = null;
+function configureArtifactRuntime(runtime) {
+  if (runtime.kind !== "native" || runtime.target === "wasm-web") {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_UNAVAILABLE",
+      "The synchronous artifact facade requires an exact native N-API runtime"
+    );
+  }
+  if (configuredRuntime && configuredRuntime !== runtime) {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_INCOMPATIBLE",
+      "A different artifact runtime is already configured in this process"
+    );
+  }
+  configuredRuntime = runtime;
+}
+function getConfiguredArtifactRuntime() {
+  return configuredRuntime;
+}
+var WorkbookFacade = createStaticFacade(Workbook, "Workbook", {
+  create(options = {}) {
+    return attachWorkbook(Workbook.create(options), randomNamespace());
+  },
+  async fromCSV(csvText, options = {}) {
+    return attachWorkbook(await Workbook.fromCSV(csvText, options), randomNamespace());
+  },
+  fromJSON(input) {
+    return attachWorkbook(Workbook.fromJSON(input), randomNamespace());
+  }
+});
+var DocumentFacade = createStaticFacade(Document, "Document", {
+  create(options = {}) {
+    const document = Document.create(options);
+    return attachDocument(document, BigInt(`0x${document.idNamespace}`));
+  },
+  fromJSON(input) {
+    const document = Document.fromJSON(input);
+    return attachDocument(document, BigInt(`0x${document.idNamespace}`));
+  }
+});
+var PresentationFacade = createStaticFacade(Presentation, "Presentation", {
+  create(options = {}) {
+    return attachPresentation(Presentation.create(options), randomNamespace());
+  }
+});
+var Workbook2 = WorkbookFacade;
+var Document2 = DocumentFacade;
+var Presentation2 = PresentationFacade;
+var SpreadsheetFile2 = class {
+  static async importXlsx(...args) {
+    requireConfiguredRuntime();
+    const workbook = await SpreadsheetFile.importXlsx(...args);
+    return attachWorkbook(workbook, randomNamespace());
+  }
+  static async exportXlsx(workbook, options = {}) {
+    const raw = rawArtifact(workbook, "spreadsheet");
+    return await SpreadsheetFile.exportXlsx(raw, options);
+  }
+  static fidelityReport(workbook) {
+    return SpreadsheetFile.fidelityReport(rawArtifact(workbook, "spreadsheet"));
+  }
+  static lossPreservationEnvelope(workbook) {
+    return SpreadsheetFile.lossPreservationEnvelope(rawArtifact(workbook, "spreadsheet"));
+  }
+  static async attachLossPreservationEnvelope(workbook, envelope2, options = {}) {
+    const state = requireCompositeState(workbook, "spreadsheet");
+    await state.mutate(
+      () => SpreadsheetFile.attachLossPreservationEnvelope(
+        state.rawRoot(),
+        envelope2,
+        options
+      ),
+      { member: "attachLossPreservationEnvelope", owner: state.rawRoot() }
+    );
+  }
+};
+var DocumentFile2 = class {
+  static async importDocx(...args) {
+    requireConfiguredRuntime();
+    const document = await DocumentFile.importDocx(...args);
+    return attachDocument(document, BigInt(`0x${document.idNamespace}`));
+  }
+  static async exportDocx(document) {
+    return await DocumentFile.exportDocx(rawArtifact(document, "document"));
+  }
+};
+var PresentationFile2 = class {
+  static async importPptx(...args) {
+    requireConfiguredRuntime();
+    const presentation = await PresentationFile.importPptx(...args);
+    return attachPresentation(presentation, randomNamespace());
+  }
+  static async exportPptx(presentation, options = {}) {
+    return await PresentationFile.exportPptx(
+      rawArtifact(presentation, "presentation"),
+      options
+    );
+  }
+  static fidelityReport(presentation) {
+    return PresentationFile.fidelityReport(rawArtifact(presentation, "presentation"));
+  }
+  static lossPreservationEnvelope(presentation) {
+    return PresentationFile.lossPreservationEnvelope(
+      rawArtifact(presentation, "presentation")
+    );
+  }
+};
+function getArtifactCompositeDiagnostics(artifact) {
+  const state = requireCompositeState(artifact);
+  const root = state.rawRoot();
+  const hostProjection = state.modality === "presentation" ? root.layoutSnapshot() : root.toJSON();
+  return Object.freeze({
+    version: 1,
+    modality: state.modality,
+    namespace: u64Hex2(state.namespace),
+    runtimeTarget: state.native.target,
+    runtimeBuildIdentity: state.native.buildIdentity,
+    nativeRevision: state.native.revision(),
+    nativeStateHash: state.native.stateHash(),
+    nativeSnapshot: state.native.snapshot().slice(),
+    hostProjection: structuredClone(hostProjection)
+  });
+}
+function disposeArtifact(artifact) {
+  requireCompositeState(artifact).dispose();
+}
+function attachWorkbook(workbook, namespace) {
+  const runtime = requireConfiguredRuntime();
+  const reconcile = (root) => reconcileSpreadsheetProjection(root, runtime, namespace);
+  const reconciliation = reconcile(workbook);
+  const state = new CompositeArtifactState({
+    modality: "spreadsheet",
+    namespace,
+    root: workbook,
+    reconciliation,
+    reconcile,
+    prepareMutation: prepareSpreadsheetMutation,
+    installProjection: installSpreadsheetProjection,
+    readProperty: readSpreadsheetProperty,
+    captureAuxiliary: captureSpreadsheetAuxiliary,
+    restoreAuxiliary: restoreSpreadsheetAuxiliary
+  });
+  return state.proxy();
+}
+function attachDocument(document, namespace) {
+  const runtime = requireConfiguredRuntime();
+  const reconcile = (root) => reconcileDocumentProjection(root, runtime, namespace);
+  const reconciliation = reconcile(document);
+  const state = new CompositeArtifactState({
+    modality: "document",
+    namespace,
+    root: document,
+    reconciliation,
+    reconcile,
+    prepareMutation: prepareDocumentMutation,
+    captureAuxiliary: captureDocumentAuxiliary,
+    restoreAuxiliary: restoreDocumentAuxiliary
+  });
+  return state.proxy();
+}
+function attachPresentation(presentation, namespace) {
+  const runtime = requireConfiguredRuntime();
+  const reconcile = (root) => reconcilePresentationProjection(root, runtime, namespace);
+  const reconciliation = reconcile(presentation);
+  const state = new CompositeArtifactState({
+    modality: "presentation",
+    namespace,
+    root: presentation,
+    reconciliation,
+    reconcile,
+    prepareMutation: preparePresentationMutation,
+    captureAuxiliary: capturePresentationAuxiliary,
+    restoreAuxiliary: restorePresentationAuxiliary
+  });
+  return state.proxy();
+}
+function reconcileDocumentProjection(document, runtime, namespace) {
+  const session = NativeDocumentSession.create(runtime, namespace);
+  try {
+    const commands = encodeDocumentProjectionCommands(document.toJSON());
+    if (envelopeCommandCount(commands) > 0) session.applyCommands(commands);
+    return { session };
+  } catch (cause) {
+    session.dispose();
+    throw cause;
+  }
+}
+function prepareDocumentMutation(mutation, state) {
+  const root = state.rawRoot();
+  const owner = mutation.owner;
+  const member = mutation.member;
+  if (owner instanceof DocumentBlockCollection || owner instanceof DocumentStory) {
+    if (member === "addParagraph" || member === "addHeading" || member === "addTable" || member === "addPageBreak") {
+      const target = owner instanceof DocumentStory ? documentStoryTarget(root, owner) : { kind: "body" };
+      return commitDocumentMutation(state, (result) => {
+        if (!isSerializedDocumentBlock(result)) {
+          throw new Error(`${String(member)} did not return a document block`);
+        }
+        return [{ kind: "block.add", target, block: result.serialize() }];
+      });
+    }
+  }
+  if (owner instanceof DocumentParagraph) {
+    if (member === "setStyle") {
+      const style = mutation.arguments?.[0];
+      return commitDocumentMutation(state, () => [
+        { kind: "paragraph.style", id: owner.id, style }
+      ]);
+    }
+    if (member === "format") {
+      const format = mutation.arguments?.[0];
+      return commitDocumentMutation(state, () => [
+        { kind: "paragraph.format", id: owner.id, format }
+      ]);
+    }
+    if (member === "edit") {
+      const edit = documentParagraphEdit(mutation.arguments ?? []);
+      if (!edit) return null;
+      return commitDocumentMutation(state, () => [
+        { kind: "paragraph.edit", id: owner.id, ...edit }
+      ]);
+    }
+    if (member === "append") {
+      const text = mutation.arguments?.[0];
+      const style = mutation.arguments?.[1] ?? {};
+      if (typeof text !== "string" || typeof style !== "object" || style === null) return null;
+      const start = owner.text.length;
+      return commitDocumentMutation(state, () => [
+        {
+          kind: "paragraph.edit",
+          id: owner.id,
+          start,
+          end: start,
+          text,
+          style
+        }
+      ]);
+    }
+    if (member === "text") {
+      const before = owner.text;
+      return commitDocumentMutation(state, () => {
+        const edit = minimalDocumentTextEdit(before, owner.text);
+        return edit ? [{ kind: "paragraph.edit", id: owner.id, ...edit }] : [];
+      });
+    }
+    if (member === "replace") {
+      const search = mutation.arguments?.[0];
+      const before = owner.text;
+      if (typeof search !== "string" || search.length === 0 || before.indexOf(search) !== before.lastIndexOf(search)) {
+        return null;
+      }
+      return commitDocumentMutation(state, () => {
+        const edit = minimalDocumentTextEdit(before, owner.text);
+        return edit ? [{ kind: "paragraph.edit", id: owner.id, ...edit }] : [];
+      });
+    }
+  }
+  if (owner instanceof DocumentTable && member === "setStyle") {
+    const style = mutation.arguments?.[0];
+    return commitDocumentMutation(state, () => [{ kind: "table.style", id: owner.id, style }]);
+  }
+  if (owner === root && (member === "setEvenAndOddHeaders" || member === "setTrackRevisions")) {
+    const enabled = mutation.arguments?.[0];
+    if (typeof enabled !== "boolean") return null;
+    return commitDocumentMutation(state, () => [
+      {
+        kind: "document.flags",
+        ...member === "setEvenAndOddHeaders" ? { evenAndOddHeaders: enabled } : { trackRevisions: enabled }
+      }
+    ]);
+  }
+  if (owner instanceof DocumentSections && member === "add") {
+    return commitDocumentMutation(state, (result) => {
+      if (!(result instanceof DocumentSection))
+        throw new Error("Section add did not return a section");
+      return [{ kind: "section.add", section: result.serialize() }];
+    });
+  }
+  if (owner instanceof DocumentSection && member === "setTitlePage") {
+    const enabled = mutation.arguments?.[0];
+    if (typeof enabled !== "boolean") return null;
+    return commitDocumentMutation(state, () => [
+      { kind: "section.title", id: owner.id, titlePage: enabled }
+    ]);
+  }
+  if (owner instanceof DocumentComments) {
+    if (member === "setSelf") return { commit: () => false };
+    if (member === "addThread") {
+      return commitDocumentMutation(state, (result) => {
+        if (!(result instanceof DocumentCommentThread))
+          throw new Error("Comment add did not return a thread");
+        return [{ kind: "comment.add", comment: result.serialize() }];
+      });
+    }
+  }
+  if (owner instanceof DocumentCommentThread) {
+    if (member === "addReply") {
+      const before = owner.replies.length;
+      return commitDocumentMutation(state, () => {
+        const reply = owner.serialize().replies[before];
+        return reply ? [{ kind: "comment.reply", id: owner.id, reply }] : [];
+      });
+    }
+    if (member === "resolve" || member === "reopen") {
+      const before = owner.resolved;
+      return commitDocumentMutation(
+        state,
+        () => before === owner.resolved ? [] : [{ kind: "comment.resolved", id: owner.id, resolved: owner.resolved }]
+      );
+    }
+  }
+  if (owner instanceof TrackedChanges && member === "add") {
+    return commitDocumentMutation(state, (result) => {
+      if (!result || typeof result !== "object" || typeof Reflect.get(result, "serialize") !== "function") {
+        throw new Error("Tracked-change add did not return a change");
+      }
+      return [
+        {
+          kind: "tracked.add",
+          change: Reflect.get(result, "serialize").call(result)
+        }
+      ];
+    });
+  }
+  return null;
+}
+function commitDocumentMutation(state, commands) {
+  return {
+    commit(result) {
+      const batch = commands(result);
+      if (batch.length === 0) return false;
+      const session = state.native;
+      if (!(session instanceof NativeDocumentSession))
+        throw new TypeError("Expected native document session");
+      const before = session.revision();
+      session.applyCommands(encodeDocumentIncrementalCommands(batch));
+      return session.revision() > before;
+    }
+  };
+}
+function documentStoryTarget(document, story) {
+  for (const section of document.sections.items) {
+    for (const storyKind of ["header", "footer"]) {
+      const collection = storyKind === "header" ? section.headers : section.footers;
+      for (const variant of ["default", "first", "even"]) {
+        if (collection[variant] === story)
+          return { kind: "story", sectionId: section.id, storyKind, variant };
+      }
+    }
+  }
+  throw new Error(`Document story is not attached: ${story.id}`);
+}
+function isSerializedDocumentBlock(value) {
+  return typeof value === "object" && value !== null && typeof Reflect.get(value, "serialize") === "function";
+}
+function documentParagraphEdit(args) {
+  if (typeof args[0] === "number") {
+    if (typeof args[1] !== "number" || typeof args[2] !== "string") return null;
+    return {
+      start: args[0],
+      end: args[1],
+      text: args[2],
+      ...args[3] && typeof args[3] === "object" ? { style: args[3] } : {}
+    };
+  }
+  const edit = args[0];
+  if (!edit || typeof edit.start !== "number" || typeof edit.end !== "number" || typeof edit.text !== "string") {
+    return null;
+  }
+  return {
+    start: edit.start,
+    end: edit.end,
+    text: edit.text,
+    ...edit.style && typeof edit.style === "object" ? { style: edit.style } : {}
+  };
+}
+function minimalDocumentTextEdit(before, after) {
+  if (before === after) return null;
+  let start = 0;
+  while (start < before.length && start < after.length && before[start] === after[start])
+    start += 1;
+  let beforeEnd = before.length;
+  let afterEnd = after.length;
+  while (beforeEnd > start && afterEnd > start && before[beforeEnd - 1] === after[afterEnd - 1]) {
+    beforeEnd -= 1;
+    afterEnd -= 1;
+  }
+  return { start, end: beforeEnd, text: after.slice(start, afterEnd) };
+}
+function reconcilePresentationProjection(presentation, runtime, namespace) {
+  const session = NativePresentationSession.create(runtime, namespace);
+  try {
+    const commands = encodePresentationProjectionCommands(presentation, namespace);
+    if (envelopeCommandCount(commands) > 0) session.applyCommands(commands);
+    return { session };
+  } catch (cause) {
+    session.dispose();
+    throw cause;
+  }
+}
+function preparePresentationMutation(mutation, state) {
+  const root = state.rawRoot();
+  const owner = mutation.owner;
+  const member = mutation.member;
+  if (owner instanceof SlideCollection && member === "add") {
+    const index = root.slides.items.length;
+    return commitPresentationMutation(state, (result) => {
+      if (!(result instanceof Slide)) throw new Error("Slide add did not return a slide");
+      return [{ kind: "slide.create", slide: result, index }];
+    });
+  }
+  if ((owner instanceof PresentationShapeCollection || owner instanceof PresentationChartCollection || owner instanceof PresentationImageCollection || owner instanceof PresentationTableCollection || owner instanceof PresentationGroupCollection) && member === "add") {
+    return commitPresentationMutation(state, (result) => {
+      if (!isPresentationElement(result))
+        throw new Error("Presentation add did not return an element");
+      const index = result.slide.elements.indexOf(result);
+      if (index < 0) throw new Error("Presentation element was not attached to its slide");
+      return [{ kind: "node.insert", slideId: result.slide.id, index, element: result }];
+    });
+  }
+  if (owner instanceof Slide) {
+    if (member === "title") {
+      return commitPresentationMutation(state, () => [
+        { kind: "slide.title", id: owner.id, title: owner.title }
+      ]);
+    }
+    if (member === "setLayout") {
+      return commitPresentationMutation(state, () => [
+        {
+          kind: "slide.layout",
+          id: owner.id,
+          ...owner.layout ? { layoutId: owner.layout.id } : {}
+        }
+      ]);
+    }
+  }
+  if (owner === root.slideSize && (member === "width" || member === "height")) {
+    return commitPresentationMutation(state, () => [
+      {
+        kind: "presentation.size",
+        width: root.slideSize.width,
+        height: root.slideSize.height
+      }
+    ]);
+  }
+  if (owner instanceof PresentationText) {
+    const target = findPresentationTextOwner(root, owner);
+    if (!target) return null;
+    return commitPresentationMutation(
+      state,
+      () => target.kind === "notes" ? [{ kind: "slide.notes", id: target.slide.id, notes: owner }] : [{ kind: "node.update", element: target.element }]
+    );
+  }
+  if (isPresentationElement(owner)) {
+    return commitPresentationMutation(state, () => [{ kind: "node.update", element: owner }]);
+  }
+  return null;
+}
+function commitPresentationMutation(state, commands) {
+  return {
+    commit(result) {
+      const batch = commands(result);
+      if (batch.length === 0) return false;
+      const session = state.native;
+      if (!(session instanceof NativePresentationSession)) {
+        throw new TypeError("Expected native presentation session");
+      }
+      const before = session.revision();
+      session.applyCommands(encodePresentationIncrementalCommands(batch, state.namespace));
+      return session.revision() > before;
+    }
+  };
+}
+function isPresentationElement(value) {
+  return value instanceof PresentationShape || value instanceof PresentationChart || value instanceof PresentationImage || value instanceof PresentationTable || value instanceof PresentationGroup;
+}
+function findPresentationTextOwner(presentation, text) {
+  const visit = (element) => {
+    if (element instanceof PresentationShape && element.text === text) return element;
+    if (element instanceof PresentationGroup) {
+      for (const child of element.children) {
+        const match = visit(child);
+        if (match) return match;
+      }
+    }
+    if (element instanceof PresentationTable) {
+      if (element.rows.some((row) => row.some((cell) => cell?.text === text))) return element;
+    }
+    return null;
+  };
+  for (const slide of presentation.slides.items) {
+    if (slide.notes === text) return { kind: "notes", slide };
+    for (const element of slide.elements) {
+      const match = visit(element);
+      if (match) return { kind: "node", element: match };
+    }
+  }
+  return null;
+}
+function captureSpreadsheetAuxiliary(workbook) {
+  const value = LOSS_PRESERVATION.get(workbook);
+  return value ? structuredClone(value) : void 0;
+}
+function restoreSpreadsheetAuxiliary(workbook, value) {
+  if (value)
+    LOSS_PRESERVATION.set(workbook, value);
+}
+function captureDocumentAuxiliary(document) {
+  const value = DOCUMENT_LOSS_PRESERVATION.get(document);
+  return value ? structuredClone(value) : void 0;
+}
+function restoreDocumentAuxiliary(document, value) {
+  if (value) {
+    DOCUMENT_LOSS_PRESERVATION.set(
+      document,
+      value
+    );
+  }
+}
+function capturePresentationAuxiliary(presentation) {
+  const value = presentationLossState(presentation);
+  return value ? structuredClone(value) : void 0;
+}
+function restorePresentationAuxiliary(presentation, value) {
+  setPresentationLossState(presentation, value);
+}
+function rawArtifact(artifact, modality) {
+  return requireCompositeState(artifact, modality).rawRoot();
+}
+function createStaticFacade(reference, name, statics) {
+  const facade = function ArtifactFacade() {
+    throw new TypeError(`${name} cannot be constructed directly; use ${name}.create()`);
+  };
+  Object.setPrototypeOf(facade, reference);
+  Object.defineProperty(facade, "name", { configurable: true, value: name });
+  Object.defineProperty(facade, "prototype", { value: reference.prototype });
+  for (const [key, value] of Object.entries(statics)) {
+    Object.defineProperty(facade, key, { configurable: false, enumerable: false, value });
+  }
+  return facade;
+}
+function requireConfiguredRuntime() {
+  if (!configuredRuntime) {
+    throw new ArtifactRuntimeError(
+      "ARTIFACT_RUNTIME_UNAVAILABLE",
+      "No exact artifact runtime is configured; host bootstrap must call configureArtifactRuntime()"
+    );
+  }
+  return configuredRuntime;
+}
+function envelopeCommandCount(bytes) {
+  if (bytes.byteLength < 16) throw new TypeError("Native command envelope is truncated");
+  return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getUint32(12, true);
+}
+function randomNamespace() {
+  const words = crypto.getRandomValues(new Uint32Array(2));
+  const namespace = BigInt(words[0]) << 32n | BigInt(words[1]);
+  return namespace === 0n ? randomNamespace() : namespace;
+}
+function u64Hex2(value) {
+  if (value <= 0n || value > 0xffffffffffffffffn) {
+    throw new RangeError("Artifact namespace must be a nonzero u64");
+  }
+  return value.toString(16).padStart(16, "0");
+}
+
+export {
+  configureArtifactRuntime,
+  getConfiguredArtifactRuntime,
+  Workbook2 as Workbook,
+  Document2 as Document,
+  Presentation2 as Presentation,
+  SpreadsheetFile2 as SpreadsheetFile,
+  DocumentFile2 as DocumentFile,
+  PresentationFile2 as PresentationFile,
+  getArtifactCompositeDiagnostics,
+  disposeArtifact
+};
+//# sourceMappingURL=chunk-ZZXPEE4S.js.map