superdoc 2.2.0 → 2.3.0

package/dist/chunks/rolldown-runtime-BJVcqBbz.es.js

@@ -0,0 +1,43 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget, symbols) => {
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+		secondTarget && __defProp(secondTarget, Symbol.toStringTag, { value: "Module" });
+	}
+	__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default");
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, { get: (a, b) => (typeof require !== "undefined" ? require : a)[b] }) : x)(function(x) {
+	if (typeof require !== "undefined") return require.apply(this, arguments);
+	throw Error("Calling `require` for \"" + x + "\" in an environment that doesn't expose the `require` function.");
+});
+export { __require as a, __reExport as i, __esmMin as n, __toESM as o, __export as r, __commonJSMin as t };

package/dist/chunks/rolldown-runtime-_dR15c8t.cjs

@@ -0,0 +1,68 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esmMin = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (all, symbols) => {
+	let target = {};
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+	if (symbols) __defProp(target, Symbol.toStringTag, { value: "Module" });
+	return target;
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __reExport = (target, mod, secondTarget, symbols) => {
+	if (symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+		secondTarget && __defProp(secondTarget, Symbol.toStringTag, { value: "Module" });
+	}
+	__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default");
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+Object.defineProperty(exports, "__commonJSMin", {
+	enumerable: true,
+	get: function() {
+		return __commonJSMin;
+	}
+});
+Object.defineProperty(exports, "__esmMin", {
+	enumerable: true,
+	get: function() {
+		return __esmMin;
+	}
+});
+Object.defineProperty(exports, "__export", {
+	enumerable: true,
+	get: function() {
+		return __export;
+	}
+});
+Object.defineProperty(exports, "__reExport", {
+	enumerable: true,
+	get: function() {
+		return __reExport;
+	}
+});
+Object.defineProperty(exports, "__toESM", {
+	enumerable: true,
+	get: function() {
+		return __toESM;
+	}
+});

package/dist/chunks/uuid-B2Sqk-3p.es.js

@@ -0,0 +1,32 @@
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
+function unsafeStringify(arr, offset = 0) {
+	return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+	if (!getRandomValues) {
+		if (typeof crypto === "undefined" || !crypto.getRandomValues) throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+		getRandomValues = crypto.getRandomValues.bind(crypto);
+	}
+	return getRandomValues(rnds8);
+}
+var native_default = { randomUUID: typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto) };
+function v4(options, buf, offset) {
+	if (native_default.randomUUID && !buf && !options) return native_default.randomUUID();
+	options = options || {};
+	const rnds = options.random ?? options.rng?.() ?? rng();
+	if (rnds.length < 16) throw new Error("Random bytes length must be >= 16");
+	rnds[6] = rnds[6] & 15 | 64;
+	rnds[8] = rnds[8] & 63 | 128;
+	if (buf) {
+		offset = offset || 0;
+		if (offset < 0 || offset + 16 > buf.length) throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+		for (let i = 0; i < 16; ++i) buf[offset + i] = rnds[i];
+		return buf;
+	}
+	return unsafeStringify(rnds);
+}
+var v4_default = v4;
+export { v4_default as t };

package/dist/chunks/uuid-CFp0WGVU.cjs

@@ -0,0 +1,38 @@
+var byteToHex = [];
+for (let i = 0; i < 256; ++i) byteToHex.push((i + 256).toString(16).slice(1));
+function unsafeStringify(arr, offset = 0) {
+	return (byteToHex[arr[offset + 0]] + byteToHex[arr[offset + 1]] + byteToHex[arr[offset + 2]] + byteToHex[arr[offset + 3]] + "-" + byteToHex[arr[offset + 4]] + byteToHex[arr[offset + 5]] + "-" + byteToHex[arr[offset + 6]] + byteToHex[arr[offset + 7]] + "-" + byteToHex[arr[offset + 8]] + byteToHex[arr[offset + 9]] + "-" + byteToHex[arr[offset + 10]] + byteToHex[arr[offset + 11]] + byteToHex[arr[offset + 12]] + byteToHex[arr[offset + 13]] + byteToHex[arr[offset + 14]] + byteToHex[arr[offset + 15]]).toLowerCase();
+}
+var getRandomValues;
+var rnds8 = new Uint8Array(16);
+function rng() {
+	if (!getRandomValues) {
+		if (typeof crypto === "undefined" || !crypto.getRandomValues) throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+		getRandomValues = crypto.getRandomValues.bind(crypto);
+	}
+	return getRandomValues(rnds8);
+}
+var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+var native_default = { randomUUID };
+function v4(options, buf, offset) {
+	if (native_default.randomUUID && !buf && !options) return native_default.randomUUID();
+	options = options || {};
+	const rnds = options.random ?? options.rng?.() ?? rng();
+	if (rnds.length < 16) throw new Error("Random bytes length must be >= 16");
+	rnds[6] = rnds[6] & 15 | 64;
+	rnds[8] = rnds[8] & 63 | 128;
+	if (buf) {
+		offset = offset || 0;
+		if (offset < 0 || offset + 16 > buf.length) throw new RangeError(`UUID byte range ${offset}:${offset + 15} is out of buffer bounds`);
+		for (let i = 0; i < 16; ++i) buf[offset + i] = rnds[i];
+		return buf;
+	}
+	return unsafeStringify(rnds);
+}
+var v4_default = v4;
+Object.defineProperty(exports, "v4_default", {
+	enumerable: true,
+	get: function() {
+		return v4_default;
+	}
+});

package/dist/collaboration-upgrade-engine.cjs

@@ -0,0 +1,37 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+let __superdoc_docx_engine_collaboration_upgrade_engine = require("@superdoc/docx-engine/collaboration-upgrade-engine");
+const COLLABORATION_UPGRADE_ENGINE_PROTOCOL_VERSION = 1;
+const SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS = Object.freeze([1]);
+const SUPPORTED_V1_READER_CONTRACT_VERSIONS = Object.freeze([1]);
+const COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR = 20;
+var PRIVATE_ENGINE_INFO = (0, __superdoc_docx_engine_collaboration_upgrade_engine.getCollaborationUpgradeEngineInfo)();
+var ENGINE_INFO = Object.freeze({
+	...PRIVATE_ENGINE_INFO,
+	superdocVersion: "2.3.0",
+	roomSchemaVersion: Object.freeze({ ...PRIVATE_ENGINE_INFO.roomSchemaVersion }),
+	supportedBundleVersions: SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS,
+	supportedV1ReaderContractVersions: SUPPORTED_V1_READER_CONTRACT_VERSIONS
+});
+function getCollaborationUpgradeEngineInfo() {
+	return ENGINE_INFO;
+}
+async function buildV2CollaborationUpgradeArtifactFromBundle(input) {
+	assertSupportedNodeRuntime();
+	return (0, __superdoc_docx_engine_collaboration_upgrade_engine.buildV2CollaborationUpgradeArtifactFromBundle)(input);
+}
+async function validateV2CollaborationUpgradeTarget(input) {
+	assertSupportedNodeRuntime();
+	return (0, __superdoc_docx_engine_collaboration_upgrade_engine.validateV2CollaborationUpgradeTarget)(input);
+}
+function assertSupportedNodeRuntime() {
+	const nodeVersion = globalThis.process?.versions?.node;
+	const nodeMajor = nodeVersion ? Number.parseInt(nodeVersion.split(".")[0] ?? "", 10) : NaN;
+	if (!Number.isInteger(nodeMajor) || nodeMajor < 20) throw new Error(`superdoc/collaboration-upgrade-engine requires Node.js 20 or newer`);
+}
+exports.COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR = COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR;
+exports.COLLABORATION_UPGRADE_ENGINE_PROTOCOL_VERSION = COLLABORATION_UPGRADE_ENGINE_PROTOCOL_VERSION;
+exports.SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS = SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS;
+exports.SUPPORTED_V1_READER_CONTRACT_VERSIONS = SUPPORTED_V1_READER_CONTRACT_VERSIONS;
+exports.buildV2CollaborationUpgradeArtifactFromBundle = buildV2CollaborationUpgradeArtifactFromBundle;
+exports.getCollaborationUpgradeEngineInfo = getCollaborationUpgradeEngineInfo;
+exports.validateV2CollaborationUpgradeTarget = validateV2CollaborationUpgradeTarget;

package/dist/collaboration-upgrade-engine.es.js

@@ -0,0 +1,30 @@
+import { buildV2CollaborationUpgradeArtifactFromBundle as buildV2CollaborationUpgradeArtifactFromBundle$1, getCollaborationUpgradeEngineInfo as getCollaborationUpgradeEngineInfo$1, validateV2CollaborationUpgradeTarget as validateV2CollaborationUpgradeTarget$1 } from "@superdoc/docx-engine/collaboration-upgrade-engine";
+const COLLABORATION_UPGRADE_ENGINE_PROTOCOL_VERSION = 1;
+const SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS = Object.freeze([1]);
+const SUPPORTED_V1_READER_CONTRACT_VERSIONS = Object.freeze([1]);
+const COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR = 20;
+var PRIVATE_ENGINE_INFO = getCollaborationUpgradeEngineInfo$1();
+var ENGINE_INFO = Object.freeze({
+	...PRIVATE_ENGINE_INFO,
+	superdocVersion: "2.3.0",
+	roomSchemaVersion: Object.freeze({ ...PRIVATE_ENGINE_INFO.roomSchemaVersion }),
+	supportedBundleVersions: SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS,
+	supportedV1ReaderContractVersions: SUPPORTED_V1_READER_CONTRACT_VERSIONS
+});
+function getCollaborationUpgradeEngineInfo() {
+	return ENGINE_INFO;
+}
+async function buildV2CollaborationUpgradeArtifactFromBundle(input) {
+	assertSupportedNodeRuntime();
+	return buildV2CollaborationUpgradeArtifactFromBundle$1(input);
+}
+async function validateV2CollaborationUpgradeTarget(input) {
+	assertSupportedNodeRuntime();
+	return validateV2CollaborationUpgradeTarget$1(input);
+}
+function assertSupportedNodeRuntime() {
+	const nodeVersion = globalThis.process?.versions?.node;
+	const nodeMajor = nodeVersion ? Number.parseInt(nodeVersion.split(".")[0] ?? "", 10) : NaN;
+	if (!Number.isInteger(nodeMajor) || nodeMajor < 20) throw new Error(`superdoc/collaboration-upgrade-engine requires Node.js 20 or newer`);
+}
+export { COLLABORATION_UPGRADE_ENGINE_MINIMUM_NODE_MAJOR, COLLABORATION_UPGRADE_ENGINE_PROTOCOL_VERSION, SUPPORTED_COLLABORATION_UPGRADE_BUNDLE_VERSIONS, SUPPORTED_V1_READER_CONTRACT_VERSIONS, buildV2CollaborationUpgradeArtifactFromBundle, getCollaborationUpgradeEngineInfo, validateV2CollaborationUpgradeTarget };

package/dist/document-api/src/authorities/authorities.d.ts

@@ -0,0 +1,29 @@
+import { MutationOptions } from '../write/write.js';
+import { AuthoritiesListInput, AuthoritiesGetInput, AuthoritiesInsertInput, AuthoritiesConfigureInput, AuthoritiesRebuildInput, AuthoritiesRemoveInput, AuthoritiesInfo, AuthoritiesMutationResult, AuthoritiesListResult, AuthorityEntryListInput, AuthorityEntryGetInput, AuthorityEntryInsertInput, AuthorityEntryUpdateInput, AuthorityEntryRemoveInput, AuthorityEntryInfo, AuthorityEntryMutationResult, AuthorityEntryListResult } from './authorities.types.js';
+export interface AuthoritiesApi {
+    list(query?: AuthoritiesListInput): AuthoritiesListResult;
+    get(input: AuthoritiesGetInput): AuthoritiesInfo;
+    insert(input: AuthoritiesInsertInput, options?: MutationOptions): AuthoritiesMutationResult;
+    configure(input: AuthoritiesConfigureInput, options?: MutationOptions): AuthoritiesMutationResult;
+    rebuild(input: AuthoritiesRebuildInput, options?: MutationOptions): AuthoritiesMutationResult;
+    remove(input: AuthoritiesRemoveInput, options?: MutationOptions): AuthoritiesMutationResult;
+    entries: {
+        list(query?: AuthorityEntryListInput): AuthorityEntryListResult;
+        get(input: AuthorityEntryGetInput): AuthorityEntryInfo;
+        insert(input: AuthorityEntryInsertInput, options?: MutationOptions): AuthorityEntryMutationResult;
+        update(input: AuthorityEntryUpdateInput, options?: MutationOptions): AuthorityEntryMutationResult;
+        remove(input: AuthorityEntryRemoveInput, options?: MutationOptions): AuthorityEntryMutationResult;
+    };
+}
+export type AuthoritiesAdapter = AuthoritiesApi;
+export declare function executeAuthoritiesList(adapter: AuthoritiesAdapter, query?: AuthoritiesListInput): AuthoritiesListResult;
+export declare function executeAuthoritiesGet(adapter: AuthoritiesAdapter, input: AuthoritiesGetInput): AuthoritiesInfo;
+export declare function executeAuthoritiesInsert(adapter: AuthoritiesAdapter, input: AuthoritiesInsertInput, options?: MutationOptions): AuthoritiesMutationResult;
+export declare function executeAuthoritiesConfigure(adapter: AuthoritiesAdapter, input: AuthoritiesConfigureInput, options?: MutationOptions): AuthoritiesMutationResult;
+export declare function executeAuthoritiesRebuild(adapter: AuthoritiesAdapter, input: AuthoritiesRebuildInput, options?: MutationOptions): AuthoritiesMutationResult;
+export declare function executeAuthoritiesRemove(adapter: AuthoritiesAdapter, input: AuthoritiesRemoveInput, options?: MutationOptions): AuthoritiesMutationResult;
+export declare function executeAuthorityEntriesList(adapter: AuthoritiesAdapter, query?: AuthorityEntryListInput): AuthorityEntryListResult;
+export declare function executeAuthorityEntriesGet(adapter: AuthoritiesAdapter, input: AuthorityEntryGetInput): AuthorityEntryInfo;
+export declare function executeAuthorityEntriesInsert(adapter: AuthoritiesAdapter, input: AuthorityEntryInsertInput, options?: MutationOptions): AuthorityEntryMutationResult;
+export declare function executeAuthorityEntriesUpdate(adapter: AuthoritiesAdapter, input: AuthorityEntryUpdateInput, options?: MutationOptions): AuthorityEntryMutationResult;
+export declare function executeAuthorityEntriesRemove(adapter: AuthoritiesAdapter, input: AuthorityEntryRemoveInput, options?: MutationOptions): AuthorityEntryMutationResult;

package/dist/document-api/src/authorities/authorities.types.d.ts

@@ -0,0 +1,113 @@
+import { InlineAnchor } from '../types/base.js';
+import { TextTarget } from '../types/address.js';
+import { AdapterMutationFailure } from '../types/adapter-result.js';
+import { DiscoveryOutput } from '../types/discovery.js';
+import { TocCreateLocation } from '../toc/toc.types.js';
+export interface AuthoritiesAddress {
+    kind: 'block';
+    nodeType: 'tableOfAuthorities';
+    nodeId: string;
+}
+export interface AuthorityEntryAddress {
+    kind: 'inline';
+    nodeType: 'authorityEntry';
+    anchor: InlineAnchor;
+}
+export type AuthorityCategory = 'cases' | 'statutes' | 'otherAuthorities' | 'rules' | 'treatises' | 'regulations' | 'constitutional' | number;
+export interface AuthoritiesConfig {
+    category?: number;
+    entryPageSeparator?: string;
+    usePassim?: boolean;
+    includeHeadings?: boolean;
+    tabLeader?: 'none' | 'dot' | 'hyphen' | 'underscore';
+    pageRangeSeparator?: string;
+}
+export interface AuthoritiesListInput {
+    limit?: number;
+    offset?: number;
+}
+export interface AuthoritiesGetInput {
+    target: AuthoritiesAddress;
+}
+export interface AuthoritiesRemoveInput {
+    target: AuthoritiesAddress;
+}
+export interface AuthoritiesRebuildInput {
+    target: AuthoritiesAddress;
+}
+export interface AuthoritiesInsertInput {
+    at: TocCreateLocation;
+    config?: AuthoritiesConfig;
+}
+export interface AuthoritiesConfigureInput {
+    target: AuthoritiesAddress;
+    patch: AuthoritiesConfig;
+}
+export interface AuthoritiesInfo {
+    address: AuthoritiesAddress;
+    instruction: string;
+    config: AuthoritiesConfig;
+    entryCount: number;
+}
+export interface AuthoritiesDomain {
+    address: AuthoritiesAddress;
+    instruction: string;
+    config: AuthoritiesConfig;
+    entryCount: number;
+}
+export interface AuthorityEntryData {
+    longCitation: string;
+    shortCitation?: string;
+    category: AuthorityCategory;
+    bold?: boolean;
+    italic?: boolean;
+}
+export interface AuthorityEntryListInput {
+    category?: AuthorityCategory;
+    limit?: number;
+    offset?: number;
+}
+export interface AuthorityEntryGetInput {
+    target: AuthorityEntryAddress;
+}
+export interface AuthorityEntryRemoveInput {
+    target: AuthorityEntryAddress;
+}
+export interface AuthorityEntryInsertInput {
+    at: TextTarget;
+    entry: AuthorityEntryData;
+}
+export interface AuthorityEntryUpdateInput {
+    target: AuthorityEntryAddress;
+    patch: Partial<AuthorityEntryData>;
+}
+export interface AuthorityEntryInfo {
+    address: AuthorityEntryAddress;
+    longCitation: string;
+    shortCitation?: string;
+    category: AuthorityCategory;
+    bold: boolean;
+    italic: boolean;
+    instruction: string;
+}
+export interface AuthorityEntryDomain {
+    address: AuthorityEntryAddress;
+    longCitation: string;
+    shortCitation?: string;
+    category: AuthorityCategory;
+    bold: boolean;
+    italic: boolean;
+    instruction: string;
+}
+export interface AuthoritiesMutationSuccess {
+    success: true;
+    authorities: AuthoritiesAddress;
+}
+export type AuthoritiesMutationResult = AuthoritiesMutationSuccess | AdapterMutationFailure;
+export interface AuthorityEntryMutationSuccess {
+    success: true;
+    entry: AuthorityEntryAddress;
+}
+export type AuthorityEntryMutationResult = AuthorityEntryMutationSuccess | AdapterMutationFailure;
+export type AuthoritiesListResult = DiscoveryOutput<AuthoritiesDomain>;
+export type AuthorityEntryListResult = DiscoveryOutput<AuthorityEntryDomain>;

package/dist/document-api/src/blocks/blocks.d.ts

@@ -0,0 +1,29 @@
+import { MutationOptions } from '../write/write.js';
+import { BlocksDeleteInput, BlocksDeleteResult, BlocksListInput, BlocksListResult, BlocksDeleteRangeInput, BlocksDeleteRangeResult, BlocksMergeInput, BlocksMergeResult, BlocksMoveInput, BlocksMoveResult, BlocksSplitInput, BlocksSplitResult } from '../types/blocks.types.js';
+export interface BlocksApi {
+    list(input?: BlocksListInput): BlocksListResult;
+    delete(input: BlocksDeleteInput, options?: MutationOptions): BlocksDeleteResult;
+    deleteRange(input: BlocksDeleteRangeInput, options?: MutationOptions): BlocksDeleteRangeResult;
+    /** Split a paragraph at a visible-text offset. */
+    split(input: BlocksSplitInput, options?: MutationOptions): BlocksSplitResult;
+    /** Merge two adjacent paragraphs in the same story. */
+    merge(input: BlocksMergeInput, options?: MutationOptions): BlocksMergeResult;
+    /** Move a paragraph within the same story. */
+    move(input: BlocksMoveInput, options?: MutationOptions): BlocksMoveResult;
+}
+export interface BlocksAdapter {
+    list(input?: BlocksListInput): BlocksListResult;
+    delete(input: BlocksDeleteInput, options?: MutationOptions): BlocksDeleteResult;
+    deleteRange(input: BlocksDeleteRangeInput, options?: MutationOptions): BlocksDeleteRangeResult;
+    /** Structural block operations. Engines that don't support them
+     * may reject with CAPABILITY_UNAVAILABLE. */
+    split?(input: BlocksSplitInput, options?: MutationOptions): BlocksSplitResult;
+    merge?(input: BlocksMergeInput, options?: MutationOptions): BlocksMergeResult;
+    move?(input: BlocksMoveInput, options?: MutationOptions): BlocksMoveResult;
+}
+export declare function executeBlocksList(adapter: BlocksAdapter, input?: BlocksListInput): BlocksListResult;
+export declare function executeBlocksDelete(adapter: BlocksAdapter, input: BlocksDeleteInput, options?: MutationOptions): BlocksDeleteResult;
+export declare function executeBlocksDeleteRange(adapter: BlocksAdapter, input: BlocksDeleteRangeInput, options?: MutationOptions): BlocksDeleteRangeResult;
+export declare function executeBlocksSplit(adapter: BlocksAdapter, input: BlocksSplitInput, options?: MutationOptions): BlocksSplitResult;
+export declare function executeBlocksMerge(adapter: BlocksAdapter, input: BlocksMergeInput, options?: MutationOptions): BlocksMergeResult;
+export declare function executeBlocksMove(adapter: BlocksAdapter, input: BlocksMoveInput, options?: MutationOptions): BlocksMoveResult;

package/dist/document-api/src/bookmarks/bookmarks.d.ts

@@ -0,0 +1,15 @@
+import { MutationOptions } from '../write/write.js';
+import { BookmarkGetInput, BookmarkInfo, BookmarkInsertInput, BookmarkRenameInput, BookmarkRemoveInput, BookmarkMutationResult, BookmarkListInput, BookmarksListResult } from './bookmarks.types.js';
+export interface BookmarksApi {
+    list(query?: BookmarkListInput): BookmarksListResult;
+    get(input: BookmarkGetInput): BookmarkInfo;
+    insert(input: BookmarkInsertInput, options?: MutationOptions): BookmarkMutationResult;
+    rename(input: BookmarkRenameInput, options?: MutationOptions): BookmarkMutationResult;
+    remove(input: BookmarkRemoveInput, options?: MutationOptions): BookmarkMutationResult;
+}
+export type BookmarksAdapter = BookmarksApi;
+export declare function executeBookmarksList(adapter: BookmarksAdapter, query?: BookmarkListInput): BookmarksListResult;
+export declare function executeBookmarksGet(adapter: BookmarksAdapter, input: BookmarkGetInput): BookmarkInfo;
+export declare function executeBookmarksInsert(adapter: BookmarksAdapter, input: BookmarkInsertInput, options?: MutationOptions): BookmarkMutationResult;
+export declare function executeBookmarksRename(adapter: BookmarksAdapter, input: BookmarkRenameInput, options?: MutationOptions): BookmarkMutationResult;
+export declare function executeBookmarksRemove(adapter: BookmarksAdapter, input: BookmarkRemoveInput, options?: MutationOptions): BookmarkMutationResult;

package/dist/document-api/src/bookmarks/bookmarks.types.d.ts

@@ -0,0 +1,82 @@
+import { Position } from '../types/base.js';
+import { TextTarget } from '../types/address.js';
+import { StoryLocator } from '../types/story.types.js';
+import { AdapterMutationFailure } from '../types/adapter-result.js';
+import { DiscoveryOutput } from '../types/discovery.js';
+export interface BookmarkAddress {
+    kind: 'entity';
+    entityType: 'bookmark';
+    name: string;
+    /**
+     * Story containing this bookmark. Omit for body (backward compatible).
+     *
+     * When omitted, bookmark operations resolve by `name` across the whole
+     * document. If multiple stories contain the same bookmark name, omitted-story
+     * lookup resolves to the first match returned by the implementation's
+     * document-wide bookmark scan; callers must not rely on a specific cross-story
+     * ordering rule. Prefer the `address` returned by bookmark read operations
+     * (`bookmarks.list`, `bookmarks.get`) because those responses populate
+     * `story` for non-body bookmarks.
+     */
+    story?: StoryLocator;
+}
+export interface BookmarkListInput {
+    limit?: number;
+    offset?: number;
+    /** Restrict listing to a specific story. Omit to search document-wide. */
+    in?: StoryLocator;
+}
+export interface BookmarkGetInput {
+    target: BookmarkAddress;
+}
+export interface BookmarkInsertInput {
+    name: string;
+    at: TextTarget;
+    /**
+     * For table-column bookmarks: restricts the bookmark to a column range
+     * within a table row. (Amendment 8)
+     */
+    tableColumn?: {
+        colFirst: number;
+        colLast: number;
+    };
+}
+export interface BookmarkRenameInput {
+    target: BookmarkAddress;
+    newName: string;
+}
+export interface BookmarkRemoveInput {
+    target: BookmarkAddress;
+}
+export interface BookmarkInfo {
+    address: BookmarkAddress;
+    name: string;
+    bookmarkId: string;
+    range: {
+        from: Position;
+        to: Position;
+    };
+    tableColumn?: {
+        colFirst: number;
+        colLast: number;
+    };
+}
+export interface BookmarkDomain {
+    address: BookmarkAddress;
+    name: string;
+    bookmarkId: string;
+    range: {
+        from: Position;
+        to: Position;
+    };
+    tableColumn?: {
+        colFirst: number;
+        colLast: number;
+    };
+}
+export interface BookmarkMutationSuccess {
+    success: true;
+    bookmark: BookmarkAddress;
+}
+export type BookmarkMutationResult = BookmarkMutationSuccess | AdapterMutationFailure;
+export type BookmarksListResult = DiscoveryOutput<BookmarkDomain>;

package/dist/document-api/src/capabilities/capabilities.d.ts

@@ -0,0 +1,82 @@
+import { OperationId } from '../contract/types.js';
+import { InlinePropertyStorage, InlinePropertyType, InlineRunPatchKey } from '../format/inline-run-patch.js';
+export declare const CAPABILITY_REASON_CODES: readonly ["COMMAND_UNAVAILABLE", "HELPER_UNAVAILABLE", "OPERATION_UNAVAILABLE", "TRACKED_MODE_UNAVAILABLE", "DRY_RUN_UNAVAILABLE", "NAMESPACE_UNAVAILABLE", "STYLES_PART_MISSING", "COLLABORATION_ACTIVE"];
+export type CapabilityReasonCode = (typeof CAPABILITY_REASON_CODES)[number];
+/**
+ * A boolean flag indicating whether a capability is active, with optional
+ * machine-readable reason codes explaining why it is disabled.
+ */
+export type CapabilityFlag = {
+    enabled: boolean;
+    reasons?: CapabilityReasonCode[];
+};
+/** Per-operation runtime capability describing availability, tracked-mode, and dry-run support. */
+export interface OperationRuntimeCapability {
+    available: boolean;
+    tracked: boolean;
+    dryRun: boolean;
+    reasons?: CapabilityReasonCode[];
+}
+export type OperationCapabilities = Record<OperationId, OperationRuntimeCapability>;
+/** Runtime capabilities exposed by the plan engine (mutations.apply / mutations.preview). */
+export interface PlanEngineCapabilities {
+    /** Step op codes the engine can execute (e.g., 'text.rewrite', 'format.apply'). */
+    supportedStepOps: readonly string[];
+    /** Non-uniform style resolution strategies available for `onNonUniform`. */
+    supportedNonUniformStrategies: readonly string[];
+    /** Mark names that `setMarks` can override (e.g., 'bold', 'italic'). */
+    supportedSetMarks: readonly string[];
+    /** Regex selector limits enforced by the selector engine. Unsafe patterns are rejected. */
+    regex: {
+        /** Maximum allowed text-selector regex pattern length. */
+        maxPatternLength: number;
+        maxExecutionMs?: number;
+    };
+}
+/**
+ * Complete runtime capability snapshot for a Document API editor instance.
+ *
+ * `global` contains namespace-level flags (track changes, comments, lists, dry-run).
+ * `operations` contains per-operation availability details keyed by {@link OperationId}.
+ * `planEngine` describes plan engine capabilities (step ops, style strategies, limits).
+ */
+/** Per-inline-property runtime capability for `format.apply`. */
+export interface InlinePropertyCapability {
+    /** Whether this specific property is currently executable. */
+    available: boolean;
+    /** Whether this property supports tracked mode. */
+    tracked: boolean;
+    /** API value shape for this property. */
+    type: InlinePropertyType;
+    /** Runtime storage path used by the editor (mark or runAttribute). */
+    storage: InlinePropertyStorage;
+}
+/** Format capability snapshot: advertises per-property support for `format.apply`. */
+export interface FormatCapabilities {
+    /** Capability entry per canonical inline patch key. */
+    supportedInlineProperties: Record<InlineRunPatchKey, InlinePropertyCapability>;
+}
+export interface DocumentApiCapabilities {
+    global: {
+        trackChanges: CapabilityFlag;
+        comments: CapabilityFlag;
+        lists: CapabilityFlag;
+        dryRun: CapabilityFlag;
+        history: CapabilityFlag;
+    };
+    /** Format capability discovery for `format.apply`. */
+    format: FormatCapabilities;
+    operations: OperationCapabilities;
+    planEngine: PlanEngineCapabilities;
+}
+/** Engine-specific adapter that resolves runtime capabilities for the current editor instance. */
+export interface CapabilitiesAdapter {
+    get(): DocumentApiCapabilities;
+}
+/**
+ * Delegates to the capabilities adapter to retrieve the current capability snapshot.
+ *
+ * @param adapter - The engine-specific capabilities adapter.
+ * @returns The resolved capabilities for this editor instance.
+ */
+export declare function executeCapabilities(adapter: CapabilitiesAdapter): DocumentApiCapabilities;

package/dist/document-api/src/captions/captions.d.ts

@@ -0,0 +1,17 @@
+import { MutationOptions } from '../write/write.js';
+import { CaptionListInput, CaptionsListResult, CaptionGetInput, CaptionInfo, CaptionInsertInput, CaptionUpdateInput, CaptionRemoveInput, CaptionMutationResult, CaptionConfigureInput, CaptionConfigResult } from './captions.types.js';
+export interface CaptionsApi {
+    list(input?: CaptionListInput): CaptionsListResult;
+    get(input: CaptionGetInput): CaptionInfo;
+    insert(input: CaptionInsertInput, options?: MutationOptions): CaptionMutationResult;
+    update(input: CaptionUpdateInput, options?: MutationOptions): CaptionMutationResult;
+    remove(input: CaptionRemoveInput, options?: MutationOptions): CaptionMutationResult;
+    configure(input: CaptionConfigureInput, options?: MutationOptions): CaptionConfigResult;
+}
+export type CaptionsAdapter = CaptionsApi;
+export declare function executeCaptionsList(adapter: CaptionsAdapter, input?: CaptionListInput): CaptionsListResult;
+export declare function executeCaptionsGet(adapter: CaptionsAdapter, input: CaptionGetInput): CaptionInfo;
+export declare function executeCaptionsInsert(adapter: CaptionsAdapter, input: CaptionInsertInput, options?: MutationOptions): CaptionMutationResult;
+export declare function executeCaptionsUpdate(adapter: CaptionsAdapter, input: CaptionUpdateInput, options?: MutationOptions): CaptionMutationResult;
+export declare function executeCaptionsRemove(adapter: CaptionsAdapter, input: CaptionRemoveInput, options?: MutationOptions): CaptionMutationResult;
+export declare function executeCaptionsConfigure(adapter: CaptionsAdapter, input: CaptionConfigureInput, options?: MutationOptions): CaptionConfigResult;