@standhigher/puck-page-builder 0.1.0

package/README.md

@@ -0,0 +1,55 @@
+# @standhigher/puck-page-builder
+
+`@standhigher/puck-page-builder` provides a React PageDocument editor, immutable extension registry and Web renderer for BestTrack page experiences.
+
+> This is the package's only install and import name. `BestTrack Page Builder` is the product name; `packages/puck-page-builder` is only this repository's source directory.
+
+## Installation
+
+```bash
+pnpm add @standhigher/puck-page-builder react react-dom @puckeditor/core @shopify/polaris @shopify/polaris-icons
+```
+
+The React, Puck and Polaris packages are peer dependencies and must be supplied by the host application.
+
+## Web rendering
+
+Import the package styles from the application's global stylesheet entry:
+
+```tsx
+import "@standhigher/puck-page-builder/styles.css";
+```
+
+Load a published `PageDocument` on the server, validate it at the storage boundary, assemble the business extensions, then render it:
+
+```tsx
+import { migratePageDocument } from "@standhigher/puck-page-builder";
+import { WebRenderer } from "@standhigher/puck-page-builder/renderer";
+import { createExtensionRegistry } from "@standhigher/puck-page-builder/extensions";
+
+const migration = migratePageDocument(storedDocument);
+if (!migration.success) throw new Error("Invalid published PageDocument");
+
+const registry = createExtensionRegistry([bestTrackExtension]);
+const page = <WebRenderer document={migration.data} registry={registry} />;
+```
+
+## Public entry points
+
+| Import | Purpose |
+| --- | --- |
+| `@standhigher/puck-page-builder` | `PageDocument`, editor, document migration and base exports |
+| `@standhigher/puck-page-builder/renderer` | `WebRenderer` |
+| `@standhigher/puck-page-builder/extensions` | extension definitions and `createExtensionRegistry` |
+| `@standhigher/puck-page-builder/schema` | schema-specific types and migration helpers |
+| `@standhigher/puck-page-builder/styles.css` | Builder and Web renderer styles |
+
+## Runtime and DataSource boundary
+
+The package can register DataSources but does not automatically resolve `block.binding`, call a Live data source, or inject its result into `WebRenderer`. Implement authorization, data resolution, caching, error handling and temporary render-data projection in the host application's server-side Runtime. Do not persist tokens, credentials or resolved private data in `PageDocument`.
+
+See the repository's [integration documentation](https://github.com/standhigher/puck-page-builder/tree/main/docs/integration) for the Web quick start, extension development and Runtime/DataSource guidance.
+
+## Stability
+
+The package is pre-1.0. Public APIs may evolve between minor releases; validate and migrate persisted documents at every read and publish boundary.

package/dist/chunk-72MFV6J7.js

@@ -0,0 +1,15 @@
+// src/renderer/web/WebRenderer.tsx
+import { jsx } from "react/jsx-runtime";
+function WebRenderer({ document, className, registry }) {
+  return /* @__PURE__ */ jsx("main", { className: className ?? "pb-web-renderer", "data-page-id": document.pageId, lang: document.settings.locale, children: document.blocks.map((block) => {
+    if (block.type === "core.text") return /* @__PURE__ */ jsx("section", { "data-block-id": block.id, className: "pb-web-renderer__text", children: /* @__PURE__ */ jsx("p", { children: typeof block.props.content === "string" ? block.props.content : "" }) }, block.id);
+    if (block.type === "core.image") return /* @__PURE__ */ jsx("figure", { "data-block-id": block.id, className: "pb-web-renderer__image", children: /* @__PURE__ */ jsx("img", { src: typeof block.props.src === "string" ? block.props.src : "", alt: typeof block.props.alt === "string" ? block.props.alt : "" }) }, block.id);
+    const BlockRenderer = registry?.getBlock(block.type)?.render.web;
+    if (BlockRenderer) return /* @__PURE__ */ jsx("section", { "data-block-id": block.id, children: /* @__PURE__ */ jsx(BlockRenderer, { ...block.props }) }, block.id);
+    return null;
+  }) });
+}
+
+export {
+  WebRenderer
+};

package/dist/chunk-G2LNCKYO.js

@@ -0,0 +1,107 @@
+// src/core/schema/page-document.ts
+var pageDocumentKeys = /* @__PURE__ */ new Set(["schemaVersion", "pageId", "target", "templateId", "root", "blocks", "settings"]);
+var blockKeys = /* @__PURE__ */ new Set(["id", "type", "version", "props", "slots", "binding"]);
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isJsonValue(value) {
+  if (value === null || typeof value === "string" || typeof value === "number" || typeof value === "boolean") return true;
+  if (Array.isArray(value)) return value.every(isJsonValue);
+  return isRecord(value) && Object.values(value).every(isJsonValue);
+}
+function normalizeBlock(value, path, issues) {
+  if (!isRecord(value)) {
+    issues.push({ path, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
+    return null;
+  }
+  for (const key of Object.keys(value)) if (!blockKeys.has(key)) issues.push({ path: `${path}.${key}`, message: "\u4E0D\u5141\u8BB8\u4FDD\u5B58\u672A\u77E5\u5B57\u6BB5" });
+  if (typeof value.id !== "string" || !value.id) issues.push({ path: `${path}.id`, message: "\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" });
+  if (typeof value.type !== "string" || !value.type) issues.push({ path: `${path}.type`, message: "\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" });
+  if (typeof value.version !== "number" || !Number.isInteger(value.version) || value.version < 1) issues.push({ path: `${path}.version`, message: "\u5FC5\u987B\u662F\u5927\u4E8E 0 \u7684\u6574\u6570" });
+  if (!isRecord(value.props) || !Object.values(value.props).every(isJsonValue)) issues.push({ path: `${path}.props`, message: "\u5FC5\u987B\u662F JSON \u5BF9\u8C61" });
+  if (value.binding !== void 0 && (!isRecord(value.binding) || typeof value.binding.source !== "string" || value.binding.params !== void 0 && (!isRecord(value.binding.params) || !Object.values(value.binding.params).every(isJsonValue)))) issues.push({ path: `${path}.binding`, message: "\u5FC5\u987B\u5305\u542B source\uFF0C\u4E14 params \u5FC5\u987B\u662F JSON \u5BF9\u8C61" });
+  if (issues.some((issue) => issue.path.startsWith(path))) return null;
+  const slots = normalizeSlots(value.slots, `${path}.slots`, issues);
+  if (issues.some((issue) => issue.path.startsWith(path))) return null;
+  return {
+    id: value.id,
+    type: value.type,
+    version: value.version,
+    props: value.props,
+    ...slots ? { slots } : {},
+    ...value.binding ? { binding: value.binding } : {}
+  };
+}
+function normalizeSlots(value, path, issues) {
+  if (value === void 0) return void 0;
+  if (!isRecord(value)) {
+    issues.push({ path, message: "\u5FC5\u987B\u662F\u5BF9\u8C61" });
+    return void 0;
+  }
+  const slots = {};
+  for (const [slot, children] of Object.entries(value)) {
+    if (!Array.isArray(children)) {
+      issues.push({ path: `${path}.${slot}`, message: "\u5FC5\u987B\u662F\u533A\u5757\u6570\u7EC4" });
+      continue;
+    }
+    slots[slot] = children.map((child, index) => normalizeBlock(child, `${path}.${slot}[${index}]`, issues)).filter((child) => child !== null);
+  }
+  return slots;
+}
+function createPageDocument(input) {
+  return {
+    schemaVersion: 1,
+    pageId: input.pageId,
+    target: input.target ?? "web",
+    ...input.templateId ? { templateId: input.templateId } : {},
+    root: input.root ?? {},
+    blocks: input.blocks ?? [],
+    settings: { locale: input.settings?.locale ?? "en", ...input.settings?.seoTitle ? { seoTitle: input.settings.seoTitle } : {} }
+  };
+}
+function validatePageDocument(value) {
+  const issues = [];
+  if (!isRecord(value)) return { success: false, issues: [{ path: "$", message: "PageDocument \u5FC5\u987B\u662F\u5BF9\u8C61" }] };
+  for (const key of Object.keys(value)) if (!pageDocumentKeys.has(key)) issues.push({ path: `$.${key}`, message: "\u4E0D\u5141\u8BB8\u4FDD\u5B58\u672A\u77E5\u5B57\u6BB5" });
+  if (value.schemaVersion !== 1) issues.push({ path: "$.schemaVersion", message: "\u4EC5\u652F\u6301 schemaVersion 1" });
+  if (typeof value.pageId !== "string" || !value.pageId) issues.push({ path: "$.pageId", message: "\u5FC5\u987B\u662F\u975E\u7A7A\u5B57\u7B26\u4E32" });
+  if (value.target !== "web" && value.target !== "email") issues.push({ path: "$.target", message: "\u5FC5\u987B\u662F web \u6216 email" });
+  if (value.templateId !== void 0 && typeof value.templateId !== "string") issues.push({ path: "$.templateId", message: "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32" });
+  if (!isRecord(value.root) || !Object.values(value.root).every(isJsonValue)) issues.push({ path: "$.root", message: "\u5FC5\u987B\u662F JSON \u5BF9\u8C61" });
+  if (!isRecord(value.settings) || typeof value.settings.locale !== "string") issues.push({ path: "$.settings.locale", message: "\u5FC5\u987B\u662F\u5B57\u7B26\u4E32" });
+  if (!Array.isArray(value.blocks)) issues.push({ path: "$.blocks", message: "\u5FC5\u987B\u662F\u6570\u7EC4" });
+  const blocks = Array.isArray(value.blocks) ? value.blocks.map((block, index) => normalizeBlock(block, `$.blocks[${index}]`, issues)).filter((block) => block !== null) : [];
+  const blockIds = /* @__PURE__ */ new Set();
+  for (const block of blocks) {
+    if (blockIds.has(block.id)) issues.push({ path: "$.blocks", message: `\u533A\u5757 ID \u91CD\u590D\uFF1A${block.id}` });
+    blockIds.add(block.id);
+  }
+  if (issues.length > 0) return { success: false, issues };
+  return {
+    success: true,
+    data: createPageDocument({
+      pageId: value.pageId,
+      target: value.target,
+      ...typeof value.templateId === "string" ? { templateId: value.templateId } : {},
+      root: value.root,
+      blocks,
+      settings: value.settings
+    })
+  };
+}
+function migratePageDocument(value) {
+  if (!isRecord(value)) {
+    const validation2 = validatePageDocument(value);
+    return validation2.success ? { ...validation2, migrated: false } : validation2;
+  }
+  const migrated = value.schemaVersion === void 0;
+  const candidate = migrated ? { ...value, schemaVersion: 1 } : value;
+  const validation = validatePageDocument(candidate);
+  return validation.success ? { ...validation, migrated } : validation;
+}
+
+export {
+  createPageDocument,
+  validatePageDocument,
+  migratePageDocument
+};

package/dist/chunk-RGB53WE6.js

@@ -0,0 +1,180 @@
+// src/core/extensions/registry.ts
+var ExtensionRegistryError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ExtensionRegistryError";
+  }
+  code;
+};
+var namespacedIdentifier = /^[a-z][a-z0-9-]*(?:\.[a-z][a-z0-9-]*)+$/;
+var slotNames = /* @__PURE__ */ new Set(["toolbar.left", "toolbar.center", "toolbar.right", "inspector.content"]);
+function compareByOrder(left, right) {
+  return (left.order ?? 0) - (right.order ?? 0);
+}
+function assertIdentifier(identifier, label) {
+  if (!namespacedIdentifier.test(identifier)) throw new ExtensionRegistryError("invalid-identifier", `${label} \u5FC5\u987B\u4F7F\u7528\u547D\u540D\u7A7A\u95F4 ID\uFF1A${identifier}`);
+}
+function assertTargets(targets, label) {
+  if (targets.length === 0 || targets.some((target) => target !== "web" && target !== "email" && target !== "all")) throw new ExtensionRegistryError("invalid-target", `${label} \u5FC5\u987B\u58F0\u660E web\u3001email \u6216 all target`);
+}
+function register(items, values, extension, registry, kind) {
+  for (const item of values ?? []) {
+    const id = item.id ?? item.type ?? item.key;
+    if (!id) throw new ExtensionRegistryError("invalid-identifier", `${kind} \u7F3A\u5C11\u6CE8\u518C ID`);
+    assertIdentifier(id, kind);
+    if (registry.has(id)) throw new ExtensionRegistryError("duplicate-definition", `${kind} ID \u51B2\u7A81\uFF1A${id}`);
+    const registered = Object.freeze({ ...item, extension });
+    registry.set(id, registered);
+    items.push(registered);
+  }
+}
+function resolveOrder(extensions, disabled) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const extension of extensions) {
+    assertIdentifier(extension.name, "Extension name");
+    if (byName.has(extension.name)) throw new ExtensionRegistryError("duplicate-extension", `Extension \u91CD\u590D\uFF1A${extension.name}`);
+    byName.set(extension.name, extension);
+  }
+  const active = extensions.filter((extension) => !disabled.has(extension.name));
+  const activeNames = new Set(active.map((extension) => extension.name));
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const sorted = [];
+  const visit = (extension) => {
+    if (visited.has(extension.name)) return;
+    if (visiting.has(extension.name)) throw new ExtensionRegistryError("dependency-cycle", `Extension \u4F9D\u8D56\u5B58\u5728\u5FAA\u73AF\uFF1A${extension.name}`);
+    visiting.add(extension.name);
+    for (const dependency of extension.dependsOn ?? []) {
+      if (!activeNames.has(dependency)) throw new ExtensionRegistryError("missing-dependency", `Extension ${extension.name} \u7F3A\u5C11\u542F\u7528\u7684\u4F9D\u8D56\uFF1A${dependency}`);
+      visit(byName.get(dependency));
+    }
+    visiting.delete(extension.name);
+    visited.add(extension.name);
+    sorted.push(extension);
+  };
+  for (const extension of [...active].sort(compareByOrder)) visit(extension);
+  return sorted;
+}
+var ExtensionRegistry = class _ExtensionRegistry {
+  constructor(extensions, blockMap, fieldMap, actionMap, rendererMap, dataSourceMap, templateMap, slotMap, hooks) {
+    this.extensions = extensions;
+    this.blockMap = blockMap;
+    this.fieldMap = fieldMap;
+    this.actionMap = actionMap;
+    this.rendererMap = rendererMap;
+    this.dataSourceMap = dataSourceMap;
+    this.templateMap = templateMap;
+    this.slotMap = slotMap;
+    this.hooks = hooks;
+  }
+  extensions;
+  blockMap;
+  fieldMap;
+  actionMap;
+  rendererMap;
+  dataSourceMap;
+  templateMap;
+  slotMap;
+  hooks;
+  get blocks() {
+    return Object.freeze([...this.blockMap.values()]);
+  }
+  get fields() {
+    return Object.freeze([...this.fieldMap.values()]);
+  }
+  get actions() {
+    return Object.freeze([...this.actionMap.values()].sort(compareByOrder));
+  }
+  get renderers() {
+    return Object.freeze([...this.rendererMap.values()]);
+  }
+  get dataSources() {
+    return Object.freeze([...this.dataSourceMap.values()]);
+  }
+  get templates() {
+    return Object.freeze([...this.templateMap.values()]);
+  }
+  getBlock(type) {
+    return this.blockMap.get(type);
+  }
+  getField(type) {
+    return this.fieldMap.get(type);
+  }
+  getAction(id) {
+    return this.actionMap.get(id);
+  }
+  getRenderer(id) {
+    return this.rendererMap.get(id);
+  }
+  getDataSource(key) {
+    return this.dataSourceMap.get(key);
+  }
+  getTemplate(id) {
+    return this.templateMap.get(id);
+  }
+  getSlot(slot) {
+    return this.slotMap.get(slot) ?? [];
+  }
+  notifyChange(document) {
+    this.hooks.forEach((hook) => hook.onChange?.(document));
+  }
+  notifyError(error) {
+    this.hooks.forEach((hook) => hook.onError?.(error));
+  }
+  static create(extensions, options = {}) {
+    const resolved = resolveOrder(extensions, new Set(options.disabled ?? []));
+    const blocks = /* @__PURE__ */ new Map();
+    const fields = /* @__PURE__ */ new Map();
+    const actions = /* @__PURE__ */ new Map();
+    const renderers = /* @__PURE__ */ new Map();
+    const dataSources = /* @__PURE__ */ new Map();
+    const templates = /* @__PURE__ */ new Map();
+    const blockItems = [];
+    const fieldItems = [];
+    const actionItems = [];
+    const rendererItems = [];
+    const dataSourceItems = [];
+    const templateItems = [];
+    const slots = /* @__PURE__ */ new Map();
+    for (const extension of resolved) {
+      for (const block of extension.blocks ?? []) assertTargets(block.targets, `Block ${block.type}`);
+      register(blockItems, extension.blocks, extension.name, blocks, "Block");
+      register(fieldItems, extension.fields, extension.name, fields, "Field");
+      register(actionItems, extension.actions, extension.name, actions, "Action");
+      register(rendererItems, extension.renderers, extension.name, renderers, "Renderer");
+      register(dataSourceItems, extension.dataSources, extension.name, dataSources, "DataSource");
+      register(templateItems, extension.templates, extension.name, templates, "Template");
+      for (const slot of extension.slots ?? []) {
+        assertIdentifier(slot.id, "UI Slot");
+        if (!slotNames.has(slot.slot)) throw new ExtensionRegistryError("invalid-identifier", `\u672A\u77E5 UI Slot\uFF1A${slot.slot}`);
+        const current = slots.get(slot.slot) ?? [];
+        if (current.some((item) => item.id === slot.id)) throw new ExtensionRegistryError("duplicate-definition", `UI Slot ID \u51B2\u7A81\uFF1A${slot.id}`);
+        current.push(Object.freeze({ ...slot, extension: extension.name }));
+        slots.set(slot.slot, current);
+      }
+    }
+    const sortedSlots = /* @__PURE__ */ new Map();
+    for (const [slot, contributions] of slots) sortedSlots.set(slot, Object.freeze([...contributions].sort(compareByOrder)));
+    return Object.freeze(new _ExtensionRegistry(
+      Object.freeze([...resolved]),
+      blocks,
+      fields,
+      actions,
+      renderers,
+      dataSources,
+      templates,
+      sortedSlots,
+      Object.freeze(resolved.flatMap((extension) => extension.hooks ? [extension.hooks] : []))
+    ));
+  }
+};
+function createExtensionRegistry(extensions, options) {
+  return ExtensionRegistry.create(extensions, options);
+}
+
+export {
+  ExtensionRegistryError,
+  ExtensionRegistry,
+  createExtensionRegistry
+};

package/dist/extensions.d.ts

@@ -0,0 +1,148 @@
+import { ComponentType, ReactNode } from 'react';
+import { RenderTarget, PageDocument } from './schema.js';
+
+type ExtensionTarget = RenderTarget | "all";
+type EditorActionPosition = "left" | "center" | "right";
+type UISlotName = "toolbar.left" | "toolbar.center" | "toolbar.right" | "inspector.content";
+type ValidationIssue = {
+    path: string;
+    message: string;
+};
+type FieldConfig = {
+    field: string;
+    label?: string;
+    required?: boolean;
+};
+type FieldProps<T = unknown> = {
+    value: T;
+    onChange(value: T): void;
+};
+interface BlockDefinition<P = Record<string, unknown>> {
+    type: string;
+    version: number;
+    label: string;
+    category: string;
+    targets: ExtensionTarget[];
+    defaultProps: P;
+    fields: Record<string, FieldConfig>;
+    render: Partial<Record<RenderTarget, ComponentType<P>>>;
+    dataSources?: string[];
+    validate?: (props: P) => ValidationIssue[];
+}
+interface FieldDefinition<T = unknown> {
+    type: string;
+    component: ComponentType<FieldProps<T>>;
+    normalize?: (value: T) => T;
+    validate?: (value: T) => ValidationIssue[];
+}
+type ExtensionActionContext = {
+    document: PageDocument;
+    pageId: string;
+    notify?(message: string): void;
+};
+interface EditorAction {
+    id: string;
+    label: string;
+    position: EditorActionPosition;
+    order?: number;
+    variant?: "default" | "primary" | "danger";
+    hidden?: (context: ExtensionActionContext) => boolean;
+    disabled?: (context: ExtensionActionContext) => boolean;
+    execute(context: ExtensionActionContext): Promise<void> | void;
+}
+interface RendererDefinition {
+    id: string;
+    target: RenderTarget;
+    render(document: PageDocument): ReactNode | string;
+}
+/**
+ * `P` defaults to `any` so an extension may contribute a narrower, validated
+ * parameter type while the framework-independent registry remains generic.
+ */
+interface DataSourceDefinition<P = any, R = unknown> {
+    key: string;
+    mock: (params: P) => Promise<R>;
+    live: (params: P) => Promise<R>;
+    validateParams?: (params: P) => ValidationIssue[];
+}
+interface TemplateDefinition {
+    id: string;
+    version: number;
+    name: string;
+    target: RenderTarget;
+    thumbnail?: string;
+    create(): PageDocument;
+}
+interface LifecycleHooks {
+    onChange?(document: PageDocument): void;
+    beforeSave?(document: PageDocument): Promise<PageDocument>;
+    afterSave?(result: unknown): Promise<void>;
+    beforePublish?(document: PageDocument): Promise<PageDocument>;
+    afterPublish?(result: unknown): Promise<void>;
+    onError?(error: Error): void;
+}
+interface UISlotContribution {
+    id: string;
+    slot: UISlotName;
+    order?: number;
+    component: ComponentType;
+}
+interface PageBuilderExtension {
+    /** Namespaced, stable extension identifier, such as `besttrack.tracking`. */
+    name: string;
+    version: string;
+    order?: number;
+    dependsOn?: string[];
+    blocks?: BlockDefinition[];
+    fields?: FieldDefinition[];
+    actions?: EditorAction[];
+    renderers?: RendererDefinition[];
+    dataSources?: DataSourceDefinition[];
+    templates?: TemplateDefinition[];
+    hooks?: LifecycleHooks;
+    slots?: UISlotContribution[];
+}
+type ExtensionRegistryOptions = {
+    disabled?: string[];
+};
+
+type ExtensionRegistryErrorCode = "duplicate-extension" | "duplicate-definition" | "invalid-identifier" | "invalid-target" | "missing-dependency" | "dependency-cycle";
+declare class ExtensionRegistryError extends Error {
+    readonly code: ExtensionRegistryErrorCode;
+    constructor(code: ExtensionRegistryErrorCode, message: string);
+}
+type Registered<T> = T & {
+    extension: string;
+};
+/** Immutable compiled view of all enabled extensions. */
+declare class ExtensionRegistry {
+    readonly extensions: readonly PageBuilderExtension[];
+    private readonly blockMap;
+    private readonly fieldMap;
+    private readonly actionMap;
+    private readonly rendererMap;
+    private readonly dataSourceMap;
+    private readonly templateMap;
+    private readonly slotMap;
+    private readonly hooks;
+    private constructor();
+    get blocks(): readonly Registered<BlockDefinition<Record<string, unknown>>>[];
+    get fields(): readonly Registered<FieldDefinition<unknown>>[];
+    get actions(): readonly Registered<EditorAction>[];
+    get renderers(): readonly Registered<RendererDefinition>[];
+    get dataSources(): readonly Registered<DataSourceDefinition<any, unknown>>[];
+    get templates(): readonly Registered<TemplateDefinition>[];
+    getBlock(type: string): Registered<BlockDefinition<Record<string, unknown>>> | undefined;
+    getField(type: string): Registered<FieldDefinition<unknown>> | undefined;
+    getAction(id: string): Registered<EditorAction> | undefined;
+    getRenderer(id: string): Registered<RendererDefinition> | undefined;
+    getDataSource(key: string): Registered<DataSourceDefinition<any, unknown>> | undefined;
+    getTemplate(id: string): Registered<TemplateDefinition> | undefined;
+    getSlot(slot: UISlotName): readonly Registered<UISlotContribution>[];
+    notifyChange(document: PageDocument): void;
+    notifyError(error: Error): void;
+    static create(extensions: PageBuilderExtension[], options?: ExtensionRegistryOptions): ExtensionRegistry;
+}
+declare function createExtensionRegistry(extensions: PageBuilderExtension[], options?: ExtensionRegistryOptions): ExtensionRegistry;
+
+export { type BlockDefinition, type DataSourceDefinition, type EditorAction, type EditorActionPosition, type ExtensionActionContext, ExtensionRegistry, ExtensionRegistryError, type ExtensionRegistryErrorCode, type ExtensionRegistryOptions, type ExtensionTarget, type FieldConfig, type FieldDefinition, type FieldProps, type LifecycleHooks, type PageBuilderExtension, type RendererDefinition, type TemplateDefinition, type UISlotContribution, type UISlotName, type ValidationIssue, createExtensionRegistry };

package/dist/extensions.js

@@ -0,0 +1,10 @@
+import {
+  ExtensionRegistry,
+  ExtensionRegistryError,
+  createExtensionRegistry
+} from "./chunk-RGB53WE6.js";
+export {
+  ExtensionRegistry,
+  ExtensionRegistryError,
+  createExtensionRegistry
+};