@nextlyhq/plugin-page-builder 0.0.2-alpha.31

package/dist/index.d.ts

@@ -0,0 +1,196 @@
+import { B as BlockNode, R as ResponsiveStyle, a as BlockRegistry, b as BlockDocument } from './style-compiler-hnWIDfko.js';
+export { c as Binding, d as BlockCategory, e as BlockDefinition, f as BlockDocumentKind, g as BlockRenderArgs, h as BoxSides, i as Breakpoint, j as BreakpointDef, C as CompileOptions, k as ControlDef, l as ControlRef, m as ControlRegistry, D as DEFAULT_BREAKPOINTS, n as DEFAULT_SLOT, o as DEFAULT_TOKENS, p as DocumentVersion, M as MAX_DEPTH, q as MAX_NODES, S as SlotSpec, r as StyleScalar, s as StyleValues, T as TokenRef, t as compileDocumentCss, u as compileNodeCss, v as compileTokensCss, w as createBlockRegistry, x as createControlRegistry, y as defaultBlockRegistry, z as defaultControlRegistry, A as defineBlock, E as nodeClass } from './style-compiler-hnWIDfko.js';
+import * as nextly from 'nextly';
+import 'react';
+
+/**
+ * Slot-aware, immutable operations over the block tree (spec §5/§6). Pure and
+ * React-free. Every mutation returns a new tree; the input is never modified.
+ */
+
+/** Stable unique id. `crypto.randomUUID` is available in Node ≥18 and modern browsers. */
+declare function newId(): string;
+declare function makeNode(type: string, props?: Record<string, unknown>, style?: ResponsiveStyle, slots?: Record<string, BlockNode[]>): BlockNode;
+/** Depth-first visit: the node, then each slot's children in order. */
+declare function walk(node: BlockNode, fn: (n: BlockNode, parent?: BlockNode) => void, parent?: BlockNode): void;
+declare function findNode(node: BlockNode, id: string): BlockNode | undefined;
+declare function insertNode(root: BlockNode, parentId: string, slot: string, node: BlockNode, index: number): BlockNode;
+declare function removeNode(root: BlockNode, id: string): BlockNode;
+declare function moveNode(root: BlockNode, id: string, parentId: string, slot: string, index: number): BlockNode;
+declare function duplicateNode(root: BlockNode, id: string): BlockNode;
+declare function updateNode(root: BlockNode, id: string, patch: Partial<BlockNode>): BlockNode;
+
+/**
+ * Document validation invariants (spec §14). Returns `true` when valid, else a
+ * human-readable error string. Used as the `pages.content` field validator (M3) and
+ * defensively in the editor. Pure and React-free.
+ */
+
+interface ValidateOptions {
+    /** Preserve/accept unknown block types (resilience, spec §12). Default false. */
+    allowUnknown?: boolean;
+}
+declare function validateDocument(doc: unknown, registry: BlockRegistry, opts?: ValidateOptions): true | string;
+
+/**
+ * Migration runner (spec §12). Upgrades a stored document to current block versions
+ * by running each block's `migrate()` when its instance is older than the registered
+ * definition. Unknown block types are PRESERVED as-is (Nextly's "retain and flag"
+ * philosophy) — never dropped, never fatal. Pure JSON→JSON; React-free.
+ */
+
+/** Upgrade a stored document to current block versions. */
+declare function migrateDocument(doc: BlockDocument, registry: BlockRegistry): BlockDocument;
+
+declare function sanitizeCustomCss(css: string, scopeClass: string): string;
+
+/**
+ * Typed data-binding resolution for the Query Loop (spec §10). React-free.
+ *
+ * Bindings live in `node.bindings` (kept separate from literal props). At render time
+ * each binding is resolved from the current loop item via a dot-path, optionally
+ * transformed, and merged over the node's literal props.
+ */
+
+/** Safe dotted read: getPath({a:{b:2}}, "a.b") === 2. */
+declare function getPath(obj: unknown, path: string): unknown;
+/**
+ * Return a props object with each `node.bindings[prop]` resolved from `item`
+ * (dot-path + optional transform) merged over `node.props`. Literal props untouched.
+ */
+declare function resolveBindings(node: BlockNode, item: Record<string, unknown>): Record<string, unknown>;
+
+interface PageBuilderOptions {
+    /** Disable behavior while still applying schema. Default true. */
+    enabled?: boolean;
+}
+/**
+ * The Page Builder plugin factory. Call it in a host app's
+ * `defineConfig({ plugins: [pageBuilder()] })`.
+ */
+declare const pageBuilder: (opts?: PageBuilderOptions) => nextly.PluginDefinition;
+
+/**
+ * Registry path of the full-screen builder Edit view — still exported (and registered)
+ * for hosts that want a builder-only collection. The default `pages` collection below
+ * instead offers a per-entry CHOICE between the normal Nextly editor and the builder.
+ */
+declare const EDIT_VIEW_PATH = "@nextlyhq/plugin-page-builder/admin#PageBuilderEditView";
+/**
+ * The plugin-owned `pages` collection. Each page CHOOSES its editor (Elementor-style):
+ *  - "Page Builder" → the visual block tree (`content`, a `pageBuilderField`).
+ *  - "Normal editor" → Nextly's default rich-text form (`body`).
+ * The front-end renders whichever was chosen. Using field conditions (not an Edit-view
+ * override) keeps the normal editor available — a single Edit view can't offer both.
+ */
+declare function pagesCollection(): nextly.CollectionConfig;
+
+/** String path the host admin resolves to our field editor (registered on `./admin`). */
+declare const FIELD_COMPONENT_PATH = "@nextlyhq/plugin-page-builder/admin#PageBuilderField";
+interface PageBuilderFieldOptions {
+    /** Admin label for the field editor. */
+    label?: string;
+    /**
+     * Show the editor only when a sibling field matches — enables an Elementor-style
+     * "choose your editor" workflow (e.g. show the builder only when a `mode` select is
+     * "page-builder"). Maps to the field's `admin.condition`.
+     */
+    condition?: {
+        field: string;
+        equals?: unknown;
+        notEquals?: unknown;
+        exists?: boolean;
+    };
+}
+/**
+ * A page-builder editor as a custom field (spec §9/§11). Stores the BlockDocument as
+ * JSON and renders our editor via `admin.component` (D24, the plugin-supplied field
+ * editor). Works in BOTH collections and singles — the host form persists the value.
+ * Register the component with `@nextlyhq/plugin-page-builder/admin`.
+ *
+ * Node-side the block registry is empty at config-load (renderers live in `./render`),
+ * so the validator runs with `allowUnknown: true` — it still enforces the structural
+ * invariants (depth / node count / unique ids / namespaced types).
+ */
+declare function pageBuilderField(name: string, opts?: PageBuilderFieldOptions): nextly.JSONFieldConfig;
+
+/**
+ * A drop-in "choose your editor" field set (Elementor/WordPress-style). Spread it into
+ * ANY code-first collection to give each entry a choice between the visual Page Builder
+ * and Nextly's normal rich-text editor — the front-end renders whichever was chosen:
+ *
+ * ```ts
+ * defineCollection({
+ *   slug: "landing-pages",
+ *   fields: [text({ name: "title" }), text({ name: "slug" }), ...editorChoiceFields()],
+ * });
+ * ```
+ *
+ * On the front-end: `entry.editorMode === "builder"` → render `entry[builderField]` via
+ * `<PageRenderer>`; otherwise render `entry[normalField]` (rich text, fetched with
+ * `richTextFormat: "html"`).
+ *
+ * Note: this is for CODE-FIRST collections. Collections built in the admin schema-builder
+ * UI can't add these fields yet (that needs a UI-registered field type — a future door).
+ */
+interface EditorChoiceOptions {
+    /** Field name for the block tree (Page Builder mode). Default "content". */
+    builderField?: string;
+    /** Field name for the rich-text body (Normal mode). Default "body". */
+    normalField?: string;
+    /** Which editor is selected by default. Default "builder". */
+    defaultMode?: "builder" | "normal";
+}
+declare function editorChoiceFields(opts?: EditorChoiceOptions): (nextly.JSONFieldConfig | nextly.SelectFieldConfig | nextly.RichTextFieldConfig)[];
+
+/** Reserved system field holding the BlockDocument JSON (spec §2). */
+declare const PAGE_BUILDER_CONTENT_FIELD = "content";
+/** Plugin-registered field type id (spec §4.1). */
+declare const PAGE_BUILDER_TYPE = "page-builder";
+type EditorMode = "default" | "builder";
+/**
+ * @deprecated The editor-choice is now signalled purely by the presence of the
+ * `page-builder` field (a `layout: "takeover"` field type) — no collection-level
+ * flag is read anymore. Retained only for back-compat of existing type imports.
+ */
+interface PageBuilderAdminConfig {
+    enabled?: boolean;
+    defaultMode?: EditorMode;
+}
+/**
+ * Field-type descriptor registered via the plugin's `contributes.fieldTypes`.
+ * `layout: "takeover"` tells the admin entry form to show only this field (plus
+ * its editor-mode controller) when the field is visible — hiding the rest.
+ */
+declare const PAGE_BUILDER_FIELD_TYPE: {
+    readonly type: "page-builder";
+    readonly storage: "json";
+    readonly component: "@nextlyhq/plugin-page-builder/admin#PageBuilderField";
+    readonly layout: "takeover";
+};
+/**
+ * The two fields an entity needs to offer the Default / Page Builder choice: an `editorMode`
+ * select and the reserved `content` page-builder field (shown only in builder mode). The
+ * entity's OWN fields serve as the "Default" editor; the admin hides the non-essential ones
+ * in builder mode (a later stage). Works in both `defineCollection` and `defineSingle`.
+ */
+declare function pageBuilderFields(opts?: {
+    defaultMode?: EditorMode;
+}): (nextly.JSONFieldConfig | nextly.SelectFieldConfig)[];
+/**
+ * Opt a CODE-FIRST collection/single config into the Page Builder editor choice:
+ * appends `pageBuilderFields()`. The presence of the `page-builder` field is the
+ * signal — no collection-level flag needed. Wrap the config passed to
+ * `defineCollection`/`defineSingle`:
+ *
+ * ```ts
+ * defineCollection(withPageBuilder({ slug: "landing", fields: [text({ name: "title" })] }));
+ * ```
+ */
+declare function withPageBuilder<T extends {
+    fields?: unknown[];
+}>(config: T, opts?: {
+    defaultMode?: EditorMode;
+}): T;
+
+export { BlockDocument, BlockNode, BlockRegistry, EDIT_VIEW_PATH, type EditorChoiceOptions, type EditorMode, FIELD_COMPONENT_PATH, PAGE_BUILDER_CONTENT_FIELD, PAGE_BUILDER_FIELD_TYPE, PAGE_BUILDER_TYPE, type PageBuilderAdminConfig, type PageBuilderFieldOptions, type PageBuilderOptions, ResponsiveStyle, type ValidateOptions, duplicateNode, editorChoiceFields, findNode, getPath, insertNode, makeNode, migrateDocument, moveNode, newId, pageBuilder, pageBuilderField, pageBuilderFields, pagesCollection, removeNode, resolveBindings, sanitizeCustomCss, updateNode, validateDocument, walk, withPageBuilder };

package/dist/index.js

@@ -0,0 +1,190 @@
+import {
+  FIELD_COMPONENT_PATH,
+  PAGE_BUILDER_CONTENT_FIELD,
+  PAGE_BUILDER_FIELD_TYPE,
+  PAGE_BUILDER_TYPE,
+  pageBuilderField,
+  pageBuilderFields,
+  validateDocument,
+  withPageBuilder
+} from "./chunk-EGU6QGUC.js";
+import {
+  sanitizeCustomCss
+} from "./chunk-7VN7UNLK.js";
+import {
+  DEFAULT_BREAKPOINTS,
+  DEFAULT_SLOT,
+  DEFAULT_TOKENS,
+  MAX_DEPTH,
+  MAX_NODES,
+  compileDocumentCss,
+  compileNodeCss,
+  compileTokensCss,
+  createBlockRegistry,
+  createControlRegistry,
+  defaultBlockRegistry,
+  defaultControlRegistry,
+  defineBlock,
+  duplicateNode,
+  findNode,
+  getPath,
+  insertNode,
+  makeNode,
+  moveNode,
+  newId,
+  nodeClass,
+  removeNode,
+  resolveBindings,
+  updateNode,
+  walk
+} from "./chunk-ABMSYCSD.js";
+
+// src/core/migrate.ts
+function migrateNode(node, registry) {
+  const def = registry.get(node.type);
+  let next = node;
+  if (def) {
+    const from = node.definitionVersion ?? 1;
+    if (from < def.version && def.migrate) {
+      const { props, style } = def.migrate(node.props, from);
+      next = {
+        ...node,
+        props,
+        ...style ? { style } : {},
+        definitionVersion: def.version
+      };
+    } else if (from !== def.version) {
+      next = { ...node, definitionVersion: def.version };
+    }
+  }
+  if (!next.slots) return next;
+  const slots = {};
+  for (const [name, children] of Object.entries(next.slots)) {
+    slots[name] = children.map((c) => migrateNode(c, registry));
+  }
+  return { ...next, slots };
+}
+function migrateDocument(doc, registry) {
+  return { ...doc, root: migrateNode(doc.root, registry) };
+}
+
+// src/plugin.ts
+import { definePlugin } from "@nextlyhq/plugin-sdk";
+
+// src/collections/pages.ts
+import { defineCollection, text, code } from "nextly/config";
+
+// src/collections/editorChoice.ts
+import { option, richText, select } from "nextly/config";
+function editorChoiceFields(opts = {}) {
+  const builderField = opts.builderField ?? "content";
+  const normalField = opts.normalField ?? "body";
+  const defaultMode = opts.defaultMode ?? "builder";
+  return [
+    select({
+      name: "editorMode",
+      label: "Editor",
+      defaultValue: defaultMode,
+      options: [
+        option("Page Builder", "builder"),
+        option("Normal editor", "normal")
+      ],
+      admin: { description: "Choose how to edit this entry." }
+    }),
+    pageBuilderField(builderField, {
+      label: "Page Builder",
+      condition: { field: "editorMode", equals: "builder" }
+    }),
+    richText({
+      name: normalField,
+      label: "Content",
+      admin: { condition: { field: "editorMode", equals: "normal" } }
+    })
+  ];
+}
+
+// src/collections/pages.ts
+var EDIT_VIEW_PATH = "@nextlyhq/plugin-page-builder/admin#PageBuilderEditView";
+function pagesCollection() {
+  return defineCollection({
+    slug: "pages",
+    labels: { singular: "Page", plural: "Pages" },
+    fields: [
+      text({ name: "title", required: true }),
+      text({ name: "slug", required: true, unique: true }),
+      // The Elementor-style editor choice (select + Page Builder + normal rich text).
+      ...editorChoiceFields(),
+      code({ name: "customCss", admin: { language: "css" } })
+    ],
+    status: true,
+    admin: { useAsTitle: "title" }
+  });
+}
+
+// src/plugin.ts
+var pageBuilder = (opts = {}) => definePlugin({
+  name: "@nextlyhq/plugin-page-builder",
+  version: "0.0.2-alpha.29",
+  nextly: ">=0.0.2-alpha.21",
+  enabled: opts.enabled,
+  contributes: {
+    collections: [pagesCollection()],
+    fieldTypes: [PAGE_BUILDER_FIELD_TYPE],
+    permissions: [
+      { action: "publish", resource: "pages", label: "Publish Pages" }
+    ],
+    admin: {
+      menu: [
+        { label: "Pages", to: "/admin/collections/pages", icon: "Layout" }
+      ],
+      // Schema-builder "Use Page Builder" toggle, rendered generically by the
+      // admin above the field list in the collection/single builders.
+      schemaBuilderSlot: "@nextlyhq/plugin-page-builder/admin#PageBuilderToggle",
+      // Per-entry Normal / Page Builder toggle, rendered in the entry/single
+      // form header toolbar (drives the hidden editor-mode field).
+      entryFormToolbarSlot: "@nextlyhq/plugin-page-builder/admin#PageBuilderModeToggle"
+    }
+  }
+});
+export {
+  DEFAULT_BREAKPOINTS,
+  DEFAULT_SLOT,
+  DEFAULT_TOKENS,
+  EDIT_VIEW_PATH,
+  FIELD_COMPONENT_PATH,
+  MAX_DEPTH,
+  MAX_NODES,
+  PAGE_BUILDER_CONTENT_FIELD,
+  PAGE_BUILDER_FIELD_TYPE,
+  PAGE_BUILDER_TYPE,
+  compileDocumentCss,
+  compileNodeCss,
+  compileTokensCss,
+  createBlockRegistry,
+  createControlRegistry,
+  defaultBlockRegistry,
+  defaultControlRegistry,
+  defineBlock,
+  duplicateNode,
+  editorChoiceFields,
+  findNode,
+  getPath,
+  insertNode,
+  makeNode,
+  migrateDocument,
+  moveNode,
+  newId,
+  nodeClass,
+  pageBuilder,
+  pageBuilderField,
+  pageBuilderFields,
+  pagesCollection,
+  removeNode,
+  resolveBindings,
+  sanitizeCustomCss,
+  updateNode,
+  validateDocument,
+  walk,
+  withPageBuilder
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/core/migrate.ts","../src/plugin.ts","../src/collections/pages.ts","../src/collections/editorChoice.ts"],"sourcesContent":["/**\n * Migration runner (spec §12). Upgrades a stored document to current block versions\n * by running each block's `migrate()` when its instance is older than the registered\n * definition. Unknown block types are PRESERVED as-is (Nextly's \"retain and flag\"\n * philosophy) — never dropped, never fatal. Pure JSON→JSON; React-free.\n */\nimport type { BlockRegistry } from \"./registry\";\nimport type { BlockDocument, BlockNode } from \"./types\";\n\nfunction migrateNode(node: BlockNode, registry: BlockRegistry): BlockNode {\n  const def = registry.get(node.type);\n  let next: BlockNode = node;\n\n  if (def) {\n    const from = node.definitionVersion ?? 1;\n    if (from < def.version && def.migrate) {\n      const { props, style } = def.migrate(node.props, from);\n      next = {\n        ...node,\n        props: props,\n        ...(style ? { style } : {}),\n        definitionVersion: def.version,\n      };\n    } else if (from !== def.version) {\n      next = { ...node, definitionVersion: def.version };\n    }\n  }\n  // Unknown blocks (def === undefined): preserved untouched.\n\n  if (!next.slots) return next;\n  const slots: Record<string, BlockNode[]> = {};\n  for (const [name, children] of Object.entries(next.slots)) {\n    slots[name] = children.map(c => migrateNode(c, registry));\n  }\n  return { ...next, slots };\n}\n\n/** Upgrade a stored document to current block versions. */\nexport function migrateDocument(\n  doc: BlockDocument,\n  registry: BlockRegistry\n): BlockDocument {\n  return { ...doc, root: migrateNode(doc.root, registry) };\n}\n","import { definePlugin } from \"@nextlyhq/plugin-sdk\";\n\nimport { PAGE_BUILDER_FIELD_TYPE } from \"./collections/pageBuilderEntry\";\nimport { pagesCollection } from \"./collections/pages\";\n\nexport interface PageBuilderOptions {\n  /** Disable behavior while still applying schema. Default true. */\n  enabled?: boolean;\n}\n\n/**\n * The Page Builder plugin factory. Call it in a host app's\n * `defineConfig({ plugins: [pageBuilder()] })`.\n */\nexport const pageBuilder = (opts: PageBuilderOptions = {}) =>\n  definePlugin({\n    name: \"@nextlyhq/plugin-page-builder\",\n    version: \"0.0.2-alpha.29\",\n    nextly: \">=0.0.2-alpha.21\",\n    enabled: opts.enabled,\n    contributes: {\n      collections: [pagesCollection()],\n      fieldTypes: [PAGE_BUILDER_FIELD_TYPE],\n      permissions: [\n        { action: \"publish\", resource: \"pages\", label: \"Publish Pages\" },\n      ],\n      admin: {\n        menu: [\n          { label: \"Pages\", to: \"/admin/collections/pages\", icon: \"Layout\" },\n        ],\n        // Schema-builder \"Use Page Builder\" toggle, rendered generically by the\n        // admin above the field list in the collection/single builders.\n        schemaBuilderSlot:\n          \"@nextlyhq/plugin-page-builder/admin#PageBuilderToggle\",\n        // Per-entry Normal / Page Builder toggle, rendered in the entry/single\n        // form header toolbar (drives the hidden editor-mode field).\n        entryFormToolbarSlot:\n          \"@nextlyhq/plugin-page-builder/admin#PageBuilderModeToggle\",\n      },\n    },\n  });\n","import { defineCollection, text, code } from \"nextly/config\";\n\nimport { editorChoiceFields } from \"./editorChoice\";\n\n/**\n * Registry path of the full-screen builder Edit view — still exported (and registered)\n * for hosts that want a builder-only collection. The default `pages` collection below\n * instead offers a per-entry CHOICE between the normal Nextly editor and the builder.\n */\nexport const EDIT_VIEW_PATH =\n  \"@nextlyhq/plugin-page-builder/admin#PageBuilderEditView\";\n\n/**\n * The plugin-owned `pages` collection. Each page CHOOSES its editor (Elementor-style):\n *  - \"Page Builder\" → the visual block tree (`content`, a `pageBuilderField`).\n *  - \"Normal editor\" → Nextly's default rich-text form (`body`).\n * The front-end renders whichever was chosen. Using field conditions (not an Edit-view\n * override) keeps the normal editor available — a single Edit view can't offer both.\n */\nexport function pagesCollection() {\n  return defineCollection({\n    slug: \"pages\",\n    labels: { singular: \"Page\", plural: \"Pages\" },\n    fields: [\n      text({ name: \"title\", required: true }),\n      text({ name: \"slug\", required: true, unique: true }),\n      // The Elementor-style editor choice (select + Page Builder + normal rich text).\n      ...editorChoiceFields(),\n      code({ name: \"customCss\", admin: { language: \"css\" } }),\n    ],\n    status: true,\n    admin: { useAsTitle: \"title\" },\n  });\n}\n","import { option, richText, select } from \"nextly/config\";\n\nimport { pageBuilderField } from \"./pageBuilderField\";\n\n/**\n * A drop-in \"choose your editor\" field set (Elementor/WordPress-style). Spread it into\n * ANY code-first collection to give each entry a choice between the visual Page Builder\n * and Nextly's normal rich-text editor — the front-end renders whichever was chosen:\n *\n * ```ts\n * defineCollection({\n *   slug: \"landing-pages\",\n *   fields: [text({ name: \"title\" }), text({ name: \"slug\" }), ...editorChoiceFields()],\n * });\n * ```\n *\n * On the front-end: `entry.editorMode === \"builder\"` → render `entry[builderField]` via\n * `<PageRenderer>`; otherwise render `entry[normalField]` (rich text, fetched with\n * `richTextFormat: \"html\"`).\n *\n * Note: this is for CODE-FIRST collections. Collections built in the admin schema-builder\n * UI can't add these fields yet (that needs a UI-registered field type — a future door).\n */\nexport interface EditorChoiceOptions {\n  /** Field name for the block tree (Page Builder mode). Default \"content\". */\n  builderField?: string;\n  /** Field name for the rich-text body (Normal mode). Default \"body\". */\n  normalField?: string;\n  /** Which editor is selected by default. Default \"builder\". */\n  defaultMode?: \"builder\" | \"normal\";\n}\n\nexport function editorChoiceFields(opts: EditorChoiceOptions = {}) {\n  const builderField = opts.builderField ?? \"content\";\n  const normalField = opts.normalField ?? \"body\";\n  const defaultMode = opts.defaultMode ?? \"builder\";\n\n  return [\n    select({\n      name: \"editorMode\",\n      label: \"Editor\",\n      defaultValue: defaultMode,\n      options: [\n        option(\"Page Builder\", \"builder\"),\n        option(\"Normal editor\", \"normal\"),\n      ],\n      admin: { description: \"Choose how to edit this entry.\" },\n    }),\n    pageBuilderField(builderField, {\n      label: \"Page Builder\",\n      condition: { field: \"editorMode\", equals: \"builder\" },\n    }),\n    richText({\n      name: normalField,\n      label: \"Content\",\n      admin: { condition: { field: \"editorMode\", equals: \"normal\" } },\n    }),\n  ];\n}\n"],"mappings":"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","names":[]}

package/dist/render/ErrorBoundary.d.ts

@@ -0,0 +1,23 @@
+import { Component, ReactNode } from 'react';
+
+/**
+ * Per-block error isolation (spec §10). The single intentional client island in
+ * `render/`: a throwing block renders a small fallback instead of taking down the
+ * whole page/canvas. `getDerivedStateFromError` also works under
+ * `renderToStaticMarkup`, so server output is protected too.
+ */
+
+interface Props {
+    children: ReactNode;
+    fallback?: ReactNode;
+}
+interface State {
+    failed: boolean;
+}
+declare class BlockErrorBoundary extends Component<Props, State> {
+    state: State;
+    static getDerivedStateFromError(): State;
+    render(): ReactNode;
+}
+
+export { BlockErrorBoundary };

package/dist/render/ErrorBoundary.js

@@ -0,0 +1,8 @@
+"use client";
+import {
+  BlockErrorBoundary
+} from "../chunk-E4G7NNXW.js";
+export {
+  BlockErrorBoundary
+};
+//# sourceMappingURL=ErrorBoundary.js.map

package/dist/render/ErrorBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/render/index.d.ts

@@ -0,0 +1,151 @@
+import { e as BlockDefinition, b as BlockDocument, a as BlockRegistry, j as BreakpointDef, B as BlockNode } from '../style-compiler-hnWIDfko.js';
+import { ReactNode } from 'react';
+export { BlockErrorBoundary } from './ErrorBoundary.js';
+
+declare const paragraph: BlockDefinition<{
+    text: string;
+}>;
+
+declare const heading: BlockDefinition<{
+    text: string;
+    level: string;
+}>;
+
+interface MediaValue {
+    mediaId?: string;
+    url?: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+}
+interface ImageProps extends MediaValue {
+    /** Editor-populated media object (from the media control). */
+    media?: MediaValue;
+}
+declare const image: BlockDefinition<ImageProps>;
+
+declare const button: BlockDefinition<{
+    text: string;
+    link: {
+        href: string;
+        target: string;
+    };
+}>;
+
+declare const video: BlockDefinition<{
+    provider: string;
+    videoId: string;
+}>;
+
+declare const container: BlockDefinition<{
+    as: string;
+}>;
+
+interface GridProps {
+    columns?: number;
+    gap?: string;
+}
+declare const grid: BlockDefinition<GridProps>;
+
+/**
+ * Query Loop block (spec §10/§5). At production render, RenderNode intercepts this type and
+ * renders it data-driven via QueryLoop. The editor uses a dedicated settings panel + a live
+ * sample-data preview (see admin). This `render` is the plain design-time fallback: the
+ * template laid out in the configured column grid.
+ *
+ * Config lives in `props` (collection / sort / limit / columns / gap / where) and is driven
+ * by the admin's QueryLoopSettings panel rather than generic content fields.
+ */
+declare const queryLoop: BlockDefinition<{
+    collection: string;
+    sort: string;
+    limit: number;
+    columns: number;
+    gap: string;
+}>;
+
+/**
+ * The renderer's data seam (spec §10). The host injects an implementation (e.g. one
+ * backed by `getNextly()`), so the renderer itself imports NO CMS runtime and stays
+ * import-safe + testable. Query Loop (M6) uses `find`; Image uses denormalized props
+ * in M3 and `resolveMedia` later.
+ */
+interface FindArgs {
+    collection: string;
+    where?: unknown;
+    sort?: string;
+    limit?: number;
+    populate?: unknown;
+}
+interface ResolvedMedia {
+    url: string;
+    alt?: string;
+    width?: number;
+    height?: number;
+}
+interface DataProvider {
+    find(args: FindArgs): Promise<{
+        items: Record<string, unknown>[];
+    }>;
+    findOne(args: {
+        collection: string;
+        id: string;
+    }): Promise<Record<string, unknown> | null>;
+    resolveMedia(id: string): Promise<ResolvedMedia | null>;
+}
+
+/**
+ * Server-first page renderer (spec §10). Import-safe: NO `getNextly`, no browser
+ * globals. Emits one scoped `<style>` block (node styles + sanitized custom CSS) and
+ * renders the block tree. The host injects a `dataProvider`; the default registry holds
+ * the built-in blocks (populated by importing `./blocks`).
+ */
+
+interface PageRendererProps {
+    document: BlockDocument;
+    registry?: BlockRegistry;
+    dataProvider?: DataProvider;
+    customCss?: string;
+    breakpoints?: BreakpointDef[];
+    /** Design-token overrides (`{ "color.primary": "#..." }`). Defaults ship a palette. */
+    tokens?: Record<string, string>;
+    /** Reserved (i18n, spec §13) — threaded through but ignored in the MVP. */
+    locale?: string;
+}
+declare function PageRenderer({ document, registry, dataProvider, customCss, breakpoints, tokens, }: PageRendererProps): ReactNode;
+
+/**
+ * Async fetch orchestration for the Query Loop (spec §10). Isolated from React so it is
+ * unit-testable. Enforces the per-render query budget, skips when unconfigured, and
+ * converts provider failures into an error state instead of throwing.
+ */
+
+interface QueryBudget {
+    n: number;
+}
+
+/**
+ * Recursively renders one block node to React (spec §10). Server-safe: no browser
+ * globals, no `getNextly`. The scoped class is applied to the block's OWN root element
+ * (the block spreads `className`) so there is no mandatory wrapper `<div>` — grid/flex
+ * stay correct. Unknown block types render a safe fallback; each node is isolated by an
+ * error boundary so one broken block never takes down the page.
+ *
+ * Query Loop (spec §10): the current loop `item` is threaded through recursion (NOT React
+ * context — Server Components can't consume context), so a bound prop on any nested block
+ * at any depth resolves via `resolveBindings`. `core/query-loop` is intercepted and
+ * rendered data-driven via `QueryLoop`.
+ */
+
+interface RenderNodeProps {
+    node: BlockNode;
+    registry: BlockRegistry;
+    dataProvider?: DataProvider;
+    /** Current Query Loop item — threaded to resolve bindings at any depth. */
+    item?: Record<string, unknown>;
+    /** Remaining query budget shared across nested loops on this page render. */
+    budget?: QueryBudget;
+}
+declare function RenderNode({ node, registry, dataProvider, item, budget, }: RenderNodeProps): ReactNode;
+
+export { type DataProvider, type FindArgs, PageRenderer, type PageRendererProps, RenderNode, type RenderNodeProps, type ResolvedMedia, button, container, grid, heading, image, paragraph, queryLoop, video };

package/dist/render/index.js

@@ -0,0 +1,64 @@
+import {
+  sanitizeCustomCss
+} from "../chunk-7VN7UNLK.js";
+import {
+  DEFAULT_QUERY_BUDGET,
+  RenderNode,
+  button,
+  container,
+  grid,
+  heading,
+  image,
+  paragraph,
+  queryLoop,
+  video
+} from "../chunk-R7YHOSL2.js";
+import {
+  compileDocumentCss,
+  compileTokensCss,
+  defaultBlockRegistry
+} from "../chunk-ABMSYCSD.js";
+import {
+  BlockErrorBoundary
+} from "../chunk-E4G7NNXW.js";
+
+// src/render/PageRenderer.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+var PAGE_ROOT_CLASS = "nx-pb-page";
+function PageRenderer({
+  document,
+  registry = defaultBlockRegistry,
+  dataProvider,
+  customCss,
+  breakpoints,
+  tokens
+}) {
+  if (!document?.root) return null;
+  const css = compileTokensCss(PAGE_ROOT_CLASS, tokens) + "\n" + compileDocumentCss(document, { breakpoints }) + "\n" + sanitizeCustomCss(customCss ?? "", PAGE_ROOT_CLASS);
+  return /* @__PURE__ */ jsxs("div", { className: PAGE_ROOT_CLASS, children: [
+    /* @__PURE__ */ jsx("style", { dangerouslySetInnerHTML: { __html: css } }),
+    /* @__PURE__ */ jsx(
+      RenderNode,
+      {
+        node: document.root,
+        registry,
+        dataProvider,
+        budget: { n: DEFAULT_QUERY_BUDGET }
+      }
+    )
+  ] });
+}
+export {
+  BlockErrorBoundary,
+  PageRenderer,
+  RenderNode,
+  button,
+  container,
+  grid,
+  heading,
+  image,
+  paragraph,
+  queryLoop,
+  video
+};
+//# sourceMappingURL=index.js.map

package/dist/render/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/render/PageRenderer.tsx"],"sourcesContent":["/**\n * Server-first page renderer (spec §10). Import-safe: NO `getNextly`, no browser\n * globals. Emits one scoped `<style>` block (node styles + sanitized custom CSS) and\n * renders the block tree. The host injects a `dataProvider`; the default registry holds\n * the built-in blocks (populated by importing `./blocks`).\n */\nimport type { ReactNode } from \"react\";\n\nimport { sanitizeCustomCss } from \"../core/css-sanitize\";\nimport { defaultBlockRegistry, type BlockRegistry } from \"../core/registry\";\nimport {\n  compileDocumentCss,\n  compileTokensCss,\n  type BreakpointDef,\n} from \"../core/style-compiler\";\nimport type { BlockDocument } from \"../core/types\";\n\nimport type { DataProvider } from \"./dataProvider\";\nimport { DEFAULT_QUERY_BUDGET } from \"./query/types\";\nimport { RenderNode } from \"./RenderNode\";\n\nconst PAGE_ROOT_CLASS = \"nx-pb-page\";\n\nexport interface PageRendererProps {\n  document: BlockDocument;\n  registry?: BlockRegistry;\n  dataProvider?: DataProvider;\n  customCss?: string;\n  breakpoints?: BreakpointDef[];\n  /** Design-token overrides (`{ \"color.primary\": \"#...\" }`). Defaults ship a palette. */\n  tokens?: Record<string, string>;\n  /** Reserved (i18n, spec §13) — threaded through but ignored in the MVP. */\n  locale?: string;\n}\n\nexport function PageRenderer({\n  document,\n  registry = defaultBlockRegistry,\n  dataProvider,\n  customCss,\n  breakpoints,\n  tokens,\n}: PageRendererProps): ReactNode {\n  if (!document?.root) return null;\n\n  const css =\n    compileTokensCss(PAGE_ROOT_CLASS, tokens) +\n    \"\\n\" +\n    compileDocumentCss(document, { breakpoints }) +\n    \"\\n\" +\n    sanitizeCustomCss(customCss ?? \"\", PAGE_ROOT_CLASS);\n\n  return (\n    <div className={PAGE_ROOT_CLASS}>\n      <style dangerouslySetInnerHTML={{ __html: css }} />\n      <RenderNode\n        node={document.root}\n        registry={registry}\n        dataProvider={dataProvider}\n        budget={{ n: DEFAULT_QUERY_BUDGET }}\n      />\n    </div>\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAqDI,SACE,KADF;AAhCJ,IAAM,kBAAkB;AAcjB,SAAS,aAAa;AAAA,EAC3B;AAAA,EACA,WAAW;AAAA,EACX;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAiC;AAC/B,MAAI,CAAC,UAAU,KAAM,QAAO;AAE5B,QAAM,MACJ,iBAAiB,iBAAiB,MAAM,IACxC,OACA,mBAAmB,UAAU,EAAE,YAAY,CAAC,IAC5C,OACA,kBAAkB,aAAa,IAAI,eAAe;AAEpD,SACE,qBAAC,SAAI,WAAW,iBACd;AAAA,wBAAC,WAAM,yBAAyB,EAAE,QAAQ,IAAI,GAAG;AAAA,IACjD;AAAA,MAAC;AAAA;AAAA,QACC,MAAM,SAAS;AAAA,QACf;AAAA,QACA;AAAA,QACA,QAAQ,EAAE,GAAG,qBAAqB;AAAA;AAAA,IACpC;AAAA,KACF;AAEJ;","names":[]}