phormat 0.0.5

package/dist/editor/block-specs/list/reconcile.js

@@ -0,0 +1,6 @@
+import { inlineNodesToPlainText } from '../../model/inlinePlain';
+export function listItemReconcileFingerprint(block) {
+    if (block.type !== 'listItem')
+        return '';
+    return inlineNodesToPlainText(block.inlines);
+}

package/dist/editor/block-specs/list/serialize.d.ts

@@ -0,0 +1,4 @@
+import type { EditorBlock } from '../../model/types';
+export declare function serializeListItem(item: EditorBlock, source?: string): string;
+/** Serialize a contiguous run of top-level {@link EditorBlock.type} `listItem` blocks. */
+export declare function serializeListRegion(items: EditorBlock[], source?: string): string;

package/dist/editor/block-specs/list/serialize.js

@@ -0,0 +1,83 @@
+import { serializeEditorBlock } from '../../model/serializeMarkdownDocument';
+import { serializeInlineNodes } from '../../model/serializeInlineNodes';
+function indentLines(text, prefix) {
+    return text
+        .split('\n')
+        .map((l) => prefix + l)
+        .join('\n');
+}
+/** Recover list item body from the original line slice when `inlines` are absent. */
+function listItemBodyFromSource(item, source) {
+    if (!source)
+        return '';
+    if (item.sourceRange.start < 0 || item.sourceRange.synthetic)
+        return '';
+    const slice = source.slice(item.sourceRange.start, item.sourceRange.end);
+    const firstLine = slice.split('\n')[0] ?? '';
+    const taskUm = firstLine.match(/^\s*[-*+][ \t]+\[[^\]]+\][ \t]+(.*)$/);
+    const taskOm = firstLine.match(/^\s*\d+\.[ \t]+\[[^\]]+\][ \t]+(.*)$/);
+    const tm = taskUm ?? taskOm;
+    if (tm)
+        return (tm[1] ?? '').trimEnd();
+    const um = firstLine.match(/^\s*[-*+][ \t]+(.*)$/);
+    const om = firstLine.match(/^\s*\d+\.[ \t]+(.*)$/);
+    const m = um ?? om;
+    return (m ? m[1] : firstLine).trimEnd();
+}
+function serializeListItemChild(child, source) {
+    if (child.type === 'listItem')
+        return serializeListItem(child, source);
+    return serializeEditorBlock(child, source);
+}
+export function serializeListItem(item, source) {
+    const data = item.data;
+    const body = item.inlines && item.inlines.length > 0
+        ? serializeInlineNodes(item.inlines)
+        : listItemBodyFromSource(item, source);
+    let leader;
+    if (data.task !== undefined) {
+        const inner = data.taskMarkerChar ??
+            (data.task === 'todo'
+                ? ' '
+                : data.task === 'done'
+                    ? 'x'
+                    : data.task === 'in_progress'
+                        ? '/'
+                        : data.task === 'deferred'
+                            ? '>'
+                            : '?');
+        const box = `[${inner}]`;
+        leader = data.ordered ? `${data.ordinalValue ?? 1}. ${box}` : `- ${box}`;
+    }
+    else {
+        leader = data.ordered ? `${data.ordinalValue ?? 1}.` : '-';
+    }
+    const head = body.length > 0
+        ? `${leader} ${body}`
+        : `${leader}${/\s$/.test(leader) ? '' : ' '}`;
+    if (!item.children || item.children.length === 0)
+        return head;
+    const lines = [head];
+    for (const child of item.children) {
+        const childMd = serializeListItemChild(child, source);
+        lines.push(indentLines(childMd, '    '));
+    }
+    return lines.join('\n');
+}
+/** Serialize a contiguous run of top-level {@link EditorBlock.type} `listItem` blocks. */
+export function serializeListRegion(items, source) {
+    const segments = [];
+    let i = 0;
+    while (i < items.length) {
+        const ordered = items[i].data.ordered;
+        const run = [];
+        while (i < items.length &&
+            items[i].type === 'listItem' &&
+            items[i].data.ordered === ordered) {
+            run.push(items[i]);
+            i++;
+        }
+        segments.push(run.map((it) => serializeListItem(it, source)).join('\n'));
+    }
+    return segments.join('\n');
+}

package/dist/editor/block-specs/list/types.d.ts

@@ -0,0 +1,27 @@
+export type ParsedListLine = {
+    lineIndex: number;
+    indent: number;
+    ordered: boolean;
+    orderValue?: number;
+    text: string;
+    /** Single-character checkbox marker when this is a task item. */
+    taskMarker?: string;
+};
+export type ListTree = {
+    ordered: boolean;
+    /** For `<ol start="…">` when the first marker is not `1`. */
+    start?: number;
+    items: ListItemNode[];
+};
+export type ListItemNode = {
+    text: string;
+    /** Sibling nested lists under this item (e.g. `ul` then `ol` at the same indent). */
+    nested: ListTree[];
+};
+export type ListsRegion = {
+    startLine: number;
+    endLine: number;
+    /** One or more top-level lists (e.g. `ul` then `ol` at column 0). */
+    roots: ListTree[];
+    itemLineIndices?: number[];
+};

package/dist/editor/block-specs/list/types.js

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

package/dist/editor/block-specs/listSpec.d.ts

@@ -0,0 +1,4 @@
+import type { BlockSpec } from './types';
+import { listItemReconcileFingerprint } from './list/reconcile';
+export declare const listSpec: BlockSpec;
+export { listItemReconcileFingerprint };

package/dist/editor/block-specs/listSpec.js

@@ -0,0 +1,24 @@
+import EditableList from '../blocks/EditableList.svelte';
+import { listCommands } from './list/commands';
+import { listItemRenderer } from './list/ListRenderer.svelte';
+import { buildListItemForest, parseListLine, taskCheckboxFromMarker } from './list/parse';
+import { listItemReconcileFingerprint } from './list/reconcile';
+import { serializeListItem } from './list/serialize';
+export const listSpec = {
+    type: 'listItem',
+    id: 'lists',
+    render: listItemRenderer,
+    editComponent: EditableList,
+    parse: { parseListLine, taskCheckboxFromMarker, buildListItemForest },
+    serialize: serializeListItem,
+    applyInlineSecondPass: (block) => block,
+    reconcileFingerprint: listItemReconcileFingerprint,
+    commands: listCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'lists',
+        data: block,
+        render: listItemRenderer
+    })
+};
+export { listItemReconcileFingerprint };

package/dist/editor/block-specs/paragraph/ParagraphRenderer.svelte

@@ -0,0 +1,22 @@
+<script module lang="ts">
+	import type { EditorBlock } from '../../model/types';
+	import { inlineNodesSnippet } from '../../plugins/shared/InlineNodes.svelte';
+	import type { ParagraphBlock } from './types';
+
+	export { paragraphRenderer };
+</script>
+
+{#snippet paragraphRenderer(block: EditorBlock)}
+	{@const para = block.data as ParagraphBlock}
+	<p class="mb-4 leading-relaxed whitespace-pre-wrap text-txt-secondary">
+		{#if block.inlines && block.inlines.length > 0}
+			{@render inlineNodesSnippet(block.inlines)}
+		{:else}
+			{#each para.lines as line, i (i)}
+				{line.text}{#if line.softBreakAfter}
+					<br />
+				{:else if i < para.lines.length - 1}<span class="select-none"> </span>{/if}
+			{/each}
+		{/if}
+	</p>
+{/snippet}

package/dist/editor/block-specs/paragraph/ParagraphRenderer.svelte.d.ts

@@ -0,0 +1,21 @@
+import type { EditorBlock } from '../../model/types';
+declare const paragraphRenderer: (block: EditorBlock) => ReturnType<import("svelte").Snippet>;
+export { paragraphRenderer };
+interface $$__sveltets_2_IsomorphicComponent<Props extends Record<string, any> = any, Events extends Record<string, any> = any, Slots extends Record<string, any> = any, Exports = {}, Bindings = string> {
+    new (options: import('svelte').ComponentConstructorOptions<Props>): import('svelte').SvelteComponent<Props, Events, Slots> & {
+        $$bindings?: Bindings;
+    } & Exports;
+    (internal: unknown, props: {
+        $$events?: Events;
+        $$slots?: Slots;
+    }): Exports & {
+        $set?: any;
+        $on?: any;
+    };
+    z_$$bindings?: Bindings;
+}
+declare const ParagraphRenderer: $$__sveltets_2_IsomorphicComponent<Record<string, never>, {
+    [evt: string]: CustomEvent<any>;
+}, {}, {}, string>;
+type ParagraphRenderer = InstanceType<typeof ParagraphRenderer>;
+export default ParagraphRenderer;

package/dist/editor/block-specs/paragraph/commands.d.ts

@@ -0,0 +1,2 @@
+import type { EditorCommand } from '../../commandRegistry';
+export declare const paragraphCommands: EditorCommand[];

package/dist/editor/block-specs/paragraph/commands.js

@@ -0,0 +1,41 @@
+function paragraphHeadingLevels() {
+    return [1, 2, 3];
+}
+export const paragraphCommands = [
+    ...paragraphHeadingLevels().map((level) => ({
+        id: `convertParagraphToHeading${level}`,
+        label: `Heading ${level}`,
+        group: 'turnInto',
+        surfaces: ['slash', 'blockMenu'],
+        blockTypes: ['paragraph'],
+        slashKinds: ['paragraph'],
+        isEnabled: () => true,
+        run: (ctx) => {
+            ctx.editor.convertParagraphToHeadingAt(ctx.blockIndex, level);
+        }
+    })),
+    {
+        id: 'bulletList',
+        label: 'Bullet list',
+        group: 'turnInto',
+        surfaces: ['slash', 'blockMenu'],
+        blockTypes: ['paragraph'],
+        slashKinds: ['paragraph'],
+        isEnabled: () => true,
+        run: (ctx) => {
+            ctx.editor.convertParagraphToBulletListAt(ctx.blockIndex);
+        }
+    },
+    {
+        id: 'turnIntoTableFromParagraph',
+        label: 'Table',
+        group: 'turnInto',
+        surfaces: ['slash', 'blockMenu'],
+        blockTypes: ['paragraph'],
+        slashKinds: ['paragraph'],
+        isEnabled: () => true,
+        run: (ctx) => {
+            ctx.editor.convertBlockToTableAt(ctx.blockIndex);
+        }
+    }
+];

package/dist/editor/block-specs/paragraph/edit.d.ts

@@ -0,0 +1,10 @@
+import type { EditorBlock } from '../../model/types';
+import type { ParagraphBlock } from './types';
+/** Plain-text editing buffer for a paragraph block (matches `linesToParagraphSegments` round-trip). */
+export declare function paragraphBlockToPlainText(p: ParagraphBlock): string;
+export declare function paragraphBlockFromPlainText(text: string, startLineIndex: number): ParagraphBlock;
+/** Join two paragraph blocks into one; marks the boundary with a soft break so load-time split stays one block. */
+export declare function mergeParagraphBlockData(a: ParagraphBlock, b: ParagraphBlock): ParagraphBlock;
+/** Plain text shown in the paragraph editor (prefers inline AST over `lines`). */
+export declare function paragraphDisplayPlain(block: EditorBlock): string;
+export declare function paragraphPlainOffsetToSourceOffset(block: EditorBlock, plainOffset: number): number;

package/dist/editor/block-specs/paragraph/edit.js

@@ -0,0 +1,69 @@
+import { inlineNodesToPlainText } from '../../model/inlinePlain';
+import { linesToParagraphSegments } from './parse';
+/** Plain-text editing buffer for a paragraph block (matches `linesToParagraphSegments` round-trip). */
+export function paragraphBlockToPlainText(p) {
+    if (p.lines.length === 1 && p.lines[0]?.text === ' ')
+        return '';
+    const parts = [];
+    for (let i = 0; i < p.lines.length; i++) {
+        const line = p.lines[i];
+        parts.push(line.text);
+        if (i < p.lines.length - 1) {
+            parts.push(line.softBreakAfter ? '  \n' : '\n');
+        }
+    }
+    return parts.join('');
+}
+export function paragraphBlockFromPlainText(text, startLineIndex) {
+    const rawLines = text.split('\n');
+    return { startLineIndex, lines: linesToParagraphSegments(rawLines) };
+}
+/** Join two paragraph blocks into one; marks the boundary with a soft break so load-time split stays one block. */
+export function mergeParagraphBlockData(a, b) {
+    const leftLines = a.lines.map((line) => ({ ...line }));
+    if (leftLines.length > 0 && b.lines.length > 0) {
+        const last = leftLines[leftLines.length - 1];
+        leftLines[leftLines.length - 1] = { ...last, softBreakAfter: true };
+    }
+    return {
+        startLineIndex: a.startLineIndex,
+        lines: [...leftLines, ...b.lines.map((line) => ({ ...line }))]
+    };
+}
+/** Plain text shown in the paragraph editor (prefers inline AST over `lines`). */
+export function paragraphDisplayPlain(block) {
+    if (block.type !== 'paragraph')
+        return '';
+    const plain = block.inlines?.length
+        ? inlineNodesToPlainText(block.inlines)
+        : paragraphBlockToPlainText(block.data);
+    // Demoted empty list items materialize as a lone source space — show empty in the editor.
+    return plain === ' ' ? '' : plain;
+}
+export function paragraphPlainOffsetToSourceOffset(block, plainOffset) {
+    if (block.type !== 'paragraph')
+        return block.sourceRange.start;
+    const p = block.data;
+    let mdPos = block.sourceRange.start;
+    let plainAcc = 0;
+    for (let i = 0; i < p.lines.length; i++) {
+        const line = p.lines[i];
+        const t = line.text;
+        const remaining = plainOffset - plainAcc;
+        if (remaining <= t.length) {
+            return mdPos + remaining;
+        }
+        plainAcc += t.length;
+        mdPos += t.length;
+        if (i < p.lines.length - 1) {
+            const sepPlain = line.softBreakAfter ? 3 : 1;
+            const sepMd = line.softBreakAfter ? 3 : 1;
+            if (plainOffset <= plainAcc + sepPlain) {
+                return mdPos + Math.min(sepMd, Math.max(0, plainOffset - plainAcc));
+            }
+            plainAcc += sepPlain;
+            mdPos += sepMd;
+        }
+    }
+    return block.sourceRange.end;
+}

package/dist/editor/block-specs/paragraph/index.d.ts

@@ -0,0 +1,7 @@
+export { paragraphCommands } from './commands';
+export { mergeParagraphBlockData, paragraphBlockFromPlainText, paragraphBlockToPlainText, paragraphDisplayPlain, paragraphPlainOffsetToSourceOffset } from './edit';
+export { applyParagraphInlineSecondPass } from './inlineSecondPass';
+export { linesToParagraphSegments, paragraphBlocksFromLines, parseParagraphs } from './parse';
+export { paragraphReconcileFingerprint } from './reconcile';
+export { serializeParagraphBlock, serializeParagraphData } from './serialize';
+export type { ParagraphBlock, ParagraphLine } from './types';

package/dist/editor/block-specs/paragraph/index.js

@@ -0,0 +1,6 @@
+export { paragraphCommands } from './commands';
+export { mergeParagraphBlockData, paragraphBlockFromPlainText, paragraphBlockToPlainText, paragraphDisplayPlain, paragraphPlainOffsetToSourceOffset } from './edit';
+export { applyParagraphInlineSecondPass } from './inlineSecondPass';
+export { linesToParagraphSegments, paragraphBlocksFromLines, parseParagraphs } from './parse';
+export { paragraphReconcileFingerprint } from './reconcile';
+export { serializeParagraphBlock, serializeParagraphData } from './serialize';

package/dist/editor/block-specs/paragraph/inlineSecondPass.d.ts

@@ -0,0 +1,3 @@
+import type { EditorBlock } from '../../model/types';
+import { type RichInlineContext } from '../../model/richInlines';
+export declare function applyParagraphInlineSecondPass(block: EditorBlock, source: string, insideBlockquote: boolean, ctx: RichInlineContext): EditorBlock;

package/dist/editor/block-specs/paragraph/inlineSecondPass.js

@@ -0,0 +1,25 @@
+import { buildRichInlinesForRange, createRichInlineContext } from '../../model/richInlines';
+import { withSyntheticRanges } from '../../model/syntheticInlineRanges';
+import { paragraphBlockToPlainText } from './edit';
+function paragraphInlineEnd(source, start, end) {
+    if (end <= start)
+        return end;
+    if (source[end - 1] !== '\n')
+        return end;
+    return end - (end - 2 >= start && source[end - 2] === '\r' ? 2 : 1);
+}
+export function applyParagraphInlineSecondPass(block, source, insideBlockquote, ctx) {
+    if (block.type !== 'paragraph')
+        return block;
+    if (insideBlockquote) {
+        const text = paragraphBlockToPlainText(block.data);
+        const innerCtx = createRichInlineContext(text);
+        const inlines = withSyntheticRanges(buildRichInlinesForRange(text, 0, text.length, innerCtx));
+        return { ...block, inlines };
+    }
+    const { start, end } = block.sourceRange;
+    return {
+        ...block,
+        inlines: buildRichInlinesForRange(source, start, paragraphInlineEnd(source, start, end), ctx)
+    };
+}

package/dist/editor/block-specs/paragraph/parse.d.ts

@@ -0,0 +1,9 @@
+import type { ParagraphBlock, ParagraphLine } from './types';
+/** Exported for block editing: split raw lines into paragraph segments (soft breaks via trailing two spaces). */
+export declare function linesToParagraphSegments(lines: string[]): ParagraphLine[];
+/**
+ * Split consecutive non-blank source lines into paragraph blocks (hybrid load rule):
+ * one line per block unless the line ends with a soft break (`  `), which merges with the next line.
+ */
+export declare function paragraphBlocksFromLines(lines: string[], startLineIndex: number): ParagraphBlock[];
+export declare function parseParagraphs(source: string): ParagraphBlock[];

package/dist/editor/block-specs/paragraph/parse.js

@@ -0,0 +1,76 @@
+/** Exported for block editing: split raw lines into paragraph segments (soft breaks via trailing two spaces). */
+export function linesToParagraphSegments(lines) {
+    const out = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const isLast = i === lines.length - 1;
+        if (isLast) {
+            out.push({ text: line, softBreakAfter: false });
+            continue;
+        }
+        const softBreakMatch = line.match(/^(.*?)( {2,})$/);
+        if (softBreakMatch) {
+            out.push({ text: softBreakMatch[1], softBreakAfter: true });
+        }
+        else {
+            out.push({ text: line, softBreakAfter: false });
+        }
+    }
+    return out;
+}
+/**
+ * Split consecutive non-blank source lines into paragraph blocks (hybrid load rule):
+ * one line per block unless the line ends with a soft break (`  `), which merges with the next line.
+ */
+export function paragraphBlocksFromLines(lines, startLineIndex) {
+    if (lines.length === 0)
+        return [];
+    const segments = linesToParagraphSegments(lines);
+    const out = [];
+    let buffer = [];
+    let blockStartLineIndex = startLineIndex;
+    for (let i = 0; i < segments.length; i++) {
+        const seg = segments[i];
+        if (buffer.length === 0) {
+            blockStartLineIndex = startLineIndex + i;
+        }
+        buffer.push(seg);
+        if (!seg.softBreakAfter) {
+            out.push({ startLineIndex: blockStartLineIndex, lines: buffer });
+            buffer = [];
+        }
+    }
+    if (buffer.length > 0) {
+        out.push({ startLineIndex: blockStartLineIndex, lines: buffer });
+    }
+    return out;
+}
+export function parseParagraphs(source) {
+    const lines = source.split(/\r?\n/);
+    const out = [];
+    let buffer = [];
+    let startLineIndex = 0;
+    function flush() {
+        if (buffer.length === 0)
+            return;
+        out.push({
+            startLineIndex,
+            lines: linesToParagraphSegments(buffer)
+        });
+        buffer = [];
+    }
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const isBlank = /^\s*$/.test(line);
+        if (isBlank) {
+            flush();
+            continue;
+        }
+        if (buffer.length === 0) {
+            startLineIndex = i;
+        }
+        buffer.push(line);
+    }
+    flush();
+    return out;
+}

package/dist/editor/block-specs/paragraph/reconcile.d.ts

@@ -0,0 +1,2 @@
+import type { EditorBlock } from '../../model/types';
+export declare function paragraphReconcileFingerprint(block: EditorBlock): string;

package/dist/editor/block-specs/paragraph/reconcile.js

@@ -0,0 +1,9 @@
+import { inlineNodesToPlainText } from '../../model/inlinePlain';
+import { paragraphBlockToPlainText } from './edit';
+export function paragraphReconcileFingerprint(block) {
+    if (block.type !== 'paragraph')
+        return '';
+    if (block.inlines?.length)
+        return inlineNodesToPlainText(block.inlines);
+    return paragraphBlockToPlainText(block.data);
+}

package/dist/editor/block-specs/paragraph/serialize.d.ts

@@ -0,0 +1,4 @@
+import type { EditorBlock } from '../../model/types';
+import type { ParagraphBlock } from './types';
+export declare function serializeParagraphData(p: ParagraphBlock): string;
+export declare function serializeParagraphBlock(block: EditorBlock, source?: string): string;

package/dist/editor/block-specs/paragraph/serialize.js

@@ -0,0 +1,39 @@
+import { serializeEditorBlock } from '../../model/serializeMarkdownDocument';
+import { serializeInlineNodes } from '../../model/serializeInlineNodes';
+function indentLines(text, prefix) {
+    return text
+        .split('\n')
+        .map((l) => prefix + l)
+        .join('\n');
+}
+export function serializeParagraphData(p) {
+    const parts = [];
+    for (let i = 0; i < p.lines.length; i++) {
+        const line = p.lines[i];
+        parts.push(line.text);
+        if (i < p.lines.length - 1) {
+            parts.push(line.softBreakAfter ? '  \n' : '\n');
+        }
+    }
+    const joined = parts.join('');
+    return joined.length === 0 ? ' ' : joined;
+}
+export function serializeParagraphBlock(block, source) {
+    if (block.type !== 'paragraph') {
+        throw new Error('serializeParagraphBlock expects a paragraph block');
+    }
+    let head;
+    if (block.inlines && block.inlines.length > 0) {
+        head = serializeInlineNodes(block.inlines);
+    }
+    else {
+        head = serializeParagraphData(block.data);
+    }
+    if (!block.children?.length)
+        return head;
+    const lines = [head];
+    for (const child of block.children) {
+        lines.push(indentLines(serializeEditorBlock(child, source), '    '));
+    }
+    return lines.join('\n');
+}

package/dist/editor/block-specs/paragraph/types.d.ts

@@ -0,0 +1,10 @@
+export type ParagraphLine = {
+    text: string;
+    /** True when this line ended with two-or-more spaces before the following line in the same paragraph (Markdown soft break). */
+    softBreakAfter: boolean;
+};
+export type ParagraphBlock = {
+    /** 0-based index of the first source line in this paragraph. */
+    startLineIndex: number;
+    lines: ParagraphLine[];
+};

package/dist/editor/block-specs/paragraph/types.js

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

package/dist/editor/block-specs/paragraphSpec.d.ts

@@ -0,0 +1,2 @@
+import type { BlockSpec } from './types';
+export declare const paragraphSpec: BlockSpec;

package/dist/editor/block-specs/paragraphSpec.js

@@ -0,0 +1,24 @@
+import EditableParagraph from '../blocks/EditableParagraph.svelte';
+import { paragraphRenderer } from './paragraph/ParagraphRenderer.svelte';
+import { paragraphCommands } from './paragraph/commands';
+import { applyParagraphInlineSecondPass } from './paragraph/inlineSecondPass';
+import { linesToParagraphSegments, parseParagraphs } from './paragraph/parse';
+import { paragraphReconcileFingerprint } from './paragraph/reconcile';
+import { serializeParagraphBlock } from './paragraph/serialize';
+export const paragraphSpec = {
+    type: 'paragraph',
+    id: 'paragraphs',
+    render: paragraphRenderer,
+    editComponent: EditableParagraph,
+    parse: { linesToParagraphSegments, parseParagraphs },
+    serialize: serializeParagraphBlock,
+    applyInlineSecondPass: applyParagraphInlineSecondPass,
+    reconcileFingerprint: paragraphReconcileFingerprint,
+    commands: paragraphCommands,
+    toRenderBlock: (block) => ({
+        id: block.id,
+        pluginId: 'paragraphs',
+        data: block,
+        render: paragraphRenderer
+    })
+};

package/dist/editor/block-specs/registry.d.ts

@@ -0,0 +1,10 @@
+import type { EditorBlockType } from '../model/types';
+import type { BlockSpec } from './types';
+export declare function getBlockSpec(type: EditorBlockType): BlockSpec | undefined;
+export declare function registeredBlockSpecs(): BlockSpec[];
+/** Render-adapter metadata derived from registered BlockSpecs (replaces foundationRenderAdapters). */
+export declare function registeredRenderAdapters(): {
+    id: string;
+    name: string;
+}[];
+export type { BlockSpec, BlockEditProps } from './types';

package/dist/editor/block-specs/registry.js

@@ -0,0 +1,34 @@
+import { blockquoteSpec } from './blockquoteSpec';
+import { calloutSpec } from './calloutSpec';
+import { codeFenceSpec } from './codeFenceSpec';
+import { columnsSpec } from './columnsSpec';
+import { headingSpec } from './headingSpec';
+import { horizontalRuleSpec } from './horizontalRuleSpec';
+import { listSpec } from './listSpec';
+import { paragraphSpec } from './paragraphSpec';
+import { tableSpec } from './tableSpec';
+import { tocSpec } from './tocSpec';
+import { toggleSpec } from './toggleSpec';
+const specsByType = new Map([
+    [paragraphSpec.type, paragraphSpec],
+    [headingSpec.type, headingSpec],
+    [listSpec.type, listSpec],
+    [blockquoteSpec.type, blockquoteSpec],
+    [tableSpec.type, tableSpec],
+    [codeFenceSpec.type, codeFenceSpec],
+    [horizontalRuleSpec.type, horizontalRuleSpec],
+    [calloutSpec.type, calloutSpec],
+    [toggleSpec.type, toggleSpec],
+    [columnsSpec.type, columnsSpec],
+    [tocSpec.type, tocSpec]
+]);
+export function getBlockSpec(type) {
+    return specsByType.get(type);
+}
+export function registeredBlockSpecs() {
+    return [...specsByType.values()];
+}
+/** Render-adapter metadata derived from registered BlockSpecs (replaces foundationRenderAdapters). */
+export function registeredRenderAdapters() {
+    return registeredBlockSpecs().map((spec) => ({ id: spec.id, name: spec.type }));
+}