@webx-ui/module-blocks 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 webx-ui
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,62 @@
+# @webx-ui/module-blocks
+
+The block constructor as a section of the [WebX UI](https://github.com/webx-ui/webx-ui) admin
+panel: the screen where a block type is made entirely — its fields, its Blade template, its
+styles and its script — and `wx-blocks`, the field that builds an entity's content out of such
+blocks.
+
+The other half is `webx-ui/module-blocks` on the server, which stores the types, renders them and
+serves the preview. Neither is useful alone.
+
+**Access to the section is access to deployment.** A block type is Blade, and Blade is PHP.
+
+## Install
+
+```bash
+pnpm add @webx-ui/module-blocks
+```
+
+```ts
+import { createAdmin } from '@webx-ui/module-admin'
+import { blocks } from '@webx-ui/module-blocks'
+import '@webx-ui/module-blocks/style.css'
+
+createAdmin({
+  modules: [blocks()],
+})
+```
+
+The section appears at the top level once the Composer half is installed and migrated.
+Permissions: `blocks.view`, `blocks.manage`. With `webx-blocks.editing` off on the server the
+section is read-only whatever the permission says.
+
+## What it brings
+
+- `/blocks` — every type as a card with a live thumbnail drawn on its sample values, grouped the
+  way the picker groups them.
+- `/blocks/:id` — the editor: template, styles, script, fields and settings on the left; the
+  block drawn on its sample at a desktop, tablet or phone width, the sample's form built from the
+  schema being edited, and where the type stands on the right. The loop is closed: edit the
+  schema and the form rebuilds, edit the values and the stage redraws, edit the template and so
+  does it. Under the editor, what was noticed — a selector outside the block's prefix, a bare
+  element selector, a media query, a missing `data-wx-block`, a variable the schema does not
+  declare — and what was not.
+- **Publish** — a separate step, refused with the line when the template fails on the sample or
+  on any page the block already stands on. The history lists a version per save; restoring one
+  makes it the draft.
+- `wx-blocks` — a field type any screen can put on an entity. Nothing selected: the tree of
+  blocks and the whole page in preview. A block selected: the tree, its fields, the page as a
+  phone at one to one. The preview is the entity's own `/_preview/…` address, handed in by the
+  hosting screen:
+
+```ts
+import { provideBlocksPreview } from '@webx-ui/module-blocks'
+
+provideBlocksPreview({ url: previewUrl, reload: reloadCounter })
+```
+
+Without it the field is a tree with a form, which is all a screen outside the panel can be.
+
+## License
+
+MIT.

package/dist/BlockCard.d.ts

@@ -0,0 +1,11 @@
+import { BlockType } from './types';
+/** One type in the list: its picture, its name, where it stands and which versions it has. */
+type __VLS_Props = {
+    block: BlockType;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    open: (block: BlockType) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onOpen?: ((block: BlockType) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLButtonElement>;
+export default _default;

package/dist/BlockChecks.d.ts

@@ -0,0 +1,19 @@
+import { Lint } from './types';
+/**
+ * The strip under an editor: what was noticed, and what was not — a green line for every
+ * check that passed, so that silence reads as "checked" rather than "not looked at".
+ */
+type __VLS_Props = {
+    /** Which editor this strip sits under. */
+    file: 'template' | 'styles' | 'script' | 'schema';
+    lints: Lint[];
+    slug: string;
+    /** A refusal from publishing, shown first and in red. */
+    error?: {
+        message: string;
+        line: number | null;
+        where?: string | null;
+    } | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/BlockCreateDialog.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import('vue').DefineComponent<{}, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/BlockEditorPage.d.ts

@@ -0,0 +1,86 @@
+/**
+ * The editor of one type: two columns. On the left the four files and the settings, on the
+ * right the block drawn on its sample, the sample's form built from the schema being edited,
+ * and where the type stands. The loop is closed — edit the schema and the form rebuilds,
+ * edit the values and the stage redraws, edit the template or the styles and so does it.
+ */
+type __VLS_Props = {
+    base?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    templateEditor: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        modelValue?: string;
+    } & import('@webx-ui/core').CodeEditorProps> & Readonly<{
+        onChange?: ((value: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onBlur?: (() => any) | undefined;
+        onFocus?: (() => any) | undefined;
+        onLint?: ((diagnostics: import('@webx-ui/core').CodeEditorDiagnostic[]) => any) | undefined;
+    }>, {
+        view: import('vue').ShallowRef<import('@codemirror/view').EditorView | null, import('@codemirror/view').EditorView | null>;
+        focus: () => void | undefined;
+        format: () => boolean;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+        change: (value: string) => any;
+        "update:modelValue": (value: string) => any;
+        blur: () => any;
+        focus: () => any;
+        lint: (diagnostics: import('@webx-ui/core').CodeEditorDiagnostic[]) => any;
+    }, import('vue').PublicProps, {
+        size: import('@webx-ui/core').ControlSize;
+        disabled: boolean;
+        placeholder: string;
+        ariaLabel: string;
+        status: import('@webx-ui/core').ControlStatus;
+        id: string;
+        language: import('@webx-ui/core').CodeEditorLanguage;
+        readonly: boolean;
+        minHeight: string;
+        maxHeight: string;
+        lineNumbers: boolean;
+        lineWrapping: boolean;
+        tabSize: number;
+        lint: boolean;
+        extensions: import('@codemirror/state').Extension[];
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        host: HTMLDivElement;
+    }, any, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        modelValue?: string;
+    } & import('@webx-ui/core').CodeEditorProps> & Readonly<{
+        onChange?: ((value: string) => any) | undefined;
+        "onUpdate:modelValue"?: ((value: string) => any) | undefined;
+        onBlur?: (() => any) | undefined;
+        onFocus?: (() => any) | undefined;
+        onLint?: ((diagnostics: import('@webx-ui/core').CodeEditorDiagnostic[]) => any) | undefined;
+    }>, {
+        view: import('vue').ShallowRef<import('@codemirror/view').EditorView | null, import('@codemirror/view').EditorView | null>;
+        focus: () => void | undefined;
+        format: () => boolean;
+    }, {}, {}, {}, {
+        size: import('@webx-ui/core').ControlSize;
+        disabled: boolean;
+        placeholder: string;
+        ariaLabel: string;
+        status: import('@webx-ui/core').ControlStatus;
+        id: string;
+        language: import('@webx-ui/core').CodeEditorLanguage;
+        readonly: boolean;
+        minHeight: string;
+        maxHeight: string;
+        lineNumbers: boolean;
+        lineWrapping: boolean;
+        tabSize: number;
+        lint: boolean;
+        extensions: import('@codemirror/state').Extension[];
+    }> | null;
+}, HTMLDivElement>;
+export default _default;

package/dist/BlockHistory.d.ts

@@ -0,0 +1,15 @@
+import { BlockType } from './types';
+/**
+ * A version per save, newest first, each with who and why. Restoring makes the old version a
+ * new draft — publishing it is the same separate step it always is.
+ */
+type __VLS_Props = {
+    block: BlockType;
+    canManage: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    restored: (block: BlockType) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onRestored?: ((block: BlockType) => any) | undefined;
+}>, {}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/BlockPicker.d.ts

@@ -0,0 +1,27 @@
+import { BlockNode, BlockType } from './types';
+/**
+ * "Add a block": the types as cards with their pictures, because a name says nothing about
+ * whether "Section" is a full-width band or a container with columns. Only what may go
+ * here is offered; what is exhausted is shown greyed with the reason rather than hidden,
+ * or the editor goes looking for a block that vanished.
+ */
+type __VLS_Props = {
+    catalog: BlockType[];
+    /** The container a block is being added to, or null at the page level. */
+    parent?: BlockType | null;
+    /** What the container's field allows, when the field narrows it further. */
+    allow?: string[] | null;
+    /** The whole tree, for the per-page limits. */
+    tree?: BlockNode[];
+    groups?: string[];
+    /** Where a person with the right can go and make a type. */
+    blocksPath?: string | null;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    parent: BlockType | null;
+    allow: string[] | null;
+    groups: string[];
+    tree: BlockNode[];
+    blocksPath: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/BlockStage.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The block on its own, at a chosen width: a desktop scaled down to fit the column, a tablet
+ * or a phone at one to one. The document is the block, its styles, its script and the
+ * runtime, and nothing of the panel — an iframe, so the block's CSS stays the block's.
+ */
+type __VLS_Props = {
+    html: string;
+    styles: string;
+    script?: string | null;
+    runtime?: string | null;
+    loading?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    script: string | null;
+    loading: boolean;
+    runtime: string | null;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    box: HTMLDivElement;
+    frame: HTMLIFrameElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/BlockThumb.d.ts

@@ -0,0 +1,22 @@
+import { BlockThumbnail } from './types';
+/**
+ * A block drawn small: the sample render in an iframe, scaled down to the width it is given.
+ *
+ * An iframe rather than inline markup because a block's styles are a block's business — a
+ * stray `h2 { }` in one type would otherwise restyle the whole list of cards — and because
+ * the thumbnail is a picture of the site, not a part of the panel.
+ */
+type __VLS_Props = {
+    thumbnail: BlockThumbnail | null;
+    /** The width the block is drawn at, before scaling — a desktop. */
+    width?: number;
+    /** How tall the picture is, in the panel's pixels. */
+    height?: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    width: number;
+    height: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    box: HTMLDivElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/BlocksField.d.ts

@@ -0,0 +1,78 @@
+import { RenderContext, ScreenNode } from '@webx-ui/schema';
+import { BlockNode, BlockType } from './types';
+type __VLS_Props = {
+    /** Handed over by the renderer: the node being drawn and the way down. Unused here. */
+    node?: ScreenNode;
+    context?: RenderContext;
+    name?: string;
+    localized?: boolean;
+    /** Narrows what may be added at the top level, beyond what the types themselves allow. */
+    allow?: string[] | null;
+    /** How many blocks the top level may hold. */
+    max?: number | null;
+    /**
+     * The published types with their schemas. Fetched from the panel when absent — handed
+     * in for a screen outside one, a demo or a test.
+     */
+    catalog?: BlockType[] | null;
+    disabled?: boolean;
+    /** Where the section lives, for the picker's "make one" link. */
+    blocksPath?: string;
+};
+type __VLS_PublicProps = {
+    modelValue?: BlockNode[];
+} & __VLS_Props;
+declare const _default: import('vue').DefineComponent<__VLS_PublicProps, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    "update:modelValue": (value: BlockNode[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    "onUpdate:modelValue"?: ((value: BlockNode[]) => any) | undefined;
+}>, {
+    name: string;
+    disabled: boolean;
+    node: ScreenNode;
+    allow: string[] | null;
+    localized: boolean;
+    max: number | null;
+    context: RenderContext;
+    catalog: BlockType[] | null;
+    blocksPath: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    previewEl: import('vue').CreateComponentPublicInstanceWithMixins<Readonly<{
+        url: string | null;
+        selected?: string | null;
+        mode?: "wide" | "phone";
+        reload?: number;
+    }> & Readonly<{}>, {
+        replace: (key: string, html: string) => boolean;
+        refresh: () => void;
+        open: () => boolean;
+    }, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, import('vue').PublicProps, {
+        mode: "wide" | "phone";
+        selected: string | null;
+        reload: number;
+    }, false, {}, {}, import('vue').GlobalComponents, import('vue').GlobalDirectives, string, {
+        box: HTMLDivElement;
+        frame: HTMLIFrameElement;
+    }, HTMLDivElement, import('vue').ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<{
+        url: string | null;
+        selected?: string | null;
+        mode?: "wide" | "phone";
+        reload?: number;
+    }> & Readonly<{}>, {
+        replace: (key: string, html: string) => boolean;
+        refresh: () => void;
+        open: () => boolean;
+    }, {}, {}, {}, {
+        mode: "wide" | "phone";
+        selected: string | null;
+        reload: number;
+    }> | null;
+}, any>;
+export default _default;

package/dist/BlocksPage.d.ts

@@ -0,0 +1,12 @@
+/**
+ * The section: every type as a card with a live thumbnail, grouped the way the picker groups
+ * them. Cards rather than a table because a block is recognised by its picture — "Section"
+ * says nothing about whether it is a full-width band or a container with columns.
+ */
+type __VLS_Props = {
+    base?: string;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    base: string;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/BlocksPreview.d.ts

@@ -0,0 +1,34 @@
+/**
+ * The page in an iframe, the way it will be: the same handler, the same view, the draft
+ * laid over the columns. Two shapes — the whole page wide while nothing is selected, a
+ * phone at one to one while a block is being edited — and a full-screen mode for looking
+ * at the desktop and the tablet, because a desktop in a 420 px column is a picture nobody
+ * can read.
+ *
+ * The panel and the site are one application on one domain, so the frame's document is
+ * reachable: selection is a class, a change is a swap between the marker comments.
+ */
+type __VLS_Props = {
+    url: string | null;
+    selected?: string | null;
+    /** `wide` when the page is being looked at, `phone` while a block is being edited. */
+    mode?: 'wide' | 'phone';
+    /** Bumped by the host to reload the page. */
+    reload?: number;
+};
+/** Swap one block's markup in place; false when the page has to be reloaded instead. */
+declare function replace(key: string, html: string): boolean;
+declare function refresh(): void;
+declare const _default: import('vue').DefineComponent<__VLS_Props, {
+    replace: typeof replace;
+    refresh: typeof refresh;
+    open: () => boolean;
+}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    mode: "wide" | "phone";
+    selected: string | null;
+    reload: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {
+    box: HTMLDivElement;
+    frame: HTMLIFrameElement;
+}, HTMLDivElement>;
+export default _default;

package/dist/BlocksTree.d.ts

@@ -0,0 +1,37 @@
+import { ScreenNode } from '@webx-ui/schema';
+import { BlockNode, BlockType } from './types';
+/**
+ * One level of the tree, and itself again for every container. Rows reorder among their
+ * siblings by drag; a container shows its fields' lists underneath, each with its own
+ * "add inside". Moving a block between containers is not a drag — a duplicate and a remove
+ * do it, and a drag across allow-rules would need a judge at every drop.
+ */
+type __VLS_Props = {
+    nodes: BlockNode[];
+    catalog: BlockType[];
+    parentKey?: string | null;
+    field?: string | null;
+    selected?: string | null;
+    disabled?: boolean;
+    depth?: number;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    select: (key: string) => any;
+    add: (parentKey: string | null, field: string | null, node: ScreenNode | null) => any;
+    remove: (key: string) => any;
+    duplicate: (key: string) => any;
+    reorder: (parentKey: string | null, field: string | null, list: BlockNode[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSelect?: ((key: string) => any) | undefined;
+    onAdd?: ((parentKey: string | null, field: string | null, node: ScreenNode | null) => any) | undefined;
+    onRemove?: ((key: string) => any) | undefined;
+    onDuplicate?: ((key: string) => any) | undefined;
+    onReorder?: ((parentKey: string | null, field: string | null, list: BlockNode[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    field: string | null;
+    selected: string | null;
+    parentKey: string | null;
+    depth: number;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/api.d.ts

@@ -0,0 +1,20 @@
+import { AdminContext } from '@webx-ui/module-admin';
+import { BlockInput, BlockType, BlockUsage, BlockVersion, BlockVersionMeta, RenderInput, RenderResult } from './types';
+export interface BlocksApi {
+    /** Every type, without content: the section's list. */
+    list(): Promise<BlockType[]>;
+    /** The published types with their content: what the constructor and the picker read. */
+    catalog(): Promise<BlockType[]>;
+    get(id: number): Promise<BlockType>;
+    create(input: BlockInput): Promise<BlockType>;
+    update(id: number, input: BlockInput): Promise<BlockType>;
+    remove(id: number): Promise<void>;
+    publish(id: number): Promise<BlockType>;
+    render(id: number, input?: RenderInput): Promise<RenderResult>;
+    usage(id: number): Promise<BlockUsage[]>;
+    versions(id: number): Promise<BlockVersionMeta[]>;
+    version(id: number, number: number): Promise<BlockVersion>;
+    restore(id: number, number: number): Promise<BlockType>;
+}
+/** Everything under `/blocks`, below the panel's API path. */
+export declare function createBlocksApi(admin: AdminContext): BlocksApi;

package/dist/content.d.ts

@@ -0,0 +1,43 @@
+import { ScreenNode } from '@webx-ui/schema';
+import { BlockNode } from './types';
+/**
+ * Walking and rewriting a tree of blocks.
+ *
+ * A node is `{ key, type, values }`, and a value that is itself a list of such nodes is a
+ * nested constructor — recognised by shape rather than by schema, so a tree can be walked
+ * for a type nobody can look up any more. Every rewrite returns a new tree and leaves the
+ * one it was given alone: the field's model is replaced, never mutated, which is what keeps
+ * the renderer's `update` and the preview's swap in step.
+ */
+export declare function isNode(value: unknown): value is BlockNode;
+/** A list of nodes — a nested constructor's value — as opposed to a list of anything else. */
+export declare function isNodeList(value: unknown): value is BlockNode[];
+/** An id that survives a drag: random, not positional. */
+export declare function newKey(): string;
+export declare function makeNode(type: string, values?: Record<string, unknown>): BlockNode;
+/** Where a node sits: the list it is in, its index there, and the field of the parent. */
+export interface Located {
+    node: BlockNode;
+    parent: BlockNode | null;
+    field: string | null;
+    list: BlockNode[];
+    index: number;
+}
+export declare function locate(tree: BlockNode[], key: string): Located | null;
+/** Every node, parents before children. */
+export declare function walk(tree: BlockNode[], visit: (node: BlockNode, depth: number, parent: BlockNode | null) => void, depth?: number, parent?: BlockNode | null): void;
+/** How many instances of a type the tree holds, nested ones included. */
+export declare function countType(tree: BlockNode[], slug: string): number;
+/** The distinct types a tree uses, in first-seen order. */
+export declare function typesIn(tree: BlockNode[]): string[];
+/** The `wx-blocks` nodes of a schema, through cards and tabs. */
+export declare function nestedFields(schema: ScreenNode[]): ScreenNode[];
+/** A copy with fresh keys all the way down — what a duplicate is. */
+export declare function cloneNode(node: BlockNode): BlockNode;
+export declare function insertNode(tree: BlockNode[], parentKey: string | null, field: string | null, index: number, node: BlockNode): BlockNode[];
+export declare function removeNode(tree: BlockNode[], key: string): BlockNode[];
+export declare function updateValues(tree: BlockNode[], key: string, values: Record<string, unknown>): BlockNode[];
+/** The list under one parent replaced wholesale — what a sortable list hands back. */
+export declare function replaceList(tree: BlockNode[], parentKey: string | null, field: string | null, list: BlockNode[]): BlockNode[];
+/** Values are JSON — that is the contract with the server — so a JSON round trip is a clone. */
+export declare function clone<T>(value: T): T;

package/dist/frame.d.ts

@@ -0,0 +1,43 @@
+/**
+ * The preview is a page of the site in an iframe, and the panel's hold on it is a pair of
+ * comments around every block — `<!--wx:key-->…<!--/wx:key-->` — printed by the renderer in
+ * preview mode. Finding a block is walking the comments; replacing one is swapping what sits
+ * between the pair; highlighting one is a class on the first element after the opener.
+ *
+ * The panel and the site are one application on one domain, so the frame's document is
+ * reachable and nothing has to be injected into the site's markup beyond one stylesheet.
+ */
+export declare const SELECTED_CLASS = "wx-preview-selected";
+export interface MarkerRange {
+    start: Comment;
+    end: Comment;
+}
+/** The pair of markers around a block, or null when the page does not hold it. */
+export declare function findRange(root: Node, key: string): MarkerRange | null;
+/**
+ * Swap the block's markup — markers included, since the new HTML carries its own — and let
+ * the runtime mount whatever script the new markup needs. False when the key is not on the
+ * page, which means the page has to be reloaded rather than patched.
+ */
+export declare function replaceBlock(doc: Document, key: string, html: string): boolean;
+/** The first element a block prints — where a highlight goes. */
+export declare function blockElement(root: Node, key: string): Element | null;
+/** Mark one block as the selected one, and nothing else. Null clears the selection. */
+export declare function highlightBlock(doc: Document, key: string | null): Element | null;
+export interface StageInput {
+    html: string;
+    styles: string;
+    /** The script wrapped for the runtime, or nothing. */
+    script?: string | null;
+    /** Where the runtime is served; skipped when there is no script to run. */
+    runtime?: string | null;
+    /** Resolves relative addresses the block prints — images, links — against the site. */
+    base?: string | null;
+    /** Styles the site's layout would give the page: fonts, the ground colour. */
+    frame?: string | null;
+}
+/**
+ * A whole document for the editor's stage: the block on its own, with its styles, its script
+ * and the runtime, and nothing of the panel. `srcdoc` takes it.
+ */
+export declare function stageDocument(input: StageInput): string;

package/dist/i18n.d.ts

@@ -0,0 +1,2 @@
+/** Puts this package's English under the panel's dictionary, once per panel. */
+export declare function useBlocksMessages(): void;

package/dist/index.d.ts

@@ -0,0 +1,15 @@
+export { blocks, type BlocksOptions } from './module';
+export { createBlocksApi, type BlocksApi } from './api';
+export { blocksMessages } from './messages';
+export { blocksPreviewKey, provideBlocksPreview, useBlocksPreview, type BlocksPreview, } from './preview';
+export { cloneNode, countType, insertNode, isNode, isNodeList, locate, makeNode, newKey, removeNode, replaceList, typesIn, updateValues, walk, type Located, } from './content';
+export { lintBlock, undeclared } from './lint';
+export { findRange, highlightBlock, replaceBlock, stageDocument } from './frame';
+export { formSchema } from './schema';
+export { default as WxBlocks } from './BlocksField';
+export { default as WxBlocksPage } from './BlocksPage';
+export { default as WxBlockEditorPage } from './BlockEditorPage';
+export { default as WxBlockPicker } from './BlockPicker';
+export { default as WxBlockThumb } from './BlockThumb';
+export { default as WxBlockStage } from './BlockStage';
+export type { BlockContent, BlockInput, BlockNode, BlockSource, BlocksMeta, BlockThumbnail, BlockType, BlockUsage, BlockVersion, BlockVersionMeta, Lint, PublishRefusal, RenderInput, RenderResult, } from './types';