smartrte-core 0.2.1 → 1.0.0-beta.2

package/dist/foundation/atom/declarations.js

@@ -0,0 +1,17 @@
+import { safeFormulaSource, sanitizeAtomSource } from "./security.js";
+const positiveDimensions = (attrs) => [attrs.width, attrs.height].every((value) => value === undefined || Number.isFinite(value) && Number(value) > 0 && Number(value) <= 100000);
+const imageValid = (attrs) => typeof attrs.alt === "string"
+    && (attrs.alt.length > 0 || attrs.decorative === true)
+    && positiveDimensions(attrs)
+    && Boolean(sanitizeAtomSource(String(attrs.src || ""), { kind: "image", allowBlobPreview: attrs.status === "pending" }));
+const formulaValid = (attrs) => safeFormulaSource(attrs.source) && (attrs.notation === "latex" || attrs.notation === "mathml");
+const mediaValid = (kind) => (attrs) => positiveDimensions(attrs)
+    && Boolean(sanitizeAtomSource(String(attrs.src || ""), { kind, allowBlobPreview: attrs.status === "pending" }));
+export const atomDeclarations = [
+    { type: "image", kind: "image", group: "inline", validate: imageValid },
+    { type: "block_image", kind: "image", group: "block", validate: imageValid },
+    { type: "formula", kind: "formula", group: "inline", validate: formulaValid },
+    { type: "block_formula", kind: "formula", group: "block", validate: formulaValid },
+    { type: "video", kind: "video", group: "block", validate: mediaValid("video") },
+    { type: "audio", kind: "audio", group: "block", validate: mediaValid("audio") },
+];

package/dist/foundation/atom/formats.d.ts

@@ -0,0 +1,24 @@
+import "katex/contrib/mhchem";
+import type { SmartElementNode } from "../types.js";
+export declare const atomToHtml: (node: SmartElementNode, options?: {
+    renderFormulaHtml?: boolean;
+}) => string;
+export declare const atomFromHtmlElement: (element: Element) => SmartElementNode | null;
+export declare const atomToMarkdown: (node: SmartElementNode) => string;
+export interface AtomDocxRun {
+    readonly kind: "image" | "text";
+    readonly source: string;
+    readonly alt?: string;
+}
+/**
+ * Matches packages/core/src/foundation/formats/docx/export.ts's actual
+ * behavior (SS2.1): formulas are written as literal LaTeX text inside an
+ * <m:oMath> zone, not translated to real OMML and not rendered as an
+ * image. Word will show the raw LaTeX string, not typeset math - this is
+ * `kind: "text"`, not `"image"`, to describe that honestly.
+ */
+export declare const atomToDocx: (node: SmartElementNode) => AtomDocxRun;
+export declare const atomToPdf: (node: SmartElementNode) => {
+    kind: "image" | "text";
+    value: string;
+};

package/dist/foundation/atom/formats.js

@@ -0,0 +1,105 @@
+import katex from "katex";
+// Registers \ce{...} chemistry-equation notation on the shared katex module
+// instance, matching surface/renderer.ts's own live-render import - a
+// formula baked here via renderFormulaHtml must support the exact same
+// notation the live editor does, or a chemistry entry would render live but
+// fall back to plain text in the exported/baked HTML.
+import "katex/contrib/mhchem";
+import { createNodeId } from "../identity.js";
+import { sanitizeAtomSource } from "./security.js";
+const escape = (value) => String(value ?? "").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+const attr = (name, value) => value === undefined ? "" : ` ${name}="${escape(value)}"`;
+const dimensions = (node) => `${attr("width", node.attrs?.width)}${attr("height", node.attrs?.height)}`;
+// Mirrors surface/renderer.ts's KATEX_OPTIONS and try/catch-to-plain-text
+// fallback exactly - a formula that fails to render live must fail the same
+// way when baked into exported HTML, not throw and abort the whole export.
+const KATEX_OPTIONS = { trust: false, strict: "error" };
+const renderFormulaToHtml = (source) => {
+    try {
+        return katex.renderToString(source, KATEX_OPTIONS);
+    }
+    catch {
+        return escape(source);
+    }
+};
+export const atomToHtml = (node, options) => {
+    if (node.type === "image" || node.type === "block_image") {
+        const src = sanitizeAtomSource(String(node.attrs?.src || ""), { kind: "image", allowBlobPreview: node.attrs?.status === "pending" }) || "";
+        return `<img data-smart-id="${escape(node.id)}" data-smart-type="${node.type}" src="${escape(src)}" alt="${escape(node.attrs?.alt)}"${dimensions(node)}${attr("data-smart-status", node.attrs?.status || "ready")}${node.attrs?.decorative === true ? ' data-smart-decorative="true"' : ""}${attr("data-smart-align", node.attrs?.align)}>`;
+    }
+    if (node.type === "formula" || node.type === "block_formula") {
+        const tag = node.type === "formula" ? "span" : "div";
+        const source = String(node.attrs?.source || "");
+        // The rendered KaTeX HTML is purely a self-contained visual convenience
+        // for consumers that display this HTML string directly without also
+        // running katex.render() against it themselves (docs/bugs/
+        // formula-not-rendered-in-static-html-consumers.md) - data-smart-formula
+        // stays the single source of truth for round-tripping back into the
+        // model (list/formats.ts's parser reads the attribute, never this
+        // inner content), so baking this in can never desync source vs. render.
+        const inner = options?.renderFormulaHtml ? renderFormulaToHtml(source) : "";
+        return `<${tag} data-smart-id="${escape(node.id)}" data-smart-type="${node.type}" data-smart-notation="${escape(node.attrs?.notation || "latex")}" data-smart-formula="${escape(source)}" role="math" aria-label="${escape(`Mathematical formula: ${source}`)}">${inner}</${tag}>`;
+    }
+    if (node.type === "video" || node.type === "audio") {
+        const src = sanitizeAtomSource(String(node.attrs?.src || ""), { kind: node.type }) || "";
+        return `<${node.type} data-smart-id="${escape(node.id)}" data-smart-type="${node.type}" src="${escape(src)}" controls${dimensions(node)}${node.type === "video" ? attr("poster", node.attrs?.poster) : ""}></${node.type}>`;
+    }
+    if (node.type === "divider")
+        return `<hr data-smart-id="${escape(node.id)}" data-smart-type="divider">`;
+    throw new Error(`Unsupported atom type "${node.type}".`);
+};
+export const atomFromHtmlElement = (element) => {
+    const declared = element.getAttribute("data-smart-type");
+    const type = declared || (element.tagName === "IMG" ? "image" : element.tagName.toLowerCase());
+    const id = element.getAttribute("data-smart-id") || createNodeId();
+    const number = (name) => { const value = Number(element.getAttribute(name)); return Number.isFinite(value) && value > 0 ? value : undefined; };
+    if (type === "image" || type === "block_image") {
+        const src = sanitizeAtomSource(element.getAttribute("src"), { kind: "image" });
+        if (!src)
+            return null;
+        return { type, id, attrs: { src, alt: element.getAttribute("alt") || "", status: element.getAttribute("data-smart-status") || "ready", ...(element.getAttribute("data-smart-decorative") === "true" ? { decorative: true } : {}), ...(element.getAttribute("data-smart-align") ? { align: element.getAttribute("data-smart-align") } : {}), ...(number("width") ? { width: number("width") } : {}), ...(number("height") ? { height: number("height") } : {}) } };
+    }
+    if (type === "formula" || type === "block_formula") {
+        return { type, id, attrs: { source: element.getAttribute("data-smart-formula") || "", notation: element.getAttribute("data-smart-notation") === "mathml" ? "mathml" : "latex" } };
+    }
+    if (type === "video" || type === "audio") {
+        const src = sanitizeAtomSource(element.getAttribute("src"), { kind: type });
+        if (!src)
+            return null;
+        return { type, id, attrs: { src, status: "ready", ...(type === "video" && element.getAttribute("poster") ? { poster: element.getAttribute("poster") } : {}), ...(number("width") ? { width: number("width") } : {}), ...(number("height") ? { height: number("height") } : {}) } };
+    }
+    if (type === "divider" || element.tagName === "HR")
+        return { type: "divider", id };
+    return null;
+};
+export const atomToMarkdown = (node) => {
+    if (node.type === "image" || node.type === "block_image")
+        return `![${String(node.attrs?.alt || "")}](${String(node.attrs?.src || "")})`;
+    if (node.type === "formula" || node.type === "block_formula")
+        return node.type === "formula" ? `$${String(node.attrs?.source || "")}$` : `$$\n${String(node.attrs?.source || "")}\n$$`;
+    // Media is unsupported in Markdown. Preserve a readable link instead of dropping content.
+    if (node.type === "video" || node.type === "audio")
+        return `[${node.type}: ${String(node.attrs?.src || "")}](${String(node.attrs?.src || "")})`;
+    if (node.type === "divider")
+        return "---";
+    return "";
+};
+/**
+ * Matches packages/core/src/foundation/formats/docx/export.ts's actual
+ * behavior (SS2.1): formulas are written as literal LaTeX text inside an
+ * <m:oMath> zone, not translated to real OMML and not rendered as an
+ * image. Word will show the raw LaTeX string, not typeset math - this is
+ * `kind: "text"`, not `"image"`, to describe that honestly.
+ */
+export const atomToDocx = (node) => node.type === "formula" || node.type === "block_formula"
+    ? { kind: "text", source: String(node.attrs?.source || "") }
+    : node.type === "image" || node.type === "block_image"
+        ? { kind: "image", source: String(node.attrs?.src || ""), alt: String(node.attrs?.alt || "") }
+        : node.type === "divider"
+            ? { kind: "text", source: "---" }
+            : { kind: "text", source: `[${node.type}: ${String(node.attrs?.src || "")}]` };
+export const atomToPdf = (node) => node.type === "formula" || node.type === "block_formula" ? { kind: "text", value: String(node.attrs?.source || "") }
+    : node.type === "video" ? { kind: "image", value: String(node.attrs?.poster || node.attrs?.src || "") }
+        : node.type === "image" || node.type === "block_image" ? { kind: "image", value: String(node.attrs?.src || "") }
+            : node.type === "divider" ? { kind: "text", value: "---" }
+                : { kind: "text", value: String(node.attrs?.src || "") };

package/dist/foundation/atom/index.d.ts

@@ -0,0 +1,10 @@
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./security.js";
+export * from "./declarations.js";
+export * from "./commands.js";
+export * from "./composition.js";
+export * from "./persistence.js";
+export * from "./lifecycle.js";
+export * from "./selection.js";
+export * from "./formats.js";

package/dist/foundation/atom/index.js

@@ -0,0 +1,10 @@
+export * from "./types.js";
+export * from "./schema.js";
+export * from "./security.js";
+export * from "./declarations.js";
+export * from "./commands.js";
+export * from "./composition.js";
+export * from "./persistence.js";
+export * from "./lifecycle.js";
+export * from "./selection.js";
+export * from "./formats.js";

package/dist/foundation/atom/lifecycle.d.ts

@@ -0,0 +1,12 @@
+import type { FoundationEditor } from "../editor.js";
+export interface AtomUploadCompletion {
+    readonly src?: string;
+    readonly id?: string;
+    readonly error?: string;
+}
+/** Applies upload completion outside the insertion transaction and never resurrects deleted nodes. */
+export declare const completeAtomUpload: (editor: FoundationEditor, nodeId: string, completion: AtomUploadCompletion) => boolean;
+export declare const runAtomUpload: (editor: FoundationEditor, nodeId: string, upload: () => Promise<{
+    src: string;
+    id?: string;
+}>) => Promise<boolean>;

package/dist/foundation/atom/lifecycle.js

@@ -0,0 +1,41 @@
+import { isTextNode } from "../identity.js";
+import { atomDeclarations } from "./declarations.js";
+import { sanitizeAtomSource } from "./security.js";
+/** Applies upload completion outside the insertion transaction and never resurrects deleted nodes. */
+export const completeAtomUpload = (editor, nodeId, completion) => {
+    const resolved = editor.positions.positionOf(nodeId);
+    if (!resolved)
+        return false;
+    const index = resolved.kind === "inline" ? (() => {
+        let offset = 0;
+        for (let childIndex = 0; childIndex < (resolved.parent.children?.length || 0); childIndex += 1) {
+            const child = resolved.parent.children[childIndex];
+            if (!isTextNode(child) && child.id === nodeId && offset === resolved.pos.offset)
+                return childIndex;
+            offset += isTextNode(child) ? child.text.length : 1;
+        }
+        return -1;
+    })() : resolved.pos.offset;
+    const node = resolved.parent.children?.[index];
+    if (!node || isTextNode(node) || node.id !== nodeId)
+        return false;
+    const before = node.attrs || {};
+    const declaration = atomDeclarations.find((entry) => entry.type === node.type);
+    const safeSource = completion.src && declaration && declaration.kind !== "formula"
+        ? sanitizeAtomSource(completion.src, { kind: declaration.kind }) : null;
+    const after = safeSource
+        ? { ...before, src: safeSource, status: "ready", ...(completion.id ? { uploadId: completion.id } : { uploadId: undefined }), error: undefined }
+        : { ...before, status: "error", uploadId: undefined, error: completion.error || "Upload failed" };
+    editor.transact((transaction) => transaction.operations.push({
+        type: "setNodeAttributes", pos: { path: [...resolved.pos.path, index], offset: 0 }, before, after: Object.fromEntries(Object.entries(after).filter(([, value]) => value !== undefined)),
+    }), { source: "api", addToHistory: false });
+    return true;
+};
+export const runAtomUpload = async (editor, nodeId, upload) => {
+    try {
+        return completeAtomUpload(editor, nodeId, await upload());
+    }
+    catch (error) {
+        return completeAtomUpload(editor, nodeId, { error: error instanceof Error ? error.message : "Upload failed" });
+    }
+};

package/dist/foundation/atom/persistence.d.ts

@@ -0,0 +1,3 @@
+import type { PersistedEditorDocument } from "../types.js";
+export declare const assertNoBlobAtomUrls: (envelope: PersistedEditorDocument) => void;
+export declare const serializePersistedEditorDocument: (envelope: PersistedEditorDocument) => string;

package/dist/foundation/atom/persistence.js

@@ -0,0 +1,20 @@
+import { isTextNode } from "../identity.js";
+export const assertNoBlobAtomUrls = (envelope) => {
+    const visit = (node) => {
+        if (isTextNode(node))
+            return;
+        if (node.attrs?.status === "pending")
+            throw new Error(`Cannot persist pending atom "${node.id}"; wait for completion or cancel it.`);
+        for (const key of ["src", "poster"]) {
+            if (typeof node.attrs?.[key] === "string" && /^blob:/i.test(node.attrs[key])) {
+                throw new Error(`Cannot persist transient blob URL from ${node.type}.${key}.`);
+            }
+        }
+        node.children?.forEach(visit);
+    };
+    visit(envelope.document);
+};
+export const serializePersistedEditorDocument = (envelope) => {
+    assertNoBlobAtomUrls(envelope);
+    return JSON.stringify(envelope);
+};

package/dist/foundation/atom/plugin.d.ts

@@ -0,0 +1,20 @@
+import { type PluginCommand } from "../plugin/types.js";
+import { atomDeclarations } from "./declarations.js";
+/**
+ * Wraps the four existing, already-tested atom commands (atom/commands.ts)
+ * with the description Phase 10's doc generation needs. Six atom node
+ * types (image, block_image, formula, block_formula, video, audio, per
+ * atomDeclarations) share these same four generic commands via
+ * `declaration`/`attrs` params, the same way marks' seven commands cover
+ * every mark type - there is no per-atom-type command to convert
+ * separately.
+ *
+ * MediaProvider/mediaPicker (packages/react/src/mediaProvider.ts) are left
+ * exactly as they are - direct CanonicalAuthorityEditor props, already
+ * working - rather than routed through this manifest. They are a
+ * react-layer upload/picker concern orthogonal to the core command surface
+ * atom.insert consumes (a MediaProvider's job ends at producing a URL;
+ * atom.insert takes it from there like any other src).
+ */
+export declare const atomPluginCommands: Record<string, PluginCommand>;
+export { atomDeclarations };

package/dist/foundation/atom/plugin.js

@@ -0,0 +1,55 @@
+import { definePluginCommand } from "../plugin/types.js";
+import { atomCommands } from "./commands.js";
+import { atomDeclarations } from "./declarations.js";
+/**
+ * Wraps the four existing, already-tested atom commands (atom/commands.ts)
+ * with the description Phase 10's doc generation needs. Six atom node
+ * types (image, block_image, formula, block_formula, video, audio, per
+ * atomDeclarations) share these same four generic commands via
+ * `declaration`/`attrs` params, the same way marks' seven commands cover
+ * every mark type - there is no per-atom-type command to convert
+ * separately.
+ *
+ * MediaProvider/mediaPicker (packages/react/src/mediaProvider.ts) are left
+ * exactly as they are - direct CanonicalAuthorityEditor props, already
+ * working - rather than routed through this manifest. They are a
+ * react-layer upload/picker concern orthogonal to the core command surface
+ * atom.insert consumes (a MediaProvider's job ends at producing a URL;
+ * atom.insert takes it from there like any other src).
+ */
+export const atomPluginCommands = {
+    "atom.insert": definePluginCommand({
+        id: "atom.insert", run: atomCommands["atom.insert"],
+        description: "Inserts an atom node (image, formula, video, or audio) at the given position.",
+        options: {
+            declaration: { description: "Which atom type to insert, from atomDeclarations (schema.ts).", required: true },
+            nodeId: { description: "Caller-provided id for the new node.", required: true },
+            attrs: { description: "The new node's attributes (e.g. src, alt for an image).", required: true },
+            ownerId: { description: "The inline container to insert into - required for inline atoms." },
+            offset: { description: "The inline offset to insert at." },
+            parentId: { description: "The block container to insert into - required for block atoms." },
+            index: { description: "The block index to insert at." },
+        },
+    }),
+    "atom.update": definePluginCommand({
+        id: "atom.update", run: atomCommands["atom.update"],
+        description: "Updates the selected atom's attributes.",
+        options: { attrs: { description: "The new attributes.", required: true } },
+    }),
+    "atom.delete": definePluginCommand({
+        id: "atom.delete", run: atomCommands["atom.delete"],
+        description: "Deletes the selected atom.",
+    }),
+    "atom.resize": definePluginCommand({
+        id: "atom.resize", run: atomCommands["atom.resize"],
+        description: "Resizes the selected atom, optionally preserving its aspect ratio.",
+        options: {
+            width: { description: "The new width.", required: true },
+            height: { description: "The new height.", required: true },
+            minWidth: { description: "A minimum width to clamp to." },
+            minHeight: { description: "A minimum height to clamp to." },
+            preserveAspectRatio: { description: "Whether to scale height proportionally to width (or vice versa)." },
+        },
+    }),
+};
+export { atomDeclarations };

package/dist/foundation/atom/schema.d.ts

@@ -0,0 +1,3 @@
+import type { NodeSpec } from "../types.js";
+/** Inline and block variants are distinct because schema groups are static. */
+export declare const atomNodeSpecs: readonly NodeSpec[];

package/dist/foundation/atom/schema.js

@@ -0,0 +1,29 @@
+const optionalString = { validate: (value) => typeof value === "string" };
+const requiredString = { required: true, validate: (value) => typeof value === "string" };
+const dimension = { validate: (value) => Number.isFinite(value) && Number(value) > 0 && Number(value) <= 100000 };
+const status = { default: "ready", validate: (value) => value === "pending" || value === "ready" || value === "error" };
+const imageAttrs = {
+    src: requiredString, alt: requiredString, width: dimension, height: dimension,
+    status, uploadId: optionalString, error: optionalString, decorative: { validate: (value) => typeof value === "boolean" },
+    align: { validate: (value) => value === "center" || value === "left" || value === "right" },
+};
+const formulaAttrs = {
+    source: requiredString,
+    notation: { required: true, default: "latex", validate: (value) => value === "latex" || value === "mathml" },
+    error: optionalString,
+};
+const mediaAttrs = { src: requiredString, poster: optionalString, width: dimension, height: dimension, status, uploadId: optionalString, error: optionalString };
+/** Inline and block variants are distinct because schema groups are static. */
+export const atomNodeSpecs = [
+    { type: "image", group: "inline", atomic: true, selectable: true, marks: "", attributes: imageAttrs },
+    { type: "block_image", group: "block", atomic: true, selectable: true, marks: "", attributes: imageAttrs },
+    { type: "formula", group: "inline", atomic: true, selectable: true, marks: "", attributes: formulaAttrs },
+    { type: "block_formula", group: "block", atomic: true, selectable: true, marks: "", attributes: formulaAttrs },
+    { type: "video", group: "block", atomic: true, selectable: true, marks: "", attributes: mediaAttrs },
+    { type: "audio", group: "block", atomic: true, selectable: true, marks: "", attributes: mediaAttrs },
+    // A horizontal rule (<hr>) - no content, no attrs, just a block-level
+    // separator atom. Previously unrecognized entirely (parseBlock had no
+    // case for "hr"), so every pasted <hr> fell to the generic
+    // "unrecognized tag" fallback and rendered as "[Unsupported: hr]".
+    { type: "divider", group: "block", atomic: true, selectable: true, marks: "" },
+];

package/dist/foundation/atom/security.d.ts

@@ -0,0 +1,10 @@
+import type { AtomDeclaration } from "./types.js";
+export declare const SAFE_IMAGE_MIME_TYPES: Set<string>;
+export declare const SAFE_AUDIO_MIME_TYPES: Set<string>;
+export declare const SAFE_VIDEO_MIME_TYPES: Set<string>;
+export declare const validateAtomMime: (kind: AtomDeclaration["kind"], mime: string) => boolean;
+export declare const sanitizeAtomSource: (value: string | undefined | null, options: {
+    kind: AtomDeclaration["kind"];
+    allowBlobPreview?: boolean;
+}) => string | null;
+export declare const safeFormulaSource: (source: unknown) => source is string;

package/dist/foundation/atom/security.js

@@ -0,0 +1,20 @@
+import { sanitizeResourceUrl } from "../security/urlPolicy.js";
+export const SAFE_IMAGE_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif", "image/svg+xml"]);
+const SAFE_IMAGE_DATA_MIME_TYPES = new Set(["image/png", "image/jpeg", "image/gif", "image/webp", "image/avif"]);
+export const SAFE_AUDIO_MIME_TYPES = new Set(["audio/mpeg", "audio/mp4", "audio/ogg", "audio/wav", "audio/webm"]);
+export const SAFE_VIDEO_MIME_TYPES = new Set(["video/mp4", "video/webm", "video/ogg"]);
+export const validateAtomMime = (kind, mime) => {
+    const normalized = mime.trim().toLowerCase().split(";", 1)[0];
+    if (kind === "image")
+        return SAFE_IMAGE_MIME_TYPES.has(normalized);
+    if (kind === "audio")
+        return SAFE_AUDIO_MIME_TYPES.has(normalized);
+    if (kind === "video")
+        return SAFE_VIDEO_MIME_TYPES.has(normalized);
+    return false;
+};
+export const sanitizeAtomSource = (value, options) => sanitizeResourceUrl(value, {
+    allowBlob: options.allowBlobPreview === true,
+    allowedDataMimeTypes: options.kind === "image" ? SAFE_IMAGE_DATA_MIME_TYPES : new Set(),
+});
+export const safeFormulaSource = (source) => typeof source === "string" && source.length > 0 && source.length <= 100000 && !/[\u0000]/.test(source);

package/dist/foundation/atom/selection.d.ts

@@ -0,0 +1,3 @@
+import type { PositionLookup } from "../scope/types.js";
+import type { SmartSelection } from "../types.js";
+export declare const nodeSelectionForAtom: (nodeId: string, positions: PositionLookup) => SmartSelection | null;

package/dist/foundation/atom/selection.js

@@ -0,0 +1,4 @@
+export const nodeSelectionForAtom = (nodeId, positions) => {
+    const range = positions.rangeOf(nodeId);
+    return range ? { type: "node", anchor: range.from, head: range.to } : null;
+};

package/dist/foundation/atom/types.d.ts

@@ -0,0 +1,47 @@
+import type { Attrs, SmartDocument, SmartOperation, SmartSchema } from "../types.js";
+import type { PositionLookup, ResolvedScope } from "../scope/types.js";
+export type AtomKind = "image" | "formula" | "video" | "audio";
+export type AtomStatus = "pending" | "ready" | "error";
+export interface AtomDeclaration {
+    readonly type: string;
+    readonly kind: AtomKind;
+    readonly group: "inline" | "block";
+    readonly validate: (attrs: Attrs) => boolean;
+}
+export interface AtomCommandContext {
+    readonly schema: SmartSchema;
+    readonly positions: PositionLookup;
+}
+export type AtomCommand<P> = (document: SmartDocument, scope: ResolvedScope, params: P, ctx: AtomCommandContext) => SmartOperation[];
+export interface InsertAtomParams {
+    readonly declaration: AtomDeclaration;
+    readonly nodeId: string;
+    readonly attrs: Attrs;
+    /** Required for inline atoms. */
+    readonly ownerId?: string;
+    readonly offset?: number;
+    /** Required for block atoms. */
+    readonly parentId?: string;
+    readonly index?: number;
+}
+export interface UpdateAtomParams {
+    readonly attrs: Attrs;
+}
+export interface ResizeAtomParams {
+    readonly width: number;
+    readonly height: number;
+    readonly minWidth?: number;
+    readonly minHeight?: number;
+    readonly preserveAspectRatio?: boolean;
+}
+export interface CompositionAtomToken {
+    readonly kind: "atom";
+    readonly nodeId: string;
+    readonly atomType: string;
+}
+export interface CompositionTextToken {
+    readonly kind: "text";
+    readonly text: string;
+    readonly marks: readonly import("../types.js").SmartMark[];
+}
+export type CompositionToken = CompositionAtomToken | CompositionTextToken;

package/dist/foundation/atom/types.js

@@ -0,0 +1 @@
+export {};

package/dist/foundation/block/commands.d.ts

@@ -0,0 +1,17 @@
+import type { BlockCommand, IndentBlocksParams, MoveBlocksParams, OutdentBlocksParams, SetBlockAttributesParams, SetBlockTypeParams, UnwrapBlocksParams, WrapBlocksParams } from "./types.js";
+export declare const setBlockTypeCommand: BlockCommand<SetBlockTypeParams>;
+export declare const wrapBlocks: BlockCommand<WrapBlocksParams>;
+export declare const unwrapBlocks: BlockCommand<UnwrapBlocksParams>;
+export declare const setBlockAttributes: BlockCommand<SetBlockAttributesParams>;
+export declare const moveBlockCommand: BlockCommand<MoveBlocksParams>;
+export declare const indentBlockCommand: BlockCommand<IndentBlocksParams>;
+export declare const outdentBlockCommand: BlockCommand<OutdentBlocksParams>;
+export declare const blockCommands: {
+    readonly "block.setType": BlockCommand<SetBlockTypeParams>;
+    readonly "block.wrap": BlockCommand<WrapBlocksParams>;
+    readonly "block.unwrap": BlockCommand<UnwrapBlocksParams>;
+    readonly "block.setAttributes": BlockCommand<SetBlockAttributesParams>;
+    readonly "block.move": BlockCommand<MoveBlocksParams>;
+    readonly "block.indent": BlockCommand<IndentBlocksParams>;
+    readonly "block.outdent": BlockCommand<OutdentBlocksParams>;
+};