@superdoc-dev/cli 0.3.2 → 0.4.0-next.10

package/dist/index.js

@@ -13006,27 +13006,27 @@ function executeMarkdownToFragment(adapter, input) {
 // ../../packages/document-api/src/comments/comments.ts
 function validateCreateCommentInput(input) {
   if (!isRecord(input)) {
-    throw new DocumentApiValidationError("INVALID_TARGET", "comments.create input must be a non-null object.");
+    throw new DocumentApiValidationError("INVALID_INPUT", "comments.create input must be a non-null object.");
   }
   assertNoUnknownFields(input, CREATE_COMMENT_ALLOWED_KEYS, "comments.create");
   const { target, text, parentCommentId } = input;
   const hasTarget = target !== undefined;
   const isReply = parentCommentId !== undefined;
   if (typeof text !== "string") {
-    throw new DocumentApiValidationError("INVALID_TARGET", `text must be a string, got ${typeof text}.`, {
+    throw new DocumentApiValidationError("INVALID_INPUT", `text must be a string, got ${typeof text}.`, {
       field: "text",
       value: text
     });
   }
   if (isReply) {
     if (typeof parentCommentId !== "string" || parentCommentId.length === 0) {
-      throw new DocumentApiValidationError("INVALID_TARGET", "parentCommentId must be a non-empty string.", {
+      throw new DocumentApiValidationError("INVALID_INPUT", "parentCommentId must be a non-empty string.", {
         field: "parentCommentId",
         value: parentCommentId
       });
     }
     if (hasTarget) {
-      throw new DocumentApiValidationError("INVALID_TARGET", "Cannot combine parentCommentId with target. Replies do not take a target.", { fields: ["parentCommentId", "target"] });
+      throw new DocumentApiValidationError("INVALID_INPUT", "Cannot combine parentCommentId with target. Replies do not take a target.", { fields: ["parentCommentId", "target"] });
     }
     return;
   }
@@ -13044,13 +13044,13 @@ function validateCreateCommentInput(input) {
 }
 function validatePatchCommentInput(input) {
   if (!isRecord(input)) {
-    throw new DocumentApiValidationError("INVALID_TARGET", "comments.patch input must be a non-null object.");
+    throw new DocumentApiValidationError("INVALID_INPUT", "comments.patch input must be a non-null object.");
   }
   assertNoUnknownFields(input, PATCH_COMMENT_ALLOWED_KEYS, "comments.patch");
   const { commentId, target } = input;
   const hasTarget = target !== undefined;
   if (typeof commentId !== "string") {
-    throw new DocumentApiValidationError("INVALID_TARGET", `commentId must be a string, got ${typeof commentId}.`, {
+    throw new DocumentApiValidationError("INVALID_INPUT", `commentId must be a string, got ${typeof commentId}.`, {
       field: "commentId",
       value: commentId
     });
@@ -13063,13 +13063,25 @@ function validatePatchCommentInput(input) {
   if (providedFields.length > 1) {
     throw new DocumentApiValidationError("INVALID_INPUT", `comments.patch accepts exactly one mutation field per call, got ${providedFields.length}: ${providedFields.join(", ")}.`, { providedFields: [...providedFields] });
   }
-  const { status } = input;
+  const { text, status, isInternal } = input;
+  if (text !== undefined && typeof text !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `text must be a string, got ${typeof text}.`, {
+      field: "text",
+      value: text
+    });
+  }
   if (status !== undefined && status !== "resolved") {
-    throw new DocumentApiValidationError("INVALID_TARGET", `status must be "resolved", got "${String(status)}".`, {
+    throw new DocumentApiValidationError("INVALID_INPUT", `status must be "resolved", got "${String(status)}".`, {
       field: "status",
       value: status
     });
   }
+  if (isInternal !== undefined && typeof isInternal !== "boolean") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `isInternal must be a boolean, got ${typeof isInternal}.`, {
+      field: "isInternal",
+      value: isInternal
+    });
+  }
   if (hasTarget && !isTextAddress(target)) {
     throw new DocumentApiValidationError("INVALID_TARGET", "target must be a text address object.", {
       field: "target",
@@ -13100,13 +13112,29 @@ function executeCommentsPatch(adapter, input, options) {
   }
   throw new DocumentApiValidationError("INTERNAL_ERROR", "comments.patch: no mutation field matched after validation. This is a bug.");
 }
+function validateCommentIdInput(input, operationName) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} input must be a non-null object.`);
+  }
+  if (typeof input.commentId !== "string" || input.commentId.length === 0) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} commentId must be a non-empty string.`, {
+      field: "commentId",
+      value: input.commentId
+    });
+  }
+}
 function executeCommentsDelete(adapter, input, options) {
+  validateCommentIdInput(input, "comments.delete");
   return adapter.remove({ commentId: input.commentId }, options);
 }
 function executeGetComment(adapter, input) {
+  validateCommentIdInput(input, "comments.get");
   return adapter.get(input);
 }
 function executeListComments(adapter, query2) {
+  if (query2 !== undefined && !isRecord(query2)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "comments.list query must be an object if provided.");
+  }
   return adapter.list(query2);
 }
 var CREATE_COMMENT_ALLOWED_KEYS, PATCH_COMMENT_ALLOWED_KEYS;
@@ -13220,18 +13248,45 @@ function executeGet(adapter, input) {
 
 // ../../packages/document-api/src/get-text/get-text.ts
 function executeGetText(adapter, input) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "getText input must be a non-null object.");
+  }
+  validateStoryLocator(input.in, "in");
   return adapter.getText(input);
 }
+var init_get_text = __esm(() => {
+  init_story_validator();
+  init_errors2();
+  init_validation_primitives();
+});
 
 // ../../packages/document-api/src/get-markdown/get-markdown.ts
 function executeGetMarkdown(adapter, input) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "getMarkdown input must be a non-null object.");
+  }
+  validateStoryLocator(input.in, "in");
   return adapter.getMarkdown(input);
 }
+var init_get_markdown = __esm(() => {
+  init_story_validator();
+  init_errors2();
+  init_validation_primitives();
+});
 
 // ../../packages/document-api/src/get-html/get-html.ts
 function executeGetHtml(adapter, input) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "getHtml input must be a non-null object.");
+  }
+  validateStoryLocator(input.in, "in");
   return adapter.getHtml(input);
 }
+var init_get_html = __esm(() => {
+  init_story_validator();
+  init_errors2();
+  init_validation_primitives();
+});
 
 // ../../packages/document-api/src/info/info.ts
 function executeInfo(adapter, input) {
@@ -13955,155 +14010,574 @@ var init_insert = __esm(() => {
   VALID_INSERT_TYPES = new Set(["text", "markdown", "html"]);
 });
 
+// ../../packages/document-api/src/lists/lists.types.ts
+var LIST_KINDS, LIST_INSERT_POSITIONS, JOIN_DIRECTIONS, MUTATION_SCOPES, LEVEL_ALIGNMENTS, TRAILING_CHARACTERS, LIST_PRESET_IDS;
+var init_lists_types = __esm(() => {
+  LIST_KINDS = ["ordered", "bullet"];
+  LIST_INSERT_POSITIONS = ["before", "after"];
+  JOIN_DIRECTIONS = ["withPrevious", "withNext"];
+  MUTATION_SCOPES = ["definition", "instance"];
+  LEVEL_ALIGNMENTS = ["left", "center", "right"];
+  TRAILING_CHARACTERS = ["tab", "space", "nothing"];
+  LIST_PRESET_IDS = [
+    "decimal",
+    "decimalParenthesis",
+    "lowerLetter",
+    "upperLetter",
+    "lowerRoman",
+    "upperRoman",
+    "disc",
+    "circle",
+    "square",
+    "dash"
+  ];
+});
+
 // ../../packages/document-api/src/lists/lists.ts
-function validateListTarget(input, operationName) {
-  if (input.target === undefined) {
-    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} requires a target.`);
+function validateListInput(input, operationName) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} input must be a non-null object.`);
+  }
+}
+function validateListItemAddress(value, field, operationName) {
+  if (value === undefined || value === null) {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} requires a ${field}.`);
+  }
+  if (!isRecord(value)) {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field} must be an object.`, {
+      field,
+      value
+    });
+  }
+  const t = value;
+  if (t.kind !== "block") {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field}.kind must be 'block', got "${String(t.kind)}".`, { field: `${field}.kind`, value: t.kind });
+  }
+  if (t.nodeType !== "listItem") {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field}.nodeType must be 'listItem', got "${String(t.nodeType)}".`, { field: `${field}.nodeType`, value: t.nodeType });
+  }
+  if (typeof t.nodeId !== "string" || t.nodeId === "") {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field}.nodeId must be a non-empty string.`, { field: `${field}.nodeId`, value: t.nodeId });
+  }
+}
+function validateListItemTarget(input, operationName) {
+  validateListItemAddress(input.target, "target", operationName);
+}
+function validateBlockAddress(value, field, operationName) {
+  if (!isRecord(value)) {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field} must be an object.`, {
+      field,
+      value
+    });
+  }
+  const v = value;
+  if (v.kind !== "block") {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field}.kind must be 'block', got "${String(v.kind)}".`, { field: `${field}.kind`, value: v.kind });
+  }
+  if (v.nodeType !== "paragraph") {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field}.nodeType must be 'paragraph', got "${String(v.nodeType)}".`, { field: `${field}.nodeType`, value: v.nodeType });
+  }
+  if (typeof v.nodeId !== "string" || v.nodeId === "") {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field}.nodeId must be a non-empty string.`, { field: `${field}.nodeId`, value: v.nodeId });
+  }
+}
+function validateBlockAddressOrRange(value, field, operationName) {
+  if (!isRecord(value)) {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} ${field} must be an object.`, {
+      field,
+      value
+    });
+  }
+  const v = value;
+  if (v.from !== undefined) {
+    validateBlockAddress(v.from, `${field}.from`, operationName);
+    validateBlockAddress(v.to, `${field}.to`, operationName);
+  } else {
+    validateBlockAddress(value, field, operationName);
+  }
+}
+function requireLevel(value, operationName) {
+  if (!isInteger(value) || value < 0) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} level must be a non-negative integer, got ${JSON.stringify(value)}.`, { field: "level", value });
+  }
+}
+function requireEnum(value, field, validSet, operationName) {
+  if (!validSet.has(value)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be one of: ${[...validSet].join(", ")}. Got ${JSON.stringify(value)}.`, { field, value });
+  }
+}
+function optionalBoolean(value, field, operationName) {
+  if (value !== undefined && typeof value !== "boolean") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be a boolean if provided, got ${typeof value}.`, { field, value });
+  }
+}
+function optionalNumber(value, field, operationName) {
+  if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value))) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be a number if provided, got ${typeof value}.`, { field, value });
+  }
+}
+function optionalInteger(value, field, operationName) {
+  if (value !== undefined && !isInteger(value)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be an integer if provided, got ${JSON.stringify(value)}.`, { field, value });
+  }
+}
+function optionalLevelsArray(value, field, operationName) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be an array if provided.`, {
+      field,
+      value
+    });
+  }
+  for (let i = 0;i < value.length; i++) {
+    if (!isInteger(value[i]) || value[i] < 0) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field}[${i}] must be a non-negative integer.`, { field: `${field}[${i}]`, value: value[i] });
+    }
+  }
+}
+function validateListLevelTemplate(entry, path, operationName) {
+  if (!isRecord(entry)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${path} must be an object.`, {
+      field: path,
+      value: entry
+    });
+  }
+  const e = entry;
+  if (!isInteger(e.level) || e.level < 0) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${path}.level must be a non-negative integer.`, { field: `${path}.level`, value: e.level });
+  }
+  if (e.numFmt !== undefined && typeof e.numFmt !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${path}.numFmt must be a string.`, {
+      field: `${path}.numFmt`,
+      value: e.numFmt
+    });
+  }
+  if (e.lvlText !== undefined && typeof e.lvlText !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${path}.lvlText must be a string.`, {
+      field: `${path}.lvlText`,
+      value: e.lvlText
+    });
+  }
+  optionalInteger(e.start, `${path}.start`, operationName);
+  if (e.alignment !== undefined) {
+    requireEnum(e.alignment, `${path}.alignment`, VALID_LEVEL_ALIGNMENTS, operationName);
+  }
+  if (e.trailingCharacter !== undefined) {
+    requireEnum(e.trailingCharacter, `${path}.trailingCharacter`, VALID_TRAILING_CHARACTERS, operationName);
+  }
+  if (e.markerFont !== undefined && typeof e.markerFont !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${path}.markerFont must be a string.`, {
+      field: `${path}.markerFont`,
+      value: e.markerFont
+    });
+  }
+  optionalInteger(e.pictureBulletId, `${path}.pictureBulletId`, operationName);
+  if (e.tabStopAt !== undefined && e.tabStopAt !== null) {
+    optionalNumber(e.tabStopAt, `${path}.tabStopAt`, operationName);
+  }
+  if (e.indents !== undefined) {
+    if (!isRecord(e.indents)) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${path}.indents must be an object.`, {
+        field: `${path}.indents`,
+        value: e.indents
+      });
+    }
+    const ind = e.indents;
+    optionalNumber(ind.left, `${path}.indents.left`, operationName);
+    optionalNumber(ind.hanging, `${path}.indents.hanging`, operationName);
+    optionalNumber(ind.firstLine, `${path}.indents.firstLine`, operationName);
+  }
+}
+function validateListTemplate(value, field, operationName) {
+  if (!isRecord(value)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be an object.`, {
+      field,
+      value
+    });
+  }
+  const t = value;
+  if (t.version !== 1) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field}.version must be 1, got ${JSON.stringify(t.version)}.`, { field: `${field}.version`, value: t.version });
+  }
+  if (!Array.isArray(t.levels)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field}.levels must be an array.`, {
+      field: `${field}.levels`,
+      value: t.levels
+    });
+  }
+  for (let i = 0;i < t.levels.length; i++) {
+    validateListLevelTemplate(t.levels[i], `${field}.levels[${i}]`, operationName);
+  }
+}
+function validateListsCreateFields(raw) {
+  const op = "lists.create";
+  if (raw.kind !== undefined) {
+    requireEnum(raw.kind, "kind", VALID_LIST_KINDS, op);
+  }
+  if (raw.level !== undefined) {
+    if (!isInteger(raw.level) || raw.level < 0) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `${op} level must be a non-negative integer, got ${JSON.stringify(raw.level)}.`, { field: "level", value: raw.level });
+    }
+  }
+  if (raw.sequence !== undefined) {
+    if (!isRecord(raw.sequence)) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `${op} sequence must be an object.`, {
+        field: "sequence",
+        value: raw.sequence
+      });
+    }
+    const seq = raw.sequence;
+    requireEnum(seq.mode, "sequence.mode", VALID_SEQUENCE_MODES, op);
+    if (seq.mode === "continuePrevious") {
+      if (raw.preset !== undefined) {
+        throw new DocumentApiValidationError("INVALID_INPUT", `${op} preset must not be provided when sequence.mode is 'continuePrevious'.`, { field: "preset" });
+      }
+      if (raw.style !== undefined) {
+        throw new DocumentApiValidationError("INVALID_INPUT", `${op} style must not be provided when sequence.mode is 'continuePrevious'.`, { field: "style" });
+      }
+      if (seq.startAt !== undefined) {
+        throw new DocumentApiValidationError("INVALID_INPUT", `${op} sequence.startAt must not be provided when sequence.mode is 'continuePrevious'.`, { field: "sequence.startAt" });
+      }
+    }
+    if (seq.mode === "new") {
+      optionalInteger(seq.startAt, "sequence.startAt", op);
+    }
+  }
+  if (raw.preset !== undefined) {
+    requireEnum(raw.preset, "preset", VALID_LIST_PRESETS, op);
+  }
+  if (raw.style !== undefined) {
+    validateListTemplate(raw.style, "style", op);
   }
 }
 function executeListsList(adapter, query2) {
+  if (query2 !== undefined) {
+    if (!isRecord(query2)) {
+      throw new DocumentApiValidationError("INVALID_INPUT", "lists.list query must be an object if provided.");
+    }
+    const q = query2;
+    if (q.kind !== undefined) {
+      requireEnum(q.kind, "kind", VALID_LIST_KINDS, "lists.list");
+    }
+    optionalInteger(q.level, "level", "lists.list");
+    optionalInteger(q.limit, "limit", "lists.list");
+    optionalInteger(q.offset, "offset", "lists.list");
+    optionalInteger(q.ordinal, "ordinal", "lists.list");
+    if (q.within !== undefined) {
+      if (!isRecord(q.within)) {
+        throw new DocumentApiValidationError("INVALID_INPUT", "lists.list within must be an object.", {
+          field: "within",
+          value: q.within
+        });
+      }
+      const w = q.within;
+      if (w.kind !== "block") {
+        throw new DocumentApiValidationError("INVALID_INPUT", `lists.list within.kind must be 'block', got "${String(w.kind)}".`, { field: "within.kind", value: w.kind });
+      }
+      if (!VALID_BLOCK_NODE_TYPES.has(w.nodeType)) {
+        throw new DocumentApiValidationError("INVALID_INPUT", `lists.list within.nodeType must be a valid BlockNodeType, got ${JSON.stringify(w.nodeType)}.`, { field: "within.nodeType", value: w.nodeType });
+      }
+      if (typeof w.nodeId !== "string" || w.nodeId === "") {
+        throw new DocumentApiValidationError("INVALID_INPUT", "lists.list within.nodeId must be a non-empty string.", {
+          field: "within.nodeId",
+          value: w.nodeId
+        });
+      }
+    }
+  }
   return adapter.list(query2);
 }
 function executeListsGet(adapter, input) {
+  validateListInput(input, "lists.get");
+  validateListItemAddress(input.address, "address", "lists.get");
   return adapter.get(input);
 }
 function executeListsInsert(adapter, input, options) {
-  validateListTarget(input, "lists.insert");
+  validateListItemTarget(input, "lists.insert");
+  requireEnum(input.position, "position", VALID_INSERT_POSITIONS, "lists.insert");
+  if (input.text !== undefined && typeof input.text !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `lists.insert text must be a string if provided, got ${typeof input.text}.`, {
+      field: "text",
+      value: input.text
+    });
+  }
   return adapter.insert(input, normalizeMutationOptions(options));
 }
 function executeListsIndent(adapter, input, options) {
-  validateListTarget(input, "lists.indent");
+  validateListItemTarget(input, "lists.indent");
   return adapter.indent(input, normalizeMutationOptions(options));
 }
 function executeListsOutdent(adapter, input, options) {
-  validateListTarget(input, "lists.outdent");
+  validateListItemTarget(input, "lists.outdent");
   return adapter.outdent(input, normalizeMutationOptions(options));
 }
 function executeListsCreate(adapter, input, options) {
+  validateListInput(input, "lists.create");
+  const raw = input;
+  if (!VALID_LIST_CREATE_MODES.has(raw.mode)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `lists.create mode must be "empty" or "fromParagraphs", got ${JSON.stringify(raw.mode)}.`, { field: "mode", value: raw.mode });
+  }
+  if (raw.mode === "empty") {
+    validateBlockAddress(raw.at, "at", "lists.create");
+  }
+  if (raw.mode === "fromParagraphs") {
+    if (raw.target === undefined || raw.target === null) {
+      throw new DocumentApiValidationError("INVALID_TARGET", 'lists.create with mode "fromParagraphs" requires a target.', { field: "target" });
+    }
+    validateBlockAddressOrRange(raw.target, "target", "lists.create");
+  }
+  validateListsCreateFields(raw);
   return adapter.create(input, normalizeMutationOptions(options));
 }
 function executeListsAttach(adapter, input, options) {
-  validateListTarget(input, "lists.attach");
+  validateListInput(input, "lists.attach");
+  validateBlockAddressOrRange(input.target, "target", "lists.attach");
+  validateListItemAddress(input.attachTo, "attachTo", "lists.attach");
+  optionalInteger(input.level, "level", "lists.attach");
   return adapter.attach(input, normalizeMutationOptions(options));
 }
 function executeListsDetach(adapter, input, options) {
-  validateListTarget(input, "lists.detach");
+  validateListItemTarget(input, "lists.detach");
   return adapter.detach(input, normalizeMutationOptions(options));
 }
 function executeListsJoin(adapter, input, options) {
-  validateListTarget(input, "lists.join");
+  validateListItemTarget(input, "lists.join");
+  requireEnum(input.direction, "direction", VALID_JOIN_DIRECTIONS, "lists.join");
   return adapter.join(input, normalizeMutationOptions(options));
 }
 function executeListsCanJoin(adapter, input) {
-  validateListTarget(input, "lists.canJoin");
+  validateListItemTarget(input, "lists.canJoin");
+  requireEnum(input.direction, "direction", VALID_JOIN_DIRECTIONS, "lists.canJoin");
   return adapter.canJoin(input);
 }
 function executeListsSeparate(adapter, input, options) {
-  validateListTarget(input, "lists.separate");
+  validateListItemTarget(input, "lists.separate");
+  optionalBoolean(input.copyOverrides, "copyOverrides", "lists.separate");
   return adapter.separate(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevel(adapter, input, options) {
-  validateListTarget(input, "lists.setLevel");
+  validateListItemTarget(input, "lists.setLevel");
+  requireLevel(input.level, "lists.setLevel");
   return adapter.setLevel(input, normalizeMutationOptions(options));
 }
 function executeListsSetValue(adapter, input, options) {
-  validateListTarget(input, "lists.setValue");
+  validateListItemTarget(input, "lists.setValue");
+  if (input.value !== null && !isInteger(input.value)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `lists.setValue value must be an integer or null, got ${JSON.stringify(input.value)}.`, { field: "value", value: input.value });
+  }
   return adapter.setValue(input, normalizeMutationOptions(options));
 }
 function executeListsContinuePrevious(adapter, input, options) {
-  validateListTarget(input, "lists.continuePrevious");
+  validateListItemTarget(input, "lists.continuePrevious");
   return adapter.continuePrevious(input, normalizeMutationOptions(options));
 }
 function executeListsCanContinuePrevious(adapter, input) {
-  validateListTarget(input, "lists.canContinuePrevious");
+  validateListItemTarget(input, "lists.canContinuePrevious");
   return adapter.canContinuePrevious(input);
 }
 function executeListsSetLevelRestart(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelRestart");
+  validateListItemTarget(input, "lists.setLevelRestart");
+  requireLevel(input.level, "lists.setLevelRestart");
+  if (input.restartAfterLevel !== null && !isInteger(input.restartAfterLevel)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `lists.setLevelRestart restartAfterLevel must be an integer or null.`, { field: "restartAfterLevel", value: input.restartAfterLevel });
+  }
+  if (input.scope !== undefined) {
+    requireEnum(input.scope, "scope", VALID_MUTATION_SCOPES, "lists.setLevelRestart");
+  }
   return adapter.setLevelRestart(input, normalizeMutationOptions(options));
 }
 function executeListsConvertToText(adapter, input, options) {
-  validateListTarget(input, "lists.convertToText");
+  validateListItemTarget(input, "lists.convertToText");
+  optionalBoolean(input.includeMarker, "includeMarker", "lists.convertToText");
   return adapter.convertToText(input, normalizeMutationOptions(options));
 }
 function executeListsApplyTemplate(adapter, input, options) {
-  validateListTarget(input, "lists.applyTemplate");
+  validateListItemTarget(input, "lists.applyTemplate");
+  validateListTemplate(input.template, "template", "lists.applyTemplate");
+  optionalLevelsArray(input.levels, "levels", "lists.applyTemplate");
   return adapter.applyTemplate(input, normalizeMutationOptions(options));
 }
 function executeListsApplyPreset(adapter, input, options) {
-  validateListTarget(input, "lists.applyPreset");
+  validateListItemTarget(input, "lists.applyPreset");
+  requireEnum(input.preset, "preset", VALID_LIST_PRESETS, "lists.applyPreset");
+  optionalLevelsArray(input.levels, "levels", "lists.applyPreset");
   return adapter.applyPreset(input, normalizeMutationOptions(options));
 }
 function executeListsCaptureTemplate(adapter, input) {
-  validateListTarget(input, "lists.captureTemplate");
+  validateListItemTarget(input, "lists.captureTemplate");
+  optionalLevelsArray(input.levels, "levels", "lists.captureTemplate");
   return adapter.captureTemplate(input);
 }
 function executeListsSetLevelNumbering(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelNumbering");
+  validateListItemTarget(input, "lists.setLevelNumbering");
+  requireLevel(input.level, "lists.setLevelNumbering");
+  if (typeof input.numFmt !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", "lists.setLevelNumbering numFmt must be a string.", {
+      field: "numFmt",
+      value: input.numFmt
+    });
+  }
+  if (typeof input.lvlText !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", "lists.setLevelNumbering lvlText must be a string.", {
+      field: "lvlText",
+      value: input.lvlText
+    });
+  }
+  optionalInteger(input.start, "start", "lists.setLevelNumbering");
   return adapter.setLevelNumbering(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelBullet(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelBullet");
+  validateListItemTarget(input, "lists.setLevelBullet");
+  requireLevel(input.level, "lists.setLevelBullet");
+  if (typeof input.markerText !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", "lists.setLevelBullet markerText must be a string.", {
+      field: "markerText",
+      value: input.markerText
+    });
+  }
   return adapter.setLevelBullet(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelPictureBullet(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelPictureBullet");
+  validateListItemTarget(input, "lists.setLevelPictureBullet");
+  requireLevel(input.level, "lists.setLevelPictureBullet");
+  if (!isInteger(input.pictureBulletId)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "lists.setLevelPictureBullet pictureBulletId must be an integer.", { field: "pictureBulletId", value: input.pictureBulletId });
+  }
   return adapter.setLevelPictureBullet(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelAlignment(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelAlignment");
+  validateListItemTarget(input, "lists.setLevelAlignment");
+  requireLevel(input.level, "lists.setLevelAlignment");
+  requireEnum(input.alignment, "alignment", VALID_LEVEL_ALIGNMENTS, "lists.setLevelAlignment");
   return adapter.setLevelAlignment(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelIndents(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelIndents");
+  validateListItemTarget(input, "lists.setLevelIndents");
+  requireLevel(input.level, "lists.setLevelIndents");
+  optionalNumber(input.left, "left", "lists.setLevelIndents");
+  optionalNumber(input.hanging, "hanging", "lists.setLevelIndents");
+  optionalNumber(input.firstLine, "firstLine", "lists.setLevelIndents");
   return adapter.setLevelIndents(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelTrailingCharacter(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelTrailingCharacter");
+  validateListItemTarget(input, "lists.setLevelTrailingCharacter");
+  requireLevel(input.level, "lists.setLevelTrailingCharacter");
+  requireEnum(input.trailingCharacter, "trailingCharacter", VALID_TRAILING_CHARACTERS, "lists.setLevelTrailingCharacter");
   return adapter.setLevelTrailingCharacter(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelMarkerFont(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelMarkerFont");
+  validateListItemTarget(input, "lists.setLevelMarkerFont");
+  requireLevel(input.level, "lists.setLevelMarkerFont");
+  if (typeof input.fontFamily !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", "lists.setLevelMarkerFont fontFamily must be a string.", {
+      field: "fontFamily",
+      value: input.fontFamily
+    });
+  }
   return adapter.setLevelMarkerFont(input, normalizeMutationOptions(options));
 }
 function executeListsClearLevelOverrides(adapter, input, options) {
-  validateListTarget(input, "lists.clearLevelOverrides");
+  validateListItemTarget(input, "lists.clearLevelOverrides");
+  requireLevel(input.level, "lists.clearLevelOverrides");
   return adapter.clearLevelOverrides(input, normalizeMutationOptions(options));
 }
 function executeListsSetType(adapter, input, options) {
-  validateListTarget(input, "lists.setType");
+  validateListItemTarget(input, "lists.setType");
+  requireEnum(input.kind, "kind", VALID_LIST_KINDS, "lists.setType");
+  if (input.continuity !== undefined) {
+    requireEnum(input.continuity, "continuity", VALID_CONTINUITY_VALUES, "lists.setType");
+  }
   return adapter.setType(input, normalizeMutationOptions(options));
 }
 function executeListsGetStyle(adapter, input) {
-  validateListTarget(input, "lists.getStyle");
+  validateListItemTarget(input, "lists.getStyle");
+  optionalLevelsArray(input.levels, "levels", "lists.getStyle");
   return adapter.getStyle(input);
 }
 function executeListsApplyStyle(adapter, input, options) {
-  validateListTarget(input, "lists.applyStyle");
+  validateListItemTarget(input, "lists.applyStyle");
+  validateListTemplate(input.style, "style", "lists.applyStyle");
+  optionalLevelsArray(input.levels, "levels", "lists.applyStyle");
   return adapter.applyStyle(input, normalizeMutationOptions(options));
 }
 function executeListsRestartAt(adapter, input, options) {
-  validateListTarget(input, "lists.restartAt");
+  validateListItemTarget(input, "lists.restartAt");
+  if (!isInteger(input.startAt)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `lists.restartAt startAt must be an integer, got ${JSON.stringify(input.startAt)}.`, { field: "startAt", value: input.startAt });
+  }
   return adapter.restartAt(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelNumberStyle(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelNumberStyle");
+  validateListItemTarget(input, "lists.setLevelNumberStyle");
+  requireLevel(input.level, "lists.setLevelNumberStyle");
+  if (typeof input.numberStyle !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", "lists.setLevelNumberStyle numberStyle must be a string.", {
+      field: "numberStyle",
+      value: input.numberStyle
+    });
+  }
   return adapter.setLevelNumberStyle(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelText(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelText");
+  validateListItemTarget(input, "lists.setLevelText");
+  requireLevel(input.level, "lists.setLevelText");
+  if (typeof input.text !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", "lists.setLevelText text must be a string.", {
+      field: "text",
+      value: input.text
+    });
+  }
   return adapter.setLevelText(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelStart(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelStart");
+  validateListItemTarget(input, "lists.setLevelStart");
+  requireLevel(input.level, "lists.setLevelStart");
+  if (!isInteger(input.startAt)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `lists.setLevelStart startAt must be an integer, got ${JSON.stringify(input.startAt)}.`, { field: "startAt", value: input.startAt });
+  }
   return adapter.setLevelStart(input, normalizeMutationOptions(options));
 }
 function executeListsSetLevelLayout(adapter, input, options) {
-  validateListTarget(input, "lists.setLevelLayout");
+  validateListItemTarget(input, "lists.setLevelLayout");
+  requireLevel(input.level, "lists.setLevelLayout");
+  if (!isRecord(input.layout)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "lists.setLevelLayout layout must be an object.", {
+      field: "layout",
+      value: input.layout
+    });
+  }
+  const layout = input.layout;
+  if (layout.alignment !== undefined) {
+    requireEnum(layout.alignment, "layout.alignment", VALID_LEVEL_ALIGNMENTS, "lists.setLevelLayout");
+  }
+  if (layout.followCharacter !== undefined) {
+    requireEnum(layout.followCharacter, "layout.followCharacter", VALID_TRAILING_CHARACTERS, "lists.setLevelLayout");
+  }
+  optionalNumber(layout.alignedAt, "layout.alignedAt", "lists.setLevelLayout");
+  optionalNumber(layout.textIndentAt, "layout.textIndentAt", "lists.setLevelLayout");
+  if (layout.tabStopAt !== undefined && layout.tabStopAt !== null) {
+    optionalNumber(layout.tabStopAt, "layout.tabStopAt", "lists.setLevelLayout");
+  }
   return adapter.setLevelLayout(input, normalizeMutationOptions(options));
 }
+var VALID_BLOCK_NODE_TYPES, VALID_LIST_KINDS, VALID_INSERT_POSITIONS, VALID_JOIN_DIRECTIONS, VALID_MUTATION_SCOPES, VALID_LEVEL_ALIGNMENTS, VALID_TRAILING_CHARACTERS, VALID_LIST_PRESETS, VALID_CONTINUITY_VALUES, VALID_SEQUENCE_MODES, VALID_LIST_CREATE_MODES;
 var init_lists = __esm(() => {
   init_errors2();
+  init_validation_primitives();
+  init_base();
+  init_lists_types();
+  VALID_BLOCK_NODE_TYPES = new Set(BLOCK_NODE_TYPES);
+  VALID_LIST_KINDS = new Set(LIST_KINDS);
+  VALID_INSERT_POSITIONS = new Set(LIST_INSERT_POSITIONS);
+  VALID_JOIN_DIRECTIONS = new Set(JOIN_DIRECTIONS);
+  VALID_MUTATION_SCOPES = new Set(MUTATION_SCOPES);
+  VALID_LEVEL_ALIGNMENTS = new Set(LEVEL_ALIGNMENTS);
+  VALID_TRAILING_CHARACTERS = new Set(TRAILING_CHARACTERS);
+  VALID_LIST_PRESETS = new Set(LIST_PRESET_IDS);
+  VALID_CONTINUITY_VALUES = new Set(["preserve", "none"]);
+  VALID_SEQUENCE_MODES = new Set(["new", "continuePrevious"]);
+  VALID_LIST_CREATE_MODES = new Set(["empty", "fromParagraphs"]);
 });
 
 // ../../packages/document-api/src/replace/replace.ts
@@ -14281,16 +14755,36 @@ function validateCreateSectionBreakInput(input) {
   }
 }
 function executeCreateParagraph(adapter, input, options) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "create.paragraph input must be a non-null object.");
+  }
+  validateStoryLocator(input.in, "in");
   const at = normalizeCreateLocation(input.at, (loc) => validateTargetOnlyCreateLocation(loc, "create.paragraph"));
   const normalized = { at, text: input.text ?? "" };
   return adapter.paragraph(normalized, normalizeMutationOptions(options));
 }
 function executeCreateHeading(adapter, input, options) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "create.heading input must be a non-null object.");
+  }
+  validateStoryLocator(input.in, "in");
+  if (!isInteger(input.level) || !VALID_HEADING_LEVELS.has(input.level)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `create.heading level must be an integer 1–6, got ${JSON.stringify(input.level)}.`, { field: "level", value: input.level });
+  }
   const at = normalizeCreateLocation(input.at, (loc) => validateTargetOnlyCreateLocation(loc, "create.heading"));
   const normalized = { level: input.level, at, text: input.text ?? "" };
   return adapter.heading(normalized, normalizeMutationOptions(options));
 }
 function executeCreateTable(adapter, input, options) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "create.table input must be a non-null object.");
+  }
+  if (!isInteger(input.rows) || input.rows < 1) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `create.table rows must be a positive integer, got ${JSON.stringify(input.rows)}.`, { field: "rows", value: input.rows });
+  }
+  if (!isInteger(input.columns) || input.columns < 1) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `create.table columns must be a positive integer, got ${JSON.stringify(input.columns)}.`, { field: "columns", value: input.columns });
+  }
   const at = normalizeCreateLocation(input.at, (loc) => validateTargetOrNodeIdCreateLocation(loc, "create.table"));
   const normalized = { rows: input.rows, columns: input.columns, at };
   return adapter.table(normalized, normalizeMutationOptions(options));
@@ -14316,9 +14810,12 @@ function executeCreateTableOfContents(adapter, input, options) {
   const normalized = { at, config: input.config };
   return adapter.tableOfContents(normalized, normalizeMutationOptions(options));
 }
-var SECTION_BREAK_TYPES;
+var VALID_HEADING_LEVELS, SECTION_BREAK_TYPES;
 var init_create = __esm(() => {
   init_errors2();
+  init_validation_primitives();
+  init_story_validator();
+  VALID_HEADING_LEVELS = new Set([1, 2, 3, 4, 5, 6]);
   SECTION_BREAK_TYPES = ["continuous", "nextPage", "evenPage", "oddPage"];
 });
 
@@ -14343,7 +14840,7 @@ function validateBlocksListInput(input) {
       });
     }
     for (const nt of input.nodeTypes) {
-      if (!VALID_BLOCK_NODE_TYPES.has(nt)) {
+      if (!VALID_BLOCK_NODE_TYPES2.has(nt)) {
         throw new DocumentApiValidationError("INVALID_INPUT", `blocks.list nodeTypes contains unknown type "${nt}".`, {
           fields: ["nodeTypes"],
           nodeType: nt
@@ -14428,13 +14925,13 @@ function executeBlocksDeleteRange(adapter, input, options) {
   validateBlocksDeleteRangeInput(input);
   return adapter.deleteRange(input, normalizeMutationOptions(options));
 }
-var SUPPORTED_DELETE_NODE_TYPES, REJECTED_DELETE_NODE_TYPES, VALID_BLOCK_NODE_TYPES;
+var SUPPORTED_DELETE_NODE_TYPES, REJECTED_DELETE_NODE_TYPES, VALID_BLOCK_NODE_TYPES2;
 var init_blocks = __esm(() => {
   init_base();
   init_errors2();
   SUPPORTED_DELETE_NODE_TYPES = new Set(DELETABLE_BLOCK_NODE_TYPES);
   REJECTED_DELETE_NODE_TYPES = new Set(["tableRow", "tableCell"]);
-  VALID_BLOCK_NODE_TYPES = new Set(BLOCK_NODE_TYPES);
+  VALID_BLOCK_NODE_TYPES2 = new Set(BLOCK_NODE_TYPES);
 });
 
 // ../../packages/document-api/src/track-changes/track-changes.ts
@@ -14442,6 +14939,19 @@ function executeTrackChangesList(adapter, input) {
   return adapter.list(input);
 }
 function executeTrackChangesGet(adapter, input) {
+  const raw = input;
+  if (typeof raw !== "object" || raw == null) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "trackChanges.get input must be a non-null object.", {
+      value: raw
+    });
+  }
+  const { id } = raw;
+  if (typeof id !== "string" || id.length === 0) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "trackChanges.get id must be a non-empty string.", {
+      field: "id",
+      value: id
+    });
+  }
   return adapter.get(input);
 }
 function executeTrackChangesDecide(adapter, rawInput, options) {
@@ -15838,11 +16348,13 @@ function executeImagesRemoveCaption(adapter, input, options) {
 }
 function executeCreateImage(adapter, input, options) {
   requireString(input?.src, "src");
+  validateStoryLocator(input?.in, "in");
   return adapter.image(input, options);
 }
 var VALID_WRAP_TYPES, VALID_WRAP_SIDES, VALID_IMAGE_SIZE_UNITS;
 var init_images = __esm(() => {
   init_errors2();
+  init_story_validator();
   VALID_WRAP_TYPES = new Set(["Inline", "None", "Square", "Tight", "Through", "TopAndBottom"]);
   VALID_WRAP_SIDES = new Set(["bothSides", "left", "right", "largest"]);
   VALID_IMAGE_SIZE_UNITS = new Set(["px", "pt", "twip"]);
@@ -15882,26 +16394,39 @@ function validateInsertionTarget(target, operationName) {
     throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} target.anchor must have nodeType 'paragraph' and a string nodeId.`, { target });
   }
 }
+function validateTocInput(input, operationName) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} input must be a non-null object.`);
+  }
+}
 function executeTocList(adapter, query2) {
   return adapter.list(query2);
 }
 function executeTocGet(adapter, input) {
+  validateTocInput(input, "toc.get");
   validateTocTarget(input.target, "toc.get");
   return adapter.get(input);
 }
 function executeTocConfigure(adapter, input, options) {
+  validateTocInput(input, "toc.configure");
   validateTocTarget(input.target, "toc.configure");
   return adapter.configure(input, normalizeMutationOptions(options));
 }
 function executeTocUpdate(adapter, input, options) {
+  validateTocInput(input, "toc.update");
   validateTocTarget(input.target, "toc.update");
+  if (input.mode !== undefined && !VALID_TOC_UPDATE_MODES.has(input.mode)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `toc.update mode must be "all" or "pageNumbers", got "${String(input.mode)}".`, { field: "mode", value: input.mode });
+  }
   return adapter.update(input, normalizeMutationOptions(options));
 }
 function executeTocRemove(adapter, input, options) {
+  validateTocInput(input, "toc.remove");
   validateTocTarget(input.target, "toc.remove");
   return adapter.remove(input, normalizeMutationOptions(options));
 }
 function executeTocMarkEntry(adapter, input, options) {
+  validateTocInput(input, "toc.markEntry");
   validateInsertionTarget(input.target, "toc.markEntry");
   if (!input.text || typeof input.text !== "string") {
     throw new DocumentApiValidationError("INVALID_INPUT", "toc.markEntry requires a non-empty text string.");
@@ -15909,6 +16434,7 @@ function executeTocMarkEntry(adapter, input, options) {
   return adapter.markEntry(input, normalizeMutationOptions(options));
 }
 function executeTocUnmarkEntry(adapter, input, options) {
+  validateTocInput(input, "toc.unmarkEntry");
   validateTocEntryTarget(input.target, "toc.unmarkEntry");
   return adapter.unmarkEntry(input, normalizeMutationOptions(options));
 }
@@ -15916,15 +16442,63 @@ function executeTocListEntries(adapter, query2) {
   return adapter.listEntries(query2);
 }
 function executeTocGetEntry(adapter, input) {
+  validateTocInput(input, "toc.getEntry");
   validateTocEntryTarget(input.target, "toc.getEntry");
   return adapter.getEntry(input);
 }
+function validateTocEditEntryPatch(patch, operationName) {
+  if (!isRecord(patch)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} patch must be a non-null object.`, {
+      field: "patch",
+      value: patch
+    });
+  }
+  for (const key of Object.keys(patch)) {
+    if (!EDIT_ENTRY_PATCH_ALLOWED_KEYS.has(key)) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `Unknown field "${key}" on ${operationName} patch. Allowed fields: ${[...EDIT_ENTRY_PATCH_ALLOWED_KEYS].join(", ")}.`, { field: `patch.${key}` });
+    }
+  }
+  if (patch.text !== undefined && typeof patch.text !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} patch.text must be a string.`, {
+      field: "patch.text",
+      value: patch.text
+    });
+  }
+  if (patch.level !== undefined) {
+    if (typeof patch.level !== "number" || !Number.isInteger(patch.level) || patch.level < 1) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} patch.level must be a positive integer.`, { field: "patch.level", value: patch.level });
+    }
+  }
+  if (patch.tableIdentifier !== undefined && typeof patch.tableIdentifier !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} patch.tableIdentifier must be a string.`, {
+      field: "patch.tableIdentifier",
+      value: patch.tableIdentifier
+    });
+  }
+  if (patch.omitPageNumber !== undefined && typeof patch.omitPageNumber !== "boolean") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} patch.omitPageNumber must be a boolean.`, {
+      field: "patch.omitPageNumber",
+      value: patch.omitPageNumber
+    });
+  }
+}
 function executeTocEditEntry(adapter, input, options) {
+  validateTocInput(input, "toc.editEntry");
   validateTocEntryTarget(input.target, "toc.editEntry");
+  validateTocEditEntryPatch(input.patch, "toc.editEntry");
   return adapter.editEntry(input, normalizeMutationOptions(options));
 }
+var VALID_TOC_UPDATE_MODES, EDIT_ENTRY_PATCH_ALLOWED_KEYS;
 var init_toc = __esm(() => {
   init_errors2();
+  init_validation_primitives();
+  VALID_TOC_UPDATE_MODES = new Set(["all", "pageNumbers"]);
+  EDIT_ENTRY_PATCH_ALLOWED_KEYS = new Set([
+    "text",
+    "level",
+    "tableIdentifier",
+    "omitPageNumber"
+  ]);
 });
 
 // ../../packages/document-api/src/hyperlinks/hyperlinks.ts
@@ -16037,172 +16611,480 @@ var init_hyperlinks = __esm(() => {
   PATCH_FIELDS = new Set(["href", "anchor", "docLocation", "tooltip", "target", "rel"]);
 });
 
+// ../../packages/document-api/src/content-controls/content-controls.types.ts
+var CONTENT_CONTROL_TYPES, LOCK_MODES, CONTENT_CONTROL_APPEARANCES;
+var init_content_controls_types = __esm(() => {
+  CONTENT_CONTROL_TYPES = [
+    "text",
+    "date",
+    "checkbox",
+    "comboBox",
+    "dropDownList",
+    "repeatingSection",
+    "repeatingSectionItem",
+    "group",
+    "unknown"
+  ];
+  LOCK_MODES = [
+    "unlocked",
+    "sdtLocked",
+    "contentLocked",
+    "sdtContentLocked"
+  ];
+  CONTENT_CONTROL_APPEARANCES = [
+    "boundingBox",
+    "tags",
+    "hidden"
+  ];
+});
+
 // ../../packages/document-api/src/content-controls/content-controls.ts
+function validateCCInput(input, operationName) {
+  if (!isRecord(input)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} input must be a non-null object.`);
+  }
+}
+function validateCCTarget(target, operationName) {
+  if (!isRecord(target)) {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} requires a valid target with { kind, nodeType: 'sdt', nodeId }.`, { field: "target", value: target });
+  }
+  if (!VALID_NODE_KINDS.has(target.kind)) {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} target.kind must be 'block' or 'inline', got "${String(target.kind)}".`, { field: "target.kind", value: target.kind });
+  }
+  if (target.nodeType !== "sdt") {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} target.nodeType must be 'sdt', got "${String(target.nodeType)}".`, { field: "target.nodeType", value: target.nodeType });
+  }
+  if (typeof target.nodeId !== "string" || target.nodeId === "") {
+    throw new DocumentApiValidationError("INVALID_TARGET", `${operationName} target.nodeId must be a non-empty string.`, { field: "target.nodeId", value: target.nodeId });
+  }
+}
+function requireString2(value, field, operationName) {
+  if (typeof value !== "string" || value.length === 0) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be a non-empty string.`, {
+      field,
+      value
+    });
+  }
+}
+function requireBoolean(value, field, operationName) {
+  if (typeof value !== "boolean") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be a boolean, got ${typeof value}.`, { field, value });
+  }
+}
+function requireIndex(value, field, operationName) {
+  if (!isInteger(value) || value < 0) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be a non-negative integer.`, {
+      field,
+      value
+    });
+  }
+}
+function requireNodeKind(value, field, operationName) {
+  if (!VALID_NODE_KINDS.has(value)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be 'block' or 'inline', got "${String(value)}".`, { field, value });
+  }
+}
+function validateContentFormat(value, field, operationName) {
+  if (value !== undefined && !VALID_CONTENT_FORMATS.has(value)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be 'text' or 'html', got "${String(value)}".`, { field, value });
+  }
+}
+function validateContentPayload(input, operationName) {
+  if (typeof input.content !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} content must be a string.`, {
+      field: "content",
+      value: input.content
+    });
+  }
+  validateContentFormat(input.format, "format", operationName);
+}
+function validateSymbol(value, field, operationName) {
+  if (!isRecord(value) || typeof value.font !== "string" || typeof value.char !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `${operationName} ${field} must be { font: string, char: string }.`, { field, value });
+  }
+}
 function executeContentControlsList(adapter, query2) {
+  if (query2 !== undefined && !isRecord(query2)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "contentControls.list query must be an object if provided.");
+  }
   return adapter.list(query2);
 }
 function executeContentControlsGet(adapter, input) {
+  validateCCInput(input, "contentControls.get");
+  validateCCTarget(input.target, "contentControls.get");
   return adapter.get(input);
 }
 function executeContentControlsListInRange(adapter, input) {
+  validateCCInput(input, "contentControls.listInRange");
+  requireString2(input.startBlockId, "startBlockId", "contentControls.listInRange");
+  requireString2(input.endBlockId, "endBlockId", "contentControls.listInRange");
   return adapter.listInRange(input);
 }
 function executeContentControlsSelectByTag(adapter, input) {
+  validateCCInput(input, "contentControls.selectByTag");
+  requireString2(input.tag, "tag", "contentControls.selectByTag");
   return adapter.selectByTag(input);
 }
 function executeContentControlsSelectByTitle(adapter, input) {
+  validateCCInput(input, "contentControls.selectByTitle");
+  requireString2(input.title, "title", "contentControls.selectByTitle");
   return adapter.selectByTitle(input);
 }
 function executeContentControlsListChildren(adapter, input) {
+  validateCCInput(input, "contentControls.listChildren");
+  validateCCTarget(input.target, "contentControls.listChildren");
   return adapter.listChildren(input);
 }
 function executeContentControlsGetParent(adapter, input) {
+  validateCCInput(input, "contentControls.getParent");
+  validateCCTarget(input.target, "contentControls.getParent");
   return adapter.getParent(input);
 }
 function executeContentControlsWrap(adapter, input, options) {
+  validateCCInput(input, "contentControls.wrap");
+  requireNodeKind(input.kind, "kind", "contentControls.wrap");
+  validateCCTarget(input.target, "contentControls.wrap");
   return adapter.wrap(input, options);
 }
 function executeContentControlsUnwrap(adapter, input, options) {
+  validateCCInput(input, "contentControls.unwrap");
+  validateCCTarget(input.target, "contentControls.unwrap");
   return adapter.unwrap(input, options);
 }
 function executeContentControlsDelete(adapter, input, options) {
+  validateCCInput(input, "contentControls.delete");
+  validateCCTarget(input.target, "contentControls.delete");
   return adapter.delete(input, options);
 }
 function executeContentControlsCopy(adapter, input, options) {
+  validateCCInput(input, "contentControls.copy");
+  validateCCTarget(input.target, "contentControls.copy");
+  validateCCTarget(input.destination, "contentControls.copy (destination)");
   return adapter.copy(input, options);
 }
 function executeContentControlsMove(adapter, input, options) {
+  validateCCInput(input, "contentControls.move");
+  validateCCTarget(input.target, "contentControls.move");
+  validateCCTarget(input.destination, "contentControls.move (destination)");
   return adapter.move(input, options);
 }
 function executeContentControlsPatch(adapter, input, options) {
+  validateCCInput(input, "contentControls.patch");
+  validateCCTarget(input.target, "contentControls.patch");
+  if (input.appearance !== undefined && input.appearance !== null && !VALID_CC_APPEARANCES.has(input.appearance)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.patch appearance must be one of: ${[...VALID_CC_APPEARANCES].join(", ")}.`, { field: "appearance", value: input.appearance });
+  }
+  if (input.showingPlaceholder !== undefined && typeof input.showingPlaceholder !== "boolean") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.patch showingPlaceholder must be a boolean, got ${typeof input.showingPlaceholder}.`, { field: "showingPlaceholder", value: input.showingPlaceholder });
+  }
+  if (input.temporary !== undefined && typeof input.temporary !== "boolean") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.patch temporary must be a boolean, got ${typeof input.temporary}.`, { field: "temporary", value: input.temporary });
+  }
+  if (input.tabIndex !== undefined && input.tabIndex !== null && !isInteger(input.tabIndex)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.patch tabIndex must be an integer or null, got ${typeof input.tabIndex}.`, { field: "tabIndex", value: input.tabIndex });
+  }
   return adapter.patch(input, options);
 }
 function executeContentControlsSetLockMode(adapter, input, options) {
+  validateCCInput(input, "contentControls.setLockMode");
+  validateCCTarget(input.target, "contentControls.setLockMode");
+  if (!VALID_LOCK_MODES.has(input.lockMode)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.setLockMode lockMode must be one of: ${[...VALID_LOCK_MODES].join(", ")}.`, { field: "lockMode", value: input.lockMode });
+  }
   return adapter.setLockMode(input, options);
 }
 function executeContentControlsSetType(adapter, input, options) {
+  validateCCInput(input, "contentControls.setType");
+  validateCCTarget(input.target, "contentControls.setType");
+  if (!VALID_CC_TYPES.has(input.controlType)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.setType controlType must be one of: ${[...VALID_CC_TYPES].join(", ")}.`, { field: "controlType", value: input.controlType });
+  }
   return adapter.setType(input, options);
 }
 function executeContentControlsGetContent(adapter, input) {
+  validateCCInput(input, "contentControls.getContent");
+  validateCCTarget(input.target, "contentControls.getContent");
   return adapter.getContent(input);
 }
 function executeContentControlsReplaceContent(adapter, input, options) {
+  validateCCInput(input, "contentControls.replaceContent");
+  validateCCTarget(input.target, "contentControls.replaceContent");
+  validateContentPayload(input, "contentControls.replaceContent");
   return adapter.replaceContent(input, options);
 }
 function executeContentControlsClearContent(adapter, input, options) {
+  validateCCInput(input, "contentControls.clearContent");
+  validateCCTarget(input.target, "contentControls.clearContent");
   return adapter.clearContent(input, options);
 }
 function executeContentControlsAppendContent(adapter, input, options) {
+  validateCCInput(input, "contentControls.appendContent");
+  validateCCTarget(input.target, "contentControls.appendContent");
+  validateContentPayload(input, "contentControls.appendContent");
   return adapter.appendContent(input, options);
 }
 function executeContentControlsPrependContent(adapter, input, options) {
+  validateCCInput(input, "contentControls.prependContent");
+  validateCCTarget(input.target, "contentControls.prependContent");
+  validateContentPayload(input, "contentControls.prependContent");
   return adapter.prependContent(input, options);
 }
 function executeContentControlsInsertBefore(adapter, input, options) {
+  validateCCInput(input, "contentControls.insertBefore");
+  validateCCTarget(input.target, "contentControls.insertBefore");
+  validateContentPayload(input, "contentControls.insertBefore");
   return adapter.insertBefore(input, options);
 }
 function executeContentControlsInsertAfter(adapter, input, options) {
+  validateCCInput(input, "contentControls.insertAfter");
+  validateCCTarget(input.target, "contentControls.insertAfter");
+  validateContentPayload(input, "contentControls.insertAfter");
   return adapter.insertAfter(input, options);
 }
 function executeContentControlsGetBinding(adapter, input) {
+  validateCCInput(input, "contentControls.getBinding");
+  validateCCTarget(input.target, "contentControls.getBinding");
   return adapter.getBinding(input);
 }
 function executeContentControlsSetBinding(adapter, input, options) {
+  validateCCInput(input, "contentControls.setBinding");
+  validateCCTarget(input.target, "contentControls.setBinding");
+  requireString2(input.storeItemId, "storeItemId", "contentControls.setBinding");
+  requireString2(input.xpath, "xpath", "contentControls.setBinding");
   return adapter.setBinding(input, options);
 }
 function executeContentControlsClearBinding(adapter, input, options) {
+  validateCCInput(input, "contentControls.clearBinding");
+  validateCCTarget(input.target, "contentControls.clearBinding");
   return adapter.clearBinding(input, options);
 }
 function executeContentControlsGetRawProperties(adapter, input) {
+  validateCCInput(input, "contentControls.getRawProperties");
+  validateCCTarget(input.target, "contentControls.getRawProperties");
   return adapter.getRawProperties(input);
 }
 function executeContentControlsPatchRawProperties(adapter, input, options) {
+  validateCCInput(input, "contentControls.patchRawProperties");
+  validateCCTarget(input.target, "contentControls.patchRawProperties");
+  if (!Array.isArray(input.patches)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "contentControls.patchRawProperties patches must be an array.", { field: "patches", value: input.patches });
+  }
+  for (let i = 0;i < input.patches.length; i++) {
+    const patch = input.patches[i];
+    if (!isRecord(patch)) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.patchRawProperties patches[${i}] must be an object.`, { field: `patches[${i}]`, value: patch });
+    }
+    if (!VALID_RAW_PATCH_OPS.has(patch.op)) {
+      throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.patchRawProperties patches[${i}].op must be one of: ${[...VALID_RAW_PATCH_OPS].join(", ")}.`, { field: `patches[${i}].op`, value: patch.op });
+    }
+    if (typeof patch.name !== "string" || patch.name === "") {
+      throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.patchRawProperties patches[${i}].name must be a non-empty string.`, { field: `patches[${i}].name`, value: patch.name });
+    }
+  }
   return adapter.patchRawProperties(input, options);
 }
 function executeContentControlsValidateWordCompatibility(adapter, input) {
+  validateCCInput(input, "contentControls.validateWordCompatibility");
+  validateCCTarget(input.target, "contentControls.validateWordCompatibility");
   return adapter.validateWordCompatibility(input);
 }
 function executeContentControlsNormalizeWordCompatibility(adapter, input, options) {
+  validateCCInput(input, "contentControls.normalizeWordCompatibility");
+  validateCCTarget(input.target, "contentControls.normalizeWordCompatibility");
   return adapter.normalizeWordCompatibility(input, options);
 }
 function executeContentControlsNormalizeTagPayload(adapter, input, options) {
+  validateCCInput(input, "contentControls.normalizeTagPayload");
+  validateCCTarget(input.target, "contentControls.normalizeTagPayload");
   return adapter.normalizeTagPayload(input, options);
 }
 function executeContentControlsTextSetMultiline(adapter, input, options) {
+  validateCCInput(input, "contentControls.text.setMultiline");
+  validateCCTarget(input.target, "contentControls.text.setMultiline");
+  requireBoolean(input.multiline, "multiline", "contentControls.text.setMultiline");
   return adapter.text.setMultiline(input, options);
 }
 function executeContentControlsTextSetValue(adapter, input, options) {
+  validateCCInput(input, "contentControls.text.setValue");
+  validateCCTarget(input.target, "contentControls.text.setValue");
+  if (typeof input.value !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.text.setValue value must be a string.`, {
+      field: "value",
+      value: input.value
+    });
+  }
   return adapter.text.setValue(input, options);
 }
 function executeContentControlsTextClearValue(adapter, input, options) {
+  validateCCInput(input, "contentControls.text.clearValue");
+  validateCCTarget(input.target, "contentControls.text.clearValue");
   return adapter.text.clearValue(input, options);
 }
 function executeContentControlsDateSetValue(adapter, input, options) {
+  validateCCInput(input, "contentControls.date.setValue");
+  validateCCTarget(input.target, "contentControls.date.setValue");
+  if (typeof input.value !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.date.setValue value must be a string.`, {
+      field: "value",
+      value: input.value
+    });
+  }
   return adapter.date.setValue(input, options);
 }
 function executeContentControlsDateClearValue(adapter, input, options) {
+  validateCCInput(input, "contentControls.date.clearValue");
+  validateCCTarget(input.target, "contentControls.date.clearValue");
   return adapter.date.clearValue(input, options);
 }
 function executeContentControlsDateSetDisplayFormat(adapter, input, options) {
+  validateCCInput(input, "contentControls.date.setDisplayFormat");
+  validateCCTarget(input.target, "contentControls.date.setDisplayFormat");
+  requireString2(input.format, "format", "contentControls.date.setDisplayFormat");
   return adapter.date.setDisplayFormat(input, options);
 }
 function executeContentControlsDateSetDisplayLocale(adapter, input, options) {
+  validateCCInput(input, "contentControls.date.setDisplayLocale");
+  validateCCTarget(input.target, "contentControls.date.setDisplayLocale");
+  requireString2(input.locale, "locale", "contentControls.date.setDisplayLocale");
   return adapter.date.setDisplayLocale(input, options);
 }
 function executeContentControlsDateSetStorageFormat(adapter, input, options) {
+  validateCCInput(input, "contentControls.date.setStorageFormat");
+  validateCCTarget(input.target, "contentControls.date.setStorageFormat");
+  requireString2(input.format, "format", "contentControls.date.setStorageFormat");
   return adapter.date.setStorageFormat(input, options);
 }
 function executeContentControlsDateSetCalendar(adapter, input, options) {
+  validateCCInput(input, "contentControls.date.setCalendar");
+  validateCCTarget(input.target, "contentControls.date.setCalendar");
+  requireString2(input.calendar, "calendar", "contentControls.date.setCalendar");
   return adapter.date.setCalendar(input, options);
 }
 function executeContentControlsCheckboxGetState(adapter, input) {
+  validateCCInput(input, "contentControls.checkbox.getState");
+  validateCCTarget(input.target, "contentControls.checkbox.getState");
   return adapter.checkbox.getState(input);
 }
 function executeContentControlsCheckboxSetState(adapter, input, options) {
+  validateCCInput(input, "contentControls.checkbox.setState");
+  validateCCTarget(input.target, "contentControls.checkbox.setState");
+  requireBoolean(input.checked, "checked", "contentControls.checkbox.setState");
   return adapter.checkbox.setState(input, options);
 }
 function executeContentControlsCheckboxToggle(adapter, input, options) {
+  validateCCInput(input, "contentControls.checkbox.toggle");
+  validateCCTarget(input.target, "contentControls.checkbox.toggle");
   return adapter.checkbox.toggle(input, options);
 }
 function executeContentControlsCheckboxSetSymbolPair(adapter, input, options) {
+  validateCCInput(input, "contentControls.checkbox.setSymbolPair");
+  validateCCTarget(input.target, "contentControls.checkbox.setSymbolPair");
+  validateSymbol(input.checkedSymbol, "checkedSymbol", "contentControls.checkbox.setSymbolPair");
+  validateSymbol(input.uncheckedSymbol, "uncheckedSymbol", "contentControls.checkbox.setSymbolPair");
   return adapter.checkbox.setSymbolPair(input, options);
 }
 function executeContentControlsChoiceListGetItems(adapter, input) {
+  validateCCInput(input, "contentControls.choiceList.getItems");
+  validateCCTarget(input.target, "contentControls.choiceList.getItems");
   return adapter.choiceList.getItems(input);
 }
 function executeContentControlsChoiceListSetItems(adapter, input, options) {
+  validateCCInput(input, "contentControls.choiceList.setItems");
+  validateCCTarget(input.target, "contentControls.choiceList.setItems");
+  if (!Array.isArray(input.items)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", "contentControls.choiceList.setItems items must be an array.", { field: "items", value: input.items });
+  }
+  for (let i = 0;i < input.items.length; i++) {
+    const item = input.items[i];
+    if (!isRecord(item) || typeof item.displayText !== "string" || typeof item.value !== "string") {
+      throw new DocumentApiValidationError("INVALID_INPUT", `contentControls.choiceList.setItems items[${i}] must be { displayText: string, value: string }.`, { field: `items[${i}]`, value: item });
+    }
+  }
   return adapter.choiceList.setItems(input, options);
 }
 function executeContentControlsChoiceListSetSelected(adapter, input, options) {
+  validateCCInput(input, "contentControls.choiceList.setSelected");
+  validateCCTarget(input.target, "contentControls.choiceList.setSelected");
+  if (typeof input.value !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", "contentControls.choiceList.setSelected value must be a string.", { field: "value", value: input.value });
+  }
   return adapter.choiceList.setSelected(input, options);
 }
 function executeContentControlsRepeatingSectionListItems(adapter, input) {
+  validateCCInput(input, "contentControls.repeatingSection.listItems");
+  validateCCTarget(input.target, "contentControls.repeatingSection.listItems");
   return adapter.repeatingSection.listItems(input);
 }
 function executeContentControlsRepeatingSectionInsertItemBefore(adapter, input, options) {
+  validateCCInput(input, "contentControls.repeatingSection.insertItemBefore");
+  validateCCTarget(input.target, "contentControls.repeatingSection.insertItemBefore");
+  requireIndex(input.index, "index", "contentControls.repeatingSection.insertItemBefore");
   return adapter.repeatingSection.insertItemBefore(input, options);
 }
 function executeContentControlsRepeatingSectionInsertItemAfter(adapter, input, options) {
+  validateCCInput(input, "contentControls.repeatingSection.insertItemAfter");
+  validateCCTarget(input.target, "contentControls.repeatingSection.insertItemAfter");
+  requireIndex(input.index, "index", "contentControls.repeatingSection.insertItemAfter");
   return adapter.repeatingSection.insertItemAfter(input, options);
 }
 function executeContentControlsRepeatingSectionCloneItem(adapter, input, options) {
+  validateCCInput(input, "contentControls.repeatingSection.cloneItem");
+  validateCCTarget(input.target, "contentControls.repeatingSection.cloneItem");
+  requireIndex(input.index, "index", "contentControls.repeatingSection.cloneItem");
   return adapter.repeatingSection.cloneItem(input, options);
 }
 function executeContentControlsRepeatingSectionDeleteItem(adapter, input, options) {
+  validateCCInput(input, "contentControls.repeatingSection.deleteItem");
+  validateCCTarget(input.target, "contentControls.repeatingSection.deleteItem");
+  requireIndex(input.index, "index", "contentControls.repeatingSection.deleteItem");
   return adapter.repeatingSection.deleteItem(input, options);
 }
 function executeContentControlsRepeatingSectionSetAllowInsertDelete(adapter, input, options) {
+  validateCCInput(input, "contentControls.repeatingSection.setAllowInsertDelete");
+  validateCCTarget(input.target, "contentControls.repeatingSection.setAllowInsertDelete");
+  requireBoolean(input.allow, "allow", "contentControls.repeatingSection.setAllowInsertDelete");
   return adapter.repeatingSection.setAllowInsertDelete(input, options);
 }
 function executeContentControlsGroupWrap(adapter, input, options) {
+  validateCCInput(input, "contentControls.group.wrap");
+  validateCCTarget(input.target, "contentControls.group.wrap");
   return adapter.group.wrap(input, options);
 }
 function executeContentControlsGroupUngroup(adapter, input, options) {
+  validateCCInput(input, "contentControls.group.ungroup");
+  validateCCTarget(input.target, "contentControls.group.ungroup");
   return adapter.group.ungroup(input, options);
 }
 function executeCreateContentControl(adapter, input, options) {
+  validateCCInput(input, "create.contentControl");
+  requireNodeKind(input.kind, "kind", "create.contentControl");
+  if (input.controlType !== undefined && !VALID_CC_TYPES.has(input.controlType)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `create.contentControl controlType must be one of: ${[...VALID_CC_TYPES].join(", ")}.`, { field: "controlType", value: input.controlType });
+  }
+  if (input.lockMode !== undefined && !VALID_LOCK_MODES.has(input.lockMode)) {
+    throw new DocumentApiValidationError("INVALID_INPUT", `create.contentControl lockMode must be one of: ${[...VALID_LOCK_MODES].join(", ")}.`, { field: "lockMode", value: input.lockMode });
+  }
+  if (input.target !== undefined) {
+    validateCCTarget(input.target, "create.contentControl");
+  }
+  if (input.content !== undefined && typeof input.content !== "string") {
+    throw new DocumentApiValidationError("INVALID_INPUT", `create.contentControl content must be a string, got ${typeof input.content}.`, { field: "content", value: input.content });
+  }
   return adapter.create(input, options);
 }
+var VALID_NODE_KINDS, VALID_LOCK_MODES, VALID_CC_TYPES, VALID_CC_APPEARANCES, VALID_CONTENT_FORMATS, VALID_RAW_PATCH_OPS;
+var init_content_controls = __esm(() => {
+  init_errors2();
+  init_validation_primitives();
+  init_content_controls_types();
+  init_base();
+  VALID_NODE_KINDS = new Set(NODE_KINDS);
+  VALID_LOCK_MODES = new Set(LOCK_MODES);
+  VALID_CC_TYPES = new Set(CONTENT_CONTROL_TYPES);
+  VALID_CC_APPEARANCES = new Set(CONTENT_CONTROL_APPEARANCES);
+  VALID_CONTENT_FORMATS = new Set(["text", "html"]);
+  VALID_RAW_PATCH_OPS = new Set(["set", "remove", "setAttr", "removeAttr"]);
+});
 
 // ../../packages/document-api/src/bookmarks/bookmarks.ts
 function validateBookmarkTarget(target, operationName) {
@@ -16656,16 +17538,6 @@ var init_authorities = __esm(() => {
   init_create_location_validator();
 });
 
-// ../../packages/document-api/src/content-controls/content-controls.types.ts
-var init_content_controls_types = () => {};
-
-// ../../packages/document-api/src/lists/lists.types.ts
-var LIST_KINDS, LIST_INSERT_POSITIONS;
-var init_lists_types = __esm(() => {
-  LIST_KINDS = ["ordered", "bullet"];
-  LIST_INSERT_POSITIONS = ["before", "after"];
-});
-
 // ../../packages/document-api/src/index.ts
 function executeQueryMatch(adapter, input) {
   if (!input || typeof input !== "object") {
@@ -17844,6 +18716,9 @@ var init_src = __esm(() => {
   init_format();
   init_inline_run_patch();
   init_styles();
+  init_get_text();
+  init_get_markdown();
+  init_get_html();
   init_story_validator();
   init_delete();
   init_resolve();
@@ -17863,6 +18738,7 @@ var init_src = __esm(() => {
   init_images();
   init_toc();
   init_hyperlinks();
+  init_content_controls();
   init_bookmarks();
   init_footnotes();
   init_cross_refs();
@@ -24837,9 +25713,9 @@ var init_jszip_ChlR43oI_es = __esm(() => {
   });
 });
 
-// ../../packages/superdoc/dist/chunks/xml-js-DLE8mr0n.es.js
+// ../../packages/superdoc/dist/chunks/xml-js-40FWvL78.es.js
 var require_events, require_inherits_browser, require_stream_browser, require_dist, require_shams$1, require_shams, require_es_object_atoms, require_es_errors, require_eval, require_range, require_ref, require_syntax, require_type, require_uri, require_abs, require_floor, require_max, require_min, require_pow, require_round, require_isNaN, require_sign, require_gOPD, require_gopd, require_es_define_property, require_has_symbols, require_Reflect_getPrototypeOf, require_Object_getPrototypeOf, require_implementation, require_function_bind, require_functionCall, require_functionApply, require_reflectApply, require_actualApply, require_call_bind_apply_helpers, require_get, require_get_proto, require_hasown, require_get_intrinsic, require_call_bound, require_is_arguments, require_is_regex, require_safe_regex_test, require_generator_function, require_is_generator_function, require_is_callable, require_for_each, require_possible_typed_array_names, require_available_typed_arrays, require_define_data_property, require_has_property_descriptors, require_set_function_length, require_applyBind, require_call_bind, require_which_typed_array, require_is_typed_array, require_types, require_isBufferBrowser, require_util, require_buffer_list, require_destroy, require_errors_browser, require_state, require_browser, require__stream_writable, require__stream_duplex, require_safe_buffer, require_string_decoder, require_end_of_stream, require_async_iterator, require_from_browser, require__stream_readable, require__stream_transform, require__stream_passthrough, require_pipeline, require_stream_browserify, require_sax, require_array_helper, require_options_helper, require_xml2js, require_xml2json, require_js2xml, require_json2xml, require_lib;
-var init_xml_js_DLE8mr0n_es = __esm(() => {
+var init_xml_js_40FWvL78_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_jszip_ChlR43oI_es();
   require_events = /* @__PURE__ */ __commonJSMin((exports, module) => {
@@ -31387,9 +32263,13 @@ var init_xml_js_DLE8mr0n_es = __esm(() => {
         clearBuffers(parser);
         parser.q = parser.c = "";
         parser.bufferCheckPosition = sax$1.MAX_BUFFER_LENGTH;
+        parser.encoding = null;
         parser.opt = opt || {};
         parser.opt.lowercase = parser.opt.lowercase || parser.opt.lowercasetags;
         parser.looseCase = parser.opt.lowercase ? "toLowerCase" : "toUpperCase";
+        parser.opt.maxEntityCount = parser.opt.maxEntityCount || 512;
+        parser.opt.maxEntityDepth = parser.opt.maxEntityDepth || 4;
+        parser.entityCount = parser.entityDepth = 0;
         parser.tags = [];
         parser.closed = parser.closedRoot = parser.sawRoot = false;
         parser.tag = parser.error = null;
@@ -31492,6 +32372,24 @@ var init_xml_js_DLE8mr0n_es = __esm(() => {
       function createStream(strict, opt) {
         return new SAXStream(strict, opt);
       }
+      function determineBufferEncoding(data, isEnd) {
+        if (data.length >= 2) {
+          if (data[0] === 255 && data[1] === 254)
+            return "utf-16le";
+          if (data[0] === 254 && data[1] === 255)
+            return "utf-16be";
+        }
+        if (data.length >= 3 && data[0] === 239 && data[1] === 187 && data[2] === 191)
+          return "utf8";
+        if (data.length >= 4) {
+          if (data[0] === 60 && data[1] === 0 && data[2] === 63 && data[3] === 0)
+            return "utf-16le";
+          if (data[0] === 0 && data[1] === 60 && data[2] === 0 && data[3] === 63)
+            return "utf-16be";
+          return "utf8";
+        }
+        return isEnd ? "utf8" : null;
+      }
       function SAXStream(strict, opt) {
         if (!(this instanceof SAXStream))
           return new SAXStream(strict, opt);
@@ -31508,6 +32406,7 @@ var init_xml_js_DLE8mr0n_es = __esm(() => {
           me._parser.error = null;
         };
         this._decoder = null;
+        this._decoderBuffer = null;
         streamWraps.forEach(function(ev) {
           Object.defineProperty(me, "on" + ev, {
             get: function() {
@@ -31527,11 +32426,31 @@ var init_xml_js_DLE8mr0n_es = __esm(() => {
         });
       }
       SAXStream.prototype = Object.create(Stream$3.prototype, { constructor: { value: SAXStream } });
+      SAXStream.prototype._decodeBuffer = function(data, isEnd) {
+        if (this._decoderBuffer) {
+          data = Buffer2.concat([this._decoderBuffer, data]);
+          this._decoderBuffer = null;
+        }
+        if (!this._decoder) {
+          var encoding = determineBufferEncoding(data, isEnd);
+          if (!encoding) {
+            this._decoderBuffer = data;
+            return "";
+          }
+          this._parser.encoding = encoding;
+          this._decoder = new TextDecoder(encoding);
+        }
+        return this._decoder.decode(data, { stream: !isEnd });
+      };
       SAXStream.prototype.write = function(data) {
-        if (typeof Buffer2 === "function" && typeof Buffer2.isBuffer === "function" && Buffer2.isBuffer(data)) {
-          if (!this._decoder)
-            this._decoder = new TextDecoder("utf8");
-          data = this._decoder.decode(data, { stream: true });
+        if (typeof Buffer2 === "function" && typeof Buffer2.isBuffer === "function" && Buffer2.isBuffer(data))
+          data = this._decodeBuffer(data, false);
+        else if (this._decoderBuffer) {
+          var remaining = this._decodeBuffer(Buffer2.alloc(0), true);
+          if (remaining) {
+            this._parser.write(remaining);
+            this.emit("data", remaining);
+          }
         }
         this._parser.write(data.toString());
         this.emit("data", data);
@@ -31540,7 +32459,13 @@ var init_xml_js_DLE8mr0n_es = __esm(() => {
       SAXStream.prototype.end = function(chunk) {
         if (chunk && chunk.length)
           this.write(chunk);
-        if (this._decoder) {
+        if (this._decoderBuffer) {
+          var finalChunk = this._decodeBuffer(Buffer2.alloc(0), true);
+          if (finalChunk) {
+            this._parser.write(finalChunk);
+            this.emit("data", finalChunk);
+          }
+        } else if (this._decoder) {
           var remaining = this._decoder.decode();
           if (remaining) {
             this._parser.write(remaining);
@@ -31900,6 +32825,31 @@ var init_xml_js_DLE8mr0n_es = __esm(() => {
       function emit(parser, event, data) {
         parser[event] && parser[event](data);
       }
+      function getDeclaredEncoding(body) {
+        var match = body && body.match(/(?:^|\s)encoding\s*=\s*(['"])([^'"]+)\1/i);
+        return match ? match[2] : null;
+      }
+      function normalizeEncodingName(encoding) {
+        if (!encoding)
+          return null;
+        return encoding.toLowerCase().replace(/[^a-z0-9]/g, "");
+      }
+      function encodingsMatch(detectedEncoding, declaredEncoding) {
+        const detected = normalizeEncodingName(detectedEncoding);
+        const declared = normalizeEncodingName(declaredEncoding);
+        if (!detected || !declared)
+          return true;
+        if (declared === "utf16")
+          return detected === "utf16le" || detected === "utf16be";
+        return detected === declared;
+      }
+      function validateXmlDeclarationEncoding(parser, data) {
+        if (!parser.strict || !parser.encoding || !data || data.name !== "xml")
+          return;
+        var declaredEncoding = getDeclaredEncoding(data.body);
+        if (declaredEncoding && !encodingsMatch(parser.encoding, declaredEncoding))
+          strictFail(parser, "XML declaration encoding " + declaredEncoding + " does not match detected stream encoding " + parser.encoding.toUpperCase());
+      }
       function emitNode(parser, nodeType, data) {
         if (parser.textNode)
           closeText(parser);
@@ -32438,10 +33388,12 @@ Actual: ` + parser.attribValue);
               continue;
             case S.PROC_INST_ENDING:
               if (c === ">") {
-                emitNode(parser, "onprocessinginstruction", {
+                const procInstEndData = {
                   name: parser.procInstName,
                   body: parser.procInstBody
-                });
+                };
+                validateXmlDeclarationEncoding(parser, procInstEndData);
+                emitNode(parser, "onprocessinginstruction", procInstEndData);
                 parser.procInstName = parser.procInstBody = "";
                 parser.state = S.TEXT;
               } else {
@@ -32638,9 +33590,14 @@ Actual: ` + parser.attribValue);
               if (c === ";") {
                 var parsedEntity = parseEntity(parser);
                 if (parser.opt.unparsedEntities && !Object.values(sax$1.XML_ENTITIES).includes(parsedEntity)) {
+                  if ((parser.entityCount += 1) > parser.opt.maxEntityCount)
+                    error(parser, "Parsed entity count exceeds max entity count");
+                  if ((parser.entityDepth += 1) > parser.opt.maxEntityDepth)
+                    error(parser, "Parsed entity depth exceeds max entity depth");
                   parser.entity = "";
                   parser.state = returnState;
                   parser.write(parsedEntity);
+                  parser.entityDepth -= 1;
                 } else {
                   parser[buffer$2] += parsedEntity;
                   parser.entity = "";
@@ -33583,7 +34540,7 @@ var init_uuid_qzgm05fK_es = __esm(() => {
   v5_default = v35("v5", 80, sha1);
 });
 
-// ../../packages/superdoc/dist/chunks/constants-CMPtQbp7.es.js
+// ../../packages/superdoc/dist/chunks/constants-Qqwopz80.es.js
 function computeCrc32Hex(data) {
   let crc = 4294967295;
   for (let i2 = 0;i2 < data.length; i2++)
@@ -33975,8 +34932,8 @@ var import_lib, CRC32_TABLE, REMOTE_RESOURCE_PATTERN, DATA_URI_PATTERN, getArray
     return "webp";
   return null;
 }, COMMENT_FILE_BASENAMES, COMMENT_RELATIONSHIP_TYPES;
-var init_constants_CMPtQbp7_es = __esm(() => {
-  init_xml_js_DLE8mr0n_es();
+var init_constants_Qqwopz80_es = __esm(() => {
+  init_xml_js_40FWvL78_es();
   import_lib = require_lib();
   CRC32_TABLE = new Uint32Array(256);
   for (let i2 = 0;i2 < 256; i2++) {
@@ -40183,7 +41140,7 @@ var init_remark_gfm_z_sDF4ss_es = __esm(() => {
   emptyOptions2 = {};
 });
 
-// ../../packages/superdoc/dist/chunks/SuperConverter-BL6WX-iN.es.js
+// ../../packages/superdoc/dist/chunks/SuperConverter-C9MZOwsC.es.js
 function getExtensionConfigField(extension$1, field, context = { name: "" }) {
   const fieldValue = extension$1.config[field];
   if (typeof fieldValue === "function")
@@ -42836,24 +43793,24 @@ function executeMarkdownToFragment2(adapter, input) {
 }
 function validateCreateCommentInput2(input) {
   if (!isRecord4(input))
-    throw new DocumentApiValidationError2("INVALID_TARGET", "comments.create input must be a non-null object.");
+    throw new DocumentApiValidationError2("INVALID_INPUT", "comments.create input must be a non-null object.");
   assertNoUnknownFields3(input, CREATE_COMMENT_ALLOWED_KEYS2, "comments.create");
   const { target, text: text$2, parentCommentId } = input;
   const hasTarget = target !== undefined;
   const isReply = parentCommentId !== undefined;
   if (typeof text$2 !== "string")
-    throw new DocumentApiValidationError2("INVALID_TARGET", `text must be a string, got ${typeof text$2}.`, {
+    throw new DocumentApiValidationError2("INVALID_INPUT", `text must be a string, got ${typeof text$2}.`, {
       field: "text",
       value: text$2
     });
   if (isReply) {
     if (typeof parentCommentId !== "string" || parentCommentId.length === 0)
-      throw new DocumentApiValidationError2("INVALID_TARGET", "parentCommentId must be a non-empty string.", {
+      throw new DocumentApiValidationError2("INVALID_INPUT", "parentCommentId must be a non-empty string.", {
         field: "parentCommentId",
         value: parentCommentId
       });
     if (hasTarget)
-      throw new DocumentApiValidationError2("INVALID_TARGET", "Cannot combine parentCommentId with target. Replies do not take a target.", { fields: ["parentCommentId", "target"] });
+      throw new DocumentApiValidationError2("INVALID_INPUT", "Cannot combine parentCommentId with target. Replies do not take a target.", { fields: ["parentCommentId", "target"] });
     return;
   }
   if (!hasTarget)
@@ -42866,12 +43823,12 @@ function validateCreateCommentInput2(input) {
 }
 function validatePatchCommentInput2(input) {
   if (!isRecord4(input))
-    throw new DocumentApiValidationError2("INVALID_TARGET", "comments.patch input must be a non-null object.");
+    throw new DocumentApiValidationError2("INVALID_INPUT", "comments.patch input must be a non-null object.");
   assertNoUnknownFields3(input, PATCH_COMMENT_ALLOWED_KEYS2, "comments.patch");
   const { commentId, target } = input;
   const hasTarget = target !== undefined;
   if (typeof commentId !== "string")
-    throw new DocumentApiValidationError2("INVALID_TARGET", `commentId must be a string, got ${typeof commentId}.`, {
+    throw new DocumentApiValidationError2("INVALID_INPUT", `commentId must be a string, got ${typeof commentId}.`, {
       field: "commentId",
       value: commentId
     });
@@ -42886,12 +43843,22 @@ function validatePatchCommentInput2(input) {
     throw new DocumentApiValidationError2("INVALID_INPUT", "comments.patch requires exactly one mutation field (text, target, status, or isInternal).", { allowedFields: [...mutationFields] });
   if (providedFields.length > 1)
     throw new DocumentApiValidationError2("INVALID_INPUT", `comments.patch accepts exactly one mutation field per call, got ${providedFields.length}: ${providedFields.join(", ")}.`, { providedFields: [...providedFields] });
-  const { status } = input;
+  const { text: text$2, status, isInternal } = input;
+  if (text$2 !== undefined && typeof text$2 !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `text must be a string, got ${typeof text$2}.`, {
+      field: "text",
+      value: text$2
+    });
   if (status !== undefined && status !== "resolved")
-    throw new DocumentApiValidationError2("INVALID_TARGET", `status must be "resolved", got "${String(status)}".`, {
+    throw new DocumentApiValidationError2("INVALID_INPUT", `status must be "resolved", got "${String(status)}".`, {
       field: "status",
       value: status
     });
+  if (isInternal !== undefined && typeof isInternal !== "boolean")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `isInternal must be a boolean, got ${typeof isInternal}.`, {
+      field: "isInternal",
+      value: isInternal
+    });
   if (hasTarget && !isTextAddress2(target))
     throw new DocumentApiValidationError2("INVALID_TARGET", "target must be a text address object.", {
       field: "target",
@@ -42928,13 +43895,26 @@ function executeCommentsPatch2(adapter, input, options) {
     }, options);
   throw new DocumentApiValidationError2("INTERNAL_ERROR", "comments.patch: no mutation field matched after validation. This is a bug.");
 }
+function validateCommentIdInput2(input, operationName) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} input must be a non-null object.`);
+  if (typeof input.commentId !== "string" || input.commentId.length === 0)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} commentId must be a non-empty string.`, {
+      field: "commentId",
+      value: input.commentId
+    });
+}
 function executeCommentsDelete2(adapter, input, options) {
+  validateCommentIdInput2(input, "comments.delete");
   return adapter.remove({ commentId: input.commentId }, options);
 }
 function executeGetComment2(adapter, input) {
+  validateCommentIdInput2(input, "comments.get");
   return adapter.get(input);
 }
 function executeListComments2(adapter, query2) {
+  if (query2 !== undefined && !isRecord4(query2))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "comments.list query must be an object if provided.");
   return adapter.list(query2);
 }
 function executeFind2(adapter, input) {
@@ -43028,12 +44008,21 @@ function executeGet2(adapter, input) {
   return adapter.get(input);
 }
 function executeGetText2(adapter, input) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "getText input must be a non-null object.");
+  validateStoryLocator2(input.in, "in");
   return adapter.getText(input);
 }
 function executeGetMarkdown2(adapter, input) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "getMarkdown input must be a non-null object.");
+  validateStoryLocator2(input.in, "in");
   return adapter.getMarkdown(input);
 }
 function executeGetHtml2(adapter, input) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "getHtml input must be a non-null object.");
+  validateStoryLocator2(input.in, "in");
   return adapter.getHtml(input);
 }
 function executeInfo2(adapter, input) {
@@ -43647,149 +44636,531 @@ function executeInsert2(selectionAdapter, writeAdapter, input, options) {
     ...storyIn ? { in: storyIn } : {}
   }, options));
 }
-function validateListTarget2(input, operationName) {
-  if (input.target === undefined)
-    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} requires a target.`);
+function validateListInput2(input, operationName) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} input must be a non-null object.`);
+}
+function validateListItemAddress2(value, field, operationName) {
+  if (value === undefined || value === null)
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} requires a ${field}.`);
+  if (!isRecord4(value))
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field} must be an object.`, {
+      field,
+      value
+    });
+  const t = value;
+  if (t.kind !== "block")
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field}.kind must be 'block', got "${String(t.kind)}".`, {
+      field: `${field}.kind`,
+      value: t.kind
+    });
+  if (t.nodeType !== "listItem")
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field}.nodeType must be 'listItem', got "${String(t.nodeType)}".`, {
+      field: `${field}.nodeType`,
+      value: t.nodeType
+    });
+  if (typeof t.nodeId !== "string" || t.nodeId === "")
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field}.nodeId must be a non-empty string.`, {
+      field: `${field}.nodeId`,
+      value: t.nodeId
+    });
+}
+function validateListItemTarget2(input, operationName) {
+  validateListItemAddress2(input.target, "target", operationName);
+}
+function validateBlockAddress2(value, field, operationName) {
+  if (!isRecord4(value))
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field} must be an object.`, {
+      field,
+      value
+    });
+  const v = value;
+  if (v.kind !== "block")
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field}.kind must be 'block', got "${String(v.kind)}".`, {
+      field: `${field}.kind`,
+      value: v.kind
+    });
+  if (v.nodeType !== "paragraph")
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field}.nodeType must be 'paragraph', got "${String(v.nodeType)}".`, {
+      field: `${field}.nodeType`,
+      value: v.nodeType
+    });
+  if (typeof v.nodeId !== "string" || v.nodeId === "")
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field}.nodeId must be a non-empty string.`, {
+      field: `${field}.nodeId`,
+      value: v.nodeId
+    });
+}
+function validateBlockAddressOrRange2(value, field, operationName) {
+  if (!isRecord4(value))
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} ${field} must be an object.`, {
+      field,
+      value
+    });
+  const v = value;
+  if (v.from !== undefined) {
+    validateBlockAddress2(v.from, `${field}.from`, operationName);
+    validateBlockAddress2(v.to, `${field}.to`, operationName);
+  } else
+    validateBlockAddress2(value, field, operationName);
+}
+function requireLevel2(value, operationName) {
+  if (!isInteger2(value) || value < 0)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} level must be a non-negative integer, got ${JSON.stringify(value)}.`, {
+      field: "level",
+      value
+    });
+}
+function requireEnum2(value, field, validSet, operationName) {
+  if (!validSet.has(value))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be one of: ${[...validSet].join(", ")}. Got ${JSON.stringify(value)}.`, {
+      field,
+      value
+    });
+}
+function optionalBoolean2(value, field, operationName) {
+  if (value !== undefined && typeof value !== "boolean")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be a boolean if provided, got ${typeof value}.`, {
+      field,
+      value
+    });
+}
+function optionalNumber2(value, field, operationName) {
+  if (value !== undefined && (typeof value !== "number" || !Number.isFinite(value)))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be a number if provided, got ${typeof value}.`, {
+      field,
+      value
+    });
+}
+function optionalInteger2(value, field, operationName) {
+  if (value !== undefined && !isInteger2(value))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be an integer if provided, got ${JSON.stringify(value)}.`, {
+      field,
+      value
+    });
+}
+function optionalLevelsArray2(value, field, operationName) {
+  if (value === undefined)
+    return;
+  if (!Array.isArray(value))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be an array if provided.`, {
+      field,
+      value
+    });
+  for (let i$1 = 0;i$1 < value.length; i$1++)
+    if (!isInteger2(value[i$1]) || value[i$1] < 0)
+      throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field}[${i$1}] must be a non-negative integer.`, {
+        field: `${field}[${i$1}]`,
+        value: value[i$1]
+      });
+}
+function validateListLevelTemplate2(entry, path2, operationName) {
+  if (!isRecord4(entry))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${path2} must be an object.`, {
+      field: path2,
+      value: entry
+    });
+  const e = entry;
+  if (!isInteger2(e.level) || e.level < 0)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${path2}.level must be a non-negative integer.`, {
+      field: `${path2}.level`,
+      value: e.level
+    });
+  if (e.numFmt !== undefined && typeof e.numFmt !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${path2}.numFmt must be a string.`, {
+      field: `${path2}.numFmt`,
+      value: e.numFmt
+    });
+  if (e.lvlText !== undefined && typeof e.lvlText !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${path2}.lvlText must be a string.`, {
+      field: `${path2}.lvlText`,
+      value: e.lvlText
+    });
+  optionalInteger2(e.start, `${path2}.start`, operationName);
+  if (e.alignment !== undefined)
+    requireEnum2(e.alignment, `${path2}.alignment`, VALID_LEVEL_ALIGNMENTS2, operationName);
+  if (e.trailingCharacter !== undefined)
+    requireEnum2(e.trailingCharacter, `${path2}.trailingCharacter`, VALID_TRAILING_CHARACTERS2, operationName);
+  if (e.markerFont !== undefined && typeof e.markerFont !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${path2}.markerFont must be a string.`, {
+      field: `${path2}.markerFont`,
+      value: e.markerFont
+    });
+  optionalInteger2(e.pictureBulletId, `${path2}.pictureBulletId`, operationName);
+  if (e.tabStopAt !== undefined && e.tabStopAt !== null)
+    optionalNumber2(e.tabStopAt, `${path2}.tabStopAt`, operationName);
+  if (e.indents !== undefined) {
+    if (!isRecord4(e.indents))
+      throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${path2}.indents must be an object.`, {
+        field: `${path2}.indents`,
+        value: e.indents
+      });
+    const ind = e.indents;
+    optionalNumber2(ind.left, `${path2}.indents.left`, operationName);
+    optionalNumber2(ind.hanging, `${path2}.indents.hanging`, operationName);
+    optionalNumber2(ind.firstLine, `${path2}.indents.firstLine`, operationName);
+  }
+}
+function validateListTemplate2(value, field, operationName) {
+  if (!isRecord4(value))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be an object.`, {
+      field,
+      value
+    });
+  const t = value;
+  if (t.version !== 1)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field}.version must be 1, got ${JSON.stringify(t.version)}.`, {
+      field: `${field}.version`,
+      value: t.version
+    });
+  if (!Array.isArray(t.levels))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field}.levels must be an array.`, {
+      field: `${field}.levels`,
+      value: t.levels
+    });
+  for (let i$1 = 0;i$1 < t.levels.length; i$1++)
+    validateListLevelTemplate2(t.levels[i$1], `${field}.levels[${i$1}]`, operationName);
+}
+function validateListsCreateFields2(raw) {
+  const op = "lists.create";
+  if (raw.kind !== undefined)
+    requireEnum2(raw.kind, "kind", VALID_LIST_KINDS2, op);
+  if (raw.level !== undefined) {
+    if (!isInteger2(raw.level) || raw.level < 0)
+      throw new DocumentApiValidationError2("INVALID_INPUT", `${op} level must be a non-negative integer, got ${JSON.stringify(raw.level)}.`, {
+        field: "level",
+        value: raw.level
+      });
+  }
+  if (raw.sequence !== undefined) {
+    if (!isRecord4(raw.sequence))
+      throw new DocumentApiValidationError2("INVALID_INPUT", `${op} sequence must be an object.`, {
+        field: "sequence",
+        value: raw.sequence
+      });
+    const seq = raw.sequence;
+    requireEnum2(seq.mode, "sequence.mode", VALID_SEQUENCE_MODES2, op);
+    if (seq.mode === "continuePrevious") {
+      if (raw.preset !== undefined)
+        throw new DocumentApiValidationError2("INVALID_INPUT", `${op} preset must not be provided when sequence.mode is 'continuePrevious'.`, { field: "preset" });
+      if (raw.style !== undefined)
+        throw new DocumentApiValidationError2("INVALID_INPUT", `${op} style must not be provided when sequence.mode is 'continuePrevious'.`, { field: "style" });
+      if (seq.startAt !== undefined)
+        throw new DocumentApiValidationError2("INVALID_INPUT", `${op} sequence.startAt must not be provided when sequence.mode is 'continuePrevious'.`, { field: "sequence.startAt" });
+    }
+    if (seq.mode === "new")
+      optionalInteger2(seq.startAt, "sequence.startAt", op);
+  }
+  if (raw.preset !== undefined)
+    requireEnum2(raw.preset, "preset", VALID_LIST_PRESETS2, op);
+  if (raw.style !== undefined)
+    validateListTemplate2(raw.style, "style", op);
 }
 function executeListsList2(adapter, query2) {
+  if (query2 !== undefined) {
+    if (!isRecord4(query2))
+      throw new DocumentApiValidationError2("INVALID_INPUT", "lists.list query must be an object if provided.");
+    const q$1 = query2;
+    if (q$1.kind !== undefined)
+      requireEnum2(q$1.kind, "kind", VALID_LIST_KINDS2, "lists.list");
+    optionalInteger2(q$1.level, "level", "lists.list");
+    optionalInteger2(q$1.limit, "limit", "lists.list");
+    optionalInteger2(q$1.offset, "offset", "lists.list");
+    optionalInteger2(q$1.ordinal, "ordinal", "lists.list");
+    if (q$1.within !== undefined) {
+      if (!isRecord4(q$1.within))
+        throw new DocumentApiValidationError2("INVALID_INPUT", "lists.list within must be an object.", {
+          field: "within",
+          value: q$1.within
+        });
+      const w = q$1.within;
+      if (w.kind !== "block")
+        throw new DocumentApiValidationError2("INVALID_INPUT", `lists.list within.kind must be 'block', got "${String(w.kind)}".`, {
+          field: "within.kind",
+          value: w.kind
+        });
+      if (!VALID_BLOCK_NODE_TYPES$1.has(w.nodeType))
+        throw new DocumentApiValidationError2("INVALID_INPUT", `lists.list within.nodeType must be a valid BlockNodeType, got ${JSON.stringify(w.nodeType)}.`, {
+          field: "within.nodeType",
+          value: w.nodeType
+        });
+      if (typeof w.nodeId !== "string" || w.nodeId === "")
+        throw new DocumentApiValidationError2("INVALID_INPUT", "lists.list within.nodeId must be a non-empty string.", {
+          field: "within.nodeId",
+          value: w.nodeId
+        });
+    }
+  }
   return adapter.list(query2);
 }
 function executeListsGet2(adapter, input) {
+  validateListInput2(input, "lists.get");
+  validateListItemAddress2(input.address, "address", "lists.get");
   return adapter.get(input);
 }
 function executeListsInsert2(adapter, input, options) {
-  validateListTarget2(input, "lists.insert");
+  validateListItemTarget2(input, "lists.insert");
+  requireEnum2(input.position, "position", VALID_INSERT_POSITIONS2, "lists.insert");
+  if (input.text !== undefined && typeof input.text !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `lists.insert text must be a string if provided, got ${typeof input.text}.`, {
+      field: "text",
+      value: input.text
+    });
   return adapter.insert(input, normalizeMutationOptions2(options));
 }
 function executeListsIndent2(adapter, input, options) {
-  validateListTarget2(input, "lists.indent");
+  validateListItemTarget2(input, "lists.indent");
   return adapter.indent(input, normalizeMutationOptions2(options));
 }
 function executeListsOutdent2(adapter, input, options) {
-  validateListTarget2(input, "lists.outdent");
+  validateListItemTarget2(input, "lists.outdent");
   return adapter.outdent(input, normalizeMutationOptions2(options));
 }
 function executeListsCreate2(adapter, input, options) {
+  validateListInput2(input, "lists.create");
+  const raw = input;
+  if (!VALID_LIST_CREATE_MODES2.has(raw.mode))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `lists.create mode must be "empty" or "fromParagraphs", got ${JSON.stringify(raw.mode)}.`, {
+      field: "mode",
+      value: raw.mode
+    });
+  if (raw.mode === "empty")
+    validateBlockAddress2(raw.at, "at", "lists.create");
+  if (raw.mode === "fromParagraphs") {
+    if (raw.target === undefined || raw.target === null)
+      throw new DocumentApiValidationError2("INVALID_TARGET", 'lists.create with mode "fromParagraphs" requires a target.', { field: "target" });
+    validateBlockAddressOrRange2(raw.target, "target", "lists.create");
+  }
+  validateListsCreateFields2(raw);
   return adapter.create(input, normalizeMutationOptions2(options));
 }
 function executeListsAttach2(adapter, input, options) {
-  validateListTarget2(input, "lists.attach");
+  validateListInput2(input, "lists.attach");
+  validateBlockAddressOrRange2(input.target, "target", "lists.attach");
+  validateListItemAddress2(input.attachTo, "attachTo", "lists.attach");
+  optionalInteger2(input.level, "level", "lists.attach");
   return adapter.attach(input, normalizeMutationOptions2(options));
 }
 function executeListsDetach2(adapter, input, options) {
-  validateListTarget2(input, "lists.detach");
+  validateListItemTarget2(input, "lists.detach");
   return adapter.detach(input, normalizeMutationOptions2(options));
 }
 function executeListsJoin2(adapter, input, options) {
-  validateListTarget2(input, "lists.join");
+  validateListItemTarget2(input, "lists.join");
+  requireEnum2(input.direction, "direction", VALID_JOIN_DIRECTIONS2, "lists.join");
   return adapter.join(input, normalizeMutationOptions2(options));
 }
 function executeListsCanJoin2(adapter, input) {
-  validateListTarget2(input, "lists.canJoin");
+  validateListItemTarget2(input, "lists.canJoin");
+  requireEnum2(input.direction, "direction", VALID_JOIN_DIRECTIONS2, "lists.canJoin");
   return adapter.canJoin(input);
 }
 function executeListsSeparate2(adapter, input, options) {
-  validateListTarget2(input, "lists.separate");
+  validateListItemTarget2(input, "lists.separate");
+  optionalBoolean2(input.copyOverrides, "copyOverrides", "lists.separate");
   return adapter.separate(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevel2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevel");
+  validateListItemTarget2(input, "lists.setLevel");
+  requireLevel2(input.level, "lists.setLevel");
   return adapter.setLevel(input, normalizeMutationOptions2(options));
 }
 function executeListsSetValue2(adapter, input, options) {
-  validateListTarget2(input, "lists.setValue");
+  validateListItemTarget2(input, "lists.setValue");
+  if (input.value !== null && !isInteger2(input.value))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `lists.setValue value must be an integer or null, got ${JSON.stringify(input.value)}.`, {
+      field: "value",
+      value: input.value
+    });
   return adapter.setValue(input, normalizeMutationOptions2(options));
 }
 function executeListsContinuePrevious2(adapter, input, options) {
-  validateListTarget2(input, "lists.continuePrevious");
+  validateListItemTarget2(input, "lists.continuePrevious");
   return adapter.continuePrevious(input, normalizeMutationOptions2(options));
 }
 function executeListsCanContinuePrevious2(adapter, input) {
-  validateListTarget2(input, "lists.canContinuePrevious");
+  validateListItemTarget2(input, "lists.canContinuePrevious");
   return adapter.canContinuePrevious(input);
 }
 function executeListsSetLevelRestart2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelRestart");
+  validateListItemTarget2(input, "lists.setLevelRestart");
+  requireLevel2(input.level, "lists.setLevelRestart");
+  if (input.restartAfterLevel !== null && !isInteger2(input.restartAfterLevel))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `lists.setLevelRestart restartAfterLevel must be an integer or null.`, {
+      field: "restartAfterLevel",
+      value: input.restartAfterLevel
+    });
+  if (input.scope !== undefined)
+    requireEnum2(input.scope, "scope", VALID_MUTATION_SCOPES2, "lists.setLevelRestart");
   return adapter.setLevelRestart(input, normalizeMutationOptions2(options));
 }
 function executeListsConvertToText2(adapter, input, options) {
-  validateListTarget2(input, "lists.convertToText");
+  validateListItemTarget2(input, "lists.convertToText");
+  optionalBoolean2(input.includeMarker, "includeMarker", "lists.convertToText");
   return adapter.convertToText(input, normalizeMutationOptions2(options));
 }
 function executeListsApplyTemplate2(adapter, input, options) {
-  validateListTarget2(input, "lists.applyTemplate");
+  validateListItemTarget2(input, "lists.applyTemplate");
+  validateListTemplate2(input.template, "template", "lists.applyTemplate");
+  optionalLevelsArray2(input.levels, "levels", "lists.applyTemplate");
   return adapter.applyTemplate(input, normalizeMutationOptions2(options));
 }
 function executeListsApplyPreset2(adapter, input, options) {
-  validateListTarget2(input, "lists.applyPreset");
+  validateListItemTarget2(input, "lists.applyPreset");
+  requireEnum2(input.preset, "preset", VALID_LIST_PRESETS2, "lists.applyPreset");
+  optionalLevelsArray2(input.levels, "levels", "lists.applyPreset");
   return adapter.applyPreset(input, normalizeMutationOptions2(options));
 }
 function executeListsCaptureTemplate2(adapter, input) {
-  validateListTarget2(input, "lists.captureTemplate");
+  validateListItemTarget2(input, "lists.captureTemplate");
+  optionalLevelsArray2(input.levels, "levels", "lists.captureTemplate");
   return adapter.captureTemplate(input);
 }
 function executeListsSetLevelNumbering2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelNumbering");
+  validateListItemTarget2(input, "lists.setLevelNumbering");
+  requireLevel2(input.level, "lists.setLevelNumbering");
+  if (typeof input.numFmt !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", "lists.setLevelNumbering numFmt must be a string.", {
+      field: "numFmt",
+      value: input.numFmt
+    });
+  if (typeof input.lvlText !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", "lists.setLevelNumbering lvlText must be a string.", {
+      field: "lvlText",
+      value: input.lvlText
+    });
+  optionalInteger2(input.start, "start", "lists.setLevelNumbering");
   return adapter.setLevelNumbering(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelBullet2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelBullet");
+  validateListItemTarget2(input, "lists.setLevelBullet");
+  requireLevel2(input.level, "lists.setLevelBullet");
+  if (typeof input.markerText !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", "lists.setLevelBullet markerText must be a string.", {
+      field: "markerText",
+      value: input.markerText
+    });
   return adapter.setLevelBullet(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelPictureBullet2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelPictureBullet");
+  validateListItemTarget2(input, "lists.setLevelPictureBullet");
+  requireLevel2(input.level, "lists.setLevelPictureBullet");
+  if (!isInteger2(input.pictureBulletId))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "lists.setLevelPictureBullet pictureBulletId must be an integer.", {
+      field: "pictureBulletId",
+      value: input.pictureBulletId
+    });
   return adapter.setLevelPictureBullet(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelAlignment2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelAlignment");
+  validateListItemTarget2(input, "lists.setLevelAlignment");
+  requireLevel2(input.level, "lists.setLevelAlignment");
+  requireEnum2(input.alignment, "alignment", VALID_LEVEL_ALIGNMENTS2, "lists.setLevelAlignment");
   return adapter.setLevelAlignment(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelIndents2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelIndents");
+  validateListItemTarget2(input, "lists.setLevelIndents");
+  requireLevel2(input.level, "lists.setLevelIndents");
+  optionalNumber2(input.left, "left", "lists.setLevelIndents");
+  optionalNumber2(input.hanging, "hanging", "lists.setLevelIndents");
+  optionalNumber2(input.firstLine, "firstLine", "lists.setLevelIndents");
   return adapter.setLevelIndents(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelTrailingCharacter2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelTrailingCharacter");
+  validateListItemTarget2(input, "lists.setLevelTrailingCharacter");
+  requireLevel2(input.level, "lists.setLevelTrailingCharacter");
+  requireEnum2(input.trailingCharacter, "trailingCharacter", VALID_TRAILING_CHARACTERS2, "lists.setLevelTrailingCharacter");
   return adapter.setLevelTrailingCharacter(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelMarkerFont2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelMarkerFont");
+  validateListItemTarget2(input, "lists.setLevelMarkerFont");
+  requireLevel2(input.level, "lists.setLevelMarkerFont");
+  if (typeof input.fontFamily !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", "lists.setLevelMarkerFont fontFamily must be a string.", {
+      field: "fontFamily",
+      value: input.fontFamily
+    });
   return adapter.setLevelMarkerFont(input, normalizeMutationOptions2(options));
 }
 function executeListsClearLevelOverrides2(adapter, input, options) {
-  validateListTarget2(input, "lists.clearLevelOverrides");
+  validateListItemTarget2(input, "lists.clearLevelOverrides");
+  requireLevel2(input.level, "lists.clearLevelOverrides");
   return adapter.clearLevelOverrides(input, normalizeMutationOptions2(options));
 }
 function executeListsSetType2(adapter, input, options) {
-  validateListTarget2(input, "lists.setType");
+  validateListItemTarget2(input, "lists.setType");
+  requireEnum2(input.kind, "kind", VALID_LIST_KINDS2, "lists.setType");
+  if (input.continuity !== undefined)
+    requireEnum2(input.continuity, "continuity", VALID_CONTINUITY_VALUES2, "lists.setType");
   return adapter.setType(input, normalizeMutationOptions2(options));
 }
 function executeListsGetStyle2(adapter, input) {
-  validateListTarget2(input, "lists.getStyle");
+  validateListItemTarget2(input, "lists.getStyle");
+  optionalLevelsArray2(input.levels, "levels", "lists.getStyle");
   return adapter.getStyle(input);
 }
 function executeListsApplyStyle2(adapter, input, options) {
-  validateListTarget2(input, "lists.applyStyle");
+  validateListItemTarget2(input, "lists.applyStyle");
+  validateListTemplate2(input.style, "style", "lists.applyStyle");
+  optionalLevelsArray2(input.levels, "levels", "lists.applyStyle");
   return adapter.applyStyle(input, normalizeMutationOptions2(options));
 }
 function executeListsRestartAt2(adapter, input, options) {
-  validateListTarget2(input, "lists.restartAt");
+  validateListItemTarget2(input, "lists.restartAt");
+  if (!isInteger2(input.startAt))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `lists.restartAt startAt must be an integer, got ${JSON.stringify(input.startAt)}.`, {
+      field: "startAt",
+      value: input.startAt
+    });
   return adapter.restartAt(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelNumberStyle2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelNumberStyle");
+  validateListItemTarget2(input, "lists.setLevelNumberStyle");
+  requireLevel2(input.level, "lists.setLevelNumberStyle");
+  if (typeof input.numberStyle !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", "lists.setLevelNumberStyle numberStyle must be a string.", {
+      field: "numberStyle",
+      value: input.numberStyle
+    });
   return adapter.setLevelNumberStyle(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelText2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelText");
+  validateListItemTarget2(input, "lists.setLevelText");
+  requireLevel2(input.level, "lists.setLevelText");
+  if (typeof input.text !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", "lists.setLevelText text must be a string.", {
+      field: "text",
+      value: input.text
+    });
   return adapter.setLevelText(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelStart2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelStart");
+  validateListItemTarget2(input, "lists.setLevelStart");
+  requireLevel2(input.level, "lists.setLevelStart");
+  if (!isInteger2(input.startAt))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `lists.setLevelStart startAt must be an integer, got ${JSON.stringify(input.startAt)}.`, {
+      field: "startAt",
+      value: input.startAt
+    });
   return adapter.setLevelStart(input, normalizeMutationOptions2(options));
 }
 function executeListsSetLevelLayout2(adapter, input, options) {
-  validateListTarget2(input, "lists.setLevelLayout");
+  validateListItemTarget2(input, "lists.setLevelLayout");
+  requireLevel2(input.level, "lists.setLevelLayout");
+  if (!isRecord4(input.layout))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "lists.setLevelLayout layout must be an object.", {
+      field: "layout",
+      value: input.layout
+    });
+  const layout = input.layout;
+  if (layout.alignment !== undefined)
+    requireEnum2(layout.alignment, "layout.alignment", VALID_LEVEL_ALIGNMENTS2, "lists.setLevelLayout");
+  if (layout.followCharacter !== undefined)
+    requireEnum2(layout.followCharacter, "layout.followCharacter", VALID_TRAILING_CHARACTERS2, "lists.setLevelLayout");
+  optionalNumber2(layout.alignedAt, "layout.alignedAt", "lists.setLevelLayout");
+  optionalNumber2(layout.textIndentAt, "layout.textIndentAt", "lists.setLevelLayout");
+  if (layout.tabStopAt !== undefined && layout.tabStopAt !== null)
+    optionalNumber2(layout.tabStopAt, "layout.tabStopAt", "lists.setLevelLayout");
   return adapter.setLevelLayout(input, normalizeMutationOptions2(options));
 }
 function isStructuralReplaceInput2(input) {
@@ -43939,6 +45310,9 @@ function validateCreateSectionBreakInput2(input) {
   }
 }
 function executeCreateParagraph2(adapter, input, options) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "create.paragraph input must be a non-null object.");
+  validateStoryLocator2(input.in, "in");
   const normalized = {
     at: normalizeCreateLocation2(input.at, (loc) => validateTargetOnlyCreateLocation2(loc, "create.paragraph")),
     text: input.text ?? ""
@@ -43946,6 +45320,14 @@ function executeCreateParagraph2(adapter, input, options) {
   return adapter.paragraph(normalized, normalizeMutationOptions2(options));
 }
 function executeCreateHeading2(adapter, input, options) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "create.heading input must be a non-null object.");
+  validateStoryLocator2(input.in, "in");
+  if (!isInteger2(input.level) || !VALID_HEADING_LEVELS2.has(input.level))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `create.heading level must be an integer 1–6, got ${JSON.stringify(input.level)}.`, {
+      field: "level",
+      value: input.level
+    });
   const at = normalizeCreateLocation2(input.at, (loc) => validateTargetOnlyCreateLocation2(loc, "create.heading"));
   const normalized = {
     level: input.level,
@@ -43955,6 +45337,18 @@ function executeCreateHeading2(adapter, input, options) {
   return adapter.heading(normalized, normalizeMutationOptions2(options));
 }
 function executeCreateTable2(adapter, input, options) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "create.table input must be a non-null object.");
+  if (!isInteger2(input.rows) || input.rows < 1)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `create.table rows must be a positive integer, got ${JSON.stringify(input.rows)}.`, {
+      field: "rows",
+      value: input.rows
+    });
+  if (!isInteger2(input.columns) || input.columns < 1)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `create.table columns must be a positive integer, got ${JSON.stringify(input.columns)}.`, {
+      field: "columns",
+      value: input.columns
+    });
   const at = normalizeCreateLocation2(input.at, (loc) => validateTargetOrNodeIdCreateLocation2(loc, "create.table"));
   const normalized = {
     rows: input.rows,
@@ -43995,7 +45389,7 @@ function validateBlocksListInput2(input) {
     if (!Array.isArray(input.nodeTypes) || input.nodeTypes.length === 0)
       throw new DocumentApiValidationError2("INVALID_INPUT", "blocks.list nodeTypes must be a non-empty array.", { fields: ["nodeTypes"] });
     for (const nt of input.nodeTypes)
-      if (!VALID_BLOCK_NODE_TYPES2.has(nt))
+      if (!VALID_BLOCK_NODE_TYPES3.has(nt))
         throw new DocumentApiValidationError2("INVALID_INPUT", `blocks.list nodeTypes contains unknown type "${nt}".`, {
           fields: ["nodeTypes"],
           nodeType: nt
@@ -44056,6 +45450,15 @@ function executeTrackChangesList2(adapter, input) {
   return adapter.list(input);
 }
 function executeTrackChangesGet2(adapter, input) {
+  const raw = input;
+  if (typeof raw !== "object" || raw == null)
+    throw new DocumentApiValidationError2("INVALID_INPUT", "trackChanges.get input must be a non-null object.", { value: raw });
+  const { id } = raw;
+  if (typeof id !== "string" || id.length === 0)
+    throw new DocumentApiValidationError2("INVALID_INPUT", "trackChanges.get id must be a non-empty string.", {
+      field: "id",
+      value: id
+    });
   return adapter.get(input);
 }
 function executeTrackChangesDecide2(adapter, rawInput, options) {
@@ -45058,12 +46461,12 @@ function executeSectionsClearPageBorders2(adapter, input, options) {
   assertSectionTarget2(input, "sections.clearPageBorders");
   return adapter.clearPageBorders(input, normalizeMutationOptions2(options));
 }
-function requireString2(value, field) {
+function requireString$1(value, field) {
   if (typeof value !== "string" || value.length === 0)
     throw new DocumentApiValidationError2("INVALID_INPUT", `${field} must be a non-empty string.`, { field });
 }
 function requireImageId2(input) {
-  requireString2(input?.imageId, "imageId");
+  requireString$1(input?.imageId, "imageId");
 }
 function requireFinitePositiveNumber2(value, field) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0)
@@ -45224,7 +46627,7 @@ function executeImagesResetCrop2(adapter, input, options) {
 }
 function executeImagesReplaceSource2(adapter, input, options) {
   requireImageId2(input);
-  requireString2(input.src, "src");
+  requireString$1(input.src, "src");
   return adapter.replaceSource(input, options);
 }
 function executeImagesSetAltText2(adapter, input, options) {
@@ -45255,12 +46658,12 @@ function executeImagesSetHyperlink2(adapter, input, options) {
 }
 function executeImagesInsertCaption2(adapter, input, options) {
   requireImageId2(input);
-  requireString2(input.text, "text");
+  requireString$1(input.text, "text");
   return adapter.insertCaption(input, options);
 }
 function executeImagesUpdateCaption2(adapter, input, options) {
   requireImageId2(input);
-  requireString2(input.text, "text");
+  requireString$1(input.text, "text");
   return adapter.updateCaption(input, options);
 }
 function executeImagesRemoveCaption2(adapter, input, options) {
@@ -45268,7 +46671,8 @@ function executeImagesRemoveCaption2(adapter, input, options) {
   return adapter.removeCaption(input, options);
 }
 function executeCreateImage2(adapter, input, options) {
-  requireString2(input?.src, "src");
+  requireString$1(input?.src, "src");
+  validateStoryLocator2(input?.in, "in");
   return adapter.image(input, options);
 }
 function validateTocTarget2(target, operationName) {
@@ -45295,32 +46699,47 @@ function validateInsertionTarget2(target, operationName) {
   if (!anchor || anchor.nodeType !== "paragraph" || typeof anchor.nodeId !== "string")
     throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} target.anchor must have nodeType 'paragraph' and a string nodeId.`, { target });
 }
+function validateTocInput2(input, operationName) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} input must be a non-null object.`);
+}
 function executeTocList2(adapter, query2) {
   return adapter.list(query2);
 }
 function executeTocGet2(adapter, input) {
+  validateTocInput2(input, "toc.get");
   validateTocTarget2(input.target, "toc.get");
   return adapter.get(input);
 }
 function executeTocConfigure2(adapter, input, options) {
+  validateTocInput2(input, "toc.configure");
   validateTocTarget2(input.target, "toc.configure");
   return adapter.configure(input, normalizeMutationOptions2(options));
 }
 function executeTocUpdate2(adapter, input, options) {
+  validateTocInput2(input, "toc.update");
   validateTocTarget2(input.target, "toc.update");
+  if (input.mode !== undefined && !VALID_TOC_UPDATE_MODES2.has(input.mode))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `toc.update mode must be "all" or "pageNumbers", got "${String(input.mode)}".`, {
+      field: "mode",
+      value: input.mode
+    });
   return adapter.update(input, normalizeMutationOptions2(options));
 }
 function executeTocRemove2(adapter, input, options) {
+  validateTocInput2(input, "toc.remove");
   validateTocTarget2(input.target, "toc.remove");
   return adapter.remove(input, normalizeMutationOptions2(options));
 }
 function executeTocMarkEntry2(adapter, input, options) {
+  validateTocInput2(input, "toc.markEntry");
   validateInsertionTarget2(input.target, "toc.markEntry");
   if (!input.text || typeof input.text !== "string")
     throw new DocumentApiValidationError2("INVALID_INPUT", "toc.markEntry requires a non-empty text string.");
   return adapter.markEntry(input, normalizeMutationOptions2(options));
 }
 function executeTocUnmarkEntry2(adapter, input, options) {
+  validateTocInput2(input, "toc.unmarkEntry");
   validateTocEntryTarget2(input.target, "toc.unmarkEntry");
   return adapter.unmarkEntry(input, normalizeMutationOptions2(options));
 }
@@ -45328,11 +46747,46 @@ function executeTocListEntries2(adapter, query2) {
   return adapter.listEntries(query2);
 }
 function executeTocGetEntry2(adapter, input) {
+  validateTocInput2(input, "toc.getEntry");
   validateTocEntryTarget2(input.target, "toc.getEntry");
   return adapter.getEntry(input);
 }
+function validateTocEditEntryPatch2(patch, operationName) {
+  if (!isRecord4(patch))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} patch must be a non-null object.`, {
+      field: "patch",
+      value: patch
+    });
+  for (const key of Object.keys(patch))
+    if (!EDIT_ENTRY_PATCH_ALLOWED_KEYS2.has(key))
+      throw new DocumentApiValidationError2("INVALID_INPUT", `Unknown field "${key}" on ${operationName} patch. Allowed fields: ${[...EDIT_ENTRY_PATCH_ALLOWED_KEYS2].join(", ")}.`, { field: `patch.${key}` });
+  if (patch.text !== undefined && typeof patch.text !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} patch.text must be a string.`, {
+      field: "patch.text",
+      value: patch.text
+    });
+  if (patch.level !== undefined) {
+    if (typeof patch.level !== "number" || !Number.isInteger(patch.level) || patch.level < 1)
+      throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} patch.level must be a positive integer.`, {
+        field: "patch.level",
+        value: patch.level
+      });
+  }
+  if (patch.tableIdentifier !== undefined && typeof patch.tableIdentifier !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} patch.tableIdentifier must be a string.`, {
+      field: "patch.tableIdentifier",
+      value: patch.tableIdentifier
+    });
+  if (patch.omitPageNumber !== undefined && typeof patch.omitPageNumber !== "boolean")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} patch.omitPageNumber must be a boolean.`, {
+      field: "patch.omitPageNumber",
+      value: patch.omitPageNumber
+    });
+}
 function executeTocEditEntry2(adapter, input, options) {
+  validateTocInput2(input, "toc.editEntry");
   validateTocEntryTarget2(input.target, "toc.editEntry");
+  validateTocEditEntryPatch2(input.patch, "toc.editEntry");
   return adapter.editEntry(input, normalizeMutationOptions2(options));
 }
 function isHyperlinkTarget2(value) {
@@ -45420,169 +46874,477 @@ function executeHyperlinksRemove2(adapter, input, options) {
     throw new DocumentApiValidationError2("INVALID_INPUT", `hyperlinks.remove mode must be 'unwrap' or 'deleteText', got '${String(input.mode)}'.`);
   return adapter.remove(input, normalizeMutationOptions2(options));
 }
+function validateCCInput2(input, operationName) {
+  if (!isRecord4(input))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} input must be a non-null object.`);
+}
+function validateCCTarget2(target, operationName) {
+  if (!isRecord4(target))
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} requires a valid target with { kind, nodeType: 'sdt', nodeId }.`, {
+      field: "target",
+      value: target
+    });
+  if (!VALID_NODE_KINDS2.has(target.kind))
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} target.kind must be 'block' or 'inline', got "${String(target.kind)}".`, {
+      field: "target.kind",
+      value: target.kind
+    });
+  if (target.nodeType !== "sdt")
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} target.nodeType must be 'sdt', got "${String(target.nodeType)}".`, {
+      field: "target.nodeType",
+      value: target.nodeType
+    });
+  if (typeof target.nodeId !== "string" || target.nodeId === "")
+    throw new DocumentApiValidationError2("INVALID_TARGET", `${operationName} target.nodeId must be a non-empty string.`, {
+      field: "target.nodeId",
+      value: target.nodeId
+    });
+}
+function requireString3(value, field, operationName) {
+  if (typeof value !== "string" || value.length === 0)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be a non-empty string.`, {
+      field,
+      value
+    });
+}
+function requireBoolean2(value, field, operationName) {
+  if (typeof value !== "boolean")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be a boolean, got ${typeof value}.`, {
+      field,
+      value
+    });
+}
+function requireIndex2(value, field, operationName) {
+  if (!isInteger2(value) || value < 0)
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be a non-negative integer.`, {
+      field,
+      value
+    });
+}
+function requireNodeKind2(value, field, operationName) {
+  if (!VALID_NODE_KINDS2.has(value))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be 'block' or 'inline', got "${String(value)}".`, {
+      field,
+      value
+    });
+}
+function validateContentFormat2(value, field, operationName) {
+  if (value !== undefined && !VALID_CONTENT_FORMATS2.has(value))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be 'text' or 'html', got "${String(value)}".`, {
+      field,
+      value
+    });
+}
+function validateContentPayload2(input, operationName) {
+  if (typeof input.content !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} content must be a string.`, {
+      field: "content",
+      value: input.content
+    });
+  validateContentFormat2(input.format, "format", operationName);
+}
+function validateSymbol2(value, field, operationName) {
+  if (!isRecord4(value) || typeof value.font !== "string" || typeof value.char !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `${operationName} ${field} must be { font: string, char: string }.`, {
+      field,
+      value
+    });
+}
 function executeContentControlsList2(adapter, query2) {
+  if (query2 !== undefined && !isRecord4(query2))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "contentControls.list query must be an object if provided.");
   return adapter.list(query2);
 }
 function executeContentControlsGet2(adapter, input) {
+  validateCCInput2(input, "contentControls.get");
+  validateCCTarget2(input.target, "contentControls.get");
   return adapter.get(input);
 }
 function executeContentControlsListInRange2(adapter, input) {
+  validateCCInput2(input, "contentControls.listInRange");
+  requireString3(input.startBlockId, "startBlockId", "contentControls.listInRange");
+  requireString3(input.endBlockId, "endBlockId", "contentControls.listInRange");
   return adapter.listInRange(input);
 }
 function executeContentControlsSelectByTag2(adapter, input) {
+  validateCCInput2(input, "contentControls.selectByTag");
+  requireString3(input.tag, "tag", "contentControls.selectByTag");
   return adapter.selectByTag(input);
 }
 function executeContentControlsSelectByTitle2(adapter, input) {
+  validateCCInput2(input, "contentControls.selectByTitle");
+  requireString3(input.title, "title", "contentControls.selectByTitle");
   return adapter.selectByTitle(input);
 }
 function executeContentControlsListChildren2(adapter, input) {
+  validateCCInput2(input, "contentControls.listChildren");
+  validateCCTarget2(input.target, "contentControls.listChildren");
   return adapter.listChildren(input);
 }
 function executeContentControlsGetParent2(adapter, input) {
+  validateCCInput2(input, "contentControls.getParent");
+  validateCCTarget2(input.target, "contentControls.getParent");
   return adapter.getParent(input);
 }
 function executeContentControlsWrap2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.wrap");
+  requireNodeKind2(input.kind, "kind", "contentControls.wrap");
+  validateCCTarget2(input.target, "contentControls.wrap");
   return adapter.wrap(input, options);
 }
 function executeContentControlsUnwrap2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.unwrap");
+  validateCCTarget2(input.target, "contentControls.unwrap");
   return adapter.unwrap(input, options);
 }
 function executeContentControlsDelete2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.delete");
+  validateCCTarget2(input.target, "contentControls.delete");
   return adapter.delete(input, options);
 }
 function executeContentControlsCopy2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.copy");
+  validateCCTarget2(input.target, "contentControls.copy");
+  validateCCTarget2(input.destination, "contentControls.copy (destination)");
   return adapter.copy(input, options);
 }
 function executeContentControlsMove2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.move");
+  validateCCTarget2(input.target, "contentControls.move");
+  validateCCTarget2(input.destination, "contentControls.move (destination)");
   return adapter.move(input, options);
 }
 function executeContentControlsPatch2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.patch");
+  validateCCTarget2(input.target, "contentControls.patch");
+  if (input.appearance !== undefined && input.appearance !== null && !VALID_CC_APPEARANCES2.has(input.appearance))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.patch appearance must be one of: ${[...VALID_CC_APPEARANCES2].join(", ")}.`, {
+      field: "appearance",
+      value: input.appearance
+    });
+  if (input.showingPlaceholder !== undefined && typeof input.showingPlaceholder !== "boolean")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.patch showingPlaceholder must be a boolean, got ${typeof input.showingPlaceholder}.`, {
+      field: "showingPlaceholder",
+      value: input.showingPlaceholder
+    });
+  if (input.temporary !== undefined && typeof input.temporary !== "boolean")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.patch temporary must be a boolean, got ${typeof input.temporary}.`, {
+      field: "temporary",
+      value: input.temporary
+    });
+  if (input.tabIndex !== undefined && input.tabIndex !== null && !isInteger2(input.tabIndex))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.patch tabIndex must be an integer or null, got ${typeof input.tabIndex}.`, {
+      field: "tabIndex",
+      value: input.tabIndex
+    });
   return adapter.patch(input, options);
 }
 function executeContentControlsSetLockMode2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.setLockMode");
+  validateCCTarget2(input.target, "contentControls.setLockMode");
+  if (!VALID_LOCK_MODES$1.has(input.lockMode))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.setLockMode lockMode must be one of: ${[...VALID_LOCK_MODES$1].join(", ")}.`, {
+      field: "lockMode",
+      value: input.lockMode
+    });
   return adapter.setLockMode(input, options);
 }
 function executeContentControlsSetType2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.setType");
+  validateCCTarget2(input.target, "contentControls.setType");
+  if (!VALID_CC_TYPES2.has(input.controlType))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.setType controlType must be one of: ${[...VALID_CC_TYPES2].join(", ")}.`, {
+      field: "controlType",
+      value: input.controlType
+    });
   return adapter.setType(input, options);
 }
 function executeContentControlsGetContent2(adapter, input) {
+  validateCCInput2(input, "contentControls.getContent");
+  validateCCTarget2(input.target, "contentControls.getContent");
   return adapter.getContent(input);
 }
 function executeContentControlsReplaceContent2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.replaceContent");
+  validateCCTarget2(input.target, "contentControls.replaceContent");
+  validateContentPayload2(input, "contentControls.replaceContent");
   return adapter.replaceContent(input, options);
 }
 function executeContentControlsClearContent2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.clearContent");
+  validateCCTarget2(input.target, "contentControls.clearContent");
   return adapter.clearContent(input, options);
 }
 function executeContentControlsAppendContent2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.appendContent");
+  validateCCTarget2(input.target, "contentControls.appendContent");
+  validateContentPayload2(input, "contentControls.appendContent");
   return adapter.appendContent(input, options);
 }
 function executeContentControlsPrependContent2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.prependContent");
+  validateCCTarget2(input.target, "contentControls.prependContent");
+  validateContentPayload2(input, "contentControls.prependContent");
   return adapter.prependContent(input, options);
 }
 function executeContentControlsInsertBefore2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.insertBefore");
+  validateCCTarget2(input.target, "contentControls.insertBefore");
+  validateContentPayload2(input, "contentControls.insertBefore");
   return adapter.insertBefore(input, options);
 }
 function executeContentControlsInsertAfter2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.insertAfter");
+  validateCCTarget2(input.target, "contentControls.insertAfter");
+  validateContentPayload2(input, "contentControls.insertAfter");
   return adapter.insertAfter(input, options);
 }
 function executeContentControlsGetBinding2(adapter, input) {
+  validateCCInput2(input, "contentControls.getBinding");
+  validateCCTarget2(input.target, "contentControls.getBinding");
   return adapter.getBinding(input);
 }
 function executeContentControlsSetBinding2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.setBinding");
+  validateCCTarget2(input.target, "contentControls.setBinding");
+  requireString3(input.storeItemId, "storeItemId", "contentControls.setBinding");
+  requireString3(input.xpath, "xpath", "contentControls.setBinding");
   return adapter.setBinding(input, options);
 }
 function executeContentControlsClearBinding2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.clearBinding");
+  validateCCTarget2(input.target, "contentControls.clearBinding");
   return adapter.clearBinding(input, options);
 }
 function executeContentControlsGetRawProperties2(adapter, input) {
+  validateCCInput2(input, "contentControls.getRawProperties");
+  validateCCTarget2(input.target, "contentControls.getRawProperties");
   return adapter.getRawProperties(input);
 }
 function executeContentControlsPatchRawProperties2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.patchRawProperties");
+  validateCCTarget2(input.target, "contentControls.patchRawProperties");
+  if (!Array.isArray(input.patches))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "contentControls.patchRawProperties patches must be an array.", {
+      field: "patches",
+      value: input.patches
+    });
+  for (let i$1 = 0;i$1 < input.patches.length; i$1++) {
+    const patch = input.patches[i$1];
+    if (!isRecord4(patch))
+      throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.patchRawProperties patches[${i$1}] must be an object.`, {
+        field: `patches[${i$1}]`,
+        value: patch
+      });
+    if (!VALID_RAW_PATCH_OPS2.has(patch.op))
+      throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.patchRawProperties patches[${i$1}].op must be one of: ${[...VALID_RAW_PATCH_OPS2].join(", ")}.`, {
+        field: `patches[${i$1}].op`,
+        value: patch.op
+      });
+    if (typeof patch.name !== "string" || patch.name === "")
+      throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.patchRawProperties patches[${i$1}].name must be a non-empty string.`, {
+        field: `patches[${i$1}].name`,
+        value: patch.name
+      });
+  }
   return adapter.patchRawProperties(input, options);
 }
 function executeContentControlsValidateWordCompatibility2(adapter, input) {
+  validateCCInput2(input, "contentControls.validateWordCompatibility");
+  validateCCTarget2(input.target, "contentControls.validateWordCompatibility");
   return adapter.validateWordCompatibility(input);
 }
 function executeContentControlsNormalizeWordCompatibility2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.normalizeWordCompatibility");
+  validateCCTarget2(input.target, "contentControls.normalizeWordCompatibility");
   return adapter.normalizeWordCompatibility(input, options);
 }
 function executeContentControlsNormalizeTagPayload2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.normalizeTagPayload");
+  validateCCTarget2(input.target, "contentControls.normalizeTagPayload");
   return adapter.normalizeTagPayload(input, options);
 }
 function executeContentControlsTextSetMultiline2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.text.setMultiline");
+  validateCCTarget2(input.target, "contentControls.text.setMultiline");
+  requireBoolean2(input.multiline, "multiline", "contentControls.text.setMultiline");
   return adapter.text.setMultiline(input, options);
 }
 function executeContentControlsTextSetValue2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.text.setValue");
+  validateCCTarget2(input.target, "contentControls.text.setValue");
+  if (typeof input.value !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.text.setValue value must be a string.`, {
+      field: "value",
+      value: input.value
+    });
   return adapter.text.setValue(input, options);
 }
 function executeContentControlsTextClearValue2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.text.clearValue");
+  validateCCTarget2(input.target, "contentControls.text.clearValue");
   return adapter.text.clearValue(input, options);
 }
 function executeContentControlsDateSetValue2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.date.setValue");
+  validateCCTarget2(input.target, "contentControls.date.setValue");
+  if (typeof input.value !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.date.setValue value must be a string.`, {
+      field: "value",
+      value: input.value
+    });
   return adapter.date.setValue(input, options);
 }
 function executeContentControlsDateClearValue2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.date.clearValue");
+  validateCCTarget2(input.target, "contentControls.date.clearValue");
   return adapter.date.clearValue(input, options);
 }
 function executeContentControlsDateSetDisplayFormat2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.date.setDisplayFormat");
+  validateCCTarget2(input.target, "contentControls.date.setDisplayFormat");
+  requireString3(input.format, "format", "contentControls.date.setDisplayFormat");
   return adapter.date.setDisplayFormat(input, options);
 }
 function executeContentControlsDateSetDisplayLocale2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.date.setDisplayLocale");
+  validateCCTarget2(input.target, "contentControls.date.setDisplayLocale");
+  requireString3(input.locale, "locale", "contentControls.date.setDisplayLocale");
   return adapter.date.setDisplayLocale(input, options);
 }
 function executeContentControlsDateSetStorageFormat2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.date.setStorageFormat");
+  validateCCTarget2(input.target, "contentControls.date.setStorageFormat");
+  requireString3(input.format, "format", "contentControls.date.setStorageFormat");
   return adapter.date.setStorageFormat(input, options);
 }
 function executeContentControlsDateSetCalendar2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.date.setCalendar");
+  validateCCTarget2(input.target, "contentControls.date.setCalendar");
+  requireString3(input.calendar, "calendar", "contentControls.date.setCalendar");
   return adapter.date.setCalendar(input, options);
 }
 function executeContentControlsCheckboxGetState2(adapter, input) {
+  validateCCInput2(input, "contentControls.checkbox.getState");
+  validateCCTarget2(input.target, "contentControls.checkbox.getState");
   return adapter.checkbox.getState(input);
 }
 function executeContentControlsCheckboxSetState2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.checkbox.setState");
+  validateCCTarget2(input.target, "contentControls.checkbox.setState");
+  requireBoolean2(input.checked, "checked", "contentControls.checkbox.setState");
   return adapter.checkbox.setState(input, options);
 }
 function executeContentControlsCheckboxToggle2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.checkbox.toggle");
+  validateCCTarget2(input.target, "contentControls.checkbox.toggle");
   return adapter.checkbox.toggle(input, options);
 }
 function executeContentControlsCheckboxSetSymbolPair2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.checkbox.setSymbolPair");
+  validateCCTarget2(input.target, "contentControls.checkbox.setSymbolPair");
+  validateSymbol2(input.checkedSymbol, "checkedSymbol", "contentControls.checkbox.setSymbolPair");
+  validateSymbol2(input.uncheckedSymbol, "uncheckedSymbol", "contentControls.checkbox.setSymbolPair");
   return adapter.checkbox.setSymbolPair(input, options);
 }
 function executeContentControlsChoiceListGetItems2(adapter, input) {
+  validateCCInput2(input, "contentControls.choiceList.getItems");
+  validateCCTarget2(input.target, "contentControls.choiceList.getItems");
   return adapter.choiceList.getItems(input);
 }
 function executeContentControlsChoiceListSetItems2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.choiceList.setItems");
+  validateCCTarget2(input.target, "contentControls.choiceList.setItems");
+  if (!Array.isArray(input.items))
+    throw new DocumentApiValidationError2("INVALID_INPUT", "contentControls.choiceList.setItems items must be an array.", {
+      field: "items",
+      value: input.items
+    });
+  for (let i$1 = 0;i$1 < input.items.length; i$1++) {
+    const item = input.items[i$1];
+    if (!isRecord4(item) || typeof item.displayText !== "string" || typeof item.value !== "string")
+      throw new DocumentApiValidationError2("INVALID_INPUT", `contentControls.choiceList.setItems items[${i$1}] must be { displayText: string, value: string }.`, {
+        field: `items[${i$1}]`,
+        value: item
+      });
+  }
   return adapter.choiceList.setItems(input, options);
 }
 function executeContentControlsChoiceListSetSelected2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.choiceList.setSelected");
+  validateCCTarget2(input.target, "contentControls.choiceList.setSelected");
+  if (typeof input.value !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", "contentControls.choiceList.setSelected value must be a string.", {
+      field: "value",
+      value: input.value
+    });
   return adapter.choiceList.setSelected(input, options);
 }
 function executeContentControlsRepeatingSectionListItems2(adapter, input) {
+  validateCCInput2(input, "contentControls.repeatingSection.listItems");
+  validateCCTarget2(input.target, "contentControls.repeatingSection.listItems");
   return adapter.repeatingSection.listItems(input);
 }
 function executeContentControlsRepeatingSectionInsertItemBefore2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.repeatingSection.insertItemBefore");
+  validateCCTarget2(input.target, "contentControls.repeatingSection.insertItemBefore");
+  requireIndex2(input.index, "index", "contentControls.repeatingSection.insertItemBefore");
   return adapter.repeatingSection.insertItemBefore(input, options);
 }
 function executeContentControlsRepeatingSectionInsertItemAfter2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.repeatingSection.insertItemAfter");
+  validateCCTarget2(input.target, "contentControls.repeatingSection.insertItemAfter");
+  requireIndex2(input.index, "index", "contentControls.repeatingSection.insertItemAfter");
   return adapter.repeatingSection.insertItemAfter(input, options);
 }
 function executeContentControlsRepeatingSectionCloneItem2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.repeatingSection.cloneItem");
+  validateCCTarget2(input.target, "contentControls.repeatingSection.cloneItem");
+  requireIndex2(input.index, "index", "contentControls.repeatingSection.cloneItem");
   return adapter.repeatingSection.cloneItem(input, options);
 }
 function executeContentControlsRepeatingSectionDeleteItem2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.repeatingSection.deleteItem");
+  validateCCTarget2(input.target, "contentControls.repeatingSection.deleteItem");
+  requireIndex2(input.index, "index", "contentControls.repeatingSection.deleteItem");
   return adapter.repeatingSection.deleteItem(input, options);
 }
 function executeContentControlsRepeatingSectionSetAllowInsertDelete2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.repeatingSection.setAllowInsertDelete");
+  validateCCTarget2(input.target, "contentControls.repeatingSection.setAllowInsertDelete");
+  requireBoolean2(input.allow, "allow", "contentControls.repeatingSection.setAllowInsertDelete");
   return adapter.repeatingSection.setAllowInsertDelete(input, options);
 }
 function executeContentControlsGroupWrap2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.group.wrap");
+  validateCCTarget2(input.target, "contentControls.group.wrap");
   return adapter.group.wrap(input, options);
 }
 function executeContentControlsGroupUngroup2(adapter, input, options) {
+  validateCCInput2(input, "contentControls.group.ungroup");
+  validateCCTarget2(input.target, "contentControls.group.ungroup");
   return adapter.group.ungroup(input, options);
 }
 function executeCreateContentControl2(adapter, input, options) {
+  validateCCInput2(input, "create.contentControl");
+  requireNodeKind2(input.kind, "kind", "create.contentControl");
+  if (input.controlType !== undefined && !VALID_CC_TYPES2.has(input.controlType))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `create.contentControl controlType must be one of: ${[...VALID_CC_TYPES2].join(", ")}.`, {
+      field: "controlType",
+      value: input.controlType
+    });
+  if (input.lockMode !== undefined && !VALID_LOCK_MODES$1.has(input.lockMode))
+    throw new DocumentApiValidationError2("INVALID_INPUT", `create.contentControl lockMode must be one of: ${[...VALID_LOCK_MODES$1].join(", ")}.`, {
+      field: "lockMode",
+      value: input.lockMode
+    });
+  if (input.target !== undefined)
+    validateCCTarget2(input.target, "create.contentControl");
+  if (input.content !== undefined && typeof input.content !== "string")
+    throw new DocumentApiValidationError2("INVALID_INPUT", `create.contentControl content must be a string, got ${typeof input.content}.`, {
+      field: "content",
+      value: input.content
+    });
   return adapter.create(input, options);
 }
 function validateBookmarkTarget2(target, operationName) {
@@ -49007,6 +50769,18 @@ function buildPath(existingPath = [], node3, branch) {
     path2.push(branch);
   return path2;
 }
+function isInlineNode(node3, schema) {
+  if (!node3 || typeof node3 !== "object" || typeof node3.type !== "string")
+    return false;
+  const nodeType = schema?.nodes?.[node3.type];
+  if (nodeType) {
+    if (typeof nodeType.isInline === "boolean")
+      return nodeType.isInline;
+    if (nodeType.spec?.group && typeof nodeType.spec.group === "string")
+      return nodeType.spec.group.split(" ").includes("inline");
+  }
+  return INLINE_FALLBACK_TYPES.has(node3.type);
+}
 function getTableStyleId(path2) {
   const tbl = path2.find((ancestor) => ancestor.name === "w:tbl");
   if (!tbl)
@@ -49019,6 +50793,76 @@ function getTableStyleId(path2) {
     return;
   return tblStyle.attributes?.["w:val"];
 }
+function cloneParagraphAttrsForFragment(attrs, { keepSectPr = false } = {}) {
+  if (!attrs)
+    return {};
+  const nextAttrs = { ...attrs };
+  if (attrs.paragraphProperties && typeof attrs.paragraphProperties === "object") {
+    nextAttrs.paragraphProperties = { ...attrs.paragraphProperties };
+    if (!keepSectPr)
+      delete nextAttrs.paragraphProperties.sectPr;
+  }
+  if (!keepSectPr)
+    delete nextAttrs.pageBreakSource;
+  return nextAttrs;
+}
+function hasSectionBreakAttrs(attrs) {
+  return Boolean(attrs?.paragraphProperties?.sectPr);
+}
+function cloneWrapperParagraphAttrs(attrs) {
+  return cloneParagraphAttrsForFragment(attrs, { keepSectPr: true });
+}
+function normalizeParagraphChildren(children, schema, textblockAttrs) {
+  const normalized = [];
+  let pendingInline = [];
+  const flushInline = () => {
+    if (!pendingInline.length)
+      return;
+    normalized.push({
+      type: "paragraph",
+      attrs: null,
+      content: pendingInline,
+      marks: []
+    });
+    pendingInline = [];
+  };
+  for (const child of children || []) {
+    if (isInlineNode(child, schema)) {
+      pendingInline.push(child);
+      continue;
+    }
+    flushInline();
+    if (child != null)
+      normalized.push(child);
+  }
+  flushInline();
+  const lastNodeIndex = normalized.length - 1;
+  const isSingleBlockResult = normalized.length === 1 && normalized[0] != null && normalized[0]?.type !== "paragraph";
+  const paragraphIndexes = normalized.reduce((indexes, node3, index2) => {
+    if (node3?.type === "paragraph")
+      indexes.push(index2);
+    return indexes;
+  }, []);
+  const lastParagraphIndex = paragraphIndexes.length ? paragraphIndexes[paragraphIndexes.length - 1] : -1;
+  const shouldAttachWrapperParagraph = isSingleBlockResult || hasSectionBreakAttrs(textblockAttrs) && lastNodeIndex !== lastParagraphIndex;
+  paragraphIndexes.forEach((index2) => {
+    normalized[index2] = {
+      ...normalized[index2],
+      attrs: cloneParagraphAttrsForFragment(textblockAttrs, { keepSectPr: !shouldAttachWrapperParagraph && index2 === lastParagraphIndex })
+    };
+  });
+  if (shouldAttachWrapperParagraph) {
+    const lastNode = normalized[lastNodeIndex];
+    normalized[lastNodeIndex] = {
+      ...lastNode,
+      attrs: {
+        ...lastNode?.attrs || {},
+        wrapperParagraph: cloneWrapperParagraphAttrs(textblockAttrs)
+      }
+    };
+  }
+  return normalized;
+}
 function generateParagraphProperties(params) {
   const { node: node3 } = params;
   const { attrs = {} } = node3;
@@ -49103,6 +50947,21 @@ function translateParagraphNode(params) {
     attributes
   };
 }
+function partitionEncodedParagraphAttrs(encodedAttrs = {}) {
+  const identityAttrs = {};
+  const shareableAttrs = {};
+  Object.entries(encodedAttrs).forEach(([key, value]) => {
+    if (IDENTITY_ATTR_NAMES.has(key)) {
+      identityAttrs[key] = value;
+      return;
+    }
+    shareableAttrs[key] = value;
+  });
+  return {
+    identityAttrs,
+    shareableAttrs
+  };
+}
 function generateDocxRandomId(length = 8) {
   return Math.floor(Math.random() * 2147483648).toString(16).toUpperCase().padStart(length, "0").slice(0, length);
 }
@@ -49253,7 +51112,6 @@ function normalizeTableCellContent(content$2, editor) {
     return content$2;
   const normalized = [];
   const pendingForNextBlock = [];
-  const schema = editor?.schema;
   const cloneBlock = (node3) => {
     if (!node3)
       return node3;
@@ -49268,28 +51126,12 @@ function normalizeTableCellContent(content$2, editor) {
       node3.content = [];
     return node3.content;
   };
-  const isInlineNode = (node3) => {
-    if (!node3 || typeof node3.type !== "string")
-      return false;
-    if (node3.type === "text")
-      return true;
-    if (node3.type === "bookmarkStart" || node3.type === "bookmarkEnd")
-      return true;
-    const nodeType = schema?.nodes?.[node3.type];
-    if (nodeType) {
-      if (typeof nodeType.isInline === "boolean")
-        return nodeType.isInline;
-      if (nodeType.spec?.group && typeof nodeType.spec.group === "string")
-        return nodeType.spec.group.split(" ").includes("inline");
-    }
-    return false;
-  };
   for (const node3 of content$2) {
     if (!node3 || typeof node3.type !== "string") {
       normalized.push(node3);
       continue;
     }
-    if (!isInlineNode(node3)) {
+    if (!isInlineNode(node3, editor?.schema)) {
       const blockNode = cloneBlock(node3);
       if (pendingForNextBlock.length) {
         const blockContent = ensureArray(blockNode);
@@ -49303,7 +51145,7 @@ function normalizeTableCellContent(content$2, editor) {
       pendingForNextBlock.push(node3);
     else {
       const lastNode = normalized[normalized.length - 1];
-      if (!lastNode || typeof lastNode.type !== "string" || isInlineNode(lastNode)) {
+      if (!lastNode || typeof lastNode.type !== "string" || isInlineNode(lastNode, editor?.schema)) {
         pendingForNextBlock.push(node3);
         continue;
       }
@@ -49316,7 +51158,7 @@ function normalizeTableCellContent(content$2, editor) {
   if (pendingForNextBlock.length) {
     if (normalized.length) {
       const lastNode = normalized[normalized.length - 1];
-      if (lastNode && typeof lastNode.type === "string" && !isInlineNode(lastNode)) {
+      if (lastNode && typeof lastNode.type === "string" && !isInlineNode(lastNode, editor?.schema)) {
         ensureArray(lastNode).push(...pendingForNextBlock);
         pendingForNextBlock.length = 0;
       }
@@ -51439,11 +53281,16 @@ function preProcessCitationInstruction(nodesToCombine, instrText, _docx, instruc
   }];
 }
 function preProcessBibliographyInstruction(nodesToCombine, instrText) {
+  const contentNodes = Array.isArray(nodesToCombine) && nodesToCombine.length > 0 ? nodesToCombine : [{
+    name: "w:p",
+    type: "element",
+    elements: []
+  }];
   return [{
     name: "sd:bibliography",
     type: "element",
     attributes: { instruction: instrText },
-    elements: nodesToCombine
+    elements: contentNodes
   }];
 }
 function preProcessTaInstruction(nodesToCombine, instrText, _docx, instructionTokens = null) {
@@ -59370,7 +61217,7 @@ function handleHtmlPaste(html2, editor, source) {
     cleanedHtml = htmlHandler(html2, editor);
   if (cleanedHtml?.dataset)
     cleanedHtml.dataset.superdocImport = "true";
-  let doc$2 = DOMParser$1.fromSchema(editor.schema).parse(cleanedHtml);
+  let doc$2 = DOMParser$1.fromSchema(editor.schema).parse(cleanedHtml, { preserveWhitespace: true });
   doc$2 = mergeAdjacentTableFragments(doc$2);
   doc$2 = wrapTextsInRuns(doc$2);
   const { dispatch, state } = editor.view;
@@ -65162,13 +67009,38 @@ function translateDocumentPartObj(params) {
     ...params,
     nodes: node3.content
   });
-  return {
+  const result = {
     name: "w:sdt",
     elements: [generateSdtPrForDocPartObj(attrs), {
       name: "w:sdtContent",
       elements: childContent
     }]
   };
+  if (!attrs.wrapperParagraph)
+    return result;
+  return wrapDocumentPartInParagraph(result, attrs.wrapperParagraph);
+}
+function wrapDocumentPartInParagraph(sdtNode, wrapperParagraphAttrs) {
+  const elements = [];
+  const pPr = generateParagraphProperties({ node: {
+    type: "paragraph",
+    attrs: wrapperParagraphAttrs
+  } });
+  if (pPr)
+    elements.push(pPr);
+  elements.push(sdtNode);
+  const attributes = {
+    ...extractRawParagraphXmlAttributes(wrapperParagraphAttrs),
+    ...translator.decodeAttributes({ node: { attrs: wrapperParagraphAttrs } })
+  };
+  return {
+    name: "w:p",
+    elements,
+    ...Object.keys(attributes).length ? { attributes } : {}
+  };
+}
+function extractRawParagraphXmlAttributes(attrs = {}) {
+  return Object.fromEntries(Object.entries(attrs).filter(([key]) => key.includes(":")));
 }
 function sanitizeId(id) {
   if (typeof id === "string" && id.trim() !== "")
@@ -72069,7 +73941,7 @@ function resolveControlType(attrs) {
 }
 function resolveLockMode(attrs) {
   const raw = attrs.lockMode;
-  if (typeof raw === "string" && VALID_LOCK_MODES.includes(raw))
+  if (typeof raw === "string" && VALID_LOCK_MODES2.includes(raw))
     return raw;
   return "unlocked";
 }
@@ -75221,7 +77093,7 @@ var isRegExp = (value) => {
 }, decode$73 = (attrs) => {
   const { pos } = attrs || {};
   return pos?.toString();
-}, attributes_default$6, DocumentApiValidationError2, NODE_TYPES2, BLOCK_NODE_TYPES2, DELETABLE_BLOCK_NODE_TYPES2, INLINE_NODE_TYPES2, SELECTION_EDGE_NODE_TYPES2, MARK_KEYS, INLINE_DIRECTIVES2, SD_CONTENT_NODE_KINDS2, SD_INLINE_NODE_KINDS2, PLACEMENT_VALUES2, TABLE_NESTING_POLICY_VALUES2, DEFAULT_NESTING_POLICY2, STORY_TYPES2, STORY_HEADER_FOOTER_KINDS2, STORY_HEADER_FOOTER_VARIANTS2, STORY_HEADER_FOOTER_RESOLUTIONS2, STORY_HEADER_FOOTER_ON_WRITE_VALUES2, BLOCK_NODE_TYPES_SET2, NESTING_POLICY_ALLOWED_KEYS2, schemaBooleanOrNull2 = () => ({ oneOf: [{ type: "boolean" }, { type: "null" }] }), schemaStringOrNull2 = () => ({ oneOf: [{
+}, attributes_default$6, DocumentApiValidationError2, NODE_KINDS2, NODE_TYPES2, BLOCK_NODE_TYPES2, DELETABLE_BLOCK_NODE_TYPES2, INLINE_NODE_TYPES2, SELECTION_EDGE_NODE_TYPES2, MARK_KEYS, INLINE_DIRECTIVES2, SD_CONTENT_NODE_KINDS2, SD_INLINE_NODE_KINDS2, PLACEMENT_VALUES2, TABLE_NESTING_POLICY_VALUES2, DEFAULT_NESTING_POLICY2, STORY_TYPES2, STORY_HEADER_FOOTER_KINDS2, STORY_HEADER_FOOTER_VARIANTS2, STORY_HEADER_FOOTER_RESOLUTIONS2, STORY_HEADER_FOOTER_ON_WRITE_VALUES2, BLOCK_NODE_TYPES_SET2, NESTING_POLICY_ALLOWED_KEYS2, schemaBooleanOrNull2 = () => ({ oneOf: [{ type: "boolean" }, { type: "null" }] }), schemaStringOrNull2 = () => ({ oneOf: [{
   type: "string",
   minLength: 1
 }, { type: "null" }] }), schemaNumberOrNull2 = () => ({ oneOf: [{ type: "number" }, { type: "null" }] }), schemaObjectOrNull2 = (properties) => ({ oneOf: [{
@@ -75261,7 +77133,7 @@ var isRegExp = (value) => {
   tracked: false,
   carrier: runAttributeCarrier2(runPropertyKey ?? key),
   schema
-}), INLINE_PROPERTY_REGISTRY2, INLINE_PROPERTY_KEY_SET2, INLINE_PROPERTY_BY_KEY2, UNDERLINE_OBJECT_ALLOWED_KEYS2, SHADING_ALLOWED_KEYS2, BORDER_ALLOWED_KEYS2, FIT_TEXT_ALLOWED_KEYS2, LANG_ALLOWED_KEYS2, RFONTS_ALLOWED_KEYS2, EAST_ASIAN_LAYOUT_ALLOWED_KEYS2, STYLISTIC_SET_ALLOWED_KEYS2, VERT_ALIGN_VALUES2, PROPERTY_VALIDATOR_MAP2, NONE_FAILURES2, NONE_THROWS2, T_NOT_FOUND2, T_NOT_FOUND_CAPABLE2, T_PLAN_ENGINE2, T_NOT_FOUND_COMMAND2, T_IMAGE_COMMAND2, T_CC_READ2, T_CC_MUTATION2, T_CC_TYPED2, T_CC_TYPED_READ2, T_CC_RAW2, T_QUERY_MATCH2, T_SECTION_CREATE2, T_SECTION_READ2, T_PARAGRAPH_MUTATION2, T_SECTION_MUTATION2, T_SECTION_SETTINGS_MUTATION2, T_HEADER_FOOTER_MUTATION2, T_STORY2, T_REF_READ_LIST2, T_REF_MUTATION2, T_REF_MUTATION_REMOVE2, T_REF_INSERT2, FORMAT_INLINE_ALIAS_OPERATION_DEFINITIONS2, OPERATION_DEFINITIONS2, OPERATION_IDS2, COMMAND_CATALOG3, PARAGRAPH_ALIGNMENTS2, TAB_STOP_ALIGNMENTS2, TAB_STOP_LEADERS2, BORDER_SIDES2, CLEAR_BORDER_SIDES2, LINE_RULES2, PARAGRAPH_DIRECTIONS2, ALIGNMENT_POLICIES2, PARAGRAPH_BLOCK_TYPES2, SET_STYLE_KEYS2, CLEAR_STYLE_KEYS2, RESET_DIRECT_FORMATTING_KEYS2, SET_ALIGNMENT_KEYS2, CLEAR_ALIGNMENT_KEYS2, SET_INDENTATION_KEYS2, CLEAR_INDENTATION_KEYS2, SET_SPACING_KEYS2, CLEAR_SPACING_KEYS2, SET_KEEP_OPTIONS_KEYS2, SET_OUTLINE_LEVEL_KEYS2, SET_FLOW_OPTIONS_KEYS2, SET_TAB_STOP_KEYS2, CLEAR_TAB_STOP_KEYS2, CLEAR_ALL_TAB_STOPS_KEYS2, SET_BORDER_KEYS2, CLEAR_BORDER_KEYS2, SET_SHADING_KEYS2, CLEAR_SHADING_KEYS2, SET_DIRECTION_KEYS2, CLEAR_DIRECTION_KEYS2, ST_ON_OFF_ON_VALUES2, ST_ON_OFF_OFF_VALUES2, ST_UNDERLINE_VALUES2, ST_UNDERLINE_VALUE_SET2, ST_VERTICAL_ALIGN_RUN2, ST_EM2, ST_TEXT_ALIGNMENT2, ST_TEXT_DIRECTION2, ST_TEXTBOX_TIGHT_WRAP2, ST_TEXT_TRANSFORM2, ST_JUSTIFICATION2, FONT_FAMILY_SCHEMA2, COLOR_SCHEMA2, SPACING_SCHEMA2, INDENT_SCHEMA2, UNDERLINE_SCHEMA2, BORDER_PROPERTIES_SCHEMA2, SHADING_SCHEMA2, LANG_SCHEMA2, EAST_ASIAN_LAYOUT_SCHEMA2, FIT_TEXT_SCHEMA2, NUMBERING_PROPERTIES_SCHEMA2, FRAME_PR_SCHEMA2, PARAGRAPH_BORDERS_SCHEMA2, TAB_STOP_SCHEMA2, PROPERTY_REGISTRY2, ALLOWED_KEYS_BY_CHANNEL2, PROPERTY_INDEX2, EXCLUDED_KEYS2, INPUT_ALLOWED_KEYS2, TARGET_ALLOWED_KEYS2, OPTIONS_ALLOWED_KEYS2, VALID_CHANNELS2, Z_ORDER_RELATIVE_HEIGHT_MAX2 = 4294967295, nodeTypeValues2, blockNodeTypeValues2, deletableBlockNodeTypeValues2, inlineNodeTypeValues2, rangeSchema2, textAddressSchema2, textTargetSchema2, blockNodeAddressSchema2, deletableBlockNodeAddressSchema2, tableAddressSchema2, tableRowAddressSchema2, tableCellAddressSchema2, tableOrCellAddressSchema2, paragraphAddressSchema2, headingAddressSchema2, listItemAddressSchema2, paragraphTargetSchema2, sectionAddressSchema2, nodeAddressSchema2, commentAddressSchema2, trackedChangeAddressSchema2, entityAddressSchema2, selectionTargetSchema2, deleteBehaviorSchema2, resolvedHandleSchema2, pageInfoSchema2, receiptSuccessSchema2, textMutationRangeSchema2, textMutationResolutionSchema2, textMutationSuccessSchema2, matchBlockSchema2, storyLocatorSchema2, trackChangeRefSchema2, createParagraphSuccessSchema2, createHeadingSuccessSchema2, headingLevelSchema2, listsInsertSuccessSchema2, listsMutateItemSuccessSchema2, textSelectorSchema2, nodeSelectorSchema2, sdMutationResolutionSchema2, sdMutationSuccessSchema2, documentInfoCountsSchema2, documentInfoOutlineItemSchema2, documentInfoCapabilitiesSchema2, documentStylesSchema2, documentDefaultsSchema2, listKindSchema2, listInsertPositionSchema2, sectionBreakTypeSchema2, sectionOrientationSchema2, sectionVerticalAlignSchema2, sectionDirectionSchema2, sectionHeaderFooterKindSchema2, sectionHeaderFooterVariantSchema2, sectionLineNumberRestartSchema2, sectionPageNumberFormatSchema2, sectionRangeDomainSchema2, sectionPageMarginsSchema2, sectionHeaderFooterMarginsSchema2, sectionPageSetupSchema2, sectionColumnsSchema2, sectionLineNumberingSchema2, sectionPageNumberingSchema2, sectionHeaderFooterRefsSchema2, sectionBorderSpecSchema2, sectionPageBordersSchema2, sectionMutationSuccessSchema2, documentMutationSuccessSchema2, paragraphMutationTargetSchema2, paragraphMutationSuccessSchema2, createSectionBreakSuccessSchema2, capabilityReasonsSchema2, capabilityFlagSchema2, operationRuntimeCapabilitySchema2, operationCapabilitiesSchema2, inlinePropertyCapabilitySchema2, formatCapabilitiesSchema2, planEngineCapabilitiesSchema2, nullableTableBorderSpecSchema2, sdFragmentSchema2, placementSchema2, nestingPolicySchema2, tableCreateLocationSchema2, formatInlineAliasOperationSchemas2, tocMutationFailureSchema2, tocMutationSuccessSchema2, tocEntryMutationFailureSchema2, tocEntryMutationSuccessSchema2, hyperlinkTargetSchema2, hyperlinkReadPropertiesSchema2, hyperlinkSpecSchema2, hyperlinkPatchSchema2, hyperlinkDomainSchema2, hyperlinkMutationSuccessSchema2, hyperlinkMutationFailureSchema2, contentControlTargetSchema2, contentControlMutationSuccessSchema2, contentControlMutationFailureSchema2, ccListResultSchema2, ccInfoSchema2, refFailureSchema2, bookmarkAddressSchema2, bookmarkMutation2, footnoteAddressSchema2, footnoteConfigScopeSchema2, footnoteNumberingSchema2, footnoteMutation2, footnoteConfig2, crossRefAddressSchema2, crossRefTargetSchema2, crossRefDisplaySchema2, crossRefMutation2, indexAddressSchema2, indexEntryAddressSchema2, indexConfigSchema2, indexEntryDataSchema2, indexEntryPatchSchema2, indexMutation2, indexEntryMutation2, captionAddressSchema2, captionMutation2, captionConfig2, fieldAddressSchema2, fieldMutation2, citationAddressSchema2, citationSourceAddressSchema2, bibliographyAddressSchema2, citationMutation2, citationSourceMutation2, bibliographyMutation2, citationPersonSchema2, citationSourceFieldsSchema2, tocCreateLocationSchema2, authoritiesAddressSchema2, authorityEntryAddressSchema2, authoritiesConfigSchema2, authorityEntryDataSchema2, authorityEntryPatchSchema2, authoritiesMutation2, authorityEntryMutation2, diffCoverageSchema2, diffSummarySchema2, diffSnapshotSchema2, diffPayloadSchema2, GROUP_METADATA2, STEP_OP_CATALOG_UNFROZEN2, PUBLIC_STEP_OP_CATALOG_UNFROZEN2, PUBLIC_MUTATION_STEP_OP_IDS2, PUBLIC_MUTATION_STEP_OP_SET2, CAPABILITY_REASON_CODES, VALID_EDGE_VALUES2, VALID_EDGE_NODE_TYPES2, VALID_DOCUMENT_EDGES2, VALID_REF_BOUNDARIES2, VALID_ANCHOR_KINDS2, RESOLVE_RANGE_ALLOWED_KEYS2, CREATE_COMMENT_ALLOWED_KEYS2, PATCH_COMMENT_ALLOWED_KEYS2, STYLE_APPLY_INPUT_ALLOWED_KEYS2, INLINE_ALIAS_INPUT_ALLOWED_KEYS2, DELETE_INPUT_ALLOWED_KEYS2, VALID_BEHAVIORS2, CONTENT_KIND_SET2, INLINE_KIND_SET2, LEGACY_TOP_LEVEL_TYPES2, TEXT_INSERT_ALLOWED_KEYS2, STRUCTURAL_INSERT_ALLOWED_KEYS2, VALID_INSERT_TYPES2, TEXT_REPLACE_ALLOWED_KEYS2, STRUCTURAL_REPLACE_ALLOWED_KEYS2, SECTION_BREAK_TYPES$1, SUPPORTED_DELETE_NODE_TYPES2, REJECTED_DELETE_NODE_TYPES2, VALID_BLOCK_NODE_TYPES2, SNAPSHOT_VERSION2 = "sd-diff-snapshot/v1", PAYLOAD_VERSION2 = "sd-diff-payload/v1", VALID_STYLE_OPTION_FLAGS2, TABLE_BORDER_COLOR_PATTERN2, VALID_APPLY_TO_VALUES2, VALID_BORDER_EDGE_KEYS2, HEADER_FOOTER_KINDS$1, HEADER_FOOTER_VARIANTS$1, DEFAULT_SECTIONS_LIST_LIMIT2 = 250, SECTION_BREAK_TYPES3, SECTION_ORIENTATIONS2, SECTION_VERTICAL_ALIGNS2, SECTION_DIRECTIONS2, HEADER_FOOTER_KINDS3, HEADER_FOOTER_VARIANTS3, LINE_NUMBER_RESTARTS2, PAGE_NUMBER_FORMATS2, PAGE_BORDER_DISPLAYS2, PAGE_BORDER_OFFSET_FROM_VALUES2, PAGE_BORDER_Z_ORDER_VALUES2, VALID_WRAP_TYPES2, VALID_WRAP_SIDES2, VALID_IMAGE_SIZE_UNITS2, PATCH_FIELDS2, VALID_CREATE_LOCATION_KINDS2, ADAPTER_GATED_PREFIXES2, _buffers, _defaultCollectionId = null, _nextCollectionId = 1, generateV2HandlerEntity = (handlerName, translator$216) => ({
+}), INLINE_PROPERTY_REGISTRY2, INLINE_PROPERTY_KEY_SET2, INLINE_PROPERTY_BY_KEY2, UNDERLINE_OBJECT_ALLOWED_KEYS2, SHADING_ALLOWED_KEYS2, BORDER_ALLOWED_KEYS2, FIT_TEXT_ALLOWED_KEYS2, LANG_ALLOWED_KEYS2, RFONTS_ALLOWED_KEYS2, EAST_ASIAN_LAYOUT_ALLOWED_KEYS2, STYLISTIC_SET_ALLOWED_KEYS2, VERT_ALIGN_VALUES2, PROPERTY_VALIDATOR_MAP2, NONE_FAILURES2, NONE_THROWS2, T_NOT_FOUND2, T_NOT_FOUND_CAPABLE2, T_PLAN_ENGINE2, T_NOT_FOUND_COMMAND2, T_IMAGE_COMMAND2, T_CC_READ2, T_CC_MUTATION2, T_CC_TYPED2, T_CC_TYPED_READ2, T_CC_RAW2, T_QUERY_MATCH2, T_SECTION_CREATE2, T_SECTION_READ2, T_PARAGRAPH_MUTATION2, T_SECTION_MUTATION2, T_SECTION_SETTINGS_MUTATION2, T_HEADER_FOOTER_MUTATION2, T_STORY2, T_REF_READ_LIST2, T_REF_MUTATION2, T_REF_MUTATION_REMOVE2, T_REF_INSERT2, FORMAT_INLINE_ALIAS_OPERATION_DEFINITIONS2, OPERATION_DEFINITIONS2, OPERATION_IDS2, COMMAND_CATALOG3, PARAGRAPH_ALIGNMENTS2, TAB_STOP_ALIGNMENTS2, TAB_STOP_LEADERS2, BORDER_SIDES2, CLEAR_BORDER_SIDES2, LINE_RULES2, PARAGRAPH_DIRECTIONS2, ALIGNMENT_POLICIES2, PARAGRAPH_BLOCK_TYPES2, SET_STYLE_KEYS2, CLEAR_STYLE_KEYS2, RESET_DIRECT_FORMATTING_KEYS2, SET_ALIGNMENT_KEYS2, CLEAR_ALIGNMENT_KEYS2, SET_INDENTATION_KEYS2, CLEAR_INDENTATION_KEYS2, SET_SPACING_KEYS2, CLEAR_SPACING_KEYS2, SET_KEEP_OPTIONS_KEYS2, SET_OUTLINE_LEVEL_KEYS2, SET_FLOW_OPTIONS_KEYS2, SET_TAB_STOP_KEYS2, CLEAR_TAB_STOP_KEYS2, CLEAR_ALL_TAB_STOPS_KEYS2, SET_BORDER_KEYS2, CLEAR_BORDER_KEYS2, SET_SHADING_KEYS2, CLEAR_SHADING_KEYS2, SET_DIRECTION_KEYS2, CLEAR_DIRECTION_KEYS2, ST_ON_OFF_ON_VALUES2, ST_ON_OFF_OFF_VALUES2, ST_UNDERLINE_VALUES2, ST_UNDERLINE_VALUE_SET2, ST_VERTICAL_ALIGN_RUN2, ST_EM2, ST_TEXT_ALIGNMENT2, ST_TEXT_DIRECTION2, ST_TEXTBOX_TIGHT_WRAP2, ST_TEXT_TRANSFORM2, ST_JUSTIFICATION2, FONT_FAMILY_SCHEMA2, COLOR_SCHEMA2, SPACING_SCHEMA2, INDENT_SCHEMA2, UNDERLINE_SCHEMA2, BORDER_PROPERTIES_SCHEMA2, SHADING_SCHEMA2, LANG_SCHEMA2, EAST_ASIAN_LAYOUT_SCHEMA2, FIT_TEXT_SCHEMA2, NUMBERING_PROPERTIES_SCHEMA2, FRAME_PR_SCHEMA2, PARAGRAPH_BORDERS_SCHEMA2, TAB_STOP_SCHEMA2, PROPERTY_REGISTRY2, ALLOWED_KEYS_BY_CHANNEL2, PROPERTY_INDEX2, EXCLUDED_KEYS2, INPUT_ALLOWED_KEYS2, TARGET_ALLOWED_KEYS2, OPTIONS_ALLOWED_KEYS2, VALID_CHANNELS2, Z_ORDER_RELATIVE_HEIGHT_MAX2 = 4294967295, nodeTypeValues2, blockNodeTypeValues2, deletableBlockNodeTypeValues2, inlineNodeTypeValues2, rangeSchema2, textAddressSchema2, textTargetSchema2, blockNodeAddressSchema2, deletableBlockNodeAddressSchema2, tableAddressSchema2, tableRowAddressSchema2, tableCellAddressSchema2, tableOrCellAddressSchema2, paragraphAddressSchema2, headingAddressSchema2, listItemAddressSchema2, paragraphTargetSchema2, sectionAddressSchema2, nodeAddressSchema2, commentAddressSchema2, trackedChangeAddressSchema2, entityAddressSchema2, selectionTargetSchema2, deleteBehaviorSchema2, resolvedHandleSchema2, pageInfoSchema2, receiptSuccessSchema2, textMutationRangeSchema2, textMutationResolutionSchema2, textMutationSuccessSchema2, matchBlockSchema2, storyLocatorSchema2, trackChangeRefSchema2, createParagraphSuccessSchema2, createHeadingSuccessSchema2, headingLevelSchema2, listsInsertSuccessSchema2, listsMutateItemSuccessSchema2, textSelectorSchema2, nodeSelectorSchema2, sdMutationResolutionSchema2, sdMutationSuccessSchema2, documentInfoCountsSchema2, documentInfoOutlineItemSchema2, documentInfoCapabilitiesSchema2, documentStylesSchema2, documentDefaultsSchema2, listKindSchema2, listInsertPositionSchema2, sectionBreakTypeSchema2, sectionOrientationSchema2, sectionVerticalAlignSchema2, sectionDirectionSchema2, sectionHeaderFooterKindSchema2, sectionHeaderFooterVariantSchema2, sectionLineNumberRestartSchema2, sectionPageNumberFormatSchema2, sectionRangeDomainSchema2, sectionPageMarginsSchema2, sectionHeaderFooterMarginsSchema2, sectionPageSetupSchema2, sectionColumnsSchema2, sectionLineNumberingSchema2, sectionPageNumberingSchema2, sectionHeaderFooterRefsSchema2, sectionBorderSpecSchema2, sectionPageBordersSchema2, sectionMutationSuccessSchema2, documentMutationSuccessSchema2, paragraphMutationTargetSchema2, paragraphMutationSuccessSchema2, createSectionBreakSuccessSchema2, capabilityReasonsSchema2, capabilityFlagSchema2, operationRuntimeCapabilitySchema2, operationCapabilitiesSchema2, inlinePropertyCapabilitySchema2, formatCapabilitiesSchema2, planEngineCapabilitiesSchema2, nullableTableBorderSpecSchema2, sdFragmentSchema2, placementSchema2, nestingPolicySchema2, tableCreateLocationSchema2, formatInlineAliasOperationSchemas2, tocMutationFailureSchema2, tocMutationSuccessSchema2, tocEntryMutationFailureSchema2, tocEntryMutationSuccessSchema2, hyperlinkTargetSchema2, hyperlinkReadPropertiesSchema2, hyperlinkSpecSchema2, hyperlinkPatchSchema2, hyperlinkDomainSchema2, hyperlinkMutationSuccessSchema2, hyperlinkMutationFailureSchema2, contentControlTargetSchema2, contentControlMutationSuccessSchema2, contentControlMutationFailureSchema2, ccListResultSchema2, ccInfoSchema2, refFailureSchema2, bookmarkAddressSchema2, bookmarkMutation2, footnoteAddressSchema2, footnoteConfigScopeSchema2, footnoteNumberingSchema2, footnoteMutation2, footnoteConfig2, crossRefAddressSchema2, crossRefTargetSchema2, crossRefDisplaySchema2, crossRefMutation2, indexAddressSchema2, indexEntryAddressSchema2, indexConfigSchema2, indexEntryDataSchema2, indexEntryPatchSchema2, indexMutation2, indexEntryMutation2, captionAddressSchema2, captionMutation2, captionConfig2, fieldAddressSchema2, fieldMutation2, citationAddressSchema2, citationSourceAddressSchema2, bibliographyAddressSchema2, citationMutation2, citationSourceMutation2, bibliographyMutation2, citationPersonSchema2, citationSourceFieldsSchema2, tocCreateLocationSchema2, authoritiesAddressSchema2, authorityEntryAddressSchema2, authoritiesConfigSchema2, authorityEntryDataSchema2, authorityEntryPatchSchema2, authoritiesMutation2, authorityEntryMutation2, diffCoverageSchema2, diffSummarySchema2, diffSnapshotSchema2, diffPayloadSchema2, GROUP_METADATA2, STEP_OP_CATALOG_UNFROZEN2, PUBLIC_STEP_OP_CATALOG_UNFROZEN2, PUBLIC_MUTATION_STEP_OP_IDS2, PUBLIC_MUTATION_STEP_OP_SET2, CAPABILITY_REASON_CODES, VALID_EDGE_VALUES2, VALID_EDGE_NODE_TYPES2, VALID_DOCUMENT_EDGES2, VALID_REF_BOUNDARIES2, VALID_ANCHOR_KINDS2, RESOLVE_RANGE_ALLOWED_KEYS2, CREATE_COMMENT_ALLOWED_KEYS2, PATCH_COMMENT_ALLOWED_KEYS2, STYLE_APPLY_INPUT_ALLOWED_KEYS2, INLINE_ALIAS_INPUT_ALLOWED_KEYS2, DELETE_INPUT_ALLOWED_KEYS2, VALID_BEHAVIORS2, CONTENT_KIND_SET2, INLINE_KIND_SET2, LEGACY_TOP_LEVEL_TYPES2, TEXT_INSERT_ALLOWED_KEYS2, STRUCTURAL_INSERT_ALLOWED_KEYS2, VALID_INSERT_TYPES2, LIST_KINDS2, LIST_INSERT_POSITIONS2, JOIN_DIRECTIONS2, MUTATION_SCOPES2, LEVEL_ALIGNMENTS2, TRAILING_CHARACTERS2, LIST_PRESET_IDS2, VALID_BLOCK_NODE_TYPES$1, VALID_LIST_KINDS2, VALID_INSERT_POSITIONS2, VALID_JOIN_DIRECTIONS2, VALID_MUTATION_SCOPES2, VALID_LEVEL_ALIGNMENTS2, VALID_TRAILING_CHARACTERS2, VALID_LIST_PRESETS2, VALID_CONTINUITY_VALUES2, VALID_SEQUENCE_MODES2, VALID_LIST_CREATE_MODES2, TEXT_REPLACE_ALLOWED_KEYS2, STRUCTURAL_REPLACE_ALLOWED_KEYS2, VALID_HEADING_LEVELS2, SECTION_BREAK_TYPES$1, SUPPORTED_DELETE_NODE_TYPES2, REJECTED_DELETE_NODE_TYPES2, VALID_BLOCK_NODE_TYPES3, SNAPSHOT_VERSION2 = "sd-diff-snapshot/v1", PAYLOAD_VERSION2 = "sd-diff-payload/v1", VALID_STYLE_OPTION_FLAGS2, TABLE_BORDER_COLOR_PATTERN2, VALID_APPLY_TO_VALUES2, VALID_BORDER_EDGE_KEYS2, HEADER_FOOTER_KINDS$1, HEADER_FOOTER_VARIANTS$1, DEFAULT_SECTIONS_LIST_LIMIT2 = 250, SECTION_BREAK_TYPES3, SECTION_ORIENTATIONS2, SECTION_VERTICAL_ALIGNS2, SECTION_DIRECTIONS2, HEADER_FOOTER_KINDS3, HEADER_FOOTER_VARIANTS3, LINE_NUMBER_RESTARTS2, PAGE_NUMBER_FORMATS2, PAGE_BORDER_DISPLAYS2, PAGE_BORDER_OFFSET_FROM_VALUES2, PAGE_BORDER_Z_ORDER_VALUES2, VALID_WRAP_TYPES2, VALID_WRAP_SIDES2, VALID_IMAGE_SIZE_UNITS2, VALID_TOC_UPDATE_MODES2, EDIT_ENTRY_PATCH_ALLOWED_KEYS2, PATCH_FIELDS2, CONTENT_CONTROL_TYPES2, LOCK_MODES2, CONTENT_CONTROL_APPEARANCES2, VALID_NODE_KINDS2, VALID_LOCK_MODES$1, VALID_CC_TYPES2, VALID_CC_APPEARANCES2, VALID_CONTENT_FORMATS2, VALID_RAW_PATCH_OPS2, VALID_CREATE_LOCATION_KINDS2, ADAPTER_GATED_PREFIXES2, _buffers, _defaultCollectionId = null, _nextCollectionId = 1, generateV2HandlerEntity = (handlerName, translator$216) => ({
   handlerName,
   handler: (params) => {
     const { nodes } = params;
@@ -75509,8 +77381,8 @@ var isRegExp = (value) => {
     }
   }
   return css;
-}, SUPPORTED_ALTERNATE_CONTENT_REQUIRES, XML_NODE_NAME$36 = "mc:AlternateContent", SD_NODE_NAME$32, validXmlAttributes$12, config$35, translator$31, translator$37, translator$39, translator$40, translator$208, translator$51, translator$54, translator$57, translator$65, translator$80, translator$85, translator$86, translator$87, translator$89, translator$102, translator$78, translator$111, propertyTranslators$16, translator$113, translator$118, translator$119, translator$45, translator$209, translator$48, translator$201, translator$103, translator$203, translator$133, translator$204, translator$169, translator$206, propertyTranslators$15, translator$121, translator$127, translator$120, translator$144, translator$145, translator$146, translator$147, propertyTranslators$14, translator$151, translator$190, translator$183, translator$191, translator$192, translator$195, translator$196, propertyTranslators$13, translator$126, handleParagraphNode$1 = (params) => {
-  const { nodes, nodeListHandler, filename } = params;
+}, SUPPORTED_ALTERNATE_CONTENT_REQUIRES, XML_NODE_NAME$36 = "mc:AlternateContent", SD_NODE_NAME$32, validXmlAttributes$12, config$35, translator$31, translator$37, translator$39, translator$40, translator$208, translator$51, translator$54, translator$57, translator$65, translator$80, translator$85, translator$86, translator$87, translator$89, translator$102, translator$78, translator$111, propertyTranslators$16, translator$113, translator$118, translator$119, translator$45, translator$209, translator$48, translator$201, translator$103, translator$203, translator$133, translator$204, translator$169, translator$206, propertyTranslators$15, translator$121, translator$127, translator$120, translator$144, translator$145, translator$146, translator$147, propertyTranslators$14, translator$151, translator$190, translator$183, translator$191, translator$192, translator$195, translator$196, propertyTranslators$13, translator$126, INLINE_FALLBACK_TYPES, handleParagraphNode$1 = (params) => {
+  const { nodes, nodeListHandler, filename, editor } = params;
   const node3 = carbonCopy(nodes[0]);
   let schemaNode;
   const pPr = node3.elements?.find((el) => el.name === "w:pPr");
@@ -75554,17 +77426,27 @@ var isRegExp = (value) => {
   schemaNode.attrs.paragraphProperties = inlineParagraphProperties;
   schemaNode.attrs.rsidRDefault = node3.attributes?.["w:rsidRDefault"];
   schemaNode.attrs.filename = filename;
-  if (schemaNode && schemaNode.content)
-    schemaNode = {
-      ...schemaNode,
-      content: mergeTextNodes(schemaNode.content)
-    };
   const sectPr = pPr?.elements?.find((el) => el.name === "w:sectPr");
   if (sectPr) {
     schemaNode.attrs.paragraphProperties.sectPr = sectPr;
     schemaNode.attrs.pageBreakSource = "sectPr";
   }
-  return schemaNode;
+  const normalizedNodes = normalizeParagraphChildren(schemaNode.content, editor?.schema, schemaNode.attrs).map((node$1) => {
+    if (node$1?.type !== "paragraph" || !Array.isArray(node$1.content))
+      return node$1;
+    return {
+      ...node$1,
+      content: mergeTextNodes(node$1.content)
+    };
+  });
+  if (!normalizedNodes.length)
+    return {
+      ...schemaNode,
+      content: mergeTextNodes(schemaNode.content || [])
+    };
+  if (normalizedNodes.length === 1 && normalizedNodes[0]?.type === "paragraph")
+    return normalizedNodes[0];
+  return normalizedNodes;
 }, encode$62 = (attributes) => {
   return attributes["w:rsidDel"];
 }, decode$64 = (attrs) => {
@@ -75593,15 +77475,36 @@ var isRegExp = (value) => {
   return attributes["w14:textId"];
 }, decode$58 = (attrs) => {
   return attrs.textId;
-}, attributes_default$5, XML_NODE_NAME$35 = "w:p", SD_NODE_NAME$31 = "paragraph", encode$55 = (params, encodedAttrs = {}) => {
+}, attributes_default$5, XML_NODE_NAME$35 = "w:p", SD_NODE_NAME$31 = "paragraph", IDENTITY_ATTR_NAMES, encode$55 = (params, encodedAttrs = {}) => {
   const node3 = handleParagraphNode$1(params);
   if (!node3)
     return;
-  if (encodedAttrs && Object.keys(encodedAttrs).length)
+  if (encodedAttrs && Object.keys(encodedAttrs).length) {
+    if (Array.isArray(node3)) {
+      const { identityAttrs, shareableAttrs } = partitionEncodedParagraphAttrs(encodedAttrs);
+      let appliedIdentityAttrs = false;
+      return node3.map((child) => {
+        if (child?.type !== "paragraph")
+          return child;
+        const attrs = {
+          ...child.attrs || {},
+          ...shareableAttrs
+        };
+        if (!appliedIdentityAttrs) {
+          Object.assign(attrs, identityAttrs);
+          appliedIdentityAttrs = true;
+        }
+        return {
+          ...child,
+          attrs
+        };
+      });
+    }
     node3.attrs = {
       ...node3.attrs,
       ...encodedAttrs
     };
+  }
   return node3;
 }, decode$57 = (params, decodedAttrs = {}) => {
   const translated = translateParagraphNode(params);
@@ -76508,10 +78411,10 @@ var isRegExp = (value) => {
       sdtPr
     }
   };
-}, validGalleryTypeMap, inlineNodeTypes, SD_TOC_XML_NAME = "sd:tableOfContents", PARAGRAPH_XML_NAME = "w:p", PARAGRAPH_PROPERTIES_XML_NAME = "w:pPr", wrapInlineNode = (node3) => ({
+}, validGalleryTypeMap, inlineNodeTypes, SD_TOC_XML_NAME = "sd:tableOfContents", PARAGRAPH_XML_NAME = "w:p", PARAGRAPH_PROPERTIES_XML_NAME$1 = "w:pPr", wrapInlineNode = (node3) => ({
   type: "paragraph",
   content: [node3]
-}), hasMeaningfulParagraphContent = (elements = []) => elements.some((element) => element?.name && element.name !== PARAGRAPH_PROPERTIES_XML_NAME), translateNodes = (params, nodes, pathTail = []) => params.nodeListHandler.handler({
+}), hasMeaningfulParagraphContent$1 = (elements = []) => elements.some((element) => element?.name && element.name !== PARAGRAPH_PROPERTIES_XML_NAME$1), translateNodes = (params, nodes, pathTail = []) => params.nodeListHandler.handler({
   ...params,
   nodes,
   path: [...params.path || [], ...pathTail]
@@ -76526,7 +78429,7 @@ var isRegExp = (value) => {
       return;
     }
     const remainingElements = childElements.filter((el) => el?.name !== SD_TOC_XML_NAME);
-    if (hasMeaningfulParagraphContent(remainingElements))
+    if (hasMeaningfulParagraphContent$1(remainingElements))
       translatedContent.push(...translateNodes(params, [{
         ...child,
         elements: remainingElements
@@ -87262,16 +89165,48 @@ var isRegExp = (value) => {
     nodes: [resultNode],
     consumed: 1
   };
-}, textNodeHandlerEntity, handleParagraphNode = (params) => {
+}, textNodeHandlerEntity, PARAGRAPH_PROPERTIES_XML_NAME = "w:pPr", BLOCK_FIELD_XML_NAMES, hasMeaningfulParagraphContent = (elements = []) => elements.some((element) => element?.name && element.name !== PARAGRAPH_PROPERTIES_XML_NAME), hoistBlockFieldNodes = (params, paragraphNode) => {
+  const paragraphElements = Array.isArray(paragraphNode?.elements) ? paragraphNode.elements : [];
+  const blockFieldElements = paragraphElements.filter((element) => BLOCK_FIELD_XML_NAMES.has(element?.name));
+  if (blockFieldElements.length === 0)
+    return null;
+  const nodes = [];
+  const remainingElements = paragraphElements.filter((element) => !BLOCK_FIELD_XML_NAMES.has(element?.name));
+  if (hasMeaningfulParagraphContent(remainingElements)) {
+    const paragraph2 = translator.encode({
+      ...params,
+      nodes: [{
+        ...paragraphNode,
+        elements: remainingElements
+      }]
+    });
+    if (paragraph2)
+      nodes.push(paragraph2);
+  }
+  blockFieldElements.forEach((blockFieldElement) => {
+    nodes.push(...params.nodeListHandler.handler({
+      ...params,
+      nodes: [blockFieldElement],
+      path: [...params.path || [], paragraphNode]
+    }));
+  });
+  return nodes;
+}, handleParagraphNode = (params) => {
   const { nodes } = params;
   if (nodes.length === 0 || nodes[0].name !== "w:p")
     return {
       nodes: [],
       consumed: 0
     };
+  const hoistedNodes = hoistBlockFieldNodes(params, nodes[0]);
+  if (hoistedNodes)
+    return {
+      nodes: hoistedNodes,
+      consumed: 1
+    };
   const schemaNode = translator.encode(params);
   return {
-    nodes: schemaNode ? [schemaNode] : [],
+    nodes: Array.isArray(schemaNode) ? schemaNode : schemaNode ? [schemaNode] : [],
     consumed: 1
   };
 }, paragraphNodeHandlerEntity, handleSdtNode = (params) => {
@@ -88222,7 +90157,7 @@ var isRegExp = (value) => {
     nodes: [translator$3.encode(params)],
     consumed: 1
   };
-}, tabNodeEntityHandler, footnoteReferenceHandlerEntity, tableNodeHandlerEntity, tableOfContentsHandlerEntity, indexHandlerEntity, indexEntryHandlerEntity, commentRangeStartHandlerEntity, commentRangeEndHandlerEntity, permStartHandlerEntity, permEndHandlerEntity, PARAGRAPH_IDENTITY_ATTRS, TABLE_IDENTITY_ATTRS, DEFAULT_BLOCK_IDENTITY_ATTRS, SYNTHETIC_PARA_ID_TYPES, DOCX_ID_LENGTH = 8, MAX_DOCX_ID = 4294967295, BLOCK_IDENTITY_ATTRS, WORD_2012_NAMESPACE = "http://schemas.microsoft.com/office/word/2012/wordml", deepClone = (value) => JSON.parse(JSON.stringify(value)), getNumberingRoot = (numberingXml) => {
+}, tabNodeEntityHandler, footnoteReferenceHandlerEntity, tableNodeHandlerEntity, tableOfContentsHandlerEntity, indexHandlerEntity, indexEntryHandlerEntity, bibliographyHandlerEntity, commentRangeStartHandlerEntity, commentRangeEndHandlerEntity, permStartHandlerEntity, permEndHandlerEntity, PARAGRAPH_IDENTITY_ATTRS, TABLE_IDENTITY_ATTRS, DEFAULT_BLOCK_IDENTITY_ATTRS, SYNTHETIC_PARA_ID_TYPES, DOCX_ID_LENGTH = 8, MAX_DOCX_ID = 4294967295, BLOCK_IDENTITY_ATTRS, WORD_2012_NAMESPACE = "http://schemas.microsoft.com/office/word/2012/wordml", deepClone = (value) => JSON.parse(JSON.stringify(value)), getNumberingRoot = (numberingXml) => {
   if (!numberingXml?.elements?.length)
     return null;
   return numberingXml.elements.find((el) => el?.name === "w:numbering") || numberingXml.elements[0] || null;
@@ -88374,6 +90309,7 @@ var isRegExp = (value) => {
     tabNodeEntityHandler,
     tableOfContentsHandlerEntity,
     indexHandlerEntity,
+    bibliographyHandlerEntity,
     indexEntryHandlerEntity,
     autoPageHandlerEntity,
     autoTotalPageCountEntity,
@@ -89401,7 +91337,7 @@ var isRegExp = (value) => {
   if (id)
     return trackedChanges.filter(({ mark }) => mark.attrs.id === id);
   return trackedChanges;
-}, DERIVED_ID_LENGTH = 24, groupedCache, SDT_NODE_NAMES, SDT_BLOCK_NAME = "structuredContentBlock", VALID_CONTROL_TYPES, VALID_LOCK_MODES, VALID_APPEARANCES, FIELD_LIKE_SDT_TYPES, liveDocumentCountsCache, SETTINGS_PART_PATH = "word/settings.xml", BIBLIOGRAPHY_NAMESPACE_URI = "http://schemas.openxmlformats.org/officeDocument/2006/bibliography", CUSTOM_XML_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml", CUSTOM_XML_PROPS_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps", DEFAULT_SELECTED_STYLE = "/APA.XSL", DEFAULT_STYLE_NAME = "APA", DEFAULT_VERSION = "6", DEFAULT_XML_DECLARATION, API_TO_OOXML_SOURCE_TYPE, OOXML_TO_API_SOURCE_TYPE, SIMPLE_FIELD_TO_XML_TAG, XML_TAG_TO_SIMPLE_FIELD, import_lib2, FONT_FAMILY_FALLBACKS, DEFAULT_GENERIC_FALLBACK = "sans-serif", DEFAULT_FONT_SIZE_PT = 10, CURRENT_APP_VERSION = "1.21.1", collectRunDefaultProperties = (runProps, { allowOverrideTypeface = true, allowOverrideSize = true, themeResolver, state }) => {
+}, DERIVED_ID_LENGTH = 24, groupedCache, SDT_NODE_NAMES, SDT_BLOCK_NAME = "structuredContentBlock", VALID_CONTROL_TYPES, VALID_LOCK_MODES2, VALID_APPEARANCES, FIELD_LIKE_SDT_TYPES, liveDocumentCountsCache, SETTINGS_PART_PATH = "word/settings.xml", BIBLIOGRAPHY_NAMESPACE_URI = "http://schemas.openxmlformats.org/officeDocument/2006/bibliography", CUSTOM_XML_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXml", CUSTOM_XML_PROPS_RELATIONSHIP_TYPE = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/customXmlProps", DEFAULT_SELECTED_STYLE = "/APA.XSL", DEFAULT_STYLE_NAME = "APA", DEFAULT_VERSION = "6", DEFAULT_XML_DECLARATION, API_TO_OOXML_SOURCE_TYPE, OOXML_TO_API_SOURCE_TYPE, SIMPLE_FIELD_TO_XML_TAG, XML_TAG_TO_SIMPLE_FIELD, import_lib2, FONT_FAMILY_FALLBACKS, DEFAULT_GENERIC_FALLBACK = "sans-serif", DEFAULT_FONT_SIZE_PT = 10, CURRENT_APP_VERSION = "1.21.0", collectRunDefaultProperties = (runProps, { allowOverrideTypeface = true, allowOverrideSize = true, themeResolver, state }) => {
   if (!runProps?.elements?.length || !state)
     return;
   const fontsNode = runProps.elements.find((el) => el.name === "w:rFonts");
@@ -89435,12 +91371,12 @@ var isRegExp = (value) => {
       state.kern = kernNode.attributes["w:val"];
   }
 }, SuperConverter;
-var init_SuperConverter_BL6WX_iN_es = __esm(() => {
+var init_SuperConverter_C9MZOwsC_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_jszip_ChlR43oI_es();
-  init_xml_js_DLE8mr0n_es();
+  init_xml_js_40FWvL78_es();
   init_uuid_qzgm05fK_es();
-  init_constants_CMPtQbp7_es();
+  init_constants_Qqwopz80_es();
   init_unified_BRHLwnjP_es();
   init_lib_HnbxUP96_es();
   init_lib_DAB30bX1_es();
@@ -91855,6 +93791,7 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
       Object.setPrototypeOf(this, DocumentApiValidationError3.prototype);
     }
   };
+  NODE_KINDS2 = ["block", "inline"];
   NODE_TYPES2 = [
     "paragraph",
     "heading",
@@ -103621,6 +105558,43 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
     "markdown",
     "html"
   ]);
+  LIST_KINDS2 = ["ordered", "bullet"];
+  LIST_INSERT_POSITIONS2 = ["before", "after"];
+  JOIN_DIRECTIONS2 = ["withPrevious", "withNext"];
+  MUTATION_SCOPES2 = ["definition", "instance"];
+  LEVEL_ALIGNMENTS2 = [
+    "left",
+    "center",
+    "right"
+  ];
+  TRAILING_CHARACTERS2 = [
+    "tab",
+    "space",
+    "nothing"
+  ];
+  LIST_PRESET_IDS2 = [
+    "decimal",
+    "decimalParenthesis",
+    "lowerLetter",
+    "upperLetter",
+    "lowerRoman",
+    "upperRoman",
+    "disc",
+    "circle",
+    "square",
+    "dash"
+  ];
+  VALID_BLOCK_NODE_TYPES$1 = new Set(BLOCK_NODE_TYPES2);
+  VALID_LIST_KINDS2 = new Set(LIST_KINDS2);
+  VALID_INSERT_POSITIONS2 = new Set(LIST_INSERT_POSITIONS2);
+  VALID_JOIN_DIRECTIONS2 = new Set(JOIN_DIRECTIONS2);
+  VALID_MUTATION_SCOPES2 = new Set(MUTATION_SCOPES2);
+  VALID_LEVEL_ALIGNMENTS2 = new Set(LEVEL_ALIGNMENTS2);
+  VALID_TRAILING_CHARACTERS2 = new Set(TRAILING_CHARACTERS2);
+  VALID_LIST_PRESETS2 = new Set(LIST_PRESET_IDS2);
+  VALID_CONTINUITY_VALUES2 = new Set(["preserve", "none"]);
+  VALID_SEQUENCE_MODES2 = new Set(["new", "continuePrevious"]);
+  VALID_LIST_CREATE_MODES2 = new Set(["empty", "fromParagraphs"]);
   TEXT_REPLACE_ALLOWED_KEYS2 = new Set([
     "text",
     "target",
@@ -103634,6 +105608,14 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
     "nestingPolicy",
     "in"
   ]);
+  VALID_HEADING_LEVELS2 = new Set([
+    1,
+    2,
+    3,
+    4,
+    5,
+    6
+  ]);
   SECTION_BREAK_TYPES$1 = [
     "continuous",
     "nextPage",
@@ -103642,7 +105624,7 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
   ];
   SUPPORTED_DELETE_NODE_TYPES2 = new Set(DELETABLE_BLOCK_NODE_TYPES2);
   REJECTED_DELETE_NODE_TYPES2 = new Set(["tableRow", "tableCell"]);
-  VALID_BLOCK_NODE_TYPES2 = new Set(BLOCK_NODE_TYPES2);
+  VALID_BLOCK_NODE_TYPES3 = new Set(BLOCK_NODE_TYPES2);
   VALID_STYLE_OPTION_FLAGS2 = new Set([
     "headerRow",
     "lastRow",
@@ -103737,6 +105719,13 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
     "pt",
     "twip"
   ]);
+  VALID_TOC_UPDATE_MODES2 = new Set(["all", "pageNumbers"]);
+  EDIT_ENTRY_PATCH_ALLOWED_KEYS2 = new Set([
+    "text",
+    "level",
+    "tableIdentifier",
+    "omitPageNumber"
+  ]);
   PATCH_FIELDS2 = new Set([
     "href",
     "anchor",
@@ -103745,6 +105734,39 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
     "target",
     "rel"
   ]);
+  CONTENT_CONTROL_TYPES2 = [
+    "text",
+    "date",
+    "checkbox",
+    "comboBox",
+    "dropDownList",
+    "repeatingSection",
+    "repeatingSectionItem",
+    "group",
+    "unknown"
+  ];
+  LOCK_MODES2 = [
+    "unlocked",
+    "sdtLocked",
+    "contentLocked",
+    "sdtContentLocked"
+  ];
+  CONTENT_CONTROL_APPEARANCES2 = [
+    "boundingBox",
+    "tags",
+    "hidden"
+  ];
+  VALID_NODE_KINDS2 = new Set(NODE_KINDS2);
+  VALID_LOCK_MODES$1 = new Set(LOCK_MODES2);
+  VALID_CC_TYPES2 = new Set(CONTENT_CONTROL_TYPES2);
+  VALID_CC_APPEARANCES2 = new Set(CONTENT_CONTROL_APPEARANCES2);
+  VALID_CONTENT_FORMATS2 = new Set(["text", "html"]);
+  VALID_RAW_PATCH_OPS2 = new Set([
+    "set",
+    "remove",
+    "setAttr",
+    "removeAttr"
+  ]);
   VALID_CREATE_LOCATION_KINDS2 = new Set([
     "documentStart",
     "documentEnd",
@@ -104420,6 +106442,34 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
     translator$129
   ];
   translator$126 = NodeTranslator.from(createNestedPropertiesTranslator("w:pPr", "paragraphProperties", propertyTranslators$13));
+  INLINE_FALLBACK_TYPES = new Set([
+    "text",
+    "run",
+    "bookmarkStart",
+    "bookmarkEnd",
+    "tab",
+    "lineBreak",
+    "hardBreak",
+    "commentRangeStart",
+    "commentRangeEnd",
+    "commentReference",
+    "permStart",
+    "permEnd",
+    "footnoteReference",
+    "endnoteReference",
+    "fieldAnnotation",
+    "structuredContent",
+    "passthroughInline",
+    "page-number",
+    "total-page-number",
+    "pageReference",
+    "crossReference",
+    "citation",
+    "authorityEntry",
+    "sequenceField",
+    "indexEntry",
+    "tableOfContentsEntry"
+  ]);
   attrConfig$22 = Object.freeze({
     xmlName: "w:rsidDel",
     sdName: "rsidDel",
@@ -104470,6 +106520,7 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
     attrConfig$25,
     attrConfig$22
   ];
+  IDENTITY_ATTR_NAMES = new Set(["paraId", "textId"]);
   config$34 = {
     xmlName: XML_NODE_NAME$35,
     sdNodeOrKeyName: SD_NODE_NAME$31,
@@ -124118,6 +126169,12 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
     handlerName: "textNodeHandler",
     handler: handleTextNode
   };
+  BLOCK_FIELD_XML_NAMES = new Set([
+    "sd:tableOfContents",
+    "sd:index",
+    "sd:bibliography",
+    "sd:tableOfAuthorities"
+  ]);
   paragraphNodeHandlerEntity = {
     handlerName: "paragraphNodeHandler",
     handler: handleParagraphNode
@@ -124741,6 +126798,7 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
   tableOfContentsHandlerEntity = generateV2HandlerEntity("tableOfContentsHandler", translator$22);
   indexHandlerEntity = generateV2HandlerEntity("indexHandler", translator$23);
   indexEntryHandlerEntity = generateV2HandlerEntity("indexEntryHandler", translator$24);
+  bibliographyHandlerEntity = generateV2HandlerEntity("bibliographyHandler", translator$18);
   commentRangeStartHandlerEntity = generateV2HandlerEntity("commentRangeStartHandler", commentRangeStartTranslator);
   commentRangeEndHandlerEntity = generateV2HandlerEntity("commentRangeEndHandler", commentRangeEndTranslator);
   permStartHandlerEntity = generateV2HandlerEntity("permStartHandler", translator$13);
@@ -124966,7 +127024,7 @@ var init_SuperConverter_BL6WX_iN_es = __esm(() => {
     "repeatingSectionItem",
     "group"
   ];
-  VALID_LOCK_MODES = [
+  VALID_LOCK_MODES2 = [
     "unlocked",
     "sdtLocked",
     "contentLocked",
@@ -126686,7 +128744,7 @@ var init_remark_stringify_D8vxv_XI_es = __esm(() => {
   eol = /\r?\n|\r/g;
 });
 
-// ../../packages/superdoc/dist/chunks/DocxZipper-BBJ5zSyW.es.js
+// ../../packages/superdoc/dist/chunks/DocxZipper-gWkmvJfR.es.js
 function getLens2(b64) {
   var len$1 = b64.length;
   if (len$1 % 4 > 0)
@@ -127381,11 +129439,11 @@ var DOCX = "application/vnd.openxmlformats-officedocument.wordprocessingml.docum
     return `image/${MIME_TYPE_FOR_EXT[detectedType] || detectedType}`;
   }
 }, DocxZipper_default;
-var init_DocxZipper_BBJ5zSyW_es = __esm(() => {
+var init_DocxZipper_gWkmvJfR_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
   init_jszip_ChlR43oI_es();
-  init_xml_js_DLE8mr0n_es();
-  init_constants_CMPtQbp7_es();
+  init_xml_js_40FWvL78_es();
+  init_constants_Qqwopz80_es();
   buffer2 = {};
   base64Js2 = {};
   base64Js2.byteLength = byteLength2;
@@ -152539,7 +154597,7 @@ var init_remark_gfm_CjV8kaUy_es = __esm(() => {
   init_remark_gfm_z_sDF4ss_es();
 });
 
-// ../../packages/superdoc/dist/chunks/src-rbevhPXm.es.js
+// ../../packages/superdoc/dist/chunks/src-8sGn3qa5.es.js
 function deleteProps(obj, propOrProps) {
   const props = typeof propOrProps === "string" ? [propOrProps] : propOrProps;
   const removeNested = (target, pathParts, index2 = 0) => {
@@ -152619,7 +154677,7 @@ function prosemirrorToYXmlFragment(doc$12, xmlFragment) {
 }
 function getSuperdocVersion() {
   try {
-    return "1.21.1";
+    return "1.21.0";
   } catch {
     return "unknown";
   }
@@ -154297,6 +156355,8 @@ function createStructuredContentLockPlugin() {
     filterTransaction(tr, state) {
       if (!tr.docChanged)
         return true;
+      if (tr.getMeta?.(ySyncPluginKey))
+        return true;
       const sdtNodes = STRUCTURED_CONTENT_LOCK_KEY.getState(state);
       if (sdtNodes.length === 0)
         return true;
@@ -158303,13 +160363,20 @@ function createChartImmutabilityPlugin() {
       init(_$1, state) {
         return countChartNodes(state.doc);
       },
-      apply(_tr, oldCount) {
+      apply(tr, oldCount, _oldState, newState) {
+        if (tr.docChanged && tr.getMeta?.(ySyncPluginKey)) {
+          if (oldCount === 0 && !transactionInsertsChart(tr))
+            return 0;
+          return countChartNodes(newState.doc);
+        }
         return oldCount;
       }
     },
     filterTransaction(tr, state) {
       if (!tr.docChanged)
         return true;
+      if (tr.getMeta?.(ySyncPluginKey))
+        return true;
       if ((CHART_IMMUTABILITY_KEY.getState(state) ?? 0) === 0)
         return !transactionInsertsChart(tr);
       return !isChartMutation(tr, state.doc);
@@ -162941,6 +165008,7 @@ async function measureParagraphBlock(block, maxWidth) {
   let hasSeenTextRun = false;
   let tabStopCursor = 0;
   let pendingTabAlignment = null;
+  let pendingLeader = null;
   let pendingRunSpacing = 0;
   let lastAppliedTabAlign = null;
   const warnedTabVals = /* @__PURE__ */ new Set;
@@ -162973,12 +165041,17 @@ async function measureParagraphBlock(block, maxWidth) {
       startX = Math.max(0, target - segmentWidth / 2);
     else
       startX = Math.max(0, target);
+    if (pendingLeader) {
+      const effectiveIndent = lines.length === 0 ? indentLeft + rawFirstLineOffset : indentLeft;
+      pendingLeader.to = startX + effectiveIndent;
+    }
     currentLine.width = roundValue(startX);
     lastAppliedTabAlign = {
       target,
       val
     };
     pendingTabAlignment = null;
+    pendingLeader = null;
     return startX;
   };
   const alignSegmentAtTab = (segmentText, font, runContext, segmentStartChar) => {
@@ -163081,6 +165154,7 @@ async function measureParagraphBlock(block, maxWidth) {
       }
       tabStopCursor = 0;
       pendingTabAlignment = null;
+      pendingLeader = null;
       lastAppliedTabAlign = null;
       pendingRunSpacing = 0;
       continue;
@@ -163125,12 +165199,14 @@ async function measureParagraphBlock(block, maxWidth) {
       };
       tabStopCursor = 0;
       pendingTabAlignment = null;
+      pendingLeader = null;
       lastAppliedTabAlign = null;
       pendingRunSpacing = 0;
       continue;
     }
     if (isTabRun$1(run2)) {
       activeTabGroup = null;
+      pendingLeader = null;
       if (!currentLine)
         currentLine = {
           fromRun: runIndex,
@@ -163156,18 +165232,19 @@ async function measureParagraphBlock(block, maxWidth) {
       currentLine.maxFontSize = Math.max(currentLine.maxFontSize, 12);
       currentLine.toRun = runIndex;
       currentLine.toChar = 1;
+      let currentLeader = null;
       if (stop && stop.leader && stop.leader !== "none") {
         const leaderStyle = stop.leader;
-        const relativeTarget = clampedTarget - effectiveIndent;
-        const from$1 = Math.min(originX, relativeTarget);
-        const to = Math.max(originX, relativeTarget);
+        const from$1 = Math.min(originX + effectiveIndent, clampedTarget);
+        const to = Math.max(originX + effectiveIndent, clampedTarget);
         if (!currentLine.leaders)
           currentLine.leaders = [];
-        currentLine.leaders.push({
+        currentLeader = {
           from: from$1,
           to,
           style: leaderStyle
-        });
+        };
+        currentLine.leaders.push(currentLeader);
       }
       if (stop) {
         validateTabStopVal(stop);
@@ -163184,6 +165261,8 @@ async function measureParagraphBlock(block, maxWidth) {
               const beforeDecimal = groupMeasure.beforeDecimalWidth ?? groupMeasure.totalWidth;
               groupStartX = Math.max(0, relativeTarget - beforeDecimal);
             }
+            if (currentLeader)
+              currentLeader.to = groupStartX + effectiveIndent;
             activeTabGroup = {
               measure: groupMeasure,
               startX: groupStartX,
@@ -163194,13 +165273,16 @@ async function measureParagraphBlock(block, maxWidth) {
             currentLine.width = roundValue(groupStartX);
           }
           pendingTabAlignment = null;
+          pendingLeader = null;
         } else
           pendingTabAlignment = {
             target: clampedTarget - effectiveIndent,
             val: stop.val
           };
-      } else
+      } else {
         pendingTabAlignment = null;
+        pendingLeader = null;
+      }
       pendingRunSpacing = 0;
       continue;
     }
@@ -163253,6 +165335,7 @@ async function measureParagraphBlock(block, maxWidth) {
         lines.push(completedLine);
         tabStopCursor = 0;
         pendingTabAlignment = null;
+        pendingLeader = null;
         lastAppliedTabAlign = null;
         activeTabGroup = null;
         currentLine = {
@@ -163352,6 +165435,7 @@ async function measureParagraphBlock(block, maxWidth) {
         lines.push(completedLine);
         tabStopCursor = 0;
         pendingTabAlignment = null;
+        pendingLeader = null;
         lastAppliedTabAlign = null;
         currentLine = {
           fromRun: runIndex,
@@ -163440,6 +165524,7 @@ async function measureParagraphBlock(block, maxWidth) {
             lines.push(completedLine);
             tabStopCursor = 0;
             pendingTabAlignment = null;
+            pendingLeader = null;
             lastAppliedTabAlign = null;
             currentLine = {
               fromRun: runIndex,
@@ -163526,6 +165611,7 @@ async function measureParagraphBlock(block, maxWidth) {
               lines.push(completedLine);
               tabStopCursor = 0;
               pendingTabAlignment = null;
+              pendingLeader = null;
               lastAppliedTabAlign = null;
               activeTabGroup = null;
               currentLine = {
@@ -163582,6 +165668,7 @@ async function measureParagraphBlock(block, maxWidth) {
             lines.push(completedLine);
             tabStopCursor = 0;
             pendingTabAlignment = null;
+            pendingLeader = null;
             currentLine = null;
           }
           const lineMaxWidth = getEffectiveWidth(lines.length === 0 ? initialAvailableWidth : contentWidth);
@@ -163626,6 +165713,7 @@ async function measureParagraphBlock(block, maxWidth) {
                 lines.push(completedLine);
                 tabStopCursor = 0;
                 pendingTabAlignment = null;
+                pendingLeader = null;
                 currentLine = null;
               }
             } else if (isLastChunk) {
@@ -163745,6 +165833,7 @@ async function measureParagraphBlock(block, maxWidth) {
           lines.push(completedLine);
           tabStopCursor = 0;
           pendingTabAlignment = null;
+          pendingLeader = null;
           currentLine = {
             fromRun: runIndex,
             fromChar: wordStartChar,
@@ -163797,6 +165886,7 @@ async function measureParagraphBlock(block, maxWidth) {
             lines.push(completedLine);
             tabStopCursor = 0;
             pendingTabAlignment = null;
+            pendingLeader = null;
             currentLine = null;
             charPosInRun = wordEndNoSpace + 1;
             continue;
@@ -163834,6 +165924,7 @@ async function measureParagraphBlock(block, maxWidth) {
       }
       if (!isLastSegment) {
         pendingTabAlignment = null;
+        pendingLeader = null;
         if (!currentLine)
           currentLine = {
             fromRun: runIndex,
@@ -163867,20 +165958,23 @@ async function measureParagraphBlock(block, maxWidth) {
             target: clampedTarget - effectiveIndent,
             val: stop.val
           };
-        } else
+        } else {
           pendingTabAlignment = null;
+          pendingLeader = null;
+        }
         if (stop && stop.leader && stop.leader !== "none" && stop.leader !== "middleDot") {
           const leaderStyle = stop.leader;
-          const relativeTarget = clampedTarget - effectiveIndent;
-          const from$1 = Math.min(originX, relativeTarget);
-          const to = Math.max(originX, relativeTarget);
+          const from$1 = Math.min(originX + effectiveIndent, clampedTarget);
+          const to = Math.max(originX + effectiveIndent, clampedTarget);
           if (!currentLine.leaders)
             currentLine.leaders = [];
-          currentLine.leaders.push({
+          const leader = {
             from: from$1,
             to,
             style: leaderStyle
-          });
+          };
+          currentLine.leaders.push(leader);
+          pendingLeader = leader;
         }
       }
     }
@@ -182235,7 +184329,7 @@ function extractBlockFormatting(node3) {
     ...fontFamily ? { fontFamily } : {},
     ...fontSize !== undefined ? { fontSize } : {},
     ...bold ? { bold } : {},
-    ...pProps?.alignment ? { alignment: pProps.alignment } : {},
+    ...pProps?.justification ? { alignment: pProps.justification } : {},
     ...headingLevel ? { headingLevel } : {}
   };
 }
@@ -182307,7 +184401,7 @@ function blocksListWrapper(editor, input2) {
       ordinal: offset$1 + i4,
       nodeId: candidate.nodeId,
       nodeType: candidate.nodeType,
-      textPreview: candidate.node.isTextblock ? candidate.node.textContent || null : null,
+      textPreview: extractTextPreview(candidate.node),
       isEmpty: candidate.node.textContent.length === 0,
       ...extractBlockFormatting(candidate.node)
     })),
@@ -194673,21 +196767,20 @@ function toReferenceBlockType(node3) {
       return;
   }
 }
-function resolvePublicReferenceBlockNodeId(node3, pos) {
-  const sdBlockId = toId(node3.attrs?.sdBlockId);
-  if (sdBlockId)
-    return sdBlockId;
+function resolvePublicReferenceBlockNodeId(node3, occurrenceIndex) {
   const blockType = toReferenceBlockType(node3);
   if (!blockType)
     throw new Error(`Unsupported reference block node type: ${node3.type.name}`);
-  return `${REFERENCE_BLOCK_PREFIX[blockType]}-${stableHash2(`${blockType}:${pos}`)}`;
+  return `${REFERENCE_BLOCK_PREFIX[blockType]}-${stableHash2(`${blockType}:${occurrenceIndex}`)}`;
 }
 function findAllIndexNodes(doc$12) {
   const results = [];
+  let occurrenceIndex = 0;
   doc$12.descendants((node3, pos) => {
     if (node3.type.name === "documentIndex" || node3.type.name === "index") {
       const commandNodeId = node3.attrs?.sdBlockId;
-      const nodeId = resolvePublicReferenceBlockNodeId(node3, pos);
+      const nodeId = resolvePublicReferenceBlockNodeId(node3, occurrenceIndex);
+      occurrenceIndex += 1;
       results.push({
         node: node3,
         pos,
@@ -195906,10 +197999,13 @@ function buildCitationDiscoveryItem(doc$12, resolved, evaluatedRevision) {
 }
 function findAllBibliographies(doc$12) {
   const results = [];
+  let occurrenceIndex = 0;
   doc$12.descendants((node3, pos) => {
     if (node3.type.name === "bibliography") {
-      const commandNodeId = node3.attrs?.sdBlockId;
-      const nodeId = resolvePublicReferenceBlockNodeId(node3, pos);
+      const rawBlockId = node3.attrs?.sdBlockId;
+      const commandNodeId = rawBlockId != null ? String(rawBlockId) : undefined;
+      const nodeId = resolvePublicReferenceBlockNodeId(node3, occurrenceIndex);
+      occurrenceIndex += 1;
       results.push({
         node: node3,
         pos,
@@ -195980,9 +198076,9 @@ function resolveSourceTarget(editor, target) {
 function resolveParentBlockId$1(doc$12, pos) {
   const resolved = doc$12.resolve(pos);
   for (let depth = resolved.depth;depth >= 0; depth--) {
-    const blockId = resolved.node(depth).attrs?.sdBlockId;
-    if (blockId)
-      return blockId;
+    const rawBlockId = resolved.node(depth).attrs?.sdBlockId;
+    if (rawBlockId != null)
+      return String(rawBlockId);
   }
   return "";
 }
@@ -196330,10 +198426,11 @@ function bibliographyInsertWrapper(editor, input2, options) {
 function bibliographyConfigureWrapper(editor, input2, options) {
   rejectTrackedMode("citations.bibliography.configure", options);
   const resolved = resolveBibliographyTarget(editor.state.doc, input2.target);
+  const stableNodeId = resolved.commandNodeId ?? resolved.nodeId;
   const address2 = {
     kind: "block",
     nodeType: "bibliography",
-    nodeId: resolved.nodeId
+    nodeId: stableNodeId
   };
   if (options?.dryRun)
     return bibSuccess(address2);
@@ -196351,7 +198448,12 @@ function bibliographyConfigureWrapper(editor, input2, options) {
   }, { expectedRevision: options?.expectedRevision })))
     return bibFailure("NO_OP", "Configure produced no change.");
   syncBibliographyStyleToConverter(editor, input2.style);
-  return bibSuccess(address2);
+  const bibliographies = findAllBibliographies(editor.state.doc);
+  return bibSuccess({
+    kind: "block",
+    nodeType: "bibliography",
+    nodeId: (bibliographies.find((bibliography) => bibliography.pos === resolved.pos) ?? bibliographies.find((bibliography) => bibliography.commandNodeId === stableNodeId))?.nodeId ?? resolvePostMutationBibliographyId(editor.state.doc, stableNodeId)
+  });
 }
 function bibliographyRebuildWrapper(editor, input2, options) {
   rejectTrackedMode("citations.bibliography.rebuild", options);
@@ -196465,10 +198567,12 @@ function buildCitationInstruction(sourceIds) {
 }
 function findAllAuthorities(doc$12) {
   const results = [];
+  let occurrenceIndex = 0;
   doc$12.descendants((node3, pos) => {
     if (node3.type.name === "tableOfAuthorities") {
       const commandNodeId = node3.attrs?.sdBlockId;
-      const nodeId = resolvePublicReferenceBlockNodeId(node3, pos);
+      const nodeId = resolvePublicReferenceBlockNodeId(node3, occurrenceIndex);
+      occurrenceIndex += 1;
       results.push({
         node: node3,
         pos,
@@ -219600,7 +221704,25 @@ var Node$13 = class Node$14 {
     this.onMouseLeave = null;
     this.hoveredSdtId = null;
   }
-}, cssToken = (varName, fallback) => ({
+}, isRtlParagraph = (attrs) => attrs?.direction === "rtl" || attrs?.rtl === true, resolveTextAlign = (alignment$1, isRtl) => {
+  switch (alignment$1) {
+    case "center":
+    case "right":
+    case "left":
+      return alignment$1;
+    case "justify":
+    default:
+      return isRtl ? "right" : "left";
+  }
+}, applyRtlStyles = (element3, attrs) => {
+  const rtl = isRtlParagraph(attrs);
+  if (rtl) {
+    element3.setAttribute("dir", "rtl");
+    element3.style.direction = "rtl";
+  }
+  element3.style.textAlign = resolveTextAlign(attrs?.alignment, rtl);
+  return rtl;
+}, shouldUseSegmentPositioning = (hasExplicitPositioning, hasSegments, isRtl) => hasExplicitPositioning && hasSegments && !isRtl, cssToken = (varName, fallback) => ({
   css: `var(${varName}, ${fallback})`,
   fallback
 }), LIST_MARKER_GAP = 8, DEFAULT_PAGE_HEIGHT_PX = 1056, DEFAULT_VIRTUALIZED_PAGE_GAP = 72, COMMENT_HIGHLIGHT_EXTERNAL, COMMENT_HIGHLIGHT_EXTERNAL_ACTIVE, COMMENT_HIGHLIGHT_EXTERNAL_FADED, COMMENT_HIGHLIGHT_INTERNAL, COMMENT_HIGHLIGHT_INTERNAL_ACTIVE, COMMENT_HIGHLIGHT_INTERNAL_FADED, COMMENT_HIGHLIGHT_EXTERNAL_NESTED_BORDER, COMMENT_HIGHLIGHT_INTERNAL_NESTED_BORDER, LINK_DATASET_KEYS, MAX_HREF_LENGTH = 2048, SAFE_ANCHOR_PATTERN, MAX_DATA_URL_LENGTH, VALID_IMAGE_DATA_URL, MAX_RESIZE_MULTIPLIER = 3, FALLBACK_MAX_DIMENSION = 1000, MIN_IMAGE_DIMENSION = 20, AMBIGUOUS_LINK_PATTERNS, linkMetrics, TRACK_CHANGE_BASE_CLASS, TRACK_CHANGE_FOCUSED_CLASS = "track-change-focused", TRACK_CHANGE_MODIFIER_CLASS, LINK_TARGET_SET, normalizeAnchor$1 = (value) => {
@@ -220267,27 +222389,12 @@ var Node$13 = class Node$14 {
         console.warn(`[DomPainter] Failed to set data attribute "${key$1}":`, error);
     }
   });
-}, resolveParagraphDirection = (attrs) => {
-  if (attrs?.direction)
-    return attrs.direction;
-  if (attrs?.rtl === true)
-    return "rtl";
-  if (attrs?.rtl === false)
-    return "ltr";
-}, applyParagraphDirection = (element3, attrs) => {
-  const direction = resolveParagraphDirection(attrs);
-  if (!direction)
-    return;
-  element3.setAttribute("dir", direction);
-  element3.style.direction = direction;
 }, applyParagraphBlockStyles = (element3, attrs) => {
   if (!attrs)
     return;
   if (attrs.styleId)
     element3.setAttribute("styleid", attrs.styleId);
-  applyParagraphDirection(element3, attrs);
-  if (attrs.alignment)
-    element3.style.textAlign = attrs.alignment === "justify" ? "left" : attrs.alignment;
+  applyRtlStyles(element3, attrs);
   if (attrs.dropCap)
     element3.classList.add("sd-editor-dropcap");
   const indent2 = attrs.indent;
@@ -222725,7 +224832,7 @@ var Node$13 = class Node$14 {
     domAvailabilityCache = false;
     return false;
   }
-}, summaryVersion = "1.21.1", nodeKeys, markKeys, transformListsInCopiedContent = (html3) => {
+}, summaryVersion = "1.21.0", nodeKeys, markKeys, transformListsInCopiedContent = (html3) => {
   const container = document.createElement("div");
   container.innerHTML = html3;
   const result = [];
@@ -223030,7 +225137,7 @@ var Node$13 = class Node$14 {
         console.warn("Failed to initialize developer tools:", error);
       }
   }
-}, BLANK_DOCX_BASE64 = `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`, BLANK_DOCX_DATA_URI, TAB_LEADER_TO_SEPARATOR, SEPARATOR_TO_TAB_LEADER, DEFAULT_TOC_CONFIG, SWITCH_PATTERN$1, BULLET_FORMATS$1, LOCK_MODE_TO_SDT_LOCK, SNIPPET_PADDING = 30, DUAL_KIND_TYPES, KNOWN_BLOCK_PM_NODE_TYPES, KNOWN_INLINE_PM_NODE_TYPES, MAX_PATTERN_LENGTH = 1024, TOGGLE_MARK_SPECS, CORE_MARK_NAMES, METADATA_MARK_NAMES, CSS_NAMED_COLORS, V3_PREFIX = "text:", V4_PREFIX = "text:v4:", HEADING_STYLE_DEPTH, BULLET_FORMATS, MARK_PRIORITY, remarkProcessor, DEFAULT_UNFLATTEN_LISTS = true, HEADING_STYLE_PATTERN, REQUIRED_COMMANDS, VALID_CAPABILITY_REASON_CODES, REQUIRED_HELPERS, SCHEMA_NODE_GATES, schemaGatedIds, SUPPORTED_NON_UNIFORM_STRATEGIES, SUPPORTED_SET_MARKS, REGEX_MAX_PATTERN_LENGTH = 1024, registry, VALID_CREATE_POSITIONS, REF_HANDLERS, STEP_INTERACTION_MATRIX, MATRIX_EXEMPT_OPS, DEFAULT_INLINE_POLICY, CORE_SET_MARK_KEYS, BOOLEAN_INLINE_MARK_KEYS, TEXT_STYLE_KEYS, PRESERVE_RUN_PROPERTIES_META_KEY = "sdPreserveRunPropertiesKeys", CONTENT_CAPABILITIES, INLINE_CAPABILITIES, SDT_LOCK_TO_LOCK_MODE, BODY_LOCATOR2, STUB_WHERE, EMPTY_RESOLUTION, CONTAINER_NODE_TYPES, VALID_EDGE_NODE_TYPES3, FALLBACK_STORE_KEY = "__documentApiComments", STYLES_PART = "word/styles.xml", PROPERTIES_KEY_BY_CHANNEL, XML_PATH_BY_CHANNEL2, UNDERLINE_API_TO_STORAGE, UNDERLINE_STORAGE_TO_API, HEX_SUBKEYS_BY_PROPERTY, PARAGRAPH_NODE_TYPES, TEXT_STYLE_CHARACTER_STYLE_ATTR = "styleId", DIRECT_FORMATTING_MARK_NAMES, ALIGNMENT_TO_JUSTIFICATION, SUPPORTED_DELETE_NODE_TYPES3, REJECTED_DELETE_NODE_TYPES3, TEXT_PREVIEW_MAX_LENGTH = 80, RANGE_DELETE_SAFE_NODE_TYPES, HEADING_PATTERN, INDENT_PER_LEVEL_TWIPS = 720, HANGING_INDENT_TWIPS = 360, ORDERED_PRESET_CONFIG, BULLET_PRESET_CONFIG, PRESET_TEMPLATES, LevelFormattingHelpers, PRESET_KIND_MAP, NUMBERING_PART = "word/numbering.xml", DEFAULT_PRESET_FOR_KIND, _setValueDelegate, PREVIEW_TEXT_MAX_LENGTH = 2000, BLOCK_PREVIEW_MAX_LENGTH = 200, EDGE_NODE_TYPES$1, POINTS_TO_PIXELS, POINTS_TO_TWIPS = 20, PIXELS_TO_TWIPS, DEFAULT_TABLE_GRID_WIDTH_TWIPS = 1500, SETTINGS_PART = "word/settings.xml", WORD_DEFAULT_TBL_LOOK, FLAG_TO_OOXML_KEY, INVERTED_FLAGS, XML_KEY_TO_STYLE_OPTION, CLEARED_BORDER_OOXML, TABLE_MARGIN_KEY_GROUPS, TABLE_ADAPTER_DISPATCH, ROW_TARGETED_TABLE_OPS, registered = false, STYLES_PART_ID = "word/styles.xml", stylesPartDescriptor, settingsPartDescriptor, RELS_PART_ID2 = "word/_rels/document.xml.rels", RELS_XMLNS2 = "http://schemas.openxmlformats.org/package/2006/relationships", HEADER_RELATIONSHIP_TYPE$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", relsPartDescriptor, HISTORY_UNSAFE_OPS, CANONICAL_COMMENT_IGNORED_KEYS, INITIAL_HASH, ROUND_CONSTANTS, V1_COVERAGE, SNAPSHOT_VERSION3 = "sd-diff-snapshot/v1", PAYLOAD_VERSION3 = "sd-diff-payload/v1", ENGINE_ID = "super-editor", STAGED_CONVERTER_KEYS, DiffServiceError, DEFAULT_LEVEL = 1, SWITCH_PATTERN, TOC_BOOKMARK_PREFIX = "_Toc", DEFAULT_RIGHT_TAB_POS = 9350, TAB_LEADER_MAP, NO_ENTRIES_PLACEHOLDER, TC_LEVEL_MIN = 1, TC_LEVEL_MAX = 9, ALLOWED_WRAP_ATTRS, WRAP_TYPES_SUPPORTING_SIDE, WRAP_TYPES_SUPPORTING_DISTANCES, RELATIVE_HEIGHT_MIN = 0, RELATIVE_HEIGHT_MAX = 4294967295, FORBIDDEN_RAW_PATCH_NAMES, CONTROL_TYPE_SDT_PR_ELEMENTS, DEFAULT_CHECKBOX_SYMBOL_FONT2 = "MS Gothic", DEFAULT_CHECKBOX_CHECKED_HEX2 = "2612", DEFAULT_CHECKBOX_UNCHECKED_HEX2 = "2610", VARIANT_ORDER, KIND_ORDER, HEADER_RELATIONSHIP_TYPE3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", DOCUMENT_RELS_PATH2 = "word/_rels/document.xml.rels", HEADER_FILE_PATTERN2, FOOTER_FILE_PATTERN2, SPECIAL_NOTE_TYPES, RESTART_POLICY_TO_OOXML, VALID_DISPLAYS, REFERENCE_BLOCK_PREFIX, CAPTION_STYLE_NAMES, CAPTION_PARAGRAPH_STYLE_ID = "Caption", CAPTION_FORMAT_TO_OOXML, DOCUMENT_STAT_FIELD_TYPES, TOA_LEADER_REVERSE_MAP, EDGE_NODE_TYPES, CONTENT_TYPES_PART_ID = "[Content_Types].xml", CONTENT_TYPES_NS = "http://schemas.openxmlformats.org/package/2006/content-types", contentTypesPartDescriptor, empty_exports, init_empty, CURRENT_APP_VERSION2 = "1.21.1", PIXELS_PER_INCH2 = 96, MAX_HEIGHT_BUFFER_PX = 50, MAX_WIDTH_BUFFER_PX = 20, Editor, EXCLUDED_PLUGIN_KEY_REF_LIST, EXCLUDED_PLUGIN_KEY_REFS, EXCLUDED_PLUGIN_KEY_PREFIXES, TEXT_RANGE_BLOCK_SEP = `
+}, BLANK_DOCX_BASE64 = `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`, BLANK_DOCX_DATA_URI, TAB_LEADER_TO_SEPARATOR, SEPARATOR_TO_TAB_LEADER, DEFAULT_TOC_CONFIG, SWITCH_PATTERN$1, BULLET_FORMATS$1, LOCK_MODE_TO_SDT_LOCK, SNIPPET_PADDING = 30, DUAL_KIND_TYPES, KNOWN_BLOCK_PM_NODE_TYPES, KNOWN_INLINE_PM_NODE_TYPES, MAX_PATTERN_LENGTH = 1024, TOGGLE_MARK_SPECS, CORE_MARK_NAMES, METADATA_MARK_NAMES, CSS_NAMED_COLORS, V3_PREFIX = "text:", V4_PREFIX = "text:v4:", HEADING_STYLE_DEPTH, BULLET_FORMATS, MARK_PRIORITY, remarkProcessor, DEFAULT_UNFLATTEN_LISTS = true, HEADING_STYLE_PATTERN, REQUIRED_COMMANDS, VALID_CAPABILITY_REASON_CODES, REQUIRED_HELPERS, SCHEMA_NODE_GATES, schemaGatedIds, SUPPORTED_NON_UNIFORM_STRATEGIES, SUPPORTED_SET_MARKS, REGEX_MAX_PATTERN_LENGTH = 1024, registry, VALID_CREATE_POSITIONS, REF_HANDLERS, STEP_INTERACTION_MATRIX, MATRIX_EXEMPT_OPS, DEFAULT_INLINE_POLICY, CORE_SET_MARK_KEYS, BOOLEAN_INLINE_MARK_KEYS, TEXT_STYLE_KEYS, PRESERVE_RUN_PROPERTIES_META_KEY = "sdPreserveRunPropertiesKeys", CONTENT_CAPABILITIES, INLINE_CAPABILITIES, SDT_LOCK_TO_LOCK_MODE, BODY_LOCATOR2, STUB_WHERE, EMPTY_RESOLUTION, CONTAINER_NODE_TYPES, VALID_EDGE_NODE_TYPES3, FALLBACK_STORE_KEY = "__documentApiComments", STYLES_PART = "word/styles.xml", PROPERTIES_KEY_BY_CHANNEL, XML_PATH_BY_CHANNEL2, UNDERLINE_API_TO_STORAGE, UNDERLINE_STORAGE_TO_API, HEX_SUBKEYS_BY_PROPERTY, PARAGRAPH_NODE_TYPES, TEXT_STYLE_CHARACTER_STYLE_ATTR = "styleId", DIRECT_FORMATTING_MARK_NAMES, ALIGNMENT_TO_JUSTIFICATION, SUPPORTED_DELETE_NODE_TYPES3, REJECTED_DELETE_NODE_TYPES3, TEXT_PREVIEW_MAX_LENGTH = 80, RANGE_DELETE_SAFE_NODE_TYPES, HEADING_PATTERN, INDENT_PER_LEVEL_TWIPS = 720, HANGING_INDENT_TWIPS = 360, ORDERED_PRESET_CONFIG, BULLET_PRESET_CONFIG, PRESET_TEMPLATES, LevelFormattingHelpers, PRESET_KIND_MAP, NUMBERING_PART = "word/numbering.xml", DEFAULT_PRESET_FOR_KIND, _setValueDelegate, PREVIEW_TEXT_MAX_LENGTH = 2000, BLOCK_PREVIEW_MAX_LENGTH = 200, EDGE_NODE_TYPES$1, POINTS_TO_PIXELS, POINTS_TO_TWIPS = 20, PIXELS_TO_TWIPS, DEFAULT_TABLE_GRID_WIDTH_TWIPS = 1500, SETTINGS_PART = "word/settings.xml", WORD_DEFAULT_TBL_LOOK, FLAG_TO_OOXML_KEY, INVERTED_FLAGS, XML_KEY_TO_STYLE_OPTION, CLEARED_BORDER_OOXML, TABLE_MARGIN_KEY_GROUPS, TABLE_ADAPTER_DISPATCH, ROW_TARGETED_TABLE_OPS, registered = false, STYLES_PART_ID = "word/styles.xml", stylesPartDescriptor, settingsPartDescriptor, RELS_PART_ID2 = "word/_rels/document.xml.rels", RELS_XMLNS2 = "http://schemas.openxmlformats.org/package/2006/relationships", HEADER_RELATIONSHIP_TYPE$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE$1 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", relsPartDescriptor, HISTORY_UNSAFE_OPS, CANONICAL_COMMENT_IGNORED_KEYS, INITIAL_HASH, ROUND_CONSTANTS, V1_COVERAGE, SNAPSHOT_VERSION3 = "sd-diff-snapshot/v1", PAYLOAD_VERSION3 = "sd-diff-payload/v1", ENGINE_ID = "super-editor", STAGED_CONVERTER_KEYS, DiffServiceError, DEFAULT_LEVEL = 1, SWITCH_PATTERN, TOC_BOOKMARK_PREFIX = "_Toc", DEFAULT_RIGHT_TAB_POS = 9350, TAB_LEADER_MAP, NO_ENTRIES_PLACEHOLDER, TC_LEVEL_MIN = 1, TC_LEVEL_MAX = 9, ALLOWED_WRAP_ATTRS, WRAP_TYPES_SUPPORTING_SIDE, WRAP_TYPES_SUPPORTING_DISTANCES, RELATIVE_HEIGHT_MIN = 0, RELATIVE_HEIGHT_MAX = 4294967295, FORBIDDEN_RAW_PATCH_NAMES, CONTROL_TYPE_SDT_PR_ELEMENTS, DEFAULT_CHECKBOX_SYMBOL_FONT2 = "MS Gothic", DEFAULT_CHECKBOX_CHECKED_HEX2 = "2612", DEFAULT_CHECKBOX_UNCHECKED_HEX2 = "2610", VARIANT_ORDER, KIND_ORDER, HEADER_RELATIONSHIP_TYPE3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/header", FOOTER_RELATIONSHIP_TYPE3 = "http://schemas.openxmlformats.org/officeDocument/2006/relationships/footer", DOCUMENT_RELS_PATH2 = "word/_rels/document.xml.rels", HEADER_FILE_PATTERN2, FOOTER_FILE_PATTERN2, SPECIAL_NOTE_TYPES, RESTART_POLICY_TO_OOXML, VALID_DISPLAYS, REFERENCE_BLOCK_PREFIX, CAPTION_STYLE_NAMES, CAPTION_PARAGRAPH_STYLE_ID = "Caption", CAPTION_FORMAT_TO_OOXML, DOCUMENT_STAT_FIELD_TYPES, TOA_LEADER_REVERSE_MAP, EDGE_NODE_TYPES, CONTENT_TYPES_PART_ID = "[Content_Types].xml", CONTENT_TYPES_NS = "http://schemas.openxmlformats.org/package/2006/content-types", contentTypesPartDescriptor, empty_exports, init_empty, CURRENT_APP_VERSION2 = "1.21.0", PIXELS_PER_INCH2 = 96, MAX_HEIGHT_BUFFER_PX = 50, MAX_WIDTH_BUFFER_PX = 20, Editor, EXCLUDED_PLUGIN_KEY_REF_LIST, EXCLUDED_PLUGIN_KEY_REFS, EXCLUDED_PLUGIN_KEY_PREFIXES, TEXT_RANGE_BLOCK_SEP = `
 `, TEXT_RANGE_LEAF_SEP = `
 `, DecorationBridge = class DecorationBridge2 {
   #applied = /* @__PURE__ */ new WeakMap;
@@ -224154,7 +226261,7 @@ var Node$13 = class Node$14 {
     return;
   const trimmed = value.trim();
   return trimmed ? trimmed : undefined;
-}, AUTO_SPACING_DEFAULT_MULTIPLIER = 1.15, AUTO_SPACING_LINE_DEFAULT = 240, normalizeAlignment = (value) => {
+}, AUTO_SPACING_DEFAULT_MULTIPLIER = 1.15, AUTO_SPACING_LINE_DEFAULT = 240, normalizeAlignment = (value, isRtl = false) => {
   switch (value) {
     case "center":
     case "right":
@@ -224165,11 +226272,14 @@ var Node$13 = class Node$14 {
     case "distribute":
     case "numTab":
     case "thaiDistribute":
+    case "lowKashida":
+    case "mediumKashida":
+    case "highKashida":
       return "justify";
     case "end":
-      return "right";
+      return isRtl ? "left" : "right";
     case "start":
-      return "left";
+      return isRtl ? "right" : "left";
     default:
       return;
   }
@@ -224429,10 +226539,11 @@ var Node$13 = class Node$14 {
     resolvedParagraphProperties = paragraphProperties;
   else
     resolvedParagraphProperties = resolveParagraphProperties(converterContext, paragraphProperties, converterContext.tableInfo);
+  const isRtl = resolvedParagraphProperties.rightToLeft === true;
   const normalizedSpacing = normalizeParagraphSpacing(resolvedParagraphProperties.spacing, Boolean(resolvedParagraphProperties.numberingProperties));
   const normalizedIndent = normalizeIndentTwipsToPx(resolvedParagraphProperties.indent);
   const normalizedTabStops = normalizeOoxmlTabs(resolvedParagraphProperties.tabStops);
-  const normalizedAlignment = normalizeAlignment(resolvedParagraphProperties.justification);
+  const normalizedAlignment = normalizeAlignment(resolvedParagraphProperties.justification, isRtl);
   const normalizedBorders = normalizeParagraphBorders(resolvedParagraphProperties.borders);
   const normalizedShading = normalizeParagraphShading(resolvedParagraphProperties.shading);
   const paragraphDecimalSeparator = DEFAULT_DECIMAL_SEPARATOR;
@@ -224461,8 +226572,10 @@ var Node$13 = class Node$14 {
     keepLines: resolvedParagraphProperties.keepLines,
     floatAlignment,
     pageBreakBefore: resolvedParagraphProperties.pageBreakBefore,
-    direction: normalizedDirection,
-    rtl: normalizedDirection === "rtl" ? true : normalizedDirection === "ltr" ? false : undefined
+    ...normalizedDirection ? {
+      direction: normalizedDirection,
+      rtl: isRtl
+    } : {}
   };
   if (normalizedNumberingProperties && normalizedListRendering) {
     const markerRunAttrs = computeRunAttrs(resolveRunProperties(converterContext, resolvedParagraphProperties.runProperties, resolvedParagraphProperties, converterContext.tableInfo, true, Boolean(paragraphProperties.numberingProperties)), converterContext);
@@ -226981,16 +229094,17 @@ var Node$13 = class Node$14 {
       const originX = cursorX;
       const { target, nextIndex, stop } = getNextTabStopPx(cursorX + effectiveIndent, tabStops, tabStopCursor);
       tabStopCursor = nextIndex;
-      const relativeTarget = (Number.isFinite(maxAbsWidth) ? Math.min(target, maxAbsWidth) : target) - effectiveIndent;
+      const clampedTarget = Number.isFinite(maxAbsWidth) ? Math.min(target, maxAbsWidth) : target;
+      const relativeTarget = clampedTarget - effectiveIndent;
       lineWidth = Math.max(lineWidth, relativeTarget);
+      let currentLeader = null;
       if (stop?.leader && stop.leader !== "none") {
-        const from$1 = Math.min(originX, relativeTarget);
-        const to = Math.max(originX, relativeTarget);
-        leaders.push({
-          from: from$1,
-          to,
+        currentLeader = {
+          from: Math.min(originX + effectiveIndent, clampedTarget),
+          to: Math.max(originX + effectiveIndent, clampedTarget),
           style: stop.leader
-        });
+        };
+        leaders.push(currentLeader);
       }
       const stopVal = stop?.val ?? "start";
       if (stopVal === "end" || stopVal === "center" || stopVal === "decimal") {
@@ -227005,6 +229119,8 @@ var Node$13 = class Node$14 {
             const beforeDecimal = groupMeasure.beforeDecimalWidth ?? groupMeasure.totalWidth;
             groupStartX = Math.max(0, relativeTarget - beforeDecimal);
           }
+          if (currentLeader)
+            currentLeader.to = groupStartX + effectiveIndent;
           pendingTabAlignStartX = groupStartX;
         } else
           cursorX = Math.max(cursorX, relativeTarget);
@@ -232089,16 +234205,16 @@ var Node$13 = class Node$14 {
     return;
   console.log(...args$1);
 }, HEADER_FOOTER_INIT_BUDGET_MS = 200, MAX_ZOOM_WARNING_THRESHOLD = 10, MAX_SELECTION_RECTS_PER_USER = 100, SEMANTIC_RESIZE_DEBOUNCE_MS = 120, MIN_SEMANTIC_CONTENT_WIDTH_PX = 1, GLOBAL_PERFORMANCE, PresentationEditor, ICONS, TEXTS, tableActionsOptions;
-var init_src_rbevhPXm_es = __esm(() => {
+var init_src_8sGn3qa5_es = __esm(() => {
   init_rolldown_runtime_B2q5OVn9_es();
-  init_SuperConverter_BL6WX_iN_es();
+  init_SuperConverter_C9MZOwsC_es();
   init_jszip_ChlR43oI_es();
   init_uuid_qzgm05fK_es();
-  init_constants_CMPtQbp7_es();
+  init_constants_Qqwopz80_es();
   init_unified_BRHLwnjP_es();
   init_remark_gfm_z_sDF4ss_es();
   init_remark_stringify_D8vxv_XI_es();
-  init_DocxZipper_BBJ5zSyW_es();
+  init_DocxZipper_gWkmvJfR_es();
   init_vue_LcaAh_pz_es();
   init__plugin_vue_export_helper_DBsdbQXw_es();
   init_eventemitter3_C8I7im8Y_es();
@@ -234585,7 +236701,8 @@ ${err.toString()}`);
         },
         id: {},
         docPartGallery: {},
-        docPartUnique: { default: true }
+        docPartUnique: { default: false },
+        wrapperParagraph: { default: null }
       };
     }
   });
@@ -249612,6 +251729,8 @@ function print() { __p += __j.call(arguments, '') }
         appendTransaction(transactions, oldState, newState) {
           if (!transactions.some((tr$1) => tr$1.docChanged))
             return null;
+          if (transactions.some((tr$1) => tr$1.getMeta?.(ySyncPluginKey)))
+            return null;
           const permTypes = getPermissionTypeInfo(newState.schema);
           if (!permTypes.startTypes.length || !permTypes.endTypes.length)
             return null;
@@ -249667,6 +251786,8 @@ function print() { __p += __j.call(arguments, '') }
         filterTransaction(tr, state) {
           if (!tr.docChanged)
             return true;
+          if (tr.getMeta?.(ySyncPluginKey))
+            return true;
           if (!editor || editor.options.documentMode !== "viewing")
             return true;
           const pluginState = PERMISSION_PLUGIN_KEY.getState(state);
@@ -252719,16 +254840,11 @@ function print() { __p += __j.call(arguments, '') }
       el.classList.add(CLASS_NAMES$1.line);
       applyStyles(el, lineStyles(line.lineHeight));
       el.dataset.layoutEpoch = String(this.layoutEpoch);
-      const paragraphAttrs = block.attrs ?? {};
-      const styleId = paragraphAttrs.styleId;
+      const styleId = (block.attrs ?? {}).styleId;
       if (styleId)
         el.setAttribute("styleid", styleId);
-      applyParagraphDirection(el, paragraphAttrs);
-      const alignment$1 = paragraphAttrs.alignment;
-      if (alignment$1 === "center" || alignment$1 === "right")
-        el.style.textAlign = alignment$1;
-      else
-        el.style.textAlign = "left";
+      const pAttrs = block.attrs;
+      const isRtl = applyRtlStyles(el, pAttrs);
       if (lineRange.pmStart != null)
         el.dataset.pmStart = String(lineRange.pmStart);
       if (lineRange.pmEnd != null)
@@ -252926,7 +255042,7 @@ function print() { __p += __j.call(arguments, '') }
       });
       if (spacingPerSpace !== 0)
         el.style.wordSpacing = `${spacingPerSpace}px`;
-      if (hasExplicitPositioning && line.segments) {
+      if (shouldUseSegmentPositioning(hasExplicitPositioning ?? false, Boolean(line.segments), isRtl)) {
         const paraIndent = block.attrs?.indent;
         const indentLeft = paraIndent?.left ?? 0;
         const firstLine = paraIndent?.firstLine ?? 0;
@@ -252939,8 +255055,9 @@ function print() { __p += __j.call(arguments, '') }
         const fallbackListTextStartPx = typeof wordLayout?.marker?.textStartX === "number" && Number.isFinite(wordLayout.marker.textStartX) ? wordLayout.marker.textStartX : typeof wordLayout?.textStartPx === "number" && Number.isFinite(wordLayout.textStartPx) ? wordLayout.textStartPx : undefined;
         const indentOffset = isListParagraph ? isFirstLineOfPara ? resolvedListTextStartPx ?? fallbackListTextStartPx ?? indentLeft : indentLeft : indentLeft + firstLineOffsetForCumX;
         let cumulativeX = 0;
+        const segments = line.segments;
         const segmentsByRun = /* @__PURE__ */ new Map;
-        line.segments.forEach((segment) => {
+        segments.forEach((segment) => {
           const list5 = segmentsByRun.get(segment.runIndex);
           if (list5)
             list5.push(segment);
@@ -265407,13 +267524,13 @@ var init_zipper_DqXT7uTa_es = __esm(() => {
 
 // ../../packages/superdoc/dist/super-editor.es.js
 var init_super_editor_es = __esm(() => {
-  init_src_rbevhPXm_es();
-  init_SuperConverter_BL6WX_iN_es();
+  init_src_8sGn3qa5_es();
+  init_SuperConverter_C9MZOwsC_es();
   init_jszip_ChlR43oI_es();
-  init_xml_js_DLE8mr0n_es();
-  init_constants_CMPtQbp7_es();
+  init_xml_js_40FWvL78_es();
+  init_constants_Qqwopz80_es();
   init_unified_BRHLwnjP_es();
-  init_DocxZipper_BBJ5zSyW_es();
+  init_DocxZipper_gWkmvJfR_es();
   init_vue_LcaAh_pz_es();
   init_eventemitter3_C8I7im8Y_es();
   init_zipper_DqXT7uTa_es();
@@ -319922,7 +322039,7 @@ function validateNodeAddress(value2, path2 = "address") {
   }
   throw new CliError("VALIDATION_ERROR", `${path2}.kind must be one of: block, inline.`);
 }
-function validateListItemAddress(value2, path2 = "target") {
+function validateListItemAddress3(value2, path2 = "target") {
   const address2 = validateNodeAddress(value2, path2);
   if (address2.kind !== "block" || address2.nodeType !== "listItem") {
     throw new CliError("VALIDATION_ERROR", `${path2} must be a block listItem address.`);
@@ -319947,7 +322064,7 @@ function validateListsListQuery(value2, path2 = "query") {
   }
   if (obj.kind != null) {
     const kind2 = expectString(obj.kind, `${path2}.kind`);
-    if (!LIST_KINDS2.has(kind2)) {
+    if (!LIST_KINDS3.has(kind2)) {
       throw new CliError("VALIDATION_ERROR", `${path2}.kind must be "ordered" or "bullet".`);
     }
     query3.kind = kind2;
@@ -320024,7 +322141,7 @@ function validateQuerySelect(value2, path2) {
   if (type2 === "node") {
     expectOnlyKeys(obj, ["type", "nodeType", "kind"], path2);
     const nodeType2 = obj.nodeType != null ? String(obj.nodeType) : undefined;
-    if (obj.kind != null && !NODE_KINDS2.has(obj.kind)) {
+    if (obj.kind != null && !NODE_KINDS3.has(obj.kind)) {
       throw new CliError("VALIDATION_ERROR", `${path2}.kind must be "block" or "inline".`);
     }
     return {
@@ -320063,16 +322180,16 @@ function validateQuery(value2, path2 = "query") {
   }
   return query3;
 }
-var NODE_TYPES3, BLOCK_NODE_TYPES3, NODE_KINDS2, LIST_KINDS2, LIST_INSERT_POSITIONS2;
+var NODE_TYPES3, BLOCK_NODE_TYPES3, NODE_KINDS3, LIST_KINDS3, LIST_INSERT_POSITIONS3;
 var init_validate = __esm(() => {
   init_errors();
   init_guards();
   init_src();
   NODE_TYPES3 = new Set(NODE_TYPES);
   BLOCK_NODE_TYPES3 = new Set(BLOCK_NODE_TYPES);
-  NODE_KINDS2 = new Set(NODE_KINDS);
-  LIST_KINDS2 = new Set(LIST_KINDS);
-  LIST_INSERT_POSITIONS2 = new Set(LIST_INSERT_POSITIONS);
+  NODE_KINDS3 = new Set(NODE_KINDS);
+  LIST_KINDS3 = new Set(LIST_KINDS);
+  LIST_INSERT_POSITIONS3 = new Set(LIST_INSERT_POSITIONS);
 });
 
 // src/lib/find-query.ts
@@ -323670,7 +325787,7 @@ async function resolveListItemAddressPayload(parsed, baseName = "target") {
   const payload = await resolveJsonInput(parsed, baseName);
   if (!payload)
     return;
-  return validateListItemAddress(payload, baseName);
+  return validateListItemAddress3(payload, baseName);
 }
 async function requireListItemAddressPayload(parsed, commandName, baseName = "target") {
   const payload = await resolveListItemAddressPayload(parsed, baseName);