@questpie/admin 1.1.1 → 3.0.0

package/dist/server/modules/admin/block/block-builder.d.mts

@@ -0,0 +1,383 @@
+import { AdminBlockConfig, FieldLayoutItem } from "../../../augmentation/form-layout.mjs";
+import { AdminConfigContext } from "../../../augmentation/views.mjs";
+import "../../../augmentation.mjs";
+import { adminFields } from "../../../fields/index.mjs";
+import { AppContext, BuiltinFields, Field, FieldBuilderProxy, FieldSchema, FieldState } from "questpie";
+
+//#region src/server/modules/admin/block/block-builder.d.ts
+
+/**
+ * Combined field types available in block field definitions.
+ * Includes all built-in questpie fields plus admin-specific fields (richText, blocks).
+ */
+type AdminBlockFields = BuiltinFields & typeof adminFields;
+/**
+ * Block prefetch context.
+ * Provided to prefetch functions to fetch related data.
+ *
+ * Use `typedApp<App>(ctx.app)` for typed access.
+ *
+ * @example
+ * ```ts
+ * .prefetch(async ({ values, ctx }) => {
+ *   const app = typedApp<App>(ctx.app);
+ *   const res = await app.collections.posts.find({ limit: 5 });
+ *   return { posts: res.docs };
+ * })
+ * ```
+ */
+type BlockPrefetchContext = AppContext & {
+  /** App instance — populated at runtime by extractAppServices */
+  app: unknown;
+  /** Database handle — populated at runtime by extractAppServices */
+  db: unknown;
+  /** Collection APIs — populated at runtime by extractAppServices */
+  collections: Record<string, any>;
+  /** Global APIs — populated at runtime by extractAppServices */
+  globals: Record<string, any>;
+  /** Block instance ID */
+  blockId: string;
+  /** Block type name */
+  blockType: string;
+  /** Current locale */
+  locale?: string;
+};
+/**
+ * Block prefetch function.
+ * Runs during CRUD read to fetch related data for the block.
+ * The returned data is attached to `_data[blockId]` in the response.
+ */
+type BlockPrefetchFn<TValues = Record<string, unknown>> = (params: {
+  /** Block field values */
+  values: TValues;
+  /** Prefetch context */
+  ctx: BlockPrefetchContext;
+}) => Promise<Record<string, unknown>> | Record<string, unknown>;
+/**
+ * Expanded record from expansion of relation/upload fields.
+ * Contains at minimum an `id` field plus any other fields from the referenced record.
+ */
+type ExpandedRecord = Record<string, unknown> & {
+  id: string;
+};
+/**
+ * Options for a single relation inside a block prefetch `with` clause.
+ * Same syntax as find's `with`, but only nested `with` is supported —
+ * query options (where, orderBy, limit, etc.) don't apply to block field expansion.
+ *
+ * Nested `with` is passed through to the collection's `find` call,
+ * reusing the existing relation resolution machinery.
+ */
+type BlockPrefetchWithOptions = {
+  with?: Record<string, true | BlockPrefetchWithOptions>;
+};
+/**
+ * Block prefetch `with` clause.
+ * Same object syntax as `with` in find operations.
+ *
+ * Each key is a relation/upload field name. Value can be:
+ * - `true` — expand the field to a full record
+ * - `{ with: { ... } }` — expand with nested relation loading
+ *
+ * @example
+ * ```ts
+ * // Simple expansion
+ * .prefetch({ with: { backgroundImage: true } })
+ *
+ * // Nested expansion (e.g., expand author and their avatar)
+ * .prefetch({ with: { author: { with: { avatar: true } } } })
+ * ```
+ */
+type BlockPrefetchWith<TFields = Record<string, unknown>> = { [K in keyof TFields]?: true | BlockPrefetchWithOptions };
+/**
+ * Compute the expanded data type from a `with` config object.
+ * Each key that is `true` or `{ with: ... }` produces `ExpandedRecord | null`.
+ */
+type ExpandWithResult<TWith> = { [K in keyof TWith as TWith[K] extends false | undefined ? never : K]: ExpandedRecord | null };
+/**
+ * Block builder state.
+ */
+interface BlockBuilderState<TName extends string = string, TFields extends Record<string, Field<FieldState>> = Record<string, Field<FieldState>>> {
+  /** Block type name */
+  name: TName;
+  /** Admin configuration (label, icon, description, category, etc.) */
+  admin?: AdminBlockConfig;
+  /** Field definitions */
+  fields?: TFields;
+  /** Allow child blocks */
+  allowChildren?: boolean;
+  /** Maximum number of child blocks */
+  maxChildren?: number;
+  /** Prefetch function (Shape 1: pure function) */
+  prefetch?: BlockPrefetchFn<any>;
+  /** Relation fields to expand via `.prefetch({ with: { ... } })` */
+  prefetchWith?: BlockPrefetchWith;
+  /** Loader function for `.prefetch({ with, loader })` (Shape 3) */
+  _prefetchLoader?: (params: {
+    values: any;
+    expanded: Record<string, unknown>;
+    ctx: BlockPrefetchContext;
+  }) => Promise<Record<string, unknown>> | Record<string, unknown>;
+  /** Type-level marker for prefetch data type (not used at runtime) */
+  "~prefetchData"?: unknown;
+  /** Form layout for block fields (sections, tabs, grid) */
+  form?: {
+    fields: FieldLayoutItem[];
+  };
+  /** Optional registered component names from Questpie builder registry */
+  "~components"?: string[];
+}
+/**
+ * Block definition - the built block ready for registration.
+ */
+interface BlockDefinition<TState extends BlockBuilderState = BlockBuilderState> {
+  /** Block type name */
+  readonly name: TState["name"];
+  /** Full state */
+  readonly state: TState;
+  /** Get field metadata for introspection */
+  getFieldMetadata(): Record<string, FieldSchema>;
+  /** Execute prefetch if defined */
+  executePrefetch(values: Record<string, unknown>, ctx: BlockPrefetchContext): Promise<Record<string, unknown>>;
+}
+/**
+ * Builder class for defining block types.
+ *
+ * @template TState - Block builder state
+ * @template TFieldMap - Field type map for typed field proxy (from builder's registered fields)
+ * @template TData - Prefetch data type (set by .prefetch(), preserved through chain)
+ */
+declare class BlockBuilder<TState extends BlockBuilderState = BlockBuilderState, TFieldMap extends Record<string, any> = AdminBlockFields, TData = Record<string, unknown>> {
+  private _state;
+  /**
+   * Runtime field factories map. When provided (by codegen-generated factories),
+   * includes both builtin fields AND module-contributed fields with extension
+   * methods (e.g. `.admin()`, `.form()`). Falls back to raw builtinFields +
+   * adminFields when not provided (direct BlockBuilder usage).
+   */
+  private _fieldDefs?;
+  constructor(state: TState);
+  /**
+   * Create a new BlockBuilder with optional pre-wrapped field defs.
+   *
+   * Mirrors CollectionBuilder.create() — codegen-generated factory functions
+   * pass the merged+wrapped field map so that field extension methods
+   * (`.admin()`, `.form()`) are available inside `.fields()` callbacks.
+   */
+  static create<TName extends string, TFieldTypes extends Record<string, any> = AdminBlockFields>(name: TName, fieldDefs?: Record<string, any>): BlockBuilder<{
+    name: TName;
+  }, TFieldTypes>;
+  /** Create a child builder that inherits _fieldDefs. */
+  private _child;
+  /**
+   * Set admin metadata for the block.
+   * Follows the same pattern as collection .admin() method.
+   *
+   * @example
+   * ```ts
+   * block("hero")
+   *   .admin(({ c }) => ({
+   *     label: { en: "Hero Section", sk: "Hero sekcia" },
+   *     icon: c.icon("ph:image"),
+   *     description: { en: "Full-width hero with background image" },
+   *     category: {
+   *       label: { en: "Sections", sk: "Sekcie" },
+   *       icon: c.icon("ph:layout"),
+   *       order: 1,
+   *     },
+   *     order: 1,
+   *     hidden: false,
+   *   }))
+   * ```
+   */
+  admin(configOrFn: AdminBlockConfig | ((ctx: AdminConfigContext) => AdminBlockConfig)): BlockBuilder<TState & {
+    admin: AdminBlockConfig;
+  }, TFieldMap, TData>;
+  /**
+   * Define fields for the block.
+   * Uses the same field builder as collections.
+   *
+   * Uses destructured context object syntax: `({ f }) =>` (not positional `(f) =>`).
+   * This is consistent with collection/global `.fields()` and allows future
+   * extension of the context without breaking changes.
+   *
+   * @example
+   * ```ts
+   * block("hero").fields(({ f }) => ({
+   *   title: f.text({ required: true }),
+   *   subtitle: f.text(),
+   *   image: f.upload({ accept: "image/*" }),
+   * }))
+   * ```
+   */
+  fields<TNewFields extends Record<string, Field<FieldState>>>(factory: (ctx: {
+    f: FieldBuilderProxy<TFieldMap>;
+  }) => TNewFields): BlockBuilder<Omit<TState, "fields"> & {
+    fields: TNewFields;
+  }, TFieldMap, TData>;
+  /**
+   * Define form layout for block fields.
+   * Supports sections, tabs, and grid layouts — same as collection .form().
+   *
+   * @example
+   * ```ts
+   * block("pricing")
+   *   .fields(({ f }) => ({
+   *     title: f.text().required(),
+   *     price: f.number().required(),
+   *     currency: f.select([...]),
+   *     description: f.textarea(),
+   *   }))
+   *   .form(({ f }) => ({
+   *     fields: [
+   *       { type: "section", label: "Basic", fields: [f.title, f.description] },
+   *       { type: "section", label: "Pricing", layout: "grid", fields: [f.price, f.currency] },
+   *     ],
+   *   }))
+   * ```
+   */
+  form(configFn: (ctx: {
+    f: Record<string, string>;
+  }) => {
+    fields: FieldLayoutItem[];
+  }): BlockBuilder<TState & {
+    form: {
+      fields: FieldLayoutItem[];
+    };
+  }, TFieldMap, TData>;
+  /**
+   * Allow child blocks (for layout blocks).
+   *
+   * @example
+   * ```ts
+   * block("columns").allowChildren()
+   * block("columns").allowChildren(4) // max 4 children
+   * ```
+   */
+  allowChildren(maxChildren?: number): BlockBuilder<TState & {
+    allowChildren: true;
+    maxChildren?: number;
+  }, TFieldMap, TData>;
+  /**
+   * Add prefetch configuration for server-side data fetching.
+   * Runs during CRUD read to fetch related data for the block.
+   *
+   * Supports three shapes:
+   *
+   * **Shape 1: Pure function** — return data directly, `TData` inferred from return type.
+   * ```ts
+   * .prefetch(async ({ values, ctx }) => {
+   *   return { services: res.docs };
+   * })
+   * ```
+   *
+   * **Shape 2: Expand relation/upload fields** — same `with` syntax as find operations.
+   * ```ts
+   * .prefetch({ with: { backgroundImage: true } })
+   *
+   * // Nested expansion (passes through to collection find's `with`)
+   * .prefetch({ with: { author: { with: { avatar: true } } } })
+   * ```
+   *
+   * **Shape 3: Expand + custom loader** — expand fields, then run a loader with the expanded data.
+   * ```ts
+   * .prefetch({
+   *   with: { backgroundImage: true },
+   *   loader: async ({ values, expanded, ctx }) => {
+   *     return { analytics: await getStats() };
+   *   },
+   * })
+   * ```
+   */
+  prefetch<TNewData extends Record<string, unknown>>(fn: (params: {
+    values: InferBlockValues<TState>;
+    ctx: BlockPrefetchContext;
+  }) => Promise<TNewData> | TNewData): BlockBuilder<Omit<TState, "prefetch" | "~prefetchData"> & {
+    prefetch: typeof fn;
+    "~prefetchData": TNewData;
+  }, TFieldMap, TNewData>;
+  prefetch<const TWith extends BlockPrefetchWith<InferBlockValues<TState>>, TLoaderData extends Record<string, unknown> = {}>(config: {
+    with: TWith;
+    loader?: (params: {
+      values: InferBlockValues<TState>;
+      expanded: ExpandWithResult<TWith>;
+      ctx: BlockPrefetchContext;
+    }) => Promise<TLoaderData> | TLoaderData;
+  }): BlockBuilder<Omit<TState, "prefetch" | "prefetchWith" | "_prefetchLoader" | "~prefetchData"> & {
+    prefetchWith: TWith;
+    "~prefetchData": ExpandWithResult<TWith> & TLoaderData;
+  }, TFieldMap, ExpandWithResult<TWith> & TLoaderData>;
+  /**
+   * Build the block definition.
+   * Called automatically when registering with .blocks().
+   */
+  build(): BlockDefinition<TState>;
+  /**
+   * Get the current state (for internal use).
+   */
+  get state(): TState;
+}
+/**
+ * Create a new server-side block builder.
+ *
+ * Defines block types with fields, validation, and prefetch logic.
+ * Blocks are server-only - the frontend handles rendering independently.
+ *
+ * @example
+ * ```ts
+ * import { block } from "@questpie/admin/server";
+ *
+ * const heroBlock = block("hero")
+ *   .admin(({ c }) => ({
+ *     label: { en: "Hero Section" },
+ *     icon: c.icon("ph:image"),
+ *     category: {
+ *       label: { en: "Layout" },
+ *     },
+ *   }))
+ *   .fields(({ f }) => ({
+ *     title: f.text({ required: true }),
+ *     subtitle: f.text(),
+ *   }));
+ *
+ * // Register blocks on QUESTPIE
+ * const app = runtimeConfig({
+ *   modules: [adminModule],
+ *   blocks: { hero: heroBlock },
+ *   .build({ ... });
+ * ```
+ */
+declare function block<TName extends string>(name: TName): BlockBuilder<{
+  name: TName;
+}>;
+/**
+ * Extract field values type from block state.
+ * Infers value type per-field to produce heterogeneous types
+ * (e.g., { title: string, count: number, showPrices: boolean }).
+ */
+type InferBlockValues<TState extends BlockBuilderState> = TState["fields"] extends Record<string, any> ? { [K in keyof TState["fields"]]: TState["fields"][K] extends {
+  readonly _: infer TS extends FieldState;
+} ? TS["data"] : unknown } : Record<string, unknown>;
+/**
+ * Extract prefetch data type from a block builder or block state.
+ * Infers the `data` type based on `.prefetch()` configuration:
+ * - Shape 1 (function): return type of the prefetch function
+ * - Shape 2 (`{ with }` ): expanded fields as `{ [field]: ExpandedRecord | null }`
+ * - Shape 3 (`{ with, loader }`): expanded fields merged with loader return type
+ * - No prefetch: `Record<string, unknown>`
+ *
+ * Accepts either a `BlockBuilder` instance or a `BlockBuilderState`.
+ * Prefer passing the builder — state-level extraction may fail when
+ * `as any` casts are present in the builder chain.
+ */
+type InferBlockData<T> = T extends BlockBuilder<any, any, infer TData> ? TData : T extends BlockBuilderState ? T["~prefetchData"] extends Record<string, unknown> ? T["~prefetchData"] : Record<string, unknown> : Record<string, unknown>;
+/**
+ * Any block builder (for generic usage).
+ */
+type AnyBlockBuilder = BlockBuilder<BlockBuilderState, any, any>;
+/**
+ * Any block definition (for generic usage).
+ */
+type AnyBlockDefinition = BlockDefinition<BlockBuilderState>;
+//#endregion
+export { AnyBlockBuilder, AnyBlockDefinition, BlockBuilder, BlockBuilderState, BlockDefinition, BlockPrefetchContext, BlockPrefetchFn, BlockPrefetchWith, BlockPrefetchWithOptions, ExpandWithResult, ExpandedRecord, InferBlockData, InferBlockValues, block };

package/dist/server/modules/admin/block/block-builder.mjs

@@ -0,0 +1,315 @@
+import { adminFields } from "../../../fields/index.mjs";
+import { builtinFields, createFieldNameProxy, createFieldsCallbackContext } from "questpie";
+
+//#region src/server/modules/admin/block/block-builder.ts
+/**
+* Block Builder
+*
+* Defines block types for the visual block editor.
+* Blocks are registered on the app builder and can be used in blocks fields.
+*
+* Each block has:
+* - Admin metadata (label, description, icon, category) via .admin()
+* - Fields (using the same field system as collections)
+* - Optional prefetch function (runs on CRUD read to fetch related data)
+* - Optional children configuration (for nested blocks)
+*
+* @example
+* ```ts
+* import { block } from "@questpie/admin/server";
+*
+* const heroBlock = block("hero")
+*   .admin(({ c }) => ({
+*     label: { en: "Hero Section", sk: "Hero sekcia" },
+*     icon: c.icon("ph:image"),
+*     category: {
+*       label: { en: "Sections", sk: "Sekcie" },
+*       icon: c.icon("ph:layout"),
+*     },
+*   }))
+*   .fields(({ f }) => ({
+*     title: f.text({ required: true }),
+*     subtitle: f.text(),
+*     backgroundImage: f.upload({ accept: "image/*" }),
+*   }))
+*   .prefetch({ with: { backgroundImage: true } });
+* ```
+*/
+/**
+* Create a component proxy for type-safe icon and UI element references.
+* Used in .admin() config functions.
+*/
+function createComponentProxy(registeredComponentNames = []) {
+	const registered = new Set(registeredComponentNames);
+	const hasRegistry = registered.size > 0;
+	return new Proxy({}, {
+		get: (_target, prop) => {
+			if (typeof prop !== "string") return;
+			if (prop === "then") return;
+			if (hasRegistry && !registered.has(prop)) throw new Error(`Unknown component "${prop}" for block admin config. Available components: ${[...registered].sort().join(", ")}`);
+			return (props) => {
+				if (prop === "icon" && typeof props === "string") return {
+					type: "icon",
+					props: { name: props }
+				};
+				if (typeof props === "object" && props !== null) return {
+					type: prop,
+					props
+				};
+				return {
+					type: prop,
+					props: { value: props }
+				};
+			};
+		},
+		has: (_target, prop) => {
+			if (typeof prop !== "string") return false;
+			return hasRegistry ? registered.has(prop) : true;
+		},
+		ownKeys: () => hasRegistry ? [...registered] : [],
+		getOwnPropertyDescriptor: (_target, prop) => {
+			if (typeof prop !== "string") return;
+			if (hasRegistry && !registered.has(prop)) return;
+			return {
+				configurable: true,
+				enumerable: hasRegistry,
+				writable: false,
+				value: (props) => {
+					if (prop === "icon" && typeof props === "string") return {
+						type: "icon",
+						props: { name: props }
+					};
+					if (typeof props === "object" && props !== null) return {
+						type: prop,
+						props
+					};
+					return {
+						type: prop,
+						props: { value: props }
+					};
+				}
+			};
+		}
+	});
+}
+/**
+* Builder class for defining block types.
+*
+* @template TState - Block builder state
+* @template TFieldMap - Field type map for typed field proxy (from builder's registered fields)
+* @template TData - Prefetch data type (set by .prefetch(), preserved through chain)
+*/
+var BlockBuilder = class BlockBuilder {
+	_state;
+	/**
+	* Runtime field factories map. When provided (by codegen-generated factories),
+	* includes both builtin fields AND module-contributed fields with extension
+	* methods (e.g. `.admin()`, `.form()`). Falls back to raw builtinFields +
+	* adminFields when not provided (direct BlockBuilder usage).
+	*/
+	_fieldDefs;
+	constructor(state) {
+		this._state = state;
+	}
+	/**
+	* Create a new BlockBuilder with optional pre-wrapped field defs.
+	*
+	* Mirrors CollectionBuilder.create() — codegen-generated factory functions
+	* pass the merged+wrapped field map so that field extension methods
+	* (`.admin()`, `.form()`) are available inside `.fields()` callbacks.
+	*/
+	static create(name, fieldDefs) {
+		const builder = new BlockBuilder({ name });
+		if (fieldDefs) builder._fieldDefs = fieldDefs;
+		return builder;
+	}
+	/** Create a child builder that inherits _fieldDefs. */
+	_child(state) {
+		const child = new BlockBuilder(state);
+		child._fieldDefs = this._fieldDefs;
+		return child;
+	}
+	/**
+	* Set admin metadata for the block.
+	* Follows the same pattern as collection .admin() method.
+	*
+	* @example
+	* ```ts
+	* block("hero")
+	*   .admin(({ c }) => ({
+	*     label: { en: "Hero Section", sk: "Hero sekcia" },
+	*     icon: c.icon("ph:image"),
+	*     description: { en: "Full-width hero with background image" },
+	*     category: {
+	*       label: { en: "Sections", sk: "Sekcie" },
+	*       icon: c.icon("ph:layout"),
+	*       order: 1,
+	*     },
+	*     order: 1,
+	*     hidden: false,
+	*   }))
+	* ```
+	*/
+	admin(configOrFn) {
+		const registeredComponents = this._state["~components"] ?? [];
+		const config = typeof configOrFn === "function" ? configOrFn({ c: createComponentProxy(registeredComponents) }) : configOrFn;
+		return this._child({
+			...this._state,
+			admin: config
+		});
+	}
+	/**
+	* Define fields for the block.
+	* Uses the same field builder as collections.
+	*
+	* Uses destructured context object syntax: `({ f }) =>` (not positional `(f) =>`).
+	* This is consistent with collection/global `.fields()` and allows future
+	* extension of the context without breaking changes.
+	*
+	* @example
+	* ```ts
+	* block("hero").fields(({ f }) => ({
+	*   title: f.text({ required: true }),
+	*   subtitle: f.text(),
+	*   image: f.upload({ accept: "image/*" }),
+	* }))
+	* ```
+	*/
+	fields(factory) {
+		const resolvedFields = factory(createFieldsCallbackContext(this._fieldDefs ?? {
+			...builtinFields,
+			...adminFields
+		}));
+		const child = new BlockBuilder({
+			...this._state,
+			fields: resolvedFields
+		});
+		child._fieldDefs = this._fieldDefs;
+		return child;
+	}
+	/**
+	* Define form layout for block fields.
+	* Supports sections, tabs, and grid layouts — same as collection .form().
+	*
+	* @example
+	* ```ts
+	* block("pricing")
+	*   .fields(({ f }) => ({
+	*     title: f.text().required(),
+	*     price: f.number().required(),
+	*     currency: f.select([...]),
+	*     description: f.textarea(),
+	*   }))
+	*   .form(({ f }) => ({
+	*     fields: [
+	*       { type: "section", label: "Basic", fields: [f.title, f.description] },
+	*       { type: "section", label: "Pricing", layout: "grid", fields: [f.price, f.currency] },
+	*     ],
+	*   }))
+	* ```
+	*/
+	form(configFn) {
+		const resolved = configFn({ f: createFieldNameProxy() });
+		return this._child({
+			...this._state,
+			form: resolved
+		});
+	}
+	/**
+	* Allow child blocks (for layout blocks).
+	*
+	* @example
+	* ```ts
+	* block("columns").allowChildren()
+	* block("columns").allowChildren(4) // max 4 children
+	* ```
+	*/
+	allowChildren(maxChildren) {
+		return this._child({
+			...this._state,
+			allowChildren: true,
+			maxChildren
+		});
+	}
+	prefetch(fnOrConfig) {
+		if (typeof fnOrConfig === "function") return this._child({
+			...this._state,
+			prefetch: fnOrConfig
+		});
+		const { with: withFields, loader } = fnOrConfig;
+		return this._child({
+			...this._state,
+			prefetchWith: withFields,
+			_prefetchLoader: loader
+		});
+	}
+	/**
+	* Build the block definition.
+	* Called automatically when registering with .blocks().
+	*/
+	build() {
+		const state = this._state;
+		return {
+			name: state.name,
+			state,
+			getFieldMetadata() {
+				if (!state.fields) return {};
+				const fields = {};
+				for (const [name, fieldDef] of Object.entries(state.fields)) fields[name] = {
+					name,
+					metadata: fieldDef.getMetadata()
+				};
+				return fields;
+			},
+			async executePrefetch(values, ctx) {
+				if (!state.prefetch) return {};
+				return state.prefetch({
+					values,
+					ctx
+				});
+			}
+		};
+	}
+	/**
+	* Get the current state (for internal use).
+	*/
+	get state() {
+		return this._state;
+	}
+};
+/**
+* Create a new server-side block builder.
+*
+* Defines block types with fields, validation, and prefetch logic.
+* Blocks are server-only - the frontend handles rendering independently.
+*
+* @example
+* ```ts
+* import { block } from "@questpie/admin/server";
+*
+* const heroBlock = block("hero")
+*   .admin(({ c }) => ({
+*     label: { en: "Hero Section" },
+*     icon: c.icon("ph:image"),
+*     category: {
+*       label: { en: "Layout" },
+*     },
+*   }))
+*   .fields(({ f }) => ({
+*     title: f.text({ required: true }),
+*     subtitle: f.text(),
+*   }));
+*
+* // Register blocks on QUESTPIE
+* const app = runtimeConfig({
+*   modules: [adminModule],
+*   blocks: { hero: heroBlock },
+*   .build({ ... });
+* ```
+*/
+function block(name) {
+	return new BlockBuilder({ name });
+}
+
+//#endregion
+export { BlockBuilder, block };

package/dist/server/modules/admin/block/index.d.mts

@@ -0,0 +1,3 @@
+import { AnyBlockBuilder, AnyBlockDefinition, BlockBuilder, BlockBuilderState, BlockDefinition, BlockPrefetchContext, BlockPrefetchFn, BlockPrefetchWith, BlockPrefetchWithOptions, ExpandWithResult, ExpandedRecord, InferBlockData, InferBlockValues, block } from "./block-builder.mjs";
+import { BlockSchema, getBlocksByCategory, introspectBlock, introspectBlocks } from "./introspection.mjs";
+import { BlocksPrefetchContext, createBlocksPrefetchHook, processBlocksDocument, processDocumentBlocksPrefetch } from "./prefetch.mjs";