mechanica-shared 2.0.0-alpha.0

package/dist/page-format.js

@@ -0,0 +1,301 @@
+import { Document, isCollection, isMap, isScalar, isSeq, parse } from "yaml";
+//#region src/page-format.ts
+/** Thrown by {@link parsePage} with the 1-based source line of the problem. */
+var PageParseError = class PageParseError extends Error {
+	line;
+	constructor(message, line) {
+		super(`${message} (line ${line})`);
+		this.line = line;
+		this.name = "PageParseError";
+		Object.setPrototypeOf(this, PageParseError.prototype);
+	}
+};
+var CLOSE_BARE = /^:::[ \t]*$/;
+var CLOSE_LABELED = /^:::[ \t]*\/[ \t]*([A-Za-z][\w-]*)?[ \t]*$/;
+var OPEN = /^:::[ \t]+([A-Za-z][\w-]*)[ \t]*(.*)$/;
+var FIELD = /^@([A-Za-z][\w.-]*)[ \t]*$/;
+/** Classify a line as a structural token, or null when it's head/region content. */
+function classify(line) {
+	if (/^[ \t]/.test(line)) return null;
+	let m;
+	if (CLOSE_BARE.test(line)) return { kind: "close" };
+	if (m = CLOSE_LABELED.exec(line)) return {
+		kind: "close",
+		id: m[1] || void 0
+	};
+	if (m = OPEN.exec(line)) return {
+		kind: "open",
+		blockId: m[1],
+		rest: m[2]
+	};
+	if (m = FIELD.exec(line)) return {
+		kind: "field",
+		name: m[1]
+	};
+	return null;
+}
+/** Leading run of backticks/tildes that opens or closes a Markdown code fence. */
+function matchFence(line) {
+	const m = /^[ \t]*([`~]{3,})/.exec(line);
+	return m ? m[1] : null;
+}
+/** Strip the common leading indentation from a block of lines (blank lines ignored). */
+function dedent(lines) {
+	let min = Infinity;
+	for (const line of lines) {
+		if (line.trim() === "") continue;
+		min = Math.min(min, /^[ \t]*/.exec(line)[0].length);
+	}
+	if (!isFinite(min) || min === 0) return lines.slice();
+	return lines.map((line) => line.trim() === "" ? line.trimStart() : line.slice(min));
+}
+/** Set `data[a.b.c] = value`, creating intermediate objects. */
+function setPath(data, path, value) {
+	const parts = path.split(".");
+	let target = data;
+	for (let i = 0; i < parts.length - 1; i++) {
+		const key = parts[i];
+		if (typeof target[key] !== "object" || target[key] === null) target[key] = {};
+		target = target[key];
+	}
+	target[parts[parts.length - 1]] = value;
+}
+/** Parse a `.page.md` document into a {@link PageDoc}. */
+function parsePage(text, options) {
+	const lines = text.replace(/\r\n/g, "\n").split("\n");
+	let i = 0;
+	let envelope = {};
+	if (lines[0] === "---") {
+		let j = 1;
+		while (j < lines.length && lines[j] !== "---") j++;
+		if (j >= lines.length) throw new PageParseError("Unterminated frontmatter (missing closing ---)", 1);
+		try {
+			envelope = parse(lines.slice(1, j).join("\n")) ?? {};
+		} catch (error) {
+			throw new PageParseError(`Invalid frontmatter YAML: ${error.message}`, 1);
+		}
+		i = j + 1;
+	}
+	const root = [];
+	const stack = [];
+	const counter = { n: 0 };
+	const flushHead = (frame, line) => {
+		if (frame.headBuf.length === 0) return;
+		const yamlText = dedent(frame.headBuf).join("\n");
+		frame.headBuf = [];
+		if (yamlText.trim() === "") return;
+		let parsed;
+		try {
+			parsed = parse(yamlText);
+		} catch (error) {
+			throw new PageParseError(`Invalid block head YAML: ${error.message}`, line);
+		}
+		if (parsed && typeof parsed === "object") Object.assign(frame.block.data, parsed);
+	};
+	const finalizeRegion = (frame) => {
+		const region = frame.region;
+		const body = dedent(region.lines);
+		while (body.length && body[0].trim() === "") body.shift();
+		while (body.length && body[body.length - 1].trim() === "") body.pop();
+		const raw = body.join("\n");
+		const value = options?.richText?.isRichText(frame.block.blockId, region.name) ? options.richText.toBlocks(raw) : raw;
+		setPath(frame.block.data, region.name, value);
+		frame.region = null;
+	};
+	for (; i < lines.length; i++) {
+		const line = lines[i];
+		const frame = stack[stack.length - 1];
+		if (frame?.region) {
+			const region = frame.region;
+			const fence = matchFence(line);
+			if (region.fence !== null) {
+				region.lines.push(line);
+				if (fence && fence.length >= region.fence.length && line.trimStart().startsWith(region.fence)) region.fence = null;
+				continue;
+			}
+			if (fence) {
+				region.lines.push(line);
+				region.fence = fence;
+				continue;
+			}
+			if (line.startsWith("\\:::") || /^\\@[A-Za-z]/.test(line)) {
+				region.lines.push(line.slice(1));
+				continue;
+			}
+			if (classify(line) === null) {
+				region.lines.push(line);
+				continue;
+			}
+			finalizeRegion(frame);
+		}
+		const token = classify(line);
+		if (token === null) {
+			if (!frame) {
+				if (line.trim() === "") continue;
+				throw new PageParseError(`Content outside any block: "${line.trim()}"`, i + 1);
+			}
+			frame.headBuf.push(line);
+			continue;
+		}
+		if (token.kind === "open") {
+			if (frame) flushHead(frame, i + 1);
+			const { id, slot, v } = parseAttrs(token.rest, i + 1);
+			const block = {
+				id: id ?? `auto${++counter.n}`,
+				blockId: token.blockId,
+				data: {}
+			};
+			if (v !== void 0) block.v = v;
+			attach(root, frame, block, slot, i + 1);
+			stack.push({
+				block,
+				headBuf: [],
+				region: null
+			});
+		} else if (token.kind === "field") {
+			if (!frame) throw new PageParseError(`@${token.name} outside any block`, i + 1);
+			flushHead(frame, i + 1);
+			frame.region = {
+				name: token.name,
+				lines: [],
+				fence: null
+			};
+		} else {
+			if (!frame) throw new PageParseError("Close ::: with no open block", i + 1);
+			flushHead(frame, i + 1);
+			if (token.id && token.id !== frame.block.blockId) throw new PageParseError(`Labeled close "::: /${token.id}" does not match open block "::: ${frame.block.blockId}"`, i + 1);
+			stack.pop();
+		}
+	}
+	if (stack.length) throw new PageParseError(`Unclosed block "::: ${stack[stack.length - 1].block.blockId}"`, lines.length);
+	return {
+		...typeof envelope.name === "string" ? { name: envelope.name } : {},
+		...envelope.meta !== void 0 ? { meta: envelope.meta } : {},
+		...typeof envelope.order === "number" ? { order: envelope.order } : {},
+		...envelope.orderAfter != null ? { orderAfter: envelope.orderAfter } : {},
+		...typeof envelope.path === "string" ? { path: envelope.path } : {},
+		data: envelope.data ?? {},
+		content: root
+	};
+}
+/** Parse the `#id` and `key=value` attributes after a block id on an open fence. */
+function parseAttrs(rest, line) {
+	const out = {};
+	for (const part of rest.trim().split(/[ \t]+/).filter(Boolean)) if (part.startsWith("#")) out.id = part.slice(1);
+	else if (part.startsWith("slot=")) out.slot = part.slice(5);
+	else if (/^v=\d+$/.test(part)) out.v = Number(part.slice(2));
+	else throw new PageParseError(`Unknown block attribute "${part}"`, line);
+	return out;
+}
+/** Place a freshly-opened block into its parent slot (or the page root). */
+function attach(root, parent, block, slot, line) {
+	if (!parent) {
+		if (slot) throw new PageParseError("A root-level block cannot have a slot", line);
+		root.push(block);
+		return;
+	}
+	const owner = parent.block;
+	if (slot) {
+		if (owner.children == null) owner.children = {};
+		if (Array.isArray(owner.children)) throw new PageParseError(`Block "::: ${owner.blockId}" mixes default and named slots`, line);
+		const map = owner.children;
+		(map[slot] ??= []).push(block);
+	} else {
+		if (owner.children == null) owner.children = [];
+		if (!Array.isArray(owner.children)) throw new PageParseError(`Block "::: ${owner.blockId}" mixes default and named slots`, line);
+		owner.children.push(block);
+	}
+}
+/** A top-level string prop becomes an `@field` region past this length, or on any newline. */
+var REGION_THRESHOLD = 80;
+var FLOW_MAX = 72;
+/** Serialize a {@link PageDoc} into canonical `.page.md` text. */
+function serializePage(doc, options) {
+	const envelope = {};
+	if (doc.name !== void 0) envelope.name = doc.name;
+	if (doc.meta !== void 0) envelope.meta = doc.meta;
+	envelope.data = doc.data ?? {};
+	if (doc.order !== void 0) envelope.order = doc.order;
+	if (doc.orderAfter != null) envelope.orderAfter = doc.orderAfter;
+	if (doc.path !== void 0) envelope.path = doc.path;
+	const out = [
+		"---",
+		emitYaml(envelope),
+		"---",
+		""
+	];
+	for (const block of doc.content) emitBlock(block, void 0, out, options);
+	return out.join("\n").replace(/\n+$/, "") + "\n";
+}
+function emitBlock(block, slot, out, options) {
+	let open = `::: ${block.blockId}`;
+	if (block.id) open += ` #${block.id}`;
+	if (slot) open += ` slot=${slot}`;
+	if (block.v !== void 0) open += ` v=${block.v}`;
+	out.push(open);
+	const head = {};
+	const regions = [];
+	for (const [key, value] of Object.entries(block.data)) if (options?.richText?.isRichText(block.blockId, key) && Array.isArray(value)) regions.push([key, options.richText.toMarkdown(value)]);
+	else if (typeof value === "string" && (value.includes("\n") || value.length > REGION_THRESHOLD)) regions.push([key, value]);
+	else head[key] = value;
+	if (Object.keys(head).length) out.push(emitYaml(head));
+	for (const [name, value] of regions) {
+		out.push(`@${name}`);
+		out.push(escapeRegion(value));
+	}
+	let hasChildren = false;
+	const children = block.children;
+	if (Array.isArray(children)) {
+		for (const child of children) emitBlock(child, void 0, out, options);
+		hasChildren = children.length > 0;
+	} else if (children && typeof children === "object") for (const [slotName, list] of Object.entries(children)) {
+		for (const child of list) emitBlock(child, slotName, out, options);
+		if (list.length) hasChildren = true;
+	}
+	out.push(hasChildren ? `::: /${block.blockId}` : ":::");
+	out.push("");
+}
+/** Backslash-escape any line-initial structural token in raw region text (outside code fences). */
+function escapeRegion(text) {
+	let fence = null;
+	return text.split("\n").map((line) => {
+		const mark = matchFence(line);
+		if (fence !== null) {
+			if (mark && mark.length >= fence.length && line.trimStart().startsWith(fence)) fence = null;
+			return line;
+		}
+		if (mark) {
+			fence = mark;
+			return line;
+		}
+		return classify(line) !== null ? "\\" + line : line;
+	}).join("\n");
+}
+/**
+* Emit a value as YAML. The root mapping always stays block style (one prop per
+* line); only nested collections collapse to flow when short and all-scalar.
+*/
+function emitYaml(value) {
+	const doc = new Document(value);
+	const root = doc.contents;
+	if (isSeq(root)) for (const item of root.items) applyFlow(item);
+	else if (isMap(root)) for (const pair of root.items) applyFlow(pair.value);
+	return doc.toString({ lineWidth: 0 }).replace(/\n$/, "");
+}
+function applyFlow(node) {
+	if (isSeq(node)) {
+		for (const item of node.items) if (isCollection(item)) applyFlow(item);
+		node.flow = node.items.length === 0 || node.items.every(isScalar) && inlineLen(node) <= FLOW_MAX;
+	} else if (isMap(node)) {
+		for (const pair of node.items) if (isCollection(pair.value)) applyFlow(pair.value);
+		node.flow = node.items.length === 0 || node.items.every((pair) => isScalar(pair.value)) && inlineLen(node) <= FLOW_MAX;
+	}
+}
+function inlineLen(node) {
+	if (isScalar(node)) return String(node.value ?? "null").length + 2;
+	if (isSeq(node)) return 4 + node.items.reduce((sum, item) => sum + inlineLen(item) + 2, 0);
+	if (isMap(node)) return 4 + node.items.reduce((sum, pair) => sum + String(pair.key?.value ?? pair.key).length + 2 + inlineLen(pair.value) + 2, 0);
+	return 0;
+}
+//#endregion
+export { PageParseError, parsePage, serializePage };

package/dist/types/fields.d.ts

@@ -0,0 +1,34 @@
+import { registerAlias, type SchemaItem } from 'compact-json-schema';
+declare module 'compact-json-schema' {
+    interface SchemaAnnotations {
+        format?: string;
+    }
+}
+/**
+ * A built-in or user-defined editable field type. The *runtime* half lives here
+ * (the compact-json-schema alias + a default value); the editor component half
+ * is attached separately in the plugin via `defineFieldType`.
+ */
+export interface FieldType {
+    /** Format name, e.g. `'image'`. Used as the compact-json-schema alias. */
+    name: string;
+    /** The compact-json-schema definition this alias expands to. */
+    schema: SchemaItem;
+    /** Default value, or a factory returning a fresh one. */
+    default?: unknown | (() => unknown);
+}
+/** The field types registered by default. */
+export declare const builtinFields: FieldType[];
+export type RegisterAlias = typeof registerAlias;
+/**
+ * Register field types as compact-json-schema aliases and record their default
+ * values. Call once per runtime before unfolding any block/data schema.
+ *
+ * @param register Override the alias registrar (defaults to compact-json-schema's).
+ * @param fields   Field set to register (defaults to {@link builtinFields}).
+ */
+export declare function registerFieldSchemas(register?: RegisterAlias, fields?: FieldType[]): void;
+/** Resolve the default value for a registered field format, or `undefined`. */
+export declare function getFieldDefault(format: string): unknown;
+/** Whether {@link registerFieldSchemas} has run in this runtime. */
+export declare function areFieldSchemasRegistered(): boolean;

package/dist/types/generate-page.d.ts

@@ -0,0 +1,85 @@
+import type { Block } from './types';
+/**
+ * Substitute `{{ a.b }}` placeholders in an HTML string with data values. Used to
+ * template the `<head>` (title, meta, Open Graph, …) from `defineData` values and
+ * the current page. Resolved values are HTML-escaped.
+ */
+export declare function passDataToHTML(html: string, data: any): string;
+export interface PageState {
+    content: any[];
+    data: Record<string, any>;
+    page?: {
+        title?: string;
+        path?: string;
+        meta?: Record<string, unknown>;
+        /** Set on paginated variants: which chunk of the page's paginated query this is. */
+        pagination?: {
+            page: number;
+            pageCount?: number;
+        };
+    };
+}
+/** What `render` may return: bare HTML, or HTML plus the queries it resolved. */
+export type RenderResult = string | {
+    html: string;
+    query?: Record<string, unknown>;
+};
+export interface GeneratePageOptions {
+    /** The index.html template. */
+    index: string;
+    /** Block metadata keyed by blockId. */
+    blocksMap: Map<string, Block>;
+    /** The page to render. */
+    state: PageState;
+    /** Declared data entries (with unfolded schemas) for default-filling. */
+    dataEntries: {
+        id: string;
+        props: any;
+    }[];
+    /** Site-level data merged under page data. */
+    projectData?: Record<string, any>;
+    baseUrl?: string;
+    path?: string;
+    /** Rewrite `/assets/` to this base when set. */
+    assetsUrl?: string;
+    /**
+     * Extra `<link>` tags for this page's content, injected before `</head>` —
+     * used by the export to preload the block chunks/CSS the page uses (blocks
+     * are code-split out of the client entry).
+     */
+    pageLinks?: (content: any[]) => string[];
+    /**
+     * Render the page state to HTML (provided by the SSR bundle). May also
+     * return the query results resolved during the render — they're baked into
+     * `window.state.query` so the client hydrates them synchronously.
+     */
+    render: (state: any, path: string) => Promise<RenderResult> | RenderResult;
+}
+/** Render a single page into the index template with serialized state. */
+export declare function generatePage(options: GeneratePageOptions): Promise<{
+    html: string;
+    query: Record<string, unknown>;
+}>;
+/**
+ * Serialize runtime state for embedding in an inline `<script>`. Plain JSON is
+ * unsafe (a `</script>` in the data would close the tag early), so the few
+ * dangerous characters are escaped to their `\uXXXX` form — valid JSON/JS that
+ * `window.state` and the router's regex read back unchanged.
+ */
+export declare function serializeState(state: unknown): string;
+export interface GenerateProjectOptions extends Omit<GeneratePageOptions, 'state' | 'path'> {
+    pages: Array<{
+        content: any[];
+        data: Record<string, any>;
+        path: string;
+        page?: PageState['page'];
+    }>;
+    /** Map an asset path to its emitted path (and copy it). */
+    onFile?: (path: string) => string;
+}
+/** Render every page of a project, yielding the html, path and resolved queries. */
+export declare function generateProject(options: GenerateProjectOptions): AsyncGenerator<{
+    html: string;
+    path: string;
+    query: Record<string, unknown>;
+}>;

package/dist/types/index.d.ts

@@ -0,0 +1,7 @@
+export type { Block, ContentBlock, DataEntry, DataScope, PageMeta, State, PageLink, } from './types';
+export { type FieldType, type RegisterAlias, builtinFields, registerFieldSchemas, getFieldDefault, areFieldSchemasRegistered, } from './fields';
+export { getDefaultValue, passDefaultValue, buildPreviewData, mergePreviewData, walkTree, walkSchema, getValueByPath, } from './schema';
+export { generatePage, generateProject, passDataToHTML, serializeState, type GeneratePageOptions, type GenerateProjectOptions, type PageState, type RenderResult, } from './generate-page';
+export { validateLinks, collectInternalLinks, normalizeInternalUrl, type LinkIssue, } from './validate-links';
+export { migrateContent, findUnknownBlocks } from './migrate';
+export { parseQueryKey, isPaginatedQuery, resolvePagesQuery, resolveQueryKey, type QuerySource, type QueryContext, type PageQueryItem, type PagesQueryArgs, type PaginatedPagesResult, } from './query-engine';

package/dist/types/migrate.d.ts

@@ -0,0 +1,19 @@
+import type { Block, ContentBlock } from './types';
+/**
+ * Upgrade placed blocks whose data was written with an older schema version.
+ *
+ * Each placed block records the schema version it was saved with (`v`, absent
+ * = 1). When a block type declares a newer `version`, its `migrate` hook runs
+ * with the stored data and the version it came from, then the block is
+ * stamped with the current version. Runs on load (dev state, export) so pages
+ * never render stale-shaped data; the upgrade persists with the next save.
+ *
+ * Returns whether anything changed.
+ */
+export declare function migrateContent(content: ContentBlock[], blocksMap: Map<string, Block>): boolean;
+/**
+ * Block ids referenced by the content tree that the block registry doesn't
+ * know (deleted or renamed block types). These render as nothing — callers
+ * should surface them (export warning, editor badge).
+ */
+export declare function findUnknownBlocks(content: ContentBlock[], blocksMap: Map<string, Block>): string[];

package/dist/types/page-format.d.ts

@@ -0,0 +1,43 @@
+import type { ContentBlock } from './types';
+/**
+ * A parsed page document — the page envelope (everything but `content`) plus the
+ * content tree. This is the in-memory shape the `.page.md` codec maps to/from;
+ * it mirrors the dev store's `PageFile`.
+ */
+export interface PageDoc {
+    name?: string;
+    meta?: Record<string, unknown>;
+    /** Page-scoped data overrides (defineData). */
+    data: Record<string, unknown>;
+    content: ContentBlock[];
+    order?: number;
+    orderAfter?: string | null;
+    path?: string;
+}
+/**
+ * Adapter that lets the codec store rich-text fields as Markdown on disk while
+ * keeping them as vuewrite `Block[]` JSON in page state. Supplied by the caller
+ * (dev server / CLI) so this module stays DOM- and vuewrite-free.
+ */
+export interface RichTextCodec {
+    /** Whether a top-level prop of the given block is a rich-text field. */
+    isRichText(blockId: string, prop: string): boolean;
+    /** vuewrite `Block[]` → Markdown (written to disk). */
+    toMarkdown(blocks: unknown): string;
+    /** Markdown → vuewrite `Block[]` (loaded into state). */
+    toBlocks(markdown: string): unknown;
+}
+/** Options for {@link parsePage} / {@link serializePage}. */
+export interface PageCodecOptions {
+    /** Rich-text ⇄ Markdown adapter; when omitted, regions stay plain strings. */
+    richText?: RichTextCodec;
+}
+/** Thrown by {@link parsePage} with the 1-based source line of the problem. */
+export declare class PageParseError extends Error {
+    readonly line: number;
+    constructor(message: string, line: number);
+}
+/** Parse a `.page.md` document into a {@link PageDoc}. */
+export declare function parsePage(text: string, options?: PageCodecOptions): PageDoc;
+/** Serialize a {@link PageDoc} into canonical `.page.md` text. */
+export declare function serializePage(doc: PageDoc, options?: PageCodecOptions): string;

package/dist/types/query-engine.d.ts

@@ -0,0 +1,83 @@
+/**
+ * The query engine: resolves the runtime's query keys (`usePages`,
+ * `usePagination`, `useFetch`) against an abstract {@link QuerySource}. One
+ * implementation, three callers — the dev server (live `.mech` store), the
+ * static export (resolved at build time and baked into `window.state.query`),
+ * and a future hosted backend (its own source). Pure and DOM/fs-free; the
+ * source supplies all I/O.
+ */
+/** A page entry as the engine consumes it (requested data entries embedded). */
+export interface PageQueryItem {
+    path: string;
+    name: string;
+    folderPath?: string | null;
+    order?: number;
+    orderAfter?: string | null;
+    [dataId: string]: unknown;
+}
+/** What a caller must supply for the engine to resolve queries. */
+export interface QuerySource {
+    /** List all pages, with the requested page-scoped data entries embedded. */
+    listPages(options: {
+        data?: {
+            id: string;
+        }[];
+    }): PageQueryItem[];
+    /** Fetch external JSON (`useFetch`). Omit to disable fetch queries. */
+    fetchJson?(options: {
+        url: string;
+    } & Record<string, unknown>): Promise<unknown>;
+}
+/** Arguments of a `getPages` query (the JSON part of its key). */
+export interface PagesQueryArgs {
+    /** Only pages inside this folder path (e.g. `'blog'`). */
+    folderName?: string;
+    /** Page-scoped data entries to embed in each result. */
+    data?: {
+        id: string;
+    }[];
+    /**
+     * Sort field: `'name'`, `'path'`, or a dotted path into an included data
+     * entry (e.g. `'postMeta.date'`). Default: the store's page order.
+     */
+    sort?: {
+        by: string;
+        dir?: 'asc' | 'desc';
+    };
+    /** Cap the number of results (non-paginated queries). */
+    limit?: number;
+    /** Split results into pages of this size — the query becomes paginated. */
+    pageSize?: number;
+}
+/** The shape a paginated `getPages` query resolves to. */
+export interface PaginatedPagesResult {
+    items: PageQueryItem[];
+    /** Current page number (1-based, clamped to `pageCount`). */
+    page: number;
+    pageCount: number;
+    pageSize: number;
+    total: number;
+}
+/** Extra context for resolving a key (which paginated variant to slice). */
+export interface QueryContext {
+    /** 1-based page number for paginated queries. Default 1. */
+    page?: number;
+}
+/** Split a query key (`"<type>.<json-args>"`) into its type and parsed args. */
+export declare function parseQueryKey(key: string): {
+    type: string;
+    args: Record<string, unknown>;
+};
+/** Whether a key is a paginated `getPages` query (drives export page-splitting). */
+export declare function isPaginatedQuery(key: string): boolean;
+/**
+ * Resolve a `getPages` query: filter by folder, sort, and either cap (`limit`)
+ * or paginate (`pageSize`). Internal ordering fields are stripped from results.
+ */
+export declare function resolvePagesQuery(source: QuerySource, args: PagesQueryArgs, context?: QueryContext): PageQueryItem[] | PaginatedPagesResult;
+/**
+ * Resolve any query key against a source. Unknown types resolve to `{}` (the
+ * runtime containers keep their initial shape). `fetch` keys require the
+ * source to provide `fetchJson`.
+ */
+export declare function resolveQueryKey(source: QuerySource, key: string, context?: QueryContext): Promise<unknown>;

package/dist/types/schema.d.ts

@@ -0,0 +1,29 @@
+import type { Block, ContentBlock } from './types';
+/**
+ * Compute the default value for a (compact-unfolded) schema node, consulting the
+ * field registry for format-specific defaults (e.g. `image`, `richText`).
+ */
+export declare function getDefaultValue(schema: any): any;
+/**
+ * Fill missing values in `state` with schema defaults, recursing into objects.
+ * Returns `state` when present, otherwise a freshly generated default.
+ */
+export declare function passDefaultValue(state: any, schema: any): any;
+/** Deep-merge `patch` over `base`: plain objects merge, arrays and scalars replace. */
+export declare function mergePreviewData(base: Record<string, unknown>, patch: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Resolve the data a block should render with outside a page: schema defaults,
+ * overlaid with the block's authored `previewData`, overlaid with per-call
+ * overrides (e.g. the `?data=` payload of the preview route).
+ *
+ * @param props Unfolded (JSON-schema shaped) props schema, as on `Block.props`.
+ */
+export declare function buildPreviewData(props: Record<string, unknown> | undefined, previewData?: Record<string, unknown>, overrides?: Record<string, unknown>): Record<string, unknown>;
+/** Depth-first walk over a content tree, including array and named-slot children. */
+export declare function walkTree(blocks: ContentBlock[], callback: (block: ContentBlock) => void): void;
+type WalkSchemaCallback = (value: any, schema: any, key?: string, parent?: any, isRequired?: boolean) => void;
+/** Walk a value alongside its schema, invoking `callback` for each described node. */
+export declare function walkSchema(obj: any, schema: Block['props'] | any, callback: WalkSchemaCallback): void;
+/** Resolve a dotted path within a data object (`'postMeta.date'`). */
+export declare function getValueByPath(data: any, path: string): unknown;
+export {};