@createcms/core 0.1.1 → 0.2.0

package/dist/plugins/multi-tenant/index.d.ts

@@ -231,12 +231,56 @@ type BlockDefinition<TProps extends Record<string, BlockProperty> = Record<strin
     allowChildren?: false;
 } | {
     allowChildren: true;
-    allowedChildBlocks?: string[];
 });
 type AnyBlockDefinition = BlockDefinition<Record<string, BlockProperty>, Record<string, EventDeclaration>>;
 type RootDefinition<TProps extends Record<string, BlockProperty> = Record<string, BlockProperty>> = {
     properties: TProps;
 };
+/**
+ * One PARENT's placement rule inside a collection's {@link CollectionStructure}
+ * — declares which child block types that parent (or the literal `'root'`) may
+ * contain. There are three mutually-exclusive modes, enforced by the type:
+ *
+ * - **open** — `{}` or `{ accepts: '*' }`: holds any block. (Same as having no
+ *   entry at all; `'*'` is just an explicit, readable form.)
+ * - **whitelist** — `{ accepts: ['a', 'b'] }`: holds ONLY `a`/`b`. Fail-closed —
+ *   a block added to the collection later is rejected until listed. `excludes`
+ *   is forbidden here (a concrete `accepts` already says exactly what's allowed).
+ * - **blacklist** — `{ excludes: ['z'] }` (or `{ accepts: '*', excludes: ['z'] }`):
+ *   holds anything EXCEPT `z`. Fail-open — a block added later is accepted.
+ *
+ * Whether a parent accepts children AT ALL is the separate, coarser
+ * `allowChildren` gate on the block (the root always accepts children); these
+ * rules only refine WHICH children an accepting parent may hold.
+ */
+type BlockStructureEntry<TBlockName extends string> = {
+    /** `'*'` = open base (optional, for readability). */
+    accepts?: '*';
+    /** Holds anything except these. */
+    excludes?: readonly TBlockName[];
+} | {
+    /** Holds ONLY these block types. */
+    accepts: readonly TBlockName[];
+    /**
+     * Forbidden alongside a concrete `accepts` list — the list already names
+     * exactly what is allowed, so `excludes` would be ignored.
+     */
+    excludes?: "Remove 'excludes': a concrete 'accepts' list already defines exactly which blocks are allowed. Use accepts: '*' with excludes for an all-except list.";
+};
+/**
+ * Placement rules for a collection, keyed by PARENT block name (or the literal
+ * `'root'` for the top level). Open by default: a parent with no entry holds any
+ * block. The keys and the `accepts` / `excludes` block names autocomplete against
+ * the collection's block names and are checked at compile time by
+ * {@link defineCollection} (the field type alone enforces this — no extra step).
+ *
+ * This is the single source of truth that the visual editor (drop-zone gating)
+ * and the server guard (createBlock / moveBlock / duplicateBlock) both read,
+ * alongside each block's `allowChildren` flag, so they can never diverge.
+ */
+type CollectionStructure<TBlocks extends Record<string, AnyBlockDefinition>> = {
+    [K in keyof TBlocks | 'root']?: BlockStructureEntry<keyof TBlocks & string>;
+};
 type SlugConfig = {
     enabled: false;
 } | {
@@ -260,6 +304,15 @@ type CollectionDefinition<TProps extends Record<string, BlockProperty> = Record<
      * regardless of this flag). Any collection can still be a reference target.
      */
     reusableBlock?: boolean;
+    /**
+     * Placement rules keyed by PARENT block name (or `'root'`) — which children
+     * each container may hold, via `accepts` (whitelist) / `excludes` (blacklist)
+     * (see {@link CollectionStructure}). Read by the editor and the server guard
+     * together with each block's `allowChildren` flag. Open by default; block
+     * names are checked at compile time by the field type itself, so a typo is a
+     * compile error at the `defineCollection` call site.
+     */
+    structure?: CollectionStructure<TBlocks>;
 };
 type AnyCollectionDefinition = CollectionDefinition<Record<string, BlockProperty>, Record<string, AnyBlockDefinition>>;
 type CollectionWithName = Omit<AnyCollectionDefinition, 'blocks'> & {

package/dist/react/blocks.d.cts

@@ -139,12 +139,56 @@ type BlockDefinition<TProps extends Record<string, BlockProperty> = Record<strin
     allowChildren?: false;
 } | {
     allowChildren: true;
-    allowedChildBlocks?: string[];
 });
 type AnyBlockDefinition = BlockDefinition<Record<string, BlockProperty>, Record<string, EventDeclaration>>;
 type RootDefinition<TProps extends Record<string, BlockProperty> = Record<string, BlockProperty>> = {
     properties: TProps;
 };
+/**
+ * One PARENT's placement rule inside a collection's {@link CollectionStructure}
+ * — declares which child block types that parent (or the literal `'root'`) may
+ * contain. There are three mutually-exclusive modes, enforced by the type:
+ *
+ * - **open** — `{}` or `{ accepts: '*' }`: holds any block. (Same as having no
+ *   entry at all; `'*'` is just an explicit, readable form.)
+ * - **whitelist** — `{ accepts: ['a', 'b'] }`: holds ONLY `a`/`b`. Fail-closed —
+ *   a block added to the collection later is rejected until listed. `excludes`
+ *   is forbidden here (a concrete `accepts` already says exactly what's allowed).
+ * - **blacklist** — `{ excludes: ['z'] }` (or `{ accepts: '*', excludes: ['z'] }`):
+ *   holds anything EXCEPT `z`. Fail-open — a block added later is accepted.
+ *
+ * Whether a parent accepts children AT ALL is the separate, coarser
+ * `allowChildren` gate on the block (the root always accepts children); these
+ * rules only refine WHICH children an accepting parent may hold.
+ */
+type BlockStructureEntry<TBlockName extends string> = {
+    /** `'*'` = open base (optional, for readability). */
+    accepts?: '*';
+    /** Holds anything except these. */
+    excludes?: readonly TBlockName[];
+} | {
+    /** Holds ONLY these block types. */
+    accepts: readonly TBlockName[];
+    /**
+     * Forbidden alongside a concrete `accepts` list — the list already names
+     * exactly what is allowed, so `excludes` would be ignored.
+     */
+    excludes?: "Remove 'excludes': a concrete 'accepts' list already defines exactly which blocks are allowed. Use accepts: '*' with excludes for an all-except list.";
+};
+/**
+ * Placement rules for a collection, keyed by PARENT block name (or the literal
+ * `'root'` for the top level). Open by default: a parent with no entry holds any
+ * block. The keys and the `accepts` / `excludes` block names autocomplete against
+ * the collection's block names and are checked at compile time by
+ * {@link defineCollection} (the field type alone enforces this — no extra step).
+ *
+ * This is the single source of truth that the visual editor (drop-zone gating)
+ * and the server guard (createBlock / moveBlock / duplicateBlock) both read,
+ * alongside each block's `allowChildren` flag, so they can never diverge.
+ */
+type CollectionStructure<TBlocks extends Record<string, AnyBlockDefinition>> = {
+    [K in keyof TBlocks | 'root']?: BlockStructureEntry<keyof TBlocks & string>;
+};
 type SlugConfig = {
     enabled: false;
 } | {
@@ -168,6 +212,15 @@ type CollectionDefinition<TProps extends Record<string, BlockProperty> = Record<
      * regardless of this flag). Any collection can still be a reference target.
      */
     reusableBlock?: boolean;
+    /**
+     * Placement rules keyed by PARENT block name (or `'root'`) — which children
+     * each container may hold, via `accepts` (whitelist) / `excludes` (blacklist)
+     * (see {@link CollectionStructure}). Read by the editor and the server guard
+     * together with each block's `allowChildren` flag. Open by default; block
+     * names are checked at compile time by the field type itself, so a typo is a
+     * compile error at the `defineCollection` call site.
+     */
+    structure?: CollectionStructure<TBlocks>;
 };
 type AnyCollectionDefinition = CollectionDefinition<Record<string, BlockProperty>, Record<string, AnyBlockDefinition>>;
 

package/dist/react/blocks.d.ts

@@ -139,12 +139,56 @@ type BlockDefinition<TProps extends Record<string, BlockProperty> = Record<strin
     allowChildren?: false;
 } | {
     allowChildren: true;
-    allowedChildBlocks?: string[];
 });
 type AnyBlockDefinition = BlockDefinition<Record<string, BlockProperty>, Record<string, EventDeclaration>>;
 type RootDefinition<TProps extends Record<string, BlockProperty> = Record<string, BlockProperty>> = {
     properties: TProps;
 };
+/**
+ * One PARENT's placement rule inside a collection's {@link CollectionStructure}
+ * — declares which child block types that parent (or the literal `'root'`) may
+ * contain. There are three mutually-exclusive modes, enforced by the type:
+ *
+ * - **open** — `{}` or `{ accepts: '*' }`: holds any block. (Same as having no
+ *   entry at all; `'*'` is just an explicit, readable form.)
+ * - **whitelist** — `{ accepts: ['a', 'b'] }`: holds ONLY `a`/`b`. Fail-closed —
+ *   a block added to the collection later is rejected until listed. `excludes`
+ *   is forbidden here (a concrete `accepts` already says exactly what's allowed).
+ * - **blacklist** — `{ excludes: ['z'] }` (or `{ accepts: '*', excludes: ['z'] }`):
+ *   holds anything EXCEPT `z`. Fail-open — a block added later is accepted.
+ *
+ * Whether a parent accepts children AT ALL is the separate, coarser
+ * `allowChildren` gate on the block (the root always accepts children); these
+ * rules only refine WHICH children an accepting parent may hold.
+ */
+type BlockStructureEntry<TBlockName extends string> = {
+    /** `'*'` = open base (optional, for readability). */
+    accepts?: '*';
+    /** Holds anything except these. */
+    excludes?: readonly TBlockName[];
+} | {
+    /** Holds ONLY these block types. */
+    accepts: readonly TBlockName[];
+    /**
+     * Forbidden alongside a concrete `accepts` list — the list already names
+     * exactly what is allowed, so `excludes` would be ignored.
+     */
+    excludes?: "Remove 'excludes': a concrete 'accepts' list already defines exactly which blocks are allowed. Use accepts: '*' with excludes for an all-except list.";
+};
+/**
+ * Placement rules for a collection, keyed by PARENT block name (or the literal
+ * `'root'` for the top level). Open by default: a parent with no entry holds any
+ * block. The keys and the `accepts` / `excludes` block names autocomplete against
+ * the collection's block names and are checked at compile time by
+ * {@link defineCollection} (the field type alone enforces this — no extra step).
+ *
+ * This is the single source of truth that the visual editor (drop-zone gating)
+ * and the server guard (createBlock / moveBlock / duplicateBlock) both read,
+ * alongside each block's `allowChildren` flag, so they can never diverge.
+ */
+type CollectionStructure<TBlocks extends Record<string, AnyBlockDefinition>> = {
+    [K in keyof TBlocks | 'root']?: BlockStructureEntry<keyof TBlocks & string>;
+};
 type SlugConfig = {
     enabled: false;
 } | {
@@ -168,6 +212,15 @@ type CollectionDefinition<TProps extends Record<string, BlockProperty> = Record<
      * regardless of this flag). Any collection can still be a reference target.
      */
     reusableBlock?: boolean;
+    /**
+     * Placement rules keyed by PARENT block name (or `'root'`) — which children
+     * each container may hold, via `accepts` (whitelist) / `excludes` (blacklist)
+     * (see {@link CollectionStructure}). Read by the editor and the server guard
+     * together with each block's `allowChildren` flag. Open by default; block
+     * names are checked at compile time by the field type itself, so a typo is a
+     * compile error at the `defineCollection` call site.
+     */
+    structure?: CollectionStructure<TBlocks>;
 };
 type AnyCollectionDefinition = CollectionDefinition<Record<string, BlockProperty>, Record<string, AnyBlockDefinition>>;
 

package/dist/react/index.cjs

@@ -150,6 +150,10 @@ const CMS_ERRORS = {
         status: 404,
         message: 'Parent block not found'
     },
+    BLOCK_NOT_ALLOWED_IN_PARENT: {
+        status: 400,
+        message: 'This block type is not allowed inside the target parent'
+    },
     ROOT_NOT_FOUND: {
         status: 404,
         message: 'Root block not found in snapshot'

package/dist/react/index.d.cts

@@ -235,12 +235,56 @@ type BlockDefinition<TProps extends Record<string, BlockProperty> = Record<strin
     allowChildren?: false;
 } | {
     allowChildren: true;
-    allowedChildBlocks?: string[];
 });
 type AnyBlockDefinition = BlockDefinition<Record<string, BlockProperty>, Record<string, EventDeclaration>>;
 type RootDefinition<TProps extends Record<string, BlockProperty> = Record<string, BlockProperty>> = {
     properties: TProps;
 };
+/**
+ * One PARENT's placement rule inside a collection's {@link CollectionStructure}
+ * — declares which child block types that parent (or the literal `'root'`) may
+ * contain. There are three mutually-exclusive modes, enforced by the type:
+ *
+ * - **open** — `{}` or `{ accepts: '*' }`: holds any block. (Same as having no
+ *   entry at all; `'*'` is just an explicit, readable form.)
+ * - **whitelist** — `{ accepts: ['a', 'b'] }`: holds ONLY `a`/`b`. Fail-closed —
+ *   a block added to the collection later is rejected until listed. `excludes`
+ *   is forbidden here (a concrete `accepts` already says exactly what's allowed).
+ * - **blacklist** — `{ excludes: ['z'] }` (or `{ accepts: '*', excludes: ['z'] }`):
+ *   holds anything EXCEPT `z`. Fail-open — a block added later is accepted.
+ *
+ * Whether a parent accepts children AT ALL is the separate, coarser
+ * `allowChildren` gate on the block (the root always accepts children); these
+ * rules only refine WHICH children an accepting parent may hold.
+ */
+type BlockStructureEntry<TBlockName extends string> = {
+    /** `'*'` = open base (optional, for readability). */
+    accepts?: '*';
+    /** Holds anything except these. */
+    excludes?: readonly TBlockName[];
+} | {
+    /** Holds ONLY these block types. */
+    accepts: readonly TBlockName[];
+    /**
+     * Forbidden alongside a concrete `accepts` list — the list already names
+     * exactly what is allowed, so `excludes` would be ignored.
+     */
+    excludes?: "Remove 'excludes': a concrete 'accepts' list already defines exactly which blocks are allowed. Use accepts: '*' with excludes for an all-except list.";
+};
+/**
+ * Placement rules for a collection, keyed by PARENT block name (or the literal
+ * `'root'` for the top level). Open by default: a parent with no entry holds any
+ * block. The keys and the `accepts` / `excludes` block names autocomplete against
+ * the collection's block names and are checked at compile time by
+ * {@link defineCollection} (the field type alone enforces this — no extra step).
+ *
+ * This is the single source of truth that the visual editor (drop-zone gating)
+ * and the server guard (createBlock / moveBlock / duplicateBlock) both read,
+ * alongside each block's `allowChildren` flag, so they can never diverge.
+ */
+type CollectionStructure<TBlocks extends Record<string, AnyBlockDefinition>> = {
+    [K in keyof TBlocks | 'root']?: BlockStructureEntry<keyof TBlocks & string>;
+};
 type SlugConfig = {
     enabled: false;
 } | {
@@ -264,6 +308,15 @@ type CollectionDefinition<TProps extends Record<string, BlockProperty> = Record<
      * regardless of this flag). Any collection can still be a reference target.
      */
     reusableBlock?: boolean;
+    /**
+     * Placement rules keyed by PARENT block name (or `'root'`) — which children
+     * each container may hold, via `accepts` (whitelist) / `excludes` (blacklist)
+     * (see {@link CollectionStructure}). Read by the editor and the server guard
+     * together with each block's `allowChildren` flag. Open by default; block
+     * names are checked at compile time by the field type itself, so a typo is a
+     * compile error at the `defineCollection` call site.
+     */
+    structure?: CollectionStructure<TBlocks>;
 };
 type AnyCollectionDefinition = CollectionDefinition<Record<string, BlockProperty>, Record<string, AnyBlockDefinition>>;
 type CollectionWithName = Omit<AnyCollectionDefinition, 'blocks'> & {
@@ -667,6 +720,10 @@ declare const CMS_ERRORS: {
         readonly status: 404;
         readonly message: "Parent block not found";
     };
+    readonly BLOCK_NOT_ALLOWED_IN_PARENT: {
+        readonly status: 400;
+        readonly message: "This block type is not allowed inside the target parent";
+    };
     readonly ROOT_NOT_FOUND: {
         readonly status: 404;
         readonly message: "Root block not found in snapshot";

package/dist/react/index.d.ts

@@ -235,12 +235,56 @@ type BlockDefinition<TProps extends Record<string, BlockProperty> = Record<strin
     allowChildren?: false;
 } | {
     allowChildren: true;
-    allowedChildBlocks?: string[];
 });
 type AnyBlockDefinition = BlockDefinition<Record<string, BlockProperty>, Record<string, EventDeclaration>>;
 type RootDefinition<TProps extends Record<string, BlockProperty> = Record<string, BlockProperty>> = {
     properties: TProps;
 };
+/**
+ * One PARENT's placement rule inside a collection's {@link CollectionStructure}
+ * — declares which child block types that parent (or the literal `'root'`) may
+ * contain. There are three mutually-exclusive modes, enforced by the type:
+ *
+ * - **open** — `{}` or `{ accepts: '*' }`: holds any block. (Same as having no
+ *   entry at all; `'*'` is just an explicit, readable form.)
+ * - **whitelist** — `{ accepts: ['a', 'b'] }`: holds ONLY `a`/`b`. Fail-closed —
+ *   a block added to the collection later is rejected until listed. `excludes`
+ *   is forbidden here (a concrete `accepts` already says exactly what's allowed).
+ * - **blacklist** — `{ excludes: ['z'] }` (or `{ accepts: '*', excludes: ['z'] }`):
+ *   holds anything EXCEPT `z`. Fail-open — a block added later is accepted.
+ *
+ * Whether a parent accepts children AT ALL is the separate, coarser
+ * `allowChildren` gate on the block (the root always accepts children); these
+ * rules only refine WHICH children an accepting parent may hold.
+ */
+type BlockStructureEntry<TBlockName extends string> = {
+    /** `'*'` = open base (optional, for readability). */
+    accepts?: '*';
+    /** Holds anything except these. */
+    excludes?: readonly TBlockName[];
+} | {
+    /** Holds ONLY these block types. */
+    accepts: readonly TBlockName[];
+    /**
+     * Forbidden alongside a concrete `accepts` list — the list already names
+     * exactly what is allowed, so `excludes` would be ignored.
+     */
+    excludes?: "Remove 'excludes': a concrete 'accepts' list already defines exactly which blocks are allowed. Use accepts: '*' with excludes for an all-except list.";
+};
+/**
+ * Placement rules for a collection, keyed by PARENT block name (or the literal
+ * `'root'` for the top level). Open by default: a parent with no entry holds any
+ * block. The keys and the `accepts` / `excludes` block names autocomplete against
+ * the collection's block names and are checked at compile time by
+ * {@link defineCollection} (the field type alone enforces this — no extra step).
+ *
+ * This is the single source of truth that the visual editor (drop-zone gating)
+ * and the server guard (createBlock / moveBlock / duplicateBlock) both read,
+ * alongside each block's `allowChildren` flag, so they can never diverge.
+ */
+type CollectionStructure<TBlocks extends Record<string, AnyBlockDefinition>> = {
+    [K in keyof TBlocks | 'root']?: BlockStructureEntry<keyof TBlocks & string>;
+};
 type SlugConfig = {
     enabled: false;
 } | {
@@ -264,6 +308,15 @@ type CollectionDefinition<TProps extends Record<string, BlockProperty> = Record<
      * regardless of this flag). Any collection can still be a reference target.
      */
     reusableBlock?: boolean;
+    /**
+     * Placement rules keyed by PARENT block name (or `'root'`) — which children
+     * each container may hold, via `accepts` (whitelist) / `excludes` (blacklist)
+     * (see {@link CollectionStructure}). Read by the editor and the server guard
+     * together with each block's `allowChildren` flag. Open by default; block
+     * names are checked at compile time by the field type itself, so a typo is a
+     * compile error at the `defineCollection` call site.
+     */
+    structure?: CollectionStructure<TBlocks>;
 };
 type AnyCollectionDefinition = CollectionDefinition<Record<string, BlockProperty>, Record<string, AnyBlockDefinition>>;
 type CollectionWithName = Omit<AnyCollectionDefinition, 'blocks'> & {
@@ -667,6 +720,10 @@ declare const CMS_ERRORS: {
         readonly status: 404;
         readonly message: "Parent block not found";
     };
+    readonly BLOCK_NOT_ALLOWED_IN_PARENT: {
+        readonly status: 400;
+        readonly message: "This block type is not allowed inside the target parent";
+    };
     readonly ROOT_NOT_FOUND: {
         readonly status: 404;
         readonly message: "Root block not found in snapshot";

package/dist/react/index.js

@@ -148,6 +148,10 @@ const CMS_ERRORS = {
         status: 404,
         message: 'Parent block not found'
     },
+    BLOCK_NOT_ALLOWED_IN_PARENT: {
+        status: 400,
+        message: 'This block type is not allowed inside the target parent'
+    },
     ROOT_NOT_FOUND: {
         status: 404,
         message: 'Root block not found in snapshot'

package/dist/react/tracking.d.cts

@@ -153,12 +153,56 @@ type BlockDefinition<TProps extends Record<string, BlockProperty> = Record<strin
     allowChildren?: false;
 } | {
     allowChildren: true;
-    allowedChildBlocks?: string[];
 });
 type AnyBlockDefinition = BlockDefinition<Record<string, BlockProperty>, Record<string, EventDeclaration>>;
 type RootDefinition<TProps extends Record<string, BlockProperty> = Record<string, BlockProperty>> = {
     properties: TProps;
 };
+/**
+ * One PARENT's placement rule inside a collection's {@link CollectionStructure}
+ * — declares which child block types that parent (or the literal `'root'`) may
+ * contain. There are three mutually-exclusive modes, enforced by the type:
+ *
+ * - **open** — `{}` or `{ accepts: '*' }`: holds any block. (Same as having no
+ *   entry at all; `'*'` is just an explicit, readable form.)
+ * - **whitelist** — `{ accepts: ['a', 'b'] }`: holds ONLY `a`/`b`. Fail-closed —
+ *   a block added to the collection later is rejected until listed. `excludes`
+ *   is forbidden here (a concrete `accepts` already says exactly what's allowed).
+ * - **blacklist** — `{ excludes: ['z'] }` (or `{ accepts: '*', excludes: ['z'] }`):
+ *   holds anything EXCEPT `z`. Fail-open — a block added later is accepted.
+ *
+ * Whether a parent accepts children AT ALL is the separate, coarser
+ * `allowChildren` gate on the block (the root always accepts children); these
+ * rules only refine WHICH children an accepting parent may hold.
+ */
+type BlockStructureEntry<TBlockName extends string> = {
+    /** `'*'` = open base (optional, for readability). */
+    accepts?: '*';
+    /** Holds anything except these. */
+    excludes?: readonly TBlockName[];
+} | {
+    /** Holds ONLY these block types. */
+    accepts: readonly TBlockName[];
+    /**
+     * Forbidden alongside a concrete `accepts` list — the list already names
+     * exactly what is allowed, so `excludes` would be ignored.
+     */
+    excludes?: "Remove 'excludes': a concrete 'accepts' list already defines exactly which blocks are allowed. Use accepts: '*' with excludes for an all-except list.";
+};
+/**
+ * Placement rules for a collection, keyed by PARENT block name (or the literal
+ * `'root'` for the top level). Open by default: a parent with no entry holds any
+ * block. The keys and the `accepts` / `excludes` block names autocomplete against
+ * the collection's block names and are checked at compile time by
+ * {@link defineCollection} (the field type alone enforces this — no extra step).
+ *
+ * This is the single source of truth that the visual editor (drop-zone gating)
+ * and the server guard (createBlock / moveBlock / duplicateBlock) both read,
+ * alongside each block's `allowChildren` flag, so they can never diverge.
+ */
+type CollectionStructure<TBlocks extends Record<string, AnyBlockDefinition>> = {
+    [K in keyof TBlocks | 'root']?: BlockStructureEntry<keyof TBlocks & string>;
+};
 type SlugConfig = {
     enabled: false;
 } | {
@@ -182,6 +226,15 @@ type CollectionDefinition<TProps extends Record<string, BlockProperty> = Record<
      * regardless of this flag). Any collection can still be a reference target.
      */
     reusableBlock?: boolean;
+    /**
+     * Placement rules keyed by PARENT block name (or `'root'`) — which children
+     * each container may hold, via `accepts` (whitelist) / `excludes` (blacklist)
+     * (see {@link CollectionStructure}). Read by the editor and the server guard
+     * together with each block's `allowChildren` flag. Open by default; block
+     * names are checked at compile time by the field type itself, so a typo is a
+     * compile error at the `defineCollection` call site.
+     */
+    structure?: CollectionStructure<TBlocks>;
 };
 type AnyCollectionDefinition = CollectionDefinition<Record<string, BlockProperty>, Record<string, AnyBlockDefinition>>;
 

package/dist/react/tracking.d.ts

@@ -153,12 +153,56 @@ type BlockDefinition<TProps extends Record<string, BlockProperty> = Record<strin
     allowChildren?: false;
 } | {
     allowChildren: true;
-    allowedChildBlocks?: string[];
 });
 type AnyBlockDefinition = BlockDefinition<Record<string, BlockProperty>, Record<string, EventDeclaration>>;
 type RootDefinition<TProps extends Record<string, BlockProperty> = Record<string, BlockProperty>> = {
     properties: TProps;
 };
+/**
+ * One PARENT's placement rule inside a collection's {@link CollectionStructure}
+ * — declares which child block types that parent (or the literal `'root'`) may
+ * contain. There are three mutually-exclusive modes, enforced by the type:
+ *
+ * - **open** — `{}` or `{ accepts: '*' }`: holds any block. (Same as having no
+ *   entry at all; `'*'` is just an explicit, readable form.)
+ * - **whitelist** — `{ accepts: ['a', 'b'] }`: holds ONLY `a`/`b`. Fail-closed —
+ *   a block added to the collection later is rejected until listed. `excludes`
+ *   is forbidden here (a concrete `accepts` already says exactly what's allowed).
+ * - **blacklist** — `{ excludes: ['z'] }` (or `{ accepts: '*', excludes: ['z'] }`):
+ *   holds anything EXCEPT `z`. Fail-open — a block added later is accepted.
+ *
+ * Whether a parent accepts children AT ALL is the separate, coarser
+ * `allowChildren` gate on the block (the root always accepts children); these
+ * rules only refine WHICH children an accepting parent may hold.
+ */
+type BlockStructureEntry<TBlockName extends string> = {
+    /** `'*'` = open base (optional, for readability). */
+    accepts?: '*';
+    /** Holds anything except these. */
+    excludes?: readonly TBlockName[];
+} | {
+    /** Holds ONLY these block types. */
+    accepts: readonly TBlockName[];
+    /**
+     * Forbidden alongside a concrete `accepts` list — the list already names
+     * exactly what is allowed, so `excludes` would be ignored.
+     */
+    excludes?: "Remove 'excludes': a concrete 'accepts' list already defines exactly which blocks are allowed. Use accepts: '*' with excludes for an all-except list.";
+};
+/**
+ * Placement rules for a collection, keyed by PARENT block name (or the literal
+ * `'root'` for the top level). Open by default: a parent with no entry holds any
+ * block. The keys and the `accepts` / `excludes` block names autocomplete against
+ * the collection's block names and are checked at compile time by
+ * {@link defineCollection} (the field type alone enforces this — no extra step).
+ *
+ * This is the single source of truth that the visual editor (drop-zone gating)
+ * and the server guard (createBlock / moveBlock / duplicateBlock) both read,
+ * alongside each block's `allowChildren` flag, so they can never diverge.
+ */
+type CollectionStructure<TBlocks extends Record<string, AnyBlockDefinition>> = {
+    [K in keyof TBlocks | 'root']?: BlockStructureEntry<keyof TBlocks & string>;
+};
 type SlugConfig = {
     enabled: false;
 } | {
@@ -182,6 +226,15 @@ type CollectionDefinition<TProps extends Record<string, BlockProperty> = Record<
      * regardless of this flag). Any collection can still be a reference target.
      */
     reusableBlock?: boolean;
+    /**
+     * Placement rules keyed by PARENT block name (or `'root'`) — which children
+     * each container may hold, via `accepts` (whitelist) / `excludes` (blacklist)
+     * (see {@link CollectionStructure}). Read by the editor and the server guard
+     * together with each block's `allowChildren` flag. Open by default; block
+     * names are checked at compile time by the field type itself, so a typo is a
+     * compile error at the `defineCollection` call site.
+     */
+    structure?: CollectionStructure<TBlocks>;
 };
 type AnyCollectionDefinition = CollectionDefinition<Record<string, BlockProperty>, Record<string, AnyBlockDefinition>>;
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@createcms/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "[Work in progress · pre-1.0 · not production-ready] Composable, block-based headless CMS powered by better-call and Drizzle ORM (Postgres). Database-native versioning with Git-like branches, copy-on-write drafts, visual diffs, merges, reusable blocks, nested pages, and a fully type-safe API.",
   "license": "MIT",
   "homepage": "https://github.com/weepaho3/createCMS#readme",