@drghaliasri/butex 6.0.0 → 6.1.1

package/dist/document2-cli.js

@@ -107,14 +107,6 @@ function normalizeDocument2Meta(value) {
     abstract: typeof raw.abstract === "string" ? raw.abstract : ""
   };
 }
-function cloneDocument2Meta(meta) {
-  return {
-    title: meta.title,
-    authors: meta.authors,
-    date: { ...meta.date },
-    abstract: meta.abstract
-  };
-}
 
 // src/document2/citations.ts
 var DEFAULT_REFERENCE_FIELD_SEPARATOR = "\u060C";
@@ -596,6 +588,76 @@ function refTokenLatex(keys, refCommand) {
   return `${command}{${keys.join(",")}}`;
 }
 
+// src/document2/inlineIdentity.ts
+function createDocument2IdentityState() {
+  return {
+    blockIds: /* @__PURE__ */ new Set(),
+    itemIds: /* @__PURE__ */ new Set(),
+    fieldIds: /* @__PURE__ */ new Set(),
+    tokenIds: /* @__PURE__ */ new Set()
+  };
+}
+function importedOrGeneratedId(value, prefix, used) {
+  const imported = typeof value === "string" ? value.trim() : "";
+  if (imported.length > 0 && !used.has(imported)) {
+    used.add(imported);
+    return imported;
+  }
+  let generated = document2Id(prefix);
+  while (used.has(generated)) {
+    generated = document2Id(prefix);
+  }
+  used.add(generated);
+  return generated;
+}
+function inlineTokenSource(token) {
+  if (token.kind === "text") {
+    return token.text;
+  }
+  if (token.kind === "math") {
+    return token.source;
+  }
+  if (token.kind === "cite") {
+    return citeTokenLatex(token.keys);
+  }
+  return refTokenLatex(token.keys, token.refCommand);
+}
+function inlineIdsFromField(field) {
+  let offset = 0;
+  const tokens = field.tokens.map((token) => {
+    const start = offset;
+    offset += inlineTokenSource(token).length;
+    return { id: token.id, kind: token.kind, start, end: offset };
+  });
+  return { field_id: field.id, tokens };
+}
+function isAlignedSidecar(value, field) {
+  if (typeof value !== "object" || value === null || !Array.isArray(value.tokens)) {
+    return false;
+  }
+  const tokens = value.tokens;
+  const expected = inlineIdsFromField(field).tokens;
+  if (tokens.length !== expected.length) {
+    return false;
+  }
+  return tokens.every((token, index) => {
+    const expectedToken = expected[index];
+    return typeof token === "object" && token !== null && expectedToken !== void 0 && token.kind === expectedToken.kind && token.start === expectedToken.start && token.end === expectedToken.end;
+  });
+}
+function applyImportedInlineIds(field, sidecar, state) {
+  field.id = importedOrGeneratedId(
+    typeof sidecar === "object" && sidecar !== null ? sidecar.field_id : void 0,
+    "field",
+    state.fieldIds
+  );
+  const aligned = isAlignedSidecar(sidecar, field);
+  field.tokens.forEach((token, index) => {
+    token.id = importedOrGeneratedId(aligned ? sidecar.tokens[index]?.id : void 0, token.kind, state.tokenIds);
+  });
+  return field;
+}
+
 // src/document2/inlineScanner.ts
 var MATH_ENVIRONMENTS = /* @__PURE__ */ new Set([
   "equation",
@@ -674,17 +736,13 @@ function citeSpan(value, start) {
 function refSpan(value, start) {
   const eqrefPrefix = "\\eqref{";
   const refPrefix = "\\ref{";
-  let refCommand = "ref";
-  let prefix = refPrefix;
-  if (value.startsWith(eqrefPrefix, start) && !isEscaped(value, start)) {
-    refCommand = "eqref";
-    prefix = eqrefPrefix;
-  } else if (value.startsWith(refPrefix, start) && !isEscaped(value, start)) {
-    refCommand = "ref";
-    prefix = refPrefix;
-  } else {
+  const isEqref = value.startsWith(eqrefPrefix, start) && !isEscaped(value, start);
+  const isRef = value.startsWith(refPrefix, start) && !isEscaped(value, start);
+  if (!isEqref && !isRef) {
     return null;
   }
+  const refCommand = isEqref ? "eqref" : "ref";
+  const prefix = isEqref ? eqrefPrefix : refPrefix;
   const openBrace = start + prefix.length - 1;
   if (value[openBrace] !== "{") {
     return null;
@@ -743,7 +801,14 @@ function mathSpanAt(value, i) {
   return null;
 }
 function detectMathSpans2(value) {
-  return detectInlineSpans2(value).filter((span) => span.kind === "math").map(({ kind: _kind, ...span }) => span);
+  return detectInlineSpans2(value).filter((span) => span.kind === "math").map((span) => ({
+    start: span.start,
+    end: span.end,
+    source: span.source,
+    opening: span.opening,
+    closing: span.closing,
+    display: span.display
+  }));
 }
 function detectInlineSpans2(value) {
   const spans = [];
@@ -797,17 +862,13 @@ function asBlockJson(value) {
   return value;
 }
 function blockIdFromJson(json, state) {
-  const imported = typeof json.id === "string" ? json.id.trim() : "";
-  if (imported.length > 0 && !state.used.has(imported)) {
-    state.used.add(imported);
-    return imported;
-  }
-  let generated = document2Id("block");
-  while (state.used.has(generated)) {
-    generated = document2Id("block");
+  return importedOrGeneratedId(json.id, "block", state.blockIds);
+}
+function metadataFromJson(value) {
+  if (!isObject2(value) || value.source !== "agent" && value.source !== "user") {
+    return {};
   }
-  state.used.add(generated);
-  return generated;
+  return { metadata: { source: value.source } };
 }
 function pushDiagnostic(diagnostics, options, path, message) {
   if (options.strict) {
@@ -990,44 +1051,54 @@ function pushFormattedTextTokens(tokens, text, sourceStart, formats) {
 function closingForList(command) {
   return command === "\\begin{itemize}" ? "\\end{itemize}" : "\\end{enumerate}";
 }
-function parseTextBlock(json, options, path, diagnostics, blockIds) {
+function parseTextBlock(json, options, path, diagnostics, identities) {
   const value = requireString(json.value, `${json.command} requires string value`);
   return {
-    id: blockIdFromJson(json, blockIds),
+    id: blockIdFromJson(json, identities),
     kind: "textBlock",
     command: json.command,
-    field: createInlineField2(value, json.math_objects ?? [], options, `${path}.value`, diagnostics, json.command === "\\paragraph" ? json.formats ?? [] : []),
+    field: applyImportedInlineIds(
+      createInlineField2(value, json.math_objects ?? [], options, `${path}.value`, diagnostics, json.command === "\\paragraph" ? json.formats ?? [] : []),
+      json.inline_ids,
+      identities
+    ),
+    ...metadataFromJson(json.metadata),
     ...json.centered === true ? { centered: true } : {}
   };
 }
-function parseListItem(json, options, path, diagnostics, blockIds) {
+function parseListItem(json, options, path, diagnostics, identities) {
   const value = requireString(json.value, "Document list item requires string value");
   const blocksJson = Array.isArray(json.blocks) ? json.blocks : [];
   return {
-    id: document2Id("item"),
-    field: createInlineField2(value, json.math_objects ?? [], options, `${path}.value`, diagnostics, json.formats ?? []),
+    id: importedOrGeneratedId(json.id, "item", identities.itemIds),
+    field: applyImportedInlineIds(
+      createInlineField2(value, json.math_objects ?? [], options, `${path}.value`, diagnostics, json.formats ?? []),
+      json.inline_ids,
+      identities
+    ),
     blocks: blocksJson.map(
-      (block, index) => parseBlock(asBlockJson(block), options, `${path}.blocks[${String(index)}]`, diagnostics, blockIds)
+      (block, index) => parseBlock(asBlockJson(block), options, `${path}.blocks[${String(index)}]`, diagnostics, identities)
     )
   };
 }
-function parseListBlock(json, options, path, diagnostics, blockIds) {
+function parseListBlock(json, options, path, diagnostics, identities) {
   if (!Array.isArray(json.items)) {
     throw new Error(`${json.command} requires items array`);
   }
   const command = json.command;
   const closing = closingForList(command);
   return {
-    id: blockIdFromJson(json, blockIds),
+    id: blockIdFromJson(json, identities),
     kind: "list",
     command,
     closing,
     items: json.items.map(
-      (item, index) => parseListItem(item, options, `${path}.items[${String(index)}]`, diagnostics, blockIds)
-    )
+      (item, index) => parseListItem(item, options, `${path}.items[${String(index)}]`, diagnostics, identities)
+    ),
+    ...metadataFromJson(json.metadata)
   };
 }
-function parseTableBlock(json, options, path, diagnostics, blockIds) {
+function parseTableBlock(json, options, path, diagnostics, identities) {
   if (!Array.isArray(json.rows)) {
     throw new Error("\\begin{tabular} requires rows array");
   }
@@ -1043,75 +1114,84 @@ function parseTableBlock(json, options, path, diagnostics, blockIds) {
       const cellMathObjects = mathObjects.slice(mathObjectIndex, mathObjectIndex + spanCount);
       mathObjectIndex += spanCount;
       const cellFormats = json.cell_formats?.[rowIndex]?.[columnIndex] ?? [];
-      return createInlineField2(value, cellMathObjects, options, `${path}.rows[${String(rowIndex)}][${String(columnIndex)}]`, diagnostics, cellFormats);
+      return applyImportedInlineIds(
+        createInlineField2(value, cellMathObjects, options, `${path}.rows[${String(rowIndex)}][${String(columnIndex)}]`, diagnostics, cellFormats),
+        json.cell_inline_ids?.[rowIndex]?.[columnIndex],
+        identities
+      );
     });
   });
   if (mathObjects.length > 0 && mathObjects.length !== mathObjectIndex) {
     pushDiagnostic(diagnostics, options, path, `math_objects count mismatch: detected ${String(mathObjectIndex)}, got ${String(mathObjects.length)}`);
   }
   return {
-    id: blockIdFromJson(json, blockIds),
+    id: blockIdFromJson(json, identities),
     kind: "table",
     command: "\\begin{tabular}",
     closing: "\\end{tabular}",
     columns: typeof json.columns === "string" ? json.columns : "",
     rows,
-    ...parseFloatMetaFromJson(json)
+    ...parseFloatMetaFromJson(json),
+    ...metadataFromJson(json.metadata)
   };
 }
-function parseImageBlock(json, blockIds) {
+function parseImageBlock(json, identities) {
   const assetId = typeof json.asset_id === "string" && json.asset_id.length > 0 ? json.asset_id : void 0;
   const value = assetId !== void 0 ? typeof json.value === "string" ? json.value : "" : requireString(json.value, "\\includegraphics requires string value");
   return {
-    id: blockIdFromJson(json, blockIds),
+    id: blockIdFromJson(json, identities),
     kind: "image",
     command: "\\includegraphics",
     value,
     ...assetId !== void 0 ? { assetId } : {},
     options: isRecordOfStrings(json.options) ? json.options : {},
-    ...parseFloatMetaFromJson(json)
+    ...parseFloatMetaFromJson(json),
+    ...metadataFromJson(json.metadata)
   };
 }
-function parseRawBlock(json, blockIds) {
+function parseRawBlock(json, identities) {
   return {
-    id: blockIdFromJson(json, blockIds),
+    id: blockIdFromJson(json, identities),
     kind: "raw",
     command: "\\raw",
-    value: typeof json.value === "string" ? json.value : ""
+    value: typeof json.value === "string" ? json.value : "",
+    ...metadataFromJson(json.metadata)
   };
 }
-function parseBibliographyBlock(json, blockIds) {
+function parseBibliographyBlock(json, identities) {
   return {
-    id: blockIdFromJson(json, blockIds),
+    id: blockIdFromJson(json, identities),
     kind: "bibliography",
     command: "\\begin{thebibliography}",
-    closing: "\\end{thebibliography}"
+    closing: "\\end{thebibliography}",
+    ...metadataFromJson(json.metadata)
   };
 }
-function parseBlock(json, options, path, diagnostics, blockIds) {
+function parseBlock(json, options, path, diagnostics, identities) {
   if (TEXT_COMMANDS.has(json.command)) {
-    return parseTextBlock(json, options, path, diagnostics, blockIds);
+    return parseTextBlock(json, options, path, diagnostics, identities);
   }
   if (LIST_COMMANDS.has(json.command)) {
-    return parseListBlock(json, options, path, diagnostics, blockIds);
+    return parseListBlock(json, options, path, diagnostics, identities);
   }
   if (json.command === "\\begin{tabular}") {
-    return parseTableBlock(json, options, path, diagnostics, blockIds);
+    return parseTableBlock(json, options, path, diagnostics, identities);
   }
   if (json.command === "\\includegraphics") {
-    return parseImageBlock(json, blockIds);
+    return parseImageBlock(json, identities);
   }
   if (json.command === "\\begin{thebibliography}" || json.command === "\\bibliography") {
-    return parseBibliographyBlock(json, blockIds);
+    return parseBibliographyBlock(json, identities);
   }
   if (json.command === "\\raw") {
-    return parseRawBlock(json, blockIds);
+    return parseRawBlock(json, identities);
   }
   return {
-    id: blockIdFromJson(json, blockIds),
+    id: blockIdFromJson(json, identities),
     kind: "raw",
     command: "\\raw",
-    value: typeof json.value === "string" ? json.value : json.command
+    value: typeof json.value === "string" ? json.value : json.command,
+    ...metadataFromJson(json.metadata)
   };
 }
 function fromDocumentJson2(json, options = {}) {
@@ -1122,13 +1202,13 @@ function fromDocumentJson2(json, options = {}) {
     throw new Error("DocumentObject requires blocks array");
   }
   const diagnostics = [];
-  const blockIds = { used: /* @__PURE__ */ new Set() };
+  const identities = createDocument2IdentityState();
   return {
     nodeType: "DocumentObject",
     meta: normalizeDocument2Meta(json.meta),
     references: parseReferences(json.references),
     blocks: json.blocks.map(
-      (block, index) => parseBlock(asBlockJson(block), options, `$.blocks[${String(index)}]`, diagnostics, blockIds)
+      (block, index) => parseBlock(asBlockJson(block), options, `$.blocks[${String(index)}]`, diagnostics, identities)
     ),
     diagnostics
   };
@@ -2446,97 +2526,762 @@ var CHAR_FONT_EXPORT_TEX = Object.fromEntries(
   NON_DEFAULT_CHARACTER_FONT_SPECS.map((font) => [font.id, font.macro])
 );
 
-// src/document2/commands.ts
-function cloneToken(token) {
-  return token.kind === "text" ? { ...token } : { ...token };
+// src/document2/jsonCommandTypes.ts
+var Document2CommandError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "Document2CommandError";
+    this.code = code;
+  }
+};
+
+// src/document2/jsonCommandHelpers.ts
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function cloneField(field) {
-  return { id: field.id, tokens: field.tokens.map(cloneToken) };
+function requireString2(value, field, allowEmpty = true) {
+  if (typeof value !== "string" || !allowEmpty && value.trim().length === 0) {
+    throw new Document2CommandError("invalid_command", `${field} must be a${allowEmpty ? "" : " non-empty"} string`);
+  }
+  return value;
 }
-function cloneBlock(block) {
-  if (block.kind === "textBlock") {
-    return { ...block, field: cloneField(block.field) };
+function optionalString(value, field) {
+  if (!(field in value)) {
+    return void 0;
   }
-  if (block.kind === "list") {
+  if (typeof value[field] !== "string") {
+    throw new Document2CommandError("invalid_command", `${field} must be a string when provided`);
+  }
+  return value[field];
+}
+function requireBoolean(value, field) {
+  if (typeof value !== "boolean") {
+    throw new Document2CommandError("invalid_command", `${field} must be a boolean`);
+  }
+  return value;
+}
+function requireIndex(value, field) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 0) {
+    throw new Document2CommandError("invalid_command", `${field} must be a non-negative integer`);
+  }
+  return value;
+}
+function parseMetadata(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isObject3(value)) {
+    throw new Document2CommandError("invalid_command", "metadata must be an object");
+  }
+  if (value.source === void 0) {
+    return void 0;
+  }
+  if (value.source !== "agent" && value.source !== "user") {
+    throw new Document2CommandError("invalid_command", "metadata.source must be agent or user");
+  }
+  return { source: value.source };
+}
+function parseBlockAnchor(value) {
+  if (!isObject3(value)) {
+    throw new Document2CommandError("invalid_anchor", "anchor must be an object");
+  }
+  const before = typeof value.before_block_id === "string" ? value.before_block_id.trim() : "";
+  const after = typeof value.after_block_id === "string" ? value.after_block_id.trim() : "";
+  const choices = Number(before.length > 0) + Number(after.length > 0) + Number(value.end === true);
+  if (choices !== 1) {
+    throw new Document2CommandError("invalid_anchor", "anchor requires exactly one block position");
+  }
+  if (before) {
+    return { before_block_id: before };
+  }
+  if (after) {
+    return { after_block_id: after };
+  }
+  return { end: true };
+}
+function parseListItemAnchor(value) {
+  if (!isObject3(value)) {
+    throw new Document2CommandError("invalid_anchor", "anchor must be an object");
+  }
+  const before = typeof value.before_item_id === "string" ? value.before_item_id.trim() : "";
+  const after = typeof value.after_item_id === "string" ? value.after_item_id.trim() : "";
+  const choices = Number(before.length > 0) + Number(after.length > 0) + Number(value.end === true);
+  if (choices !== 1) {
+    throw new Document2CommandError("invalid_anchor", "anchor requires exactly one list-item position");
+  }
+  if (before) {
+    return { before_item_id: before };
+  }
+  if (after) {
+    return { after_item_id: after };
+  }
+  return { end: true };
+}
+function blockInsertionIndex(document2, anchor) {
+  if ("end" in anchor) {
+    return document2.blocks.length;
+  }
+  const id = "before_block_id" in anchor ? anchor.before_block_id : anchor.after_block_id;
+  const index = document2.blocks.findIndex((block) => block.id === id);
+  if (index < 0) {
+    throw new Document2CommandError("anchor_not_found", "Anchor block was not found");
+  }
+  return "before_block_id" in anchor ? index : index + 1;
+}
+function itemInsertionIndex(list, anchor) {
+  if ("end" in anchor) {
+    return list.items.length;
+  }
+  const id = "before_item_id" in anchor ? anchor.before_item_id : anchor.after_item_id;
+  const index = list.items.findIndex((item) => item.id === id);
+  if (index < 0) {
+    throw new Document2CommandError("anchor_not_found", "Anchor list item was not found");
+  }
+  return "before_item_id" in anchor ? index : index + 1;
+}
+function findField(blocks, fieldId) {
+  for (const block of blocks) {
+    if (block.kind === "textBlock" && block.field.id === fieldId) {
+      return block.field;
+    }
+    if (block.kind === "list") {
+      for (const item of block.items) {
+        if (item.field.id === fieldId) {
+          return item.field;
+        }
+        const nested = findField(item.blocks, fieldId);
+        if (nested) {
+          return nested;
+        }
+      }
+    }
+    if (block.kind === "table") {
+      for (const row of block.rows) {
+        const cell = row.find((field) => field.id === fieldId);
+        if (cell) {
+          return cell;
+        }
+      }
+    }
+  }
+  return null;
+}
+function findBlock(blocks, blockId) {
+  for (const block of blocks) {
+    if (block.id === blockId) {
+      return block;
+    }
+    if (block.kind === "list") {
+      for (const item of block.items) {
+        const nested = findBlock(item.blocks, blockId);
+        if (nested) {
+          return nested;
+        }
+      }
+    }
+  }
+  return null;
+}
+function collectIdentitySets(blocks, sets) {
+  for (const block of blocks) {
+    sets.blocks.add(block.id);
+    if (block.kind === "textBlock") {
+      sets.fields.add(block.field.id);
+      block.field.tokens.forEach((token) => sets.tokens.add(token.id));
+    } else if (block.kind === "list") {
+      for (const item of block.items) {
+        sets.items.add(item.id);
+        sets.fields.add(item.field.id);
+        item.field.tokens.forEach((token) => sets.tokens.add(token.id));
+        collectIdentitySets(item.blocks, sets);
+      }
+    } else if (block.kind === "table") {
+      for (const row of block.rows) {
+        for (const field of row) {
+          sets.fields.add(field.id);
+          field.tokens.forEach((token) => sets.tokens.add(token.id));
+        }
+      }
+    }
+  }
+}
+function documentIdentitySets(document2) {
+  const sets = {
+    blocks: /* @__PURE__ */ new Set(),
+    items: /* @__PURE__ */ new Set(),
+    fields: /* @__PURE__ */ new Set(),
+    tokens: /* @__PURE__ */ new Set()
+  };
+  collectIdentitySets(document2.blocks, sets);
+  return sets;
+}
+function unusedGeneratedId(prefix, used) {
+  let id = document2Id(prefix);
+  while (used.has(id)) {
+    id = document2Id(prefix);
+  }
+  return id;
+}
+function newBlockId(document2) {
+  return unusedGeneratedId("block", documentIdentitySets(document2).blocks);
+}
+function newItemId(document2) {
+  return unusedGeneratedId("item", documentIdentitySets(document2).items);
+}
+function newTokenId(document2, prefix) {
+  return unusedGeneratedId(prefix, documentIdentitySets(document2).tokens);
+}
+function createCommandInlineField(document2, text) {
+  const field = createInlineField2(text);
+  const used = documentIdentitySets(document2);
+  field.id = unusedGeneratedId("field", used.fields);
+  field.tokens.forEach((token) => {
+    token.id = unusedGeneratedId(token.kind, used.tokens);
+    used.tokens.add(token.id);
+  });
+  return field;
+}
+function requireList(document2, listId) {
+  const block = findBlock(document2.blocks, listId);
+  if (!block) {
+    throw new Document2CommandError("list_not_found", "Document list was not found");
+  }
+  if (block.kind !== "list") {
+    throw new Document2CommandError("block_kind_mismatch", "Target block is not a list");
+  }
+  return block;
+}
+function requireTable(document2, tableId) {
+  const block = findBlock(document2.blocks, tableId);
+  if (!block) {
+    throw new Document2CommandError("table_not_found", "Document table was not found");
+  }
+  if (block.kind !== "table") {
+    throw new Document2CommandError("block_kind_mismatch", "Target block is not a table");
+  }
+  return block;
+}
+function fieldHasStructuredContent(field) {
+  return field.tokens.some((token) => token.kind !== "text" || token.style !== void 0);
+}
+function replacePlainField(document2, field, text) {
+  if (fieldHasStructuredContent(field)) {
+    throw new Document2CommandError(
+      "unsupported_inline_content",
+      "Whole-field replacement is not supported for formatted or structured inline content"
+    );
+  }
+  const next = createCommandInlineField(document2, text);
+  field.tokens = next.tokens;
+}
+function textStylesEqual2(a, b) {
+  return Boolean(a?.bold) === Boolean(b?.bold) && Boolean(a?.italic) === Boolean(b?.italic) && Boolean(a?.underline) === Boolean(b?.underline);
+}
+function compactTextTokens2(tokens, emptyTokenId = document2Id("text")) {
+  const compacted = [];
+  for (const token of tokens) {
+    const previous = compacted[compacted.length - 1];
+    if (previous?.kind === "text" && token.kind === "text" && textStylesEqual2(previous.style, token.style)) {
+      previous.text += token.text;
+    } else {
+      compacted.push(token);
+    }
+  }
+  return compacted.length > 0 ? compacted : [{ id: emptyTokenId, kind: "text", text: "" }];
+}
+
+// src/document2/inlineJsonCommands.ts
+function parseInlineAnchor(value) {
+  if (!isObject3(value)) {
+    throw new Document2CommandError("invalid_anchor", "anchor must be an object");
+  }
+  const before = typeof value.before_token_id === "string" ? value.before_token_id.trim() : "";
+  const after = typeof value.after_token_id === "string" ? value.after_token_id.trim() : "";
+  const choices = Number(before.length > 0) + Number(after.length > 0) + Number(value.start === true) + Number(value.end === true);
+  if (choices !== 1) {
+    throw new Document2CommandError("invalid_anchor", "anchor requires exactly one inline-token position");
+  }
+  if (before) {
+    return { before_token_id: before };
+  }
+  if (after) {
+    return { after_token_id: after };
+  }
+  return value.start === true ? { start: true } : { end: true };
+}
+function parseStyle(value) {
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isObject3(value)) {
+    throw new Document2CommandError("invalid_inline_token", "text token style must be an object");
+  }
+  const style = {};
+  for (const key of ["bold", "italic", "underline"]) {
+    if (value[key] !== void 0 && value[key] !== true) {
+      throw new Document2CommandError("invalid_inline_token", `text token style.${key} must be true when provided`);
+    }
+    if (value[key] === true) {
+      style[key] = true;
+    }
+  }
+  return style.bold || style.italic || style.underline ? style : void 0;
+}
+function normalizedKeys(value) {
+  if (!Array.isArray(value)) {
+    throw new Document2CommandError("invalid_inline_token", "citation/reference keys must be an array");
+  }
+  const keys = [];
+  for (const entry of value) {
+    if (typeof entry !== "string") {
+      throw new Document2CommandError("invalid_inline_token", "citation/reference keys must be strings");
+    }
+    const key = entry.trim();
+    if (key.length > 0 && !keys.includes(key)) {
+      keys.push(key);
+    }
+  }
+  if (keys.length === 0) {
+    throw new Document2CommandError("invalid_inline_token", "citation/reference requires at least one non-empty key");
+  }
+  return keys;
+}
+function parseMathObject(value, source) {
+  if (!isObject3(value) || value.node_type !== "MathObject") {
+    throw new Document2CommandError("math_object_mismatch", "math_object must be a structured MathObject");
+  }
+  const spans = detectInlineSpans2(source);
+  const span = spans[0];
+  if (spans.length !== 1 || span?.kind !== "math" || span.start !== 0 || span.end !== source.length) {
+    throw new Document2CommandError("math_object_mismatch", "math source must contain exactly one complete delimited span");
+  }
+  if (value.math_mode !== span.opening || value.closing !== span.closing) {
+    throw new Document2CommandError("math_object_mismatch", "math_object delimiters do not match math source");
+  }
+  try {
+    fromMathObjectJson(value, value.source_side === "arabic" ? "arabic" : "english");
+  } catch {
+    throw new Document2CommandError("math_object_mismatch", "math_object must contain a valid structured equation");
+  }
+  return value;
+}
+function parseToken(value) {
+  if (!isObject3(value) || typeof value.kind !== "string") {
+    throw new Document2CommandError("invalid_inline_token", "token requires a kind");
+  }
+  if (value.kind === "text") {
+    const text = requireString2(value.text, "token.text");
+    if (detectInlineSpans2(text).length > 0) {
+      throw new Document2CommandError("invalid_inline_token", "text token contains structured inline syntax");
+    }
+    const style = parseStyle(value.style);
+    return { kind: "text", text, ...style ? { style } : {} };
+  }
+  if (value.kind === "cite") {
+    return { kind: "cite", keys: normalizedKeys(value.keys) };
+  }
+  if (value.kind === "ref") {
+    if (value.ref_command !== "ref" && value.ref_command !== "eqref") {
+      throw new Document2CommandError("invalid_inline_token", "ref_command must be ref or eqref");
+    }
+    return { kind: "ref", keys: normalizedKeys(value.keys), ref_command: value.ref_command };
+  }
+  if (value.kind === "math") {
+    const source = requireString2(value.source, "token.source", false);
+    return { kind: "math", source, math_object: parseMathObject(value.math_object, source) };
+  }
+  throw new Document2CommandError("invalid_inline_token", "Unsupported inline token kind");
+}
+function parseInlineCommand(value) {
+  if (value.op === "insert_inline_token") {
     return {
-      ...block,
-      items: block.items.map((item) => ({
-        ...item,
-        field: cloneField(item.field),
-        blocks: item.blocks.map(cloneBlock)
-      }))
+      op: value.op,
+      field_id: requireString2(value.field_id, "field_id", false).trim(),
+      token: parseToken(value.token),
+      anchor: parseInlineAnchor(value.anchor)
     };
   }
-  if (block.kind === "table") {
-    return { ...block, rows: block.rows.map((row) => row.map(cloneField)) };
+  if (value.op === "replace_inline_token") {
+    return {
+      op: value.op,
+      field_id: requireString2(value.field_id, "field_id", false).trim(),
+      token_id: requireString2(value.token_id, "token_id", false).trim(),
+      token: parseToken(value.token)
+    };
   }
-  if (block.kind === "image") {
-    return { ...block, options: { ...block.options } };
+  if (value.op === "remove_inline_token") {
+    return {
+      op: value.op,
+      field_id: requireString2(value.field_id, "field_id", false).trim(),
+      token_id: requireString2(value.token_id, "token_id", false).trim()
+    };
   }
-  return { ...block };
+  throw new Document2CommandError("invalid_command", "Unsupported inline command");
 }
-function cloneDocument(document2) {
+function liveToken(input, id) {
+  if (input.kind === "text") {
+    return { id, kind: "text", text: input.text, ...input.style ? { style: { ...input.style } } : {} };
+  }
+  if (input.kind === "cite") {
+    return { id, kind: "cite", keys: [...input.keys] };
+  }
+  if (input.kind === "ref") {
+    return { id, kind: "ref", keys: [...input.keys], refCommand: input.ref_command };
+  }
+  const mathObject = input.math_object;
+  const spans = detectInlineSpans2(input.source);
+  const span = spans[0];
+  if (!span || span.kind !== "math") {
+    throw new Document2CommandError("math_object_mismatch", "math source is not a complete delimited span");
+  }
   return {
-    nodeType: "DocumentObject",
-    meta: cloneDocument2Meta(document2.meta ?? emptyDocument2Meta()),
-    references: document2.references.map((reference) => ({ ...reference })),
-    blocks: document2.blocks.map(cloneBlock),
-    diagnostics: document2.diagnostics.map((diagnostic) => ({ ...diagnostic }))
+    id,
+    kind: "math",
+    display: span.display,
+    opening: span.opening,
+    closing: span.closing,
+    source: input.source,
+    sourceSide: mathObject.source_side === "arabic" ? "arabic" : "english",
+    math: fromMathObjectJson(mathObject, mathObject.source_side === "arabic" ? "arabic" : "english"),
+    editable: true,
+    sourceOwner: mathObject.source_owner === "editor" ? "editor" : "imported-structured",
+    ...mathObject.label_enabled !== void 0 ? { labelEnabled: mathObject.label_enabled } : {},
+    ...mathObject.label !== void 0 ? { label: mathObject.label } : {}
   };
 }
-function insertBlockAfter(blocks, afterBlockId2, block) {
-  if (!afterBlockId2) {
-    blocks.push(block);
+function insertionIndex(tokens, anchor) {
+  if ("start" in anchor) {
+    return 0;
+  }
+  if ("end" in anchor) {
+    return tokens.length;
+  }
+  const id = "before_token_id" in anchor ? anchor.before_token_id : anchor.after_token_id;
+  const index = tokens.findIndex((token) => token.id === id);
+  if (index < 0) {
+    throw new Document2CommandError("token_not_found", "Anchor token was not found");
+  }
+  return "before_token_id" in anchor ? index : index + 1;
+}
+function applyInlineCommand(document2, command) {
+  const field = findField(document2.blocks, command.field_id);
+  if (!field) {
+    throw new Document2CommandError("field_not_found", "Inline field was not found");
+  }
+  if (command.op === "insert_inline_token") {
+    const index2 = insertionIndex(field.tokens, command.anchor);
+    field.tokens.splice(index2, 0, liveToken(command.token, newTokenId(document2, command.token.kind)));
     return;
   }
-  const index = blocks.findIndex((entry) => entry.id === afterBlockId2);
+  const index = field.tokens.findIndex((token) => token.id === command.token_id);
   if (index < 0) {
-    blocks.push(block);
+    throw new Document2CommandError("token_not_found", "Inline token was not found");
+  }
+  if (command.op === "replace_inline_token") {
+    field.tokens[index] = liveToken(command.token, command.token_id);
     return;
   }
-  blocks.splice(index + 1, 0, block);
+  field.tokens = compactTextTokens2(
+    [...field.tokens.slice(0, index), ...field.tokens.slice(index + 1)],
+    newTokenId(document2, "text")
+  );
+}
+
+// src/document2/listJsonCommands.ts
+function stringArray(value, field) {
+  if (!Array.isArray(value) || value.length === 0 || value.some((entry) => typeof entry !== "string")) {
+    throw new Document2CommandError("invalid_command", `${field} must be a non-empty string array`);
+  }
+  return [...value];
+}
+function parseListCommand(value) {
+  if (value.op === "insert_list") {
+    const metadata = parseMetadata(value.metadata);
+    return {
+      op: value.op,
+      ordered: requireBoolean(value.ordered, "ordered"),
+      items: stringArray(value.items, "items"),
+      anchor: parseBlockAnchor(value.anchor),
+      ...metadata ? { metadata } : {}
+    };
+  }
+  if (value.op === "insert_list_item") {
+    return {
+      op: value.op,
+      list_id: requireString2(value.list_id, "list_id", false).trim(),
+      text: requireString2(value.text, "text"),
+      anchor: parseListItemAnchor(value.anchor)
+    };
+  }
+  if (value.op === "replace_list_item") {
+    return {
+      op: value.op,
+      list_id: requireString2(value.list_id, "list_id", false).trim(),
+      item_id: requireString2(value.item_id, "item_id", false).trim(),
+      text: requireString2(value.text, "text")
+    };
+  }
+  if (value.op === "remove_list_item") {
+    return {
+      op: value.op,
+      list_id: requireString2(value.list_id, "list_id", false).trim(),
+      item_id: requireString2(value.item_id, "item_id", false).trim()
+    };
+  }
+  if (value.op === "move_list_item") {
+    return {
+      op: value.op,
+      list_id: requireString2(value.list_id, "list_id", false).trim(),
+      item_id: requireString2(value.item_id, "item_id", false).trim(),
+      anchor: parseListItemAnchor(value.anchor)
+    };
+  }
+  throw new Document2CommandError("invalid_command", "Unsupported list command");
 }
-function insertDocument2BlockAfter(document2, afterBlockId2, block) {
-  const next = cloneDocument(document2);
-  insertBlockAfter(next.blocks, afterBlockId2, block);
-  return next;
+function newItem(document2, text) {
+  return { id: newItemId(document2), field: createCommandInlineField(document2, text), blocks: [] };
 }
-function addDocument2TextBlock(document2, command = "\\paragraph", afterBlockId2) {
+function insertList(document2, command) {
+  const ordered = command.ordered;
   const block = {
-    id: document2Id("block"),
-    kind: "textBlock",
-    command,
-    field: createInlineField2(""),
-    ...command === "\\paragraph" ? { centered: false } : {}
+    id: newBlockId(document2),
+    kind: "list",
+    command: ordered ? "\\begin{enumerate}" : "\\begin{itemize}",
+    closing: ordered ? "\\end{enumerate}" : "\\end{itemize}",
+    items: command.items.map((text) => newItem(document2, text)),
+    ...command.metadata ? { metadata: { ...command.metadata } } : {}
   };
-  return insertDocument2BlockAfter(document2, afterBlockId2, block);
+  document2.blocks.splice(blockInsertionIndex(document2, command.anchor), 0, block);
 }
-function removeDocument2BlockById(document2, blockId) {
-  const next = cloneDocument(document2);
-  next.blocks = next.blocks.filter((block) => block.id !== blockId);
-  return next;
+function applyListCommand(document2, command) {
+  if (command.op === "insert_list") {
+    insertList(document2, command);
+    return;
+  }
+  const list = requireList(document2, command.list_id);
+  if (command.op === "insert_list_item") {
+    list.items.splice(itemInsertionIndex(list, command.anchor), 0, newItem(document2, command.text));
+    return;
+  }
+  const itemIndex = list.items.findIndex((item2) => item2.id === command.item_id);
+  if (itemIndex < 0) {
+    throw new Document2CommandError("item_not_found", "Document list item was not found");
+  }
+  if (command.op === "replace_list_item") {
+    replacePlainField(document2, list.items[itemIndex].field, command.text);
+    return;
+  }
+  if (command.op === "remove_list_item") {
+    if (list.items.length === 1) {
+      throw new Document2CommandError("minimum_structure", "A list must retain at least one item");
+    }
+    list.items.splice(itemIndex, 1);
+    return;
+  }
+  const anchorId = "before_item_id" in command.anchor ? command.anchor.before_item_id : "after_item_id" in command.anchor ? command.anchor.after_item_id : null;
+  if (anchorId === command.item_id) {
+    throw new Document2CommandError("invalid_anchor", "A list item cannot be moved relative to itself");
+  }
+  const [item] = list.items.splice(itemIndex, 1);
+  if (!item) {
+    throw new Document2CommandError("item_not_found", "Document list item was not found");
+  }
+  list.items.splice(itemInsertionIndex(list, command.anchor), 0, item);
+}
+
+// src/document2/tableJsonCommands.ts
+function stringArray2(value, field) {
+  if (!Array.isArray(value) || value.some((entry) => typeof entry !== "string")) {
+    throw new Document2CommandError("invalid_command", `${field} must be a string array`);
+  }
+  return [...value];
 }
-function normalizeImageInput(srcOrAsset) {
-  if (typeof srcOrAsset === "string") {
-    return srcOrAsset.length > 0 ? { value: srcOrAsset, assetId: srcOrAsset } : { value: "" };
+function rectangularRows(value) {
+  if (!Array.isArray(value) || value.length === 0) {
+    throw new Document2CommandError("invalid_table_shape", "rows must be a non-empty array");
   }
-  if (srcOrAsset && srcOrAsset.assetId.length > 0) {
-    return { value: srcOrAsset.value ?? srcOrAsset.assetId, assetId: srcOrAsset.assetId };
+  const rows = value.map((row, index) => stringArray2(row, `rows[${String(index)}]`));
+  const columnCount = rows[0]?.length ?? 0;
+  if (columnCount === 0 || rows.some((row) => row.length !== columnCount)) {
+    throw new Document2CommandError("invalid_table_shape", "Table rows must form a non-empty rectangle");
   }
-  return { value: "" };
+  return rows;
 }
-function addDocument2ImageBlock(document2, srcOrAsset, afterBlockId2) {
-  const image = normalizeImageInput(srcOrAsset);
+function columns(value) {
+  const result = requireString2(value, "columns", false);
+  if (result.trim().length === 0) {
+    throw new Document2CommandError("invalid_table_shape", "columns must be a non-empty LaTeX specification");
+  }
+  return result;
+}
+function parseTableCommand(value) {
+  if (value.op === "insert_table") {
+    const caption = optionalString(value, "caption");
+    const label = optionalString(value, "label");
+    const metadata = parseMetadata(value.metadata);
+    return {
+      op: value.op,
+      rows: rectangularRows(value.rows),
+      columns: columns(value.columns),
+      ...caption !== void 0 ? { caption } : {},
+      ...label !== void 0 ? { label } : {},
+      anchor: parseBlockAnchor(value.anchor),
+      ...metadata ? { metadata } : {}
+    };
+  }
+  if (value.op === "replace_table_cell") {
+    return {
+      op: value.op,
+      table_id: requireString2(value.table_id, "table_id", false).trim(),
+      row_index: requireIndex(value.row_index, "row_index"),
+      column_index: requireIndex(value.column_index, "column_index"),
+      text: requireString2(value.text, "text")
+    };
+  }
+  if (value.op === "insert_table_row") {
+    return {
+      op: value.op,
+      table_id: requireString2(value.table_id, "table_id", false).trim(),
+      index: requireIndex(value.index, "index"),
+      values: stringArray2(value.values, "values")
+    };
+  }
+  if (value.op === "remove_table_row") {
+    return {
+      op: value.op,
+      table_id: requireString2(value.table_id, "table_id", false).trim(),
+      index: requireIndex(value.index, "index")
+    };
+  }
+  if (value.op === "move_table_row") {
+    return {
+      op: value.op,
+      table_id: requireString2(value.table_id, "table_id", false).trim(),
+      from_index: requireIndex(value.from_index, "from_index"),
+      to_index: requireIndex(value.to_index, "to_index")
+    };
+  }
+  if (value.op === "insert_table_column") {
+    return {
+      op: value.op,
+      table_id: requireString2(value.table_id, "table_id", false).trim(),
+      index: requireIndex(value.index, "index"),
+      values: stringArray2(value.values, "values"),
+      columns: columns(value.columns)
+    };
+  }
+  if (value.op === "remove_table_column") {
+    return {
+      op: value.op,
+      table_id: requireString2(value.table_id, "table_id", false).trim(),
+      index: requireIndex(value.index, "index"),
+      columns: columns(value.columns)
+    };
+  }
+  if (value.op === "move_table_column") {
+    return {
+      op: value.op,
+      table_id: requireString2(value.table_id, "table_id", false).trim(),
+      from_index: requireIndex(value.from_index, "from_index"),
+      to_index: requireIndex(value.to_index, "to_index"),
+      columns: columns(value.columns)
+    };
+  }
+  throw new Document2CommandError("invalid_command", "Unsupported table command");
+}
+function insertTable(document2, command) {
   const block = {
-    id: document2Id("block"),
-    kind: "image",
-    command: "\\includegraphics",
-    value: image.value,
-    ...image.assetId !== void 0 ? { assetId: image.assetId } : {},
-    options: { width: "0.8\\columnwidth" },
-    ...defaultFloatMeta()
+    id: newBlockId(document2),
+    kind: "table",
+    command: "\\begin{tabular}",
+    closing: "\\end{tabular}",
+    columns: command.columns,
+    rows: command.rows.map((row) => row.map((cell) => createCommandInlineField(document2, cell))),
+    ...defaultFloatMeta(),
+    ...command.caption !== void 0 ? { caption: command.caption, captionEnabled: command.caption.trim().length > 0 } : {},
+    ...command.label !== void 0 ? { label: command.label, labelEnabled: command.label.trim().length > 0 } : {},
+    ...command.metadata ? { metadata: { ...command.metadata } } : {}
   };
-  return insertDocument2BlockAfter(document2, afterBlockId2, block);
+  document2.blocks.splice(blockInsertionIndex(document2, command.anchor), 0, block);
+}
+function checkCell(table, rowIndex, columnIndex) {
+  if (rowIndex >= table.rows.length || columnIndex >= (table.rows[rowIndex]?.length ?? 0)) {
+    throw new Document2CommandError("index_out_of_range", "Table cell index is out of range");
+  }
+}
+function checkExistingIndex(index, length, field) {
+  if (index >= length) {
+    throw new Document2CommandError("index_out_of_range", `${field} is out of range`);
+  }
+}
+function applyTableCommand(document2, command) {
+  if (command.op === "insert_table") {
+    insertTable(document2, command);
+    return;
+  }
+  const table = requireTable(document2, command.table_id);
+  const columnCount = table.rows[0]?.length ?? 0;
+  if (table.rows.length === 0 || columnCount === 0 || table.rows.some((row) => row.length !== columnCount)) {
+    throw new Document2CommandError("invalid_table_shape", "Target table must be a non-empty rectangle");
+  }
+  if (command.op === "replace_table_cell") {
+    checkCell(table, command.row_index, command.column_index);
+    replacePlainField(document2, table.rows[command.row_index][command.column_index], command.text);
+    return;
+  }
+  if (command.op === "insert_table_row") {
+    if (command.index > table.rows.length) {
+      throw new Document2CommandError("index_out_of_range", "Table row insertion index is out of range");
+    }
+    if (command.values.length !== columnCount) {
+      throw new Document2CommandError("invalid_table_shape", "Inserted row must match the current column count");
+    }
+    table.rows.splice(command.index, 0, command.values.map((value) => createCommandInlineField(document2, value)));
+    return;
+  }
+  if (command.op === "remove_table_row") {
+    checkExistingIndex(command.index, table.rows.length, "Table row index");
+    if (table.rows.length === 1) {
+      throw new Document2CommandError("minimum_structure", "A table must retain at least one row");
+    }
+    table.rows.splice(command.index, 1);
+    return;
+  }
+  if (command.op === "move_table_row") {
+    checkExistingIndex(command.from_index, table.rows.length, "Table source row index");
+    checkExistingIndex(command.to_index, table.rows.length, "Table target row index");
+    const [row] = table.rows.splice(command.from_index, 1);
+    table.rows.splice(command.to_index, 0, row);
+    return;
+  }
+  if (command.op === "insert_table_column") {
+    if (command.index > columnCount) {
+      throw new Document2CommandError("index_out_of_range", "Table column insertion index is out of range");
+    }
+    if (command.values.length !== table.rows.length) {
+      throw new Document2CommandError("invalid_table_shape", "Inserted column requires one value per row");
+    }
+    table.rows.forEach((row, index) => row.splice(command.index, 0, createCommandInlineField(document2, command.values[index])));
+    table.columns = command.columns;
+    return;
+  }
+  if (command.op === "remove_table_column") {
+    checkExistingIndex(command.index, columnCount, "Table column index");
+    if (columnCount === 1) {
+      throw new Document2CommandError("minimum_structure", "A table must retain at least one column");
+    }
+    table.rows.forEach((row) => row.splice(command.index, 1));
+    table.columns = command.columns;
+    return;
+  }
+  checkExistingIndex(command.from_index, columnCount, "Table source column index");
+  checkExistingIndex(command.to_index, columnCount, "Table target column index");
+  table.rows.forEach((row) => {
+    const [cell] = row.splice(command.from_index, 1);
+    row.splice(command.to_index, 0, cell);
+  });
+  table.columns = command.columns;
 }
 
 // src/document2/exportJson.ts
@@ -2591,12 +3336,13 @@ function serializeField(field) {
       ...token.label !== void 0 ? { label: token.label } : {}
     });
   }
-  return { value, formats, mathObjects, hasPersistedMath };
+  return { value, formats, mathObjects, hasPersistedMath, inlineIds: inlineIdsFromField(field) };
 }
 function fieldJson(field) {
   const serialized = serializeField(field);
   return {
     value: serialized.value,
+    inline_ids: serialized.inlineIds,
     ...serialized.formats.length > 0 ? { formats: serialized.formats } : {},
     ...serialized.hasPersistedMath ? { math_objects: serialized.mathObjects } : {}
   };
@@ -2604,7 +3350,9 @@ function fieldJson(field) {
 function listItemJson(item) {
   const field = fieldJson(item.field);
   return {
+    id: item.id,
     value: field.value ?? "",
+    inline_ids: field.inline_ids,
     ...field.formats ? { formats: field.formats } : {},
     ...field.math_objects ? { math_objects: field.math_objects } : {},
     ...item.blocks.length > 0 ? { blocks: item.blocks.map(blockJson) } : {}
@@ -2616,6 +3364,7 @@ function blockJson(block) {
       id: block.id,
       command: block.command,
       ...fieldJson(block.field),
+      ...block.metadata ? { metadata: { ...block.metadata } } : {},
       ...block.command === "\\paragraph" ? { centered: block.centered === true } : {}
     };
   }
@@ -2624,7 +3373,8 @@ function blockJson(block) {
       id: block.id,
       command: block.command,
       closing: block.closing,
-      items: block.items.map(listItemJson)
+      items: block.items.map(listItemJson),
+      ...block.metadata ? { metadata: { ...block.metadata } } : {}
     };
   }
   if (block.kind === "table") {
@@ -2636,13 +3386,15 @@ function blockJson(block) {
       closing: block.closing,
       columns: block.columns,
       rows: fields.map((row) => row.map((field) => field.value)),
+      cell_inline_ids: fields.map((row) => row.map((field) => field.inlineIds)),
       ...fields.some((row) => row.some((field) => field.formats.length > 0)) ? { cell_formats: fields.map((row) => row.map((field) => field.formats)) } : {},
       ...hasPersistedMath ? { math_objects: fields.flatMap((row) => row.flatMap((field) => field.mathObjects)) } : {},
       centered: block.centered,
       caption_enabled: block.captionEnabled,
       caption: block.caption,
       label_enabled: block.labelEnabled,
-      label: block.label
+      label: block.label,
+      ...block.metadata ? { metadata: { ...block.metadata } } : {}
     };
   }
   if (block.kind === "image") {
@@ -2656,13 +3408,24 @@ function blockJson(block) {
       caption_enabled: block.captionEnabled,
       caption: block.caption,
       label_enabled: block.labelEnabled,
-      label: block.label
+      label: block.label,
+      ...block.metadata ? { metadata: { ...block.metadata } } : {}
     };
   }
   if (block.kind === "bibliography") {
-    return { id: block.id, command: block.command, closing: block.closing };
+    return {
+      id: block.id,
+      command: block.command,
+      closing: block.closing,
+      ...block.metadata ? { metadata: { ...block.metadata } } : {}
+    };
   }
-  return { id: block.id, command: block.command, value: block.value };
+  return {
+    id: block.id,
+    command: block.command,
+    value: block.value,
+    ...block.metadata ? { metadata: { ...block.metadata } } : {}
+  };
 }
 function referenceJson(reference) {
   return {
@@ -2693,49 +3456,14 @@ function toDocumentJson2(document2) {
 }
 
 // src/document2/jsonCommands.ts
-var Document2CommandError = class extends Error {
-  code;
-  constructor(code, message) {
-    super(message);
-    this.name = "Document2CommandError";
-    this.code = code;
-  }
-};
-function isObject3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+function isInlineCommand(command) {
+  return command.op === "insert_inline_token" || command.op === "replace_inline_token" || command.op === "remove_inline_token";
 }
-function requireString2(value, field, allowEmpty = true) {
-  if (typeof value !== "string" || !allowEmpty && value.trim().length === 0) {
-    throw new Document2CommandError("invalid_command", `${field} must be a${allowEmpty ? "" : " non-empty"} string`);
-  }
-  return value;
+function isListCommand(command) {
+  return command.op === "insert_list" || command.op === "insert_list_item" || command.op === "replace_list_item" || command.op === "remove_list_item" || command.op === "move_list_item";
 }
-function parseAnchor(value) {
-  if (!isObject3(value)) {
-    throw new Document2CommandError("invalid_command", "anchor must be an object");
-  }
-  const hasEnd = value.end === true;
-  const afterBlockId2 = typeof value.after_block_id === "string" ? value.after_block_id.trim() : "";
-  const hasAfterBlock = afterBlockId2.length > 0;
-  if (hasEnd && hasAfterBlock) {
-    throw new Document2CommandError("invalid_command", "anchor cannot contain both end and after_block_id");
-  }
-  if (hasEnd) {
-    return { end: true };
-  }
-  if (hasAfterBlock) {
-    return { after_block_id: afterBlockId2 };
-  }
-  throw new Document2CommandError("invalid_command", "anchor requires end: true or a non-empty after_block_id");
-}
-function optionalString(value, field) {
-  if (!(field in value)) {
-    return void 0;
-  }
-  if (typeof value[field] !== "string") {
-    throw new Document2CommandError("invalid_command", `${field} must be a string when provided`);
-  }
-  return value[field];
+function isTableCommand(command) {
+  return command.op === "insert_table" || command.op === "replace_table_cell" || command.op === "insert_table_row" || command.op === "remove_table_row" || command.op === "move_table_row" || command.op === "insert_table_column" || command.op === "remove_table_column" || command.op === "move_table_column";
 }
 function parseTextBlockKind(value) {
   if (value === "section" || value === "subsection" || value === "subsubsection" || value === "paragraph") {
@@ -2743,16 +3471,15 @@ function parseTextBlockKind(value) {
   }
   throw new Document2CommandError("invalid_command", "kind must be section, subsection, subsubsection, or paragraph");
 }
-function parseCommand2(value) {
-  if (!isObject3(value) || typeof value.op !== "string") {
-    throw new Document2CommandError("invalid_command", "command requires an op");
-  }
+function parseBasicCommand(value) {
   if (value.op === "insert_text_block") {
+    const metadata = parseMetadata(value.metadata);
     return {
       op: value.op,
       kind: parseTextBlockKind(value.kind),
       text: requireString2(value.text, "text"),
-      anchor: parseAnchor(value.anchor)
+      anchor: parseBlockAnchor(value.anchor),
+      ...metadata ? { metadata } : {}
     };
   }
   if (value.op === "replace_text_block") {
@@ -2763,140 +3490,118 @@ function parseCommand2(value) {
     };
   }
   if (value.op === "remove_block") {
-    return {
-      op: value.op,
-      block_id: requireString2(value.block_id, "block_id", false).trim()
-    };
+    return { op: value.op, block_id: requireString2(value.block_id, "block_id", false).trim() };
   }
   if (value.op === "insert_figure") {
     const figureValue = optionalString(value, "value");
     const caption = optionalString(value, "caption");
     const label = optionalString(value, "label");
+    const metadata = parseMetadata(value.metadata);
     return {
       op: value.op,
       asset_id: requireString2(value.asset_id, "asset_id", false).trim(),
       ...figureValue !== void 0 ? { value: figureValue } : {},
       ...caption !== void 0 ? { caption } : {},
       ...label !== void 0 ? { label } : {},
-      anchor: parseAnchor(value.anchor)
+      anchor: parseBlockAnchor(value.anchor),
+      ...metadata ? { metadata } : {}
     };
   }
-  throw new Document2CommandError("invalid_command", `Unsupported document command: ${value.op}`);
+  throw new Document2CommandError("invalid_command", "Unsupported block command");
+}
+function parseCommand2(value) {
+  if (!isObject3(value) || typeof value.op !== "string") {
+    throw new Document2CommandError("invalid_command", "command requires an op");
+  }
+  if (value.op === "insert_inline_token" || value.op === "replace_inline_token" || value.op === "remove_inline_token") {
+    return parseInlineCommand(value);
+  }
+  if (value.op === "insert_list" || value.op === "insert_list_item" || value.op === "replace_list_item" || value.op === "remove_list_item" || value.op === "move_list_item") {
+    return parseListCommand(value);
+  }
+  if (value.op === "insert_table" || value.op === "replace_table_cell" || value.op === "insert_table_row" || value.op === "remove_table_row" || value.op === "move_table_row" || value.op === "insert_table_column" || value.op === "remove_table_column" || value.op === "move_table_column") {
+    return parseTableCommand(value);
+  }
+  if (value.op === "insert_text_block" || value.op === "replace_text_block" || value.op === "remove_block" || value.op === "insert_figure") {
+    return parseBasicCommand(value);
+  }
+  throw new Document2CommandError("invalid_command", "Unsupported document command");
 }
 function parseDocument(json) {
   try {
     return fromDocumentJson2(json);
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid DocumentObject JSON";
-    throw new Document2CommandError("invalid_document", message);
+  } catch {
+    throw new Document2CommandError("invalid_document", "Document JSON is invalid");
   }
 }
-function commandForKind(kind) {
+function textCommand(kind) {
   if (kind === "section") {
     return "\\section";
   }
   if (kind === "subsection") {
     return "\\subsection";
   }
-  if (kind === "subsubsection") {
-    return "\\subsubsection";
-  }
-  return "\\paragraph";
+  return kind === "subsubsection" ? "\\subsubsection" : "\\paragraph";
 }
-function insertionIndex(document2, anchor) {
-  if ("end" in anchor) {
-    return document2.blocks.length;
-  }
-  const index = document2.blocks.findIndex((block) => block.id === anchor.after_block_id);
-  if (index < 0) {
-    throw new Document2CommandError("anchor_not_found", `Anchor block was not found: ${anchor.after_block_id}`);
-  }
-  return index + 1;
-}
-function afterBlockId(document2, index) {
-  return index > 0 ? document2.blocks[index - 1]?.id ?? null : null;
-}
-function insertedBlock(document2, index) {
-  const block = document2.blocks[index];
-  if (!block) {
-    throw new Document2CommandError("invalid_command", "Document command did not insert a block");
-  }
-  return block;
-}
-function insertTextBlock(document2, command) {
-  const index = insertionIndex(document2, command.anchor);
-  const next = addDocument2TextBlock(document2, commandForKind(command.kind), afterBlockId(document2, index));
-  const block = insertedBlock(next, index);
-  if (block.kind !== "textBlock") {
-    throw new Document2CommandError("block_kind_mismatch", "Inserted block is not a text block");
-  }
-  block.field = createInlineField2(command.text);
-  return next;
-}
-function replaceTextBlock(document2, command) {
-  const index = document2.blocks.findIndex((block2) => block2.id === command.block_id);
-  if (index < 0) {
-    throw new Document2CommandError("block_not_found", `Document block was not found: ${command.block_id}`);
-  }
-  const block = document2.blocks[index];
-  if (!block || block.kind !== "textBlock") {
-    throw new Document2CommandError("block_kind_mismatch", `Document block is not a text block: ${command.block_id}`);
-  }
-  if (block.field.tokens.some((token) => token.kind !== "text" || token.style !== void 0)) {
-    throw new Document2CommandError(
-      "unsupported_inline_content",
-      "Whole-block replacement is not supported for formatted or structured inline content"
-    );
-  }
-  const next = parseDocument(toDocumentJson2(document2));
-  const nextBlock = next.blocks[index];
-  if (!nextBlock || nextBlock.kind !== "textBlock") {
-    throw new Document2CommandError("block_kind_mismatch", `Document block is not a text block: ${command.block_id}`);
-  }
-  nextBlock.field = createInlineField2(command.text);
-  return next;
-}
-function removeBlock(document2, command) {
-  if (!document2.blocks.some((block) => block.id === command.block_id)) {
-    throw new Document2CommandError("block_not_found", `Document block was not found: ${command.block_id}`);
-  }
-  return removeDocument2BlockById(document2, command.block_id);
-}
-function insertFigure(document2, command) {
-  const index = insertionIndex(document2, command.anchor);
-  const next = addDocument2ImageBlock(
-    document2,
-    { assetId: command.asset_id, ...command.value !== void 0 ? { value: command.value } : {} },
-    afterBlockId(document2, index)
-  );
-  const block = insertedBlock(next, index);
-  if (block.kind !== "image") {
-    throw new Document2CommandError("block_kind_mismatch", "Inserted block is not a figure");
+function applyBasicCommand(document2, command) {
+  if (command.op === "insert_text_block") {
+    const block2 = {
+      id: newBlockId(document2),
+      kind: "textBlock",
+      command: textCommand(command.kind),
+      field: createCommandInlineField(document2, command.text),
+      ...command.kind === "paragraph" ? { centered: false } : {},
+      ...command.metadata ? { metadata: { ...command.metadata } } : {}
+    };
+    document2.blocks.splice(blockInsertionIndex(document2, command.anchor), 0, block2);
+    return;
   }
-  if (command.caption !== void 0) {
-    block.caption = command.caption;
-    block.captionEnabled = command.caption.trim().length > 0;
+  if (command.op === "replace_text_block") {
+    const block2 = document2.blocks.find((entry) => entry.id === command.block_id);
+    if (!block2) {
+      throw new Document2CommandError("block_not_found", "Document block was not found");
+    }
+    if (block2.kind !== "textBlock") {
+      throw new Document2CommandError("block_kind_mismatch", "Document block is not a text block");
+    }
+    replacePlainField(document2, block2.field, command.text);
+    return;
   }
-  if (command.label !== void 0) {
-    block.label = command.label;
-    block.labelEnabled = command.label.trim().length > 0;
+  if (command.op === "remove_block") {
+    const index = document2.blocks.findIndex((block2) => block2.id === command.block_id);
+    if (index < 0) {
+      throw new Document2CommandError("block_not_found", "Document block was not found");
+    }
+    document2.blocks.splice(index, 1);
+    return;
   }
-  return next;
+  const block = {
+    id: newBlockId(document2),
+    kind: "image",
+    command: "\\includegraphics",
+    value: command.value ?? command.asset_id,
+    assetId: command.asset_id,
+    options: { width: "0.8\\columnwidth" },
+    ...defaultFloatMeta(),
+    ...command.caption !== void 0 ? { caption: command.caption, captionEnabled: command.caption.trim().length > 0 } : {},
+    ...command.label !== void 0 ? { label: command.label, labelEnabled: command.label.trim().length > 0 } : {},
+    ...command.metadata ? { metadata: { ...command.metadata } } : {}
+  };
+  document2.blocks.splice(blockInsertionIndex(document2, command.anchor), 0, block);
 }
 function applyDocument2Command(json, commandInput) {
   const document2 = parseDocument(json);
   const command = parseCommand2(commandInput);
-  let next;
-  if (command.op === "insert_text_block") {
-    next = insertTextBlock(document2, command);
-  } else if (command.op === "replace_text_block") {
-    next = replaceTextBlock(document2, command);
-  } else if (command.op === "remove_block") {
-    next = removeBlock(document2, command);
+  if (isInlineCommand(command)) {
+    applyInlineCommand(document2, command);
+  } else if (isListCommand(command)) {
+    applyListCommand(document2, command);
+  } else if (isTableCommand(command)) {
+    applyTableCommand(document2, command);
   } else {
-    next = insertFigure(document2, command);
+    applyBasicCommand(document2, command);
   }
-  return toDocumentJson2(next);
+  return toDocumentJson2(document2);
 }
 
 // src/document2/outline.ts
@@ -3041,9 +3746,8 @@ function asDocument2Command(value) {
 function normalizeDocument(document2) {
   try {
     return toDocumentJson2(fromDocumentJson2(document2));
-  } catch (error) {
-    const message = error instanceof Error ? error.message : "Invalid DocumentObject JSON";
-    throw new Document2CommandError("invalid_document", message);
+  } catch {
+    throw new Document2CommandError("invalid_document", "Document JSON is invalid");
   }
 }
 function executeDocument2WorkerRequest(input) {