@edugate/ai-agent 0.1.1 → 0.2.0

package/dist/index.d.mts

@@ -35,6 +35,599 @@ declare function applyItemPatch(items: unknown, op: "insertItem" | "updateItem"
     at?: number;
 }): any[];
 
+declare const CanvasOpSchema: z.ZodDiscriminatedUnion<"action", [z.ZodObject<{
+    action: z.ZodLiteral<"createScene">;
+    data: z.ZodObject<{
+        scene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        newIndex: z.ZodOptional<z.ZodNumber>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        scene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        newIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        scene: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        newIndex: z.ZodOptional<z.ZodNumber>;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    action: "createScene";
+    data: {
+        newIndex?: number | undefined;
+        scene?: Record<string, unknown> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+}, {
+    action: "createScene";
+    data: {
+        newIndex?: number | undefined;
+        scene?: Record<string, unknown> | undefined;
+    } & {
+        [k: string]: unknown;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"deleteScene">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+    }, {
+        sceneId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "deleteScene";
+    data: {
+        sceneId: string;
+    };
+}, {
+    action: "deleteScene";
+    data: {
+        sceneId: string;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"addBlock">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        block: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        block: Record<string, unknown>;
+    }, {
+        sceneId: string;
+        block: Record<string, unknown>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "addBlock";
+    data: {
+        sceneId: string;
+        block: Record<string, unknown>;
+    };
+}, {
+    action: "addBlock";
+    data: {
+        sceneId: string;
+        block: Record<string, unknown>;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"updateScene">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        updates: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        newIndex: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        updates?: Record<string, unknown> | undefined;
+        newIndex?: number | undefined;
+    }, {
+        sceneId: string;
+        updates?: Record<string, unknown> | undefined;
+        newIndex?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "updateScene";
+    data: {
+        sceneId: string;
+        updates?: Record<string, unknown> | undefined;
+        newIndex?: number | undefined;
+    };
+}, {
+    action: "updateScene";
+    data: {
+        sceneId: string;
+        updates?: Record<string, unknown> | undefined;
+        newIndex?: number | undefined;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"deleteBlock">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        blockId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        blockId: string;
+    }, {
+        sceneId: string;
+        blockId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "deleteBlock";
+    data: {
+        sceneId: string;
+        blockId: string;
+    };
+}, {
+    action: "deleteBlock";
+    data: {
+        sceneId: string;
+        blockId: string;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"updateBlock">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        blockId: z.ZodString;
+        updates: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        blockId: string;
+        updates: Record<string, unknown>;
+    }, {
+        sceneId: string;
+        blockId: string;
+        updates: Record<string, unknown>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "updateBlock";
+    data: {
+        sceneId: string;
+        blockId: string;
+        updates: Record<string, unknown>;
+    };
+}, {
+    action: "updateBlock";
+    data: {
+        sceneId: string;
+        blockId: string;
+        updates: Record<string, unknown>;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"duplicateBlock">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        blockId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        blockId: string;
+    }, {
+        sceneId: string;
+        blockId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "duplicateBlock";
+    data: {
+        sceneId: string;
+        blockId: string;
+    };
+}, {
+    action: "duplicateBlock";
+    data: {
+        sceneId: string;
+        blockId: string;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"groupBlocks">;
+    data: z.ZodObject<{
+        blockIds: z.ZodArray<z.ZodString, "many">;
+    }, "strip", z.ZodTypeAny, {
+        blockIds: string[];
+    }, {
+        blockIds: string[];
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "groupBlocks";
+    data: {
+        blockIds: string[];
+    };
+}, {
+    action: "groupBlocks";
+    data: {
+        blockIds: string[];
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"updateBlockTheme">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        blockId: z.ZodString;
+        theme: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        blockId: string;
+        theme: Record<string, unknown>;
+    }, {
+        sceneId: string;
+        blockId: string;
+        theme: Record<string, unknown>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "updateBlockTheme";
+    data: {
+        sceneId: string;
+        blockId: string;
+        theme: Record<string, unknown>;
+    };
+}, {
+    action: "updateBlockTheme";
+    data: {
+        sceneId: string;
+        blockId: string;
+        theme: Record<string, unknown>;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"updateBlockElementStyle">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        blockId: z.ZodString;
+        elementId: z.ZodString;
+        customStyle: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        blockId: string;
+        elementId: string;
+        customStyle: Record<string, unknown>;
+    }, {
+        sceneId: string;
+        blockId: string;
+        elementId: string;
+        customStyle: Record<string, unknown>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "updateBlockElementStyle";
+    data: {
+        sceneId: string;
+        blockId: string;
+        elementId: string;
+        customStyle: Record<string, unknown>;
+    };
+}, {
+    action: "updateBlockElementStyle";
+    data: {
+        sceneId: string;
+        blockId: string;
+        elementId: string;
+        customStyle: Record<string, unknown>;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"addAction">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        blockId: z.ZodString;
+        action: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        blockId: string;
+        action: Record<string, unknown>;
+    }, {
+        sceneId: string;
+        blockId: string;
+        action: Record<string, unknown>;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "addAction";
+    data: {
+        sceneId: string;
+        blockId: string;
+        action: Record<string, unknown>;
+    };
+}, {
+    action: "addAction";
+    data: {
+        sceneId: string;
+        blockId: string;
+        action: Record<string, unknown>;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"removeAction">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        blockId: z.ZodString;
+        actionId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        blockId: string;
+        actionId: string;
+    }, {
+        sceneId: string;
+        blockId: string;
+        actionId: string;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "removeAction";
+    data: {
+        sceneId: string;
+        blockId: string;
+        actionId: string;
+    };
+}, {
+    action: "removeAction";
+    data: {
+        sceneId: string;
+        blockId: string;
+        actionId: string;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"manageVariables">;
+    data: z.ZodObject<{
+        operation: z.ZodString;
+        name: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodUnknown>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        operation: z.ZodString;
+        name: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        operation: z.ZodString;
+        name: z.ZodString;
+        defaultValue: z.ZodOptional<z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    action: "manageVariables";
+    data: {
+        operation: string;
+        name: string;
+        defaultValue?: unknown;
+    } & {
+        [k: string]: unknown;
+    };
+}, {
+    action: "manageVariables";
+    data: {
+        operation: string;
+        name: string;
+        defaultValue?: unknown;
+    } & {
+        [k: string]: unknown;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"configureTimer">;
+    data: z.ZodObject<{
+        scope: z.ZodOptional<z.ZodString>;
+        sceneId: z.ZodOptional<z.ZodString>;
+        blockId: z.ZodOptional<z.ZodString>;
+        hasTimer: z.ZodOptional<z.ZodBoolean>;
+        timer: z.ZodOptional<z.ZodUnknown>;
+    }, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+        scope: z.ZodOptional<z.ZodString>;
+        sceneId: z.ZodOptional<z.ZodString>;
+        blockId: z.ZodOptional<z.ZodString>;
+        hasTimer: z.ZodOptional<z.ZodBoolean>;
+        timer: z.ZodOptional<z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+        scope: z.ZodOptional<z.ZodString>;
+        sceneId: z.ZodOptional<z.ZodString>;
+        blockId: z.ZodOptional<z.ZodString>;
+        hasTimer: z.ZodOptional<z.ZodBoolean>;
+        timer: z.ZodOptional<z.ZodUnknown>;
+    }, z.ZodTypeAny, "passthrough">>;
+}, "strip", z.ZodTypeAny, {
+    action: "configureTimer";
+    data: {
+        sceneId?: string | undefined;
+        blockId?: string | undefined;
+        scope?: string | undefined;
+        hasTimer?: boolean | undefined;
+        timer?: unknown;
+    } & {
+        [k: string]: unknown;
+    };
+}, {
+    action: "configureTimer";
+    data: {
+        sceneId?: string | undefined;
+        blockId?: string | undefined;
+        scope?: string | undefined;
+        hasTimer?: boolean | undefined;
+        timer?: unknown;
+    } & {
+        [k: string]: unknown;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"reorderScenes">;
+    data: z.ZodObject<{
+        sceneId: z.ZodString;
+        newIndex: z.ZodNumber;
+    }, "strip", z.ZodTypeAny, {
+        sceneId: string;
+        newIndex: number;
+    }, {
+        sceneId: string;
+        newIndex: number;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "reorderScenes";
+    data: {
+        sceneId: string;
+        newIndex: number;
+    };
+}, {
+    action: "reorderScenes";
+    data: {
+        sceneId: string;
+        newIndex: number;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"insertItem">;
+    data: z.ZodObject<{
+        sceneId: z.ZodOptional<z.ZodString>;
+        blockId: z.ZodString;
+        collection: z.ZodString;
+        item: z.ZodUnknown;
+        at: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        blockId: string;
+        collection: string;
+        sceneId?: string | undefined;
+        item?: unknown;
+        at?: number | undefined;
+    }, {
+        blockId: string;
+        collection: string;
+        sceneId?: string | undefined;
+        item?: unknown;
+        at?: number | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "insertItem";
+    data: {
+        blockId: string;
+        collection: string;
+        sceneId?: string | undefined;
+        item?: unknown;
+        at?: number | undefined;
+    };
+}, {
+    action: "insertItem";
+    data: {
+        blockId: string;
+        collection: string;
+        sceneId?: string | undefined;
+        item?: unknown;
+        at?: number | undefined;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"updateItem">;
+    data: z.ZodObject<{
+        sceneId: z.ZodOptional<z.ZodString>;
+        blockId: z.ZodString;
+        collection: z.ZodString;
+        itemId: z.ZodString;
+        item: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        blockId: string;
+        collection: string;
+        itemId: string;
+        sceneId?: string | undefined;
+        item?: unknown;
+    }, {
+        blockId: string;
+        collection: string;
+        itemId: string;
+        sceneId?: string | undefined;
+        item?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "updateItem";
+    data: {
+        blockId: string;
+        collection: string;
+        itemId: string;
+        sceneId?: string | undefined;
+        item?: unknown;
+    };
+}, {
+    action: "updateItem";
+    data: {
+        blockId: string;
+        collection: string;
+        itemId: string;
+        sceneId?: string | undefined;
+        item?: unknown;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"deleteItem">;
+    data: z.ZodObject<{
+        sceneId: z.ZodOptional<z.ZodString>;
+        blockId: z.ZodString;
+        collection: z.ZodString;
+        itemId: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        blockId: string;
+        collection: string;
+        itemId: string;
+        sceneId?: string | undefined;
+    }, {
+        blockId: string;
+        collection: string;
+        itemId: string;
+        sceneId?: string | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "deleteItem";
+    data: {
+        blockId: string;
+        collection: string;
+        itemId: string;
+        sceneId?: string | undefined;
+    };
+}, {
+    action: "deleteItem";
+    data: {
+        blockId: string;
+        collection: string;
+        itemId: string;
+        sceneId?: string | undefined;
+    };
+}>, z.ZodObject<{
+    action: z.ZodLiteral<"replaceActivity">;
+    data: z.ZodObject<{
+        activity: z.ZodUnknown;
+    }, "strip", z.ZodTypeAny, {
+        activity?: unknown;
+    }, {
+        activity?: unknown;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    action: "replaceActivity";
+    data: {
+        activity?: unknown;
+    };
+}, {
+    action: "replaceActivity";
+    data: {
+        activity?: unknown;
+    };
+}>]>;
+type CanvasOp = z.infer<typeof CanvasOpSchema>;
+
+/**
+ * Semantic (content-aware) canvas-op validation, layered on top of
+ * `CanvasOpSchema`'s structural check. Deliberately does NOT import
+ * `@edugate/types` or any concrete block registry — it receives a narrow
+ * VIEW of the registry instead (dependency inversion), so this package stays
+ * decoupled from the builder's block catalog and callers (the Dify proxy
+ * route, the client) can wire in whatever registry instance they hold without
+ * this package needing to know it exists. Only `zod` is a hard dependency.
+ *
+ * Two-tier validation:
+ *   1. Structural (`CanvasOpSchema.safeParse`) — is this a well-formed op for
+ *      its action? Runs unconditionally.
+ *   2. Semantic — does `block.type` / `collection` / item payload actually
+ *      match what the registry knows? Only runs when the caller supplies
+ *      enough context (a registry view, and for item ops a
+ *      `resolveBlockType`). Missing context means "skip", never "fail" — this
+ *      validator must never produce a false positive by rejecting an op it
+ *      lacks the information to judge.
+ */
+interface BlockRegistryView {
+    /** Content schema for a block type, or undefined if the type is unknown. */
+    getContentSchema(type: string): z.ZodTypeAny | undefined;
+    /** Item schema for one collection (e.g. quiz "questions"), or undefined if
+     * the block type or the collection name is unknown. */
+    getCollectionSchema(type: string, collection: string): z.ZodTypeAny | undefined;
+}
+type CanvasOpValidationCode = "SHAPE_INVALID" | "UNKNOWN_BLOCK_TYPE" | "CONTENT_INVALID" | "UNKNOWN_COLLECTION" | "ITEM_INVALID";
+interface CanvasOpValidationResult {
+    ok: boolean;
+    code?: CanvasOpValidationCode;
+    errors?: string[];
+}
+/**
+ * Builds a validator function bound to a registry view and (optionally) a
+ * blockId -> block-type resolver. The resolver is optional because callers
+ * validating an op BEFORE the block exists on the canvas (or without access
+ * to canvas state) have no way to resolve `blockId` to a type — in that case
+ * item-op and updateBlock semantic checks are skipped (best-effort), and only
+ * the structural check + addBlock's self-contained type/content check apply.
+ */
+declare function createCanvasOpValidator(registry: BlockRegistryView, resolveBlockType?: (blockId: string) => string | undefined): (op: unknown) => CanvasOpValidationResult;
+
 /**
  * Optimistic-concurrency conflict detection for canvas ops (Phase 7).
  *
@@ -92,59 +685,6 @@ declare function opConflictStamp(action: string, data: any, baseScenes: any[]):
     baseSignature: string | null;
 };
 
-/**
- * @-mention ("tag") resolution — turn the builder's `@[Name|UUID]` tags into an
- * AUTHORITATIVE target the agents can actually consume.
- *
- * Root cause (see docs/ai-tag-context-and-quiz-styling-rootcause.md): the builder
- * inserts a literal `@[Name|UUID]` into the message text, but NOTHING resolved it —
- * the only structured target the agents received was `selectedBlockId` (the CLICKED
- * block). Tagging ≠ selecting, so a tagged-but-not-selected block (e.g. a Quiz the
- * user wants to style) was effectively ignored and mis-targeted.
- *
- * This module is PURE (no I/O): given the message text and the activity, it strips
- * the tag noise to readable names and returns the entities that actually exist, so
- * the route can promote them to the request target and surface them in [CONTEXT].
- */
-/** A `@[Name|UUID]` reference resolved against the activity. */
-interface ResolvedEntity {
-    id: string;
-    name: string;
-    kind: "scene" | "block";
-    /** Present for blocks. */
-    blockType?: string;
-    /** The scene that contains the block (present for blocks). */
-    sceneId?: string;
-}
-interface MentionResolution {
-    /** The text with every `@[Name|UUID]` replaced by the bare `Name`. For display
-     *  or any place where the literal name is wanted. */
-    cleanedText: string;
-    /**
-     * The text to send to the AGENT PIPELINE (router + specialists). Each mention is
-     * replaced by a NEUTRAL DEICTIC ("il blocco selezionato" / "la scena selezionata")
-     * instead of the entity name. Rationale: the small routing model keyword-matches
-     * intent, and a tagged block whose name happens to read as a command — e.g. the
-     * default "Nuovo blocco quiz vuoto" ("new empty quiz block") — was mis-parsed as
-     * an `add_block` intent, creating a phantom block. The authoritative name + ID
-     * still travel in [CONTEXT] (referencedEntities), so nothing is lost.
-     */
-    agentText: string;
-    /** De-duplicated entities that exist in the activity (unknown UUIDs dropped). */
-    entities: ResolvedEntity[];
-}
-/** Raw `{name,id}` pairs as written in the text (no validation). */
-declare function parseMentions(text: string): {
-    name: string;
-    id: string;
-}[];
-/**
- * Resolve mentions against an `activity` ({ scenes: [{ id, blocks: [{ id, type }] }] }).
- * Strips every tag to its readable name; collects the ones whose UUID matches a real
- * scene/block. Pure and deterministic.
- */
-declare function resolveMentions(text: string, activity: any): MentionResolution;
-
 declare const BLOCK_TYPES: readonly ["Quiz", "Editor", "Hotpoint", "Embed", "Media", "DragAndDrop", "Anagram", "Dice", "Crossword", "WordSearch", "Puzzle", "Memory", "Flashcard", "SpinningWheel", "Chart", "MatchPairs", "Shape", "Arrow", "Cloze", "CardDeck"];
 declare const BlockTypeSchema: z.ZodEnum<["Quiz", "Editor", "Hotpoint", "Embed", "Media", "DragAndDrop", "Anagram", "Dice", "Crossword", "WordSearch", "Puzzle", "Memory", "Flashcard", "SpinningWheel", "Chart", "MatchPairs", "Shape", "Arrow", "Cloze", "CardDeck"]>;
 type BlockType = z.infer<typeof BlockTypeSchema>;
@@ -25969,6 +26509,111 @@ interface AIState {
 }
 declare const SceneTypeSchema: z.ZodEnum<["2D", "360°"]>;
 type SceneType = z.infer<typeof SceneTypeSchema>;
+declare const baseBlockShape: {
+    id: z.ZodString;
+    type: z.ZodEnum<["Quiz", "Editor", "Hotpoint", "Embed", "Media", "DragAndDrop", "Anagram", "Dice", "Crossword", "WordSearch", "Puzzle", "Memory", "Flashcard", "SpinningWheel", "Chart", "MatchPairs", "Shape", "Arrow", "Cloze", "CardDeck"]>;
+    title: z.ZodString;
+    showTitle: z.ZodOptional<z.ZodBoolean>;
+    locked: z.ZodOptional<z.ZodBoolean>;
+    groupId: z.ZodOptional<z.ZodString>;
+    position: z.ZodOptional<z.ZodObject<{
+        x: z.ZodNumber;
+        y: z.ZodNumber;
+        z: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    }, {
+        x: number;
+        y: number;
+        z?: number | undefined;
+    }>>;
+    rotation: z.ZodNumber;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    draggable: z.ZodOptional<z.ZodBoolean>;
+    size: z.ZodOptional<z.ZodObject<{
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        width?: number | undefined;
+        height?: number | undefined;
+    }, {
+        width?: number | undefined;
+        height?: number | undefined;
+    }>>;
+    minSize: z.ZodOptional<z.ZodObject<{
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        width?: number | undefined;
+        height?: number | undefined;
+    }, {
+        width?: number | undefined;
+        height?: number | undefined;
+    }>>;
+    maxSize: z.ZodOptional<z.ZodObject<{
+        width: z.ZodOptional<z.ZodNumber>;
+        height: z.ZodOptional<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        width?: number | undefined;
+        height?: number | undefined;
+    }, {
+        width?: number | undefined;
+        height?: number | undefined;
+    }>>;
+    theme: z.ZodOptional<z.ZodObject<{
+        spacing: z.ZodOptional<z.ZodEnum<["no-spacing", "small", "medium", "large"]>>;
+        animation: z.ZodOptional<z.ZodObject<{
+            type: z.ZodUnion<[z.ZodEnum<["none", "fade", "direction", "bounce", "scale", "rotate"]>, z.ZodString]>;
+            duration: z.ZodOptional<z.ZodNumber>;
+            delay: z.ZodOptional<z.ZodNumber>;
+            phase: z.ZodOptional<z.ZodEnum<["in", "both", "out"]>>;
+            direction: z.ZodOptional<z.ZodEnum<["up", "right", "down", "left"]>>;
+        }, "strip", z.ZodTypeAny, {
+            type: string;
+            duration?: number | undefined;
+            direction?: "up" | "right" | "down" | "left" | undefined;
+            delay?: number | undefined;
+            phase?: "in" | "both" | "out" | undefined;
+        }, {
+            type: string;
+            duration?: number | undefined;
+            direction?: "up" | "right" | "down" | "left" | undefined;
+            delay?: number | undefined;
+            phase?: "in" | "both" | "out" | undefined;
+        }>>;
+        styles: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, "strip", z.ZodTypeAny, {
+        spacing?: "small" | "no-spacing" | "medium" | "large" | undefined;
+        animation?: {
+            type: string;
+            duration?: number | undefined;
+            direction?: "up" | "right" | "down" | "left" | undefined;
+            delay?: number | undefined;
+            phase?: "in" | "both" | "out" | undefined;
+        } | undefined;
+        styles?: Record<string, Record<string, any>> | undefined;
+    }, {
+        spacing?: "small" | "no-spacing" | "medium" | "large" | undefined;
+        animation?: {
+            type: string;
+            duration?: number | undefined;
+            direction?: "up" | "right" | "down" | "left" | undefined;
+            delay?: number | undefined;
+            phase?: "in" | "both" | "out" | undefined;
+        } | undefined;
+        styles?: Record<string, Record<string, any>> | undefined;
+    }>>;
+};
+/**
+ * The base-block plumbing keys every block carries (identity, geometry,
+ * theme...) — editor concerns, not authorable content. Single source for
+ * consumers that need a content-only projection of a canonical block schema
+ * (e.g. `QuizBlockSchema.omit(...)` for an AI tool input): derived from
+ * baseBlockShape itself so it can never drift from the real schemas.
+ */
+declare const BASE_BLOCK_FIELDS: readonly (keyof typeof baseBlockShape)[];
 declare const ActionBlockSchema: z.ZodObject<{
     actions: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
@@ -68793,6 +69438,7 @@ type Scene = z.infer<typeof SceneSchema>;
 declare const ActivityContentSchema: z.ZodObject<{
     id: z.ZodString;
     title: z.ZodString;
+    schemaVersion: z.ZodOptional<z.ZodNumber>;
     hasTimer: z.ZodBoolean;
     timer: z.ZodOptional<z.ZodString>;
     allowNavigation: z.ZodBoolean;
@@ -69348,6 +69994,7 @@ declare const ActivityContentSchema: z.ZodObject<{
         scenes?: string | undefined;
     }[] | undefined;
     timer?: string | undefined;
+    schemaVersion?: number | undefined;
     variables?: {
         name: string;
         defaultValue: string | number | boolean;
@@ -69445,6 +70092,7 @@ declare const ActivityContentSchema: z.ZodObject<{
         scenes?: string | undefined;
     }[] | undefined;
     timer?: string | undefined;
+    schemaVersion?: number | undefined;
     variables?: {
         name: string;
         defaultValue: string | number | boolean;
@@ -77834,16 +78482,304 @@ declare const BasicContentSchema: z.ZodObject<{
 type BasicContent = z.infer<typeof BasicContentSchema>;
 
 /**
- * Map of block type → content schema used for prompt reference generation.
- * Adding a new block type means: add Zod schema + register here + (optionally)
- * add MCP tool wiring. Agent prompts stay in sync automatically.
+ * Map of block type → content schema used for prompt reference generation and
+ * the published AI JSON-schema factory (@edugate/ai-agent).
+ *
+ * Now derived from BLOCK_REGISTRY: every entry IS the canonical block schema
+ * from ./blocks.ts — the same one the editor, player and store validate
+ * against. This replaces the second, hand-written AI-facing schema system
+ * (content/*.ts), which had structurally drifted from the editor's real
+ * schemas (incompatible Question shapes, 18/20 coverage). The content/*.ts
+ * schemas stay exported for backward compatibility but are deprecated and no
+ * longer feed any AI surface.
  */
-declare const BLOCK_CONTENT_SCHEMAS: Record<string, z.ZodTypeAny>;
+declare const BLOCK_CONTENT_SCHEMAS: Record<BlockType, z.ZodTypeAny>;
+interface BlockReferenceOptions {
+    /**
+     * Omit the shared base-block plumbing (id, geometry, theme...; the
+     * BASE_BLOCK_FIELDS) so the reference covers only each block's authorable
+     * content. The full canonical reference weighs ~95KB — far too heavy to
+     * inject into a system prompt every turn; the content-only view is what
+     * agent prompts should use.
+     */
+    contentOnly?: boolean;
+}
 /**
  * Generates a human-readable Markdown reference of all block content
  * schemas, suitable for injection into agent system prompts.
  */
-declare function generateBlockReference(): string;
+declare function generateBlockReference(options?: BlockReferenceOptions): string;
+
+/**
+ * The per-block-type contract every entry of BLOCK_REGISTRY must satisfy.
+ *
+ * A definition WRAPS the existing canonical Zod schema from ../blocks.ts — it
+ * never redefines it. Everything the rest of the system needs to know about a
+ * block type (schema, defaults, capabilities, versioning) is declared here
+ * once; the hand-maintained parallel registries (BLOCK_CONTENT_SCHEMAS, the
+ * named Block union, STYLE_TARGET_MAP, …) become derivations of this registry.
+ */
+interface BlockCapabilities {
+    /** actionBlockShape vs baseBlockShape: does the block carry actions[] + score? */
+    hasActions: boolean;
+    hasScore: boolean;
+    /**
+     * Nested collections the AI canvas ops insertItem/updateItem/deleteItem may
+     * manipulate (e.g. { questions: QuestionSchema } for Quiz). A collection name
+     * not declared here is unknown to the semantic canvas-op validator, so a typo
+     * becomes a structured error instead of a silent no-op.
+     */
+    collections?: Record<string, z.ZodTypeAny>;
+    /**
+     * Logical style target → REAL style keys the block's renderer reads (same
+     * nested shape as STYLE_TARGET_MAP in ../style-targets.ts). The nested shape
+     * is load-bearing: styleTargetsHelpFor / mapLogicalThemeStyles depend on the
+     * logical→real mapping, not on a flat key list. Undefined = block is not
+     * styleable via logical targets (see UNSTYLEABLE_BLOCKS).
+     */
+    styleTargets?: Partial<Record<LogicalTarget, string[]>>;
+    /** How the 360° scene renders this block; replaces the silent raster fallback switch. */
+    vrMode: "interactive" | "raster" | "custom";
+    analytics?: {
+        scorable: boolean;
+    };
+}
+interface BlockCoreDefinition<TType extends BlockType, TContent extends z.ZodTypeAny, TTheme extends z.ZodTypeAny = never> {
+    type: TType;
+    /** The canonical schema from ../blocks.ts — reused, never rewritten. */
+    contentSchema: TContent;
+    themeSchema?: TTheme;
+    /**
+     * Checked by a generated test: contentSchema.parse(defaultContent) must not
+     * throw. `id` is a placeholder ("") replaced with a nanoid at instantiation
+     * time — the schema enforces shape, not uniqueness, so "" is valid there.
+     */
+    defaultContent: z.infer<TContent>;
+    capabilities: BlockCapabilities;
+    /** Content-schema version of THIS block type (migration pipeline, D4). */
+    version: number;
+    /** Migrations vN → vN+1, keyed by the STARTING version. */
+    migrations?: Record<number, (old: unknown) => unknown>;
+    /**
+     * Optional AI-facing projection: fields to omit from the JSON schema shown
+     * to agents (e.g. editor-only fields). Default: expose the full canonical
+     * schema. This is a projection of the ONE schema — never a second schema.
+     */
+    aiProjection?: {
+        omit: readonly string[];
+    };
+}
+
+/**
+ * Typed identity function over the registry contract: it builds no runtime
+ * block instances — it forces the caller to provide every required field of
+ * BlockCoreDefinition while preserving the literal types (the `satisfies`
+ * pattern, for a value that is also exported with a reusable explicit type).
+ * A definition missing e.g. capabilities.vrMode does not compile.
+ */
+declare function defineBlock<TType extends BlockType, TContent extends z.ZodTypeAny, TTheme extends z.ZodTypeAny = never>(def: BlockCoreDefinition<TType, TContent, TTheme>): BlockCoreDefinition<TType, TContent, TTheme>;
+
+/**
+ * The single point of declaration for everything the system knows about a
+ * block type. Mapped type over BlockType, NOT Record<string, …>: omitting an
+ * entry here is a COMPILE error (TS2741), not a silent hole like the old
+ * hand-maintained maps (BLOCK_CONTENT_SCHEMAS covered 18/20 types for months
+ * before anyone noticed).
+ *
+ * Every hand-maintained parallel view (the AI content-schema map, the style
+ * target map, …) must be derived from this registry — see ./derived.ts.
+ */
+declare const BLOCK_REGISTRY: {
+    [K in BlockType]: BlockCoreDefinition<K, z.ZodTypeAny, z.ZodTypeAny>;
+};
+declare function getBlockDefinition<T extends BlockType>(type: T): BlockCoreDefinition<T, z.ZodTypeAny, z.ZodTypeAny>;
+
+/**
+ * Views DERIVED from BLOCK_REGISTRY — successors of the hand-maintained
+ * parallel maps. They cannot drift: the registry is exhaustive by mapped type,
+ * so a new BlockType that lacks a definition breaks the build before any of
+ * these can silently miss it.
+ *
+ * NOTE: the BlockSchema discriminated union itself intentionally stays
+ * declared in ../blocks.ts — SceneSchema composes it in the same module, so
+ * deriving it here would create a blocks.ts ⇄ registry import cycle (TDZ at
+ * module init). Drift between the union and the registry is instead made
+ * impossible by the referential-identity test in
+ * __tests__/registry.consistency.spec.ts (union options === registry schemas).
+ */
+/**
+ * Block type → canonical content schema, straight from the registry.
+ * Successor of the AI-facing BLOCK_CONTENT_SCHEMAS in ../docs.ts (which was a
+ * second, hand-written schema system that drifted from the editor's real
+ * schemas — incompatible Question shapes, 18/20 coverage).
+ */
+declare const REGISTRY_CONTENT_SCHEMAS: {
+    [K in BlockType]: z.ZodTypeAny;
+};
+/**
+ * Block type → logical style-target map, from capabilities.styleTargets.
+ * Successor of the hand-written STYLE_TARGET_MAP rows in ../style-targets.ts
+ * (kept API-compatible there for the published npm surface; a consistency test
+ * pins the two together until the legacy map is physically replaced).
+ *
+ * Known PRE-EXISTING gaps carried over as-is, not regressions of this
+ * refactor: Embed and Arrow have no logical style targets (absent from the
+ * legacy map without being listed in UNSTYLEABLE_BLOCKS either).
+ */
+declare const REGISTRY_STYLE_TARGETS: {
+    [K in BlockType]: Partial<Record<LogicalTarget, string[]>>;
+};
+
+declare const CURRENT_SCHEMA_VERSION = 1;
+declare class ActivityContentMigrationError extends Error {
+    constructor(message: string);
+}
+/**
+ * The subset of BlockCoreDefinition the pipeline needs, keyed by block type.
+ * Matches BLOCK_REGISTRY's shape but is intentionally loose (not the mapped
+ * BlockType-exhaustive type BLOCK_REGISTRY itself has) so tests can pass a
+ * partial/mock registry — e.g. to exercise a multi-step migration chain
+ * without depending on a real block type ever reaching version 3.
+ */
+type MigrationRegistry = Record<string, {
+    version: number;
+    migrations?: Record<number, (old: unknown) => unknown>;
+}>;
+interface MigrateActivityContentResult {
+    content: ActivityContent;
+    changed: boolean;
+    issues: string[];
+}
+/**
+ * Migrates a raw (untyped, possibly historical) activity content blob to the
+ * current schema shape. Pure function — never mutates `raw`; every level it
+ * touches is cloned.
+ *
+ * Deliberately does NOT zod-parse the result before returning it: validating
+ * the migrated shape against ActivityContentSchema is the responsibility of
+ * whatever boundary calls this pipeline (Fase 3 wiring, not this library) —
+ * keeping that decision out of here means this stays usable for offline
+ * inspection/dry-run tooling that wants to see `issues` even when the result
+ * wouldn't (yet) pass strict validation.
+ *
+ * @param raw content as read from storage (e.g. an activities.content jsonb
+ *   column) — v0 (schemaVersion missing/undefined) is the implicit starting
+ *   point for content that predates versioning entirely.
+ * @param registry block-type → definition lookup; defaults to the real
+ *   BLOCK_REGISTRY. Overridable for testing.
+ */
+declare function migrateActivityContent(raw: unknown, registry?: MigrationRegistry): MigrateActivityContentResult;
+
+/**
+ * v1 → v2 migration for block content built on actionBlockShape (every block
+ * that carries `actions[]` — Quiz, Hotpoint, Editor, DragAndDrop, Anagram,
+ * Dice, Puzzle, Crossword, WordSearch, Memory, Flashcard, SpinningWheel,
+ * Chart, MatchPairs, Cloze, CardDeck).
+ *
+ * Collapses the legacy single `condition` field on an Action into the
+ * `conditions[]` array that now coexists with it on ActionSchema (see
+ * packages/types/src/builder/actions.ts). Today the UI normalizes this ad hoc
+ * in forms/panels/action.tsx and strips `condition` on submit — that
+ * normalization is untouched by this migration and keeps doing its job for
+ * content written through the editor.
+ *
+ * NOT registered on any BlockCoreDefinition yet, and no definition's
+ * `version` is bumped to 2 here — that adoption step is deliberately
+ * deferred until a real prod content sample has validated this transform.
+ * To adopt it once validated, on the relevant block definition(s):
+ *
+ *   migrations: { 1: actionsV1toV2 },
+ *   version: 2,
+ *
+ * Pure function: never mutates `old`. Malformed input (not an object, no
+ * actions[], actions entries that aren't objects) is returned unchanged
+ * rather than throwing — the migration pipeline calls this per-block on
+ * historical data that may not conform to any current schema.
+ */
+declare const actionsV1toV2: (old: unknown) => unknown;
+
+/**
+ * Machine-readable capabilities manifest for external agents (Dify tools,
+ * edugate-agents). Closes the "external agents guess collections and style
+ * targets" gap: STYLE_TARGET_MAP used to be copied by hand across repos and
+ * silently went stale — this is generated from BLOCK_REGISTRY instead.
+ *
+ * PLAIN DATA ONLY, by design rule: the published npm surface exchanges JSON
+ * Schema objects, op payloads and verdicts — never live Zod schema instances
+ * (a consumer resolving its own zod copy would get schemas whose identity
+ * doesn't match the bundled one). Collections are therefore exposed as key
+ * NAMES; the per-item schemas stay internal to the validation functions.
+ */
+interface BlockCapabilitiesManifestEntry {
+    type: BlockType;
+    /** Content-schema version of this block type (migration pipeline, D4). */
+    version: number;
+    hasActions: boolean;
+    hasScore: boolean;
+    /** Names of the collections insertItem/updateItem/deleteItem may target. */
+    collections: string[];
+    /**
+     * Logical style target → REAL style keys the block's renderer reads (same
+     * nested shape as capabilities.styleTargets). Empty object = the block is
+     * not styleable via logical targets.
+     */
+    styleTargets: Partial<Record<LogicalTarget, string[]>>;
+    vrMode: "interactive" | "raster" | "custom";
+}
+declare function getCapabilitiesManifest(): BlockCapabilitiesManifestEntry[];
+
+/**
+ * @-mention ("tag") resolution — turn the builder's `@[Name|UUID]` tags into an
+ * AUTHORITATIVE target the agents can actually consume.
+ *
+ * Root cause (see docs/ai-tag-context-and-quiz-styling-rootcause.md): the builder
+ * inserts a literal `@[Name|UUID]` into the message text, but NOTHING resolved it —
+ * the only structured target the agents received was `selectedBlockId` (the CLICKED
+ * block). Tagging ≠ selecting, so a tagged-but-not-selected block (e.g. a Quiz the
+ * user wants to style) was effectively ignored and mis-targeted.
+ *
+ * This module is PURE (no I/O): given the message text and the activity, it strips
+ * the tag noise to readable names and returns the entities that actually exist, so
+ * the route can promote them to the request target and surface them in [CONTEXT].
+ */
+/** A `@[Name|UUID]` reference resolved against the activity. */
+interface ResolvedEntity {
+    id: string;
+    name: string;
+    kind: "scene" | "block";
+    /** Present for blocks. */
+    blockType?: string;
+    /** The scene that contains the block (present for blocks). */
+    sceneId?: string;
+}
+interface MentionResolution {
+    /** The text with every `@[Name|UUID]` replaced by the bare `Name`. For display
+     *  or any place where the literal name is wanted. */
+    cleanedText: string;
+    /**
+     * The text to send to the AGENT PIPELINE (router + specialists). Each mention is
+     * replaced by a NEUTRAL DEICTIC ("il blocco selezionato" / "la scena selezionata")
+     * instead of the entity name. Rationale: the small routing model keyword-matches
+     * intent, and a tagged block whose name happens to read as a command — e.g. the
+     * default "Nuovo blocco quiz vuoto" ("new empty quiz block") — was mis-parsed as
+     * an `add_block` intent, creating a phantom block. The authoritative name + ID
+     * still travel in [CONTEXT] (referencedEntities), so nothing is lost.
+     */
+    agentText: string;
+    /** De-duplicated entities that exist in the activity (unknown UUIDs dropped). */
+    entities: ResolvedEntity[];
+}
+/** Raw `{name,id}` pairs as written in the text (no validation). */
+declare function parseMentions(text: string): {
+    name: string;
+    id: string;
+}[];
+/**
+ * Resolve mentions against an `activity` ({ scenes: [{ id, blocks: [{ id, type }] }] }).
+ * Strips every tag to its readable name; collects the ones whose UUID matches a real
+ * scene/block. Pure and deterministic.
+ */
+declare function resolveMentions(text: string, activity: any): MentionResolution;
 
 declare function listBlockTypes(): string[];
 /**
@@ -77863,4 +78799,4 @@ declare function getBlockJsonSchema(blockType: string): Record<string, unknown>
  */
 declare function getAllBlockJsonSchemas(): Record<string, Record<string, unknown>>;
 
-export { type AIState, type Action, type ActionBlock, ActionBlockSchema, type ActionCondition, ActionConditionSchema, ActionSchema, type ActionType, ActionTypeSchema, type ActionVariable, ActionVariableSchema, type ActivityContent, ActivityContentSchema, type ActivityContext, ActivityContextSchema, type ActivityVariable, ActivityVariableSchema, type AnagramBlock, AnagramBlockSchema, type AnagramBlockTheme, AnagramBlockThemeSchema, type AnagramContent, AnagramContentSchema, type Animation, AnimationSchema, type ArrowBlock, ArrowBlockSchema, type ArrowHeadType, ArrowHeadTypeSchema, type ArrowLabel, ArrowLabelSchema, BLOCK_CONTENT_SCHEMAS, BLOCK_STYLE_KEYS, BLOCK_TYPES, type BasicContent, BasicContentSchema, type Block, type BlockEvent, BlockEventSchema, type BlockEventType, BlockEventTypeSchema, type BlockGroup, BlockGroupSchema, BlockSchema, type BlockTheme, BlockThemeSchema, type BlockType, BlockTypeSchema, type BoxSide, BoxSideSchema, type BoxStyles, BoxStylesSchema, CANVAS_OP_NAMES, CANVAS_OP_REQUIRED, type CanvasDragItem, CanvasDragItemSchema, type CanvasOpErrorCode, type CanvasOpValidation, type Card, type CardDeckBlock, CardDeckBlockSchema, type CardDeckBlockTheme, CardDeckBlockThemeSchema, type CardFace, CardFaceSchema, type CardItem, CardItemSchema, CardSchema, type ChartBlock, ChartBlockSchema, type ChartConfig, ChartConfigSchema, type ChartContent, ChartContentSchema, type ChartType, ChartTypeSchema, type ChoiceQuestion, ChoiceQuestionSchema, type ClickCondition, ClickConditionSchema, type ClozeBlock, ClozeBlockSchema, type ClozeBlockTheme, ClozeBlockThemeSchema, type ClozeContent, ClozeContentSchema, type ClozeMode, ClozeModeSchema, type ConditionOperator, ConditionOperatorSchema, type ConflictVerdict, type CropData, CropDataSchema, type CrosswordBlock, CrosswordBlockSchema, type CrosswordBlockTheme, CrosswordBlockThemeSchema, type CrosswordCell, CrosswordCellSchema, type CrosswordContent, CrosswordContentSchema, type CrosswordLayoutOutput, CrosswordLayoutOutputSchema, type CrosswordLayoutWord, CrosswordLayoutWordSchema, type CrosswordWord, CrosswordWordSchema, type DeckBlockType, DeckBlockTypeSchema, type DeckContent, DeckContentSchema, type DiceBlock, DiceBlockSchema, type DiceBlockTheme, DiceBlockThemeSchema, type DiceContent, DiceContentSchema, type DiceType, DiceTypeSchema, type DieType, DieTypeSchema, type DragAndDropBlock, DragAndDropBlockSchema, type DragAndDropBlockTheme, DragAndDropBlockThemeSchema, type DragAndDropContent, DragAndDropContentSchema, type DragAndDropGroup, DragAndDropGroupSchema, DragAndDropItemSchema, type DragGroup, DragGroupSchema, type DragItem, DragItemSchema, type EditorBlock, EditorBlockSchema, type EditorBlockTheme, EditorBlockThemeSchema, type EmbedBlock, EmbedBlockSchema, type FlashcardBlock, FlashcardBlockSchema, type FlashcardBlockTheme, FlashcardBlockThemeSchema, FlashcardContentSchema, type FlashcardItem, FlashcardItemSchema, type GridSize, GridSizeSchema, type HotpointBlock, HotpointBlockSchema, type HotpointBlockTheme, HotpointBlockThemeSchema, ImageAlignSchema, ImageSizeSchema, type KeyPressCondition, KeyPressConditionSchema, type LogicalTarget, type MatchPairsBlock, MatchPairsBlockSchema, type MatchPairsBlockTheme, MatchPairsBlockThemeSchema, type MatchPairsPair, MatchPairsPairSchema, type MathOperation, MathOperationSchema, type MediaBlock, MediaBlockSchema, type MediaItem, MediaItemSchema, type MediaRef, MediaRefSchema, type MediaSource, MediaSourceSchema, type MediaType, MediaTypeSchema, type MemoryBlock, MemoryBlockSchema, type MemoryBlockTheme, MemoryBlockThemeSchema, type MemoryPair, MemoryPairSchema, type MemoryPairType, MemoryPairTypeSchema, type MentionResolution, type OpTarget, type OpTargetKind, type Pair, type PairGameBlockType, PairGameBlockTypeSchema, type PairGameContent, PairGameContentSchema, PairSchema, type Position, PositionSchema, type PuzzleBlock, PuzzleBlockSchema, type PuzzleContent, PuzzleContentSchema, type PuzzleGameMode, PuzzleGameModeSchema, type PuzzleType, PuzzleTypeSchema, type Question, type QuestionOption, QuestionOptionSchema, QuestionSchema, type QuestionType, QuestionTypeSchema, type QuizBlock, QuizBlockSchema, type QuizBlockTheme, QuizBlockThemeSchema, type QuizCondition, QuizConditionSchema, type QuizContent, QuizContentSchema, type QuizOption, QuizOptionSchema, type QuizQuestion, QuizQuestionSchema, type QuizQuestionType, QuizQuestionTypeSchema, type Radius, RadiusSchema, type ResolvedEntity, STYLE_TARGET_MAP, type Scene, type SceneBlockRef, SceneBlockRefSchema, SceneSchema, type SceneSummary, SceneSummarySchema, type SceneType, SceneTypeSchema, type ShapeBlock, ShapeBlockSchema, type ShapeBlockTheme, ShapeBlockThemeSchema, type ShapeType, ShapeTypeSchema, type Size, SizeSchema, type SpinnerContent, SpinnerContentSchema, type SpinnerSlice, SpinnerSliceSchema, type SpinningWheelBlock, SpinningWheelBlockSchema, type SpinningWheelBlockTheme, SpinningWheelBlockThemeSchema, type TextQuestion, TextQuestionSchema, type TextStyles, TextStylesSchema, type TimerCondition, TimerConditionSchema, type TrueFalseQuestion, TrueFalseQuestionSchema, UNSTYLEABLE_BLOCKS, type VideoSettings, VideoSettingsSchema, type WheelSlice, WheelSliceSchema, type WordGameBlockType, WordGameBlockTypeSchema, type WordSearchBlock, WordSearchBlockSchema, type WordSearchBlockTheme, WordSearchBlockThemeSchema, type WordSearchContent, WordSearchContentSchema, WordSearchDataSchema, type WordSearchDifficulty, WordSearchDifficultySchema, applyItemPatch, detectConflict, entitySignature, generateBlockReference, getAllBlockJsonSchemas, getBlockJsonSchema, isKnownCanvasOp, listBlockTypes, mapLogicalThemeStyles, mergeTheme, opConflictStamp, opTarget, parseMentions, realStyleKeysFor, resolveMentions, stableStringify, styleTargetsHelpFor, validateCanvasOp };
+export { type AIState, type Action, type ActionBlock, ActionBlockSchema, type ActionCondition, ActionConditionSchema, ActionSchema, type ActionType, ActionTypeSchema, type ActionVariable, ActionVariableSchema, type ActivityContent, ActivityContentMigrationError, ActivityContentSchema, type ActivityContext, ActivityContextSchema, type ActivityVariable, ActivityVariableSchema, type AnagramBlock, AnagramBlockSchema, type AnagramBlockTheme, AnagramBlockThemeSchema, type AnagramContent, AnagramContentSchema, type Animation, AnimationSchema, type ArrowBlock, ArrowBlockSchema, type ArrowHeadType, ArrowHeadTypeSchema, type ArrowLabel, ArrowLabelSchema, BASE_BLOCK_FIELDS, BLOCK_CONTENT_SCHEMAS, BLOCK_REGISTRY, BLOCK_STYLE_KEYS, BLOCK_TYPES, type BasicContent, BasicContentSchema, type Block, type BlockCapabilities, type BlockCapabilitiesManifestEntry, type BlockCoreDefinition, type BlockEvent, BlockEventSchema, type BlockEventType, BlockEventTypeSchema, type BlockGroup, BlockGroupSchema, type BlockReferenceOptions, type BlockRegistryView, BlockSchema, type BlockTheme, BlockThemeSchema, type BlockType, BlockTypeSchema, type BoxSide, BoxSideSchema, type BoxStyles, BoxStylesSchema, CANVAS_OP_NAMES, CANVAS_OP_REQUIRED, CURRENT_SCHEMA_VERSION, type CanvasDragItem, CanvasDragItemSchema, type CanvasOp, type CanvasOpErrorCode, CanvasOpSchema, type CanvasOpValidation, type CanvasOpValidationCode, type CanvasOpValidationResult, type Card, type CardDeckBlock, CardDeckBlockSchema, type CardDeckBlockTheme, CardDeckBlockThemeSchema, type CardFace, CardFaceSchema, type CardItem, CardItemSchema, CardSchema, type ChartBlock, ChartBlockSchema, type ChartConfig, ChartConfigSchema, type ChartContent, ChartContentSchema, type ChartType, ChartTypeSchema, type ChoiceQuestion, ChoiceQuestionSchema, type ClickCondition, ClickConditionSchema, type ClozeBlock, ClozeBlockSchema, type ClozeBlockTheme, ClozeBlockThemeSchema, type ClozeContent, ClozeContentSchema, type ClozeMode, ClozeModeSchema, type ConditionOperator, ConditionOperatorSchema, type ConflictVerdict, type CropData, CropDataSchema, type CrosswordBlock, CrosswordBlockSchema, type CrosswordBlockTheme, CrosswordBlockThemeSchema, type CrosswordCell, CrosswordCellSchema, type CrosswordContent, CrosswordContentSchema, type CrosswordLayoutOutput, CrosswordLayoutOutputSchema, type CrosswordLayoutWord, CrosswordLayoutWordSchema, type CrosswordWord, CrosswordWordSchema, type DeckBlockType, DeckBlockTypeSchema, type DeckContent, DeckContentSchema, type DiceBlock, DiceBlockSchema, type DiceBlockTheme, DiceBlockThemeSchema, type DiceContent, DiceContentSchema, type DiceType, DiceTypeSchema, type DieType, DieTypeSchema, type DragAndDropBlock, DragAndDropBlockSchema, type DragAndDropBlockTheme, DragAndDropBlockThemeSchema, type DragAndDropContent, DragAndDropContentSchema, type DragAndDropGroup, DragAndDropGroupSchema, DragAndDropItemSchema, type DragGroup, DragGroupSchema, type DragItem, DragItemSchema, type EditorBlock, EditorBlockSchema, type EditorBlockTheme, EditorBlockThemeSchema, type EmbedBlock, EmbedBlockSchema, type FlashcardBlock, FlashcardBlockSchema, type FlashcardBlockTheme, FlashcardBlockThemeSchema, FlashcardContentSchema, type FlashcardItem, FlashcardItemSchema, type GridSize, GridSizeSchema, type HotpointBlock, HotpointBlockSchema, type HotpointBlockTheme, HotpointBlockThemeSchema, ImageAlignSchema, ImageSizeSchema, type KeyPressCondition, KeyPressConditionSchema, type LogicalTarget, type MatchPairsBlock, MatchPairsBlockSchema, type MatchPairsBlockTheme, MatchPairsBlockThemeSchema, type MatchPairsPair, MatchPairsPairSchema, type MathOperation, MathOperationSchema, type MediaBlock, MediaBlockSchema, type MediaItem, MediaItemSchema, type MediaRef, MediaRefSchema, type MediaSource, MediaSourceSchema, type MediaType, MediaTypeSchema, type MemoryBlock, MemoryBlockSchema, type MemoryBlockTheme, MemoryBlockThemeSchema, type MemoryPair, MemoryPairSchema, type MemoryPairType, MemoryPairTypeSchema, type MentionResolution, type MigrateActivityContentResult, type MigrationRegistry, type OpTarget, type OpTargetKind, type Pair, type PairGameBlockType, PairGameBlockTypeSchema, type PairGameContent, PairGameContentSchema, PairSchema, type Position, PositionSchema, type PuzzleBlock, PuzzleBlockSchema, type PuzzleContent, PuzzleContentSchema, type PuzzleGameMode, PuzzleGameModeSchema, type PuzzleType, PuzzleTypeSchema, type Question, type QuestionOption, QuestionOptionSchema, QuestionSchema, type QuestionType, QuestionTypeSchema, type QuizBlock, QuizBlockSchema, type QuizBlockTheme, QuizBlockThemeSchema, type QuizCondition, QuizConditionSchema, type QuizContent, QuizContentSchema, type QuizOption, QuizOptionSchema, type QuizQuestion, QuizQuestionSchema, type QuizQuestionType, QuizQuestionTypeSchema, REGISTRY_CONTENT_SCHEMAS, REGISTRY_STYLE_TARGETS, type Radius, RadiusSchema, type ResolvedEntity, STYLE_TARGET_MAP, type Scene, type SceneBlockRef, SceneBlockRefSchema, SceneSchema, type SceneSummary, SceneSummarySchema, type SceneType, SceneTypeSchema, type ShapeBlock, ShapeBlockSchema, type ShapeBlockTheme, ShapeBlockThemeSchema, type ShapeType, ShapeTypeSchema, type Size, SizeSchema, type SpinnerContent, SpinnerContentSchema, type SpinnerSlice, SpinnerSliceSchema, type SpinningWheelBlock, SpinningWheelBlockSchema, type SpinningWheelBlockTheme, SpinningWheelBlockThemeSchema, type TextQuestion, TextQuestionSchema, type TextStyles, TextStylesSchema, type TimerCondition, TimerConditionSchema, type TrueFalseQuestion, TrueFalseQuestionSchema, UNSTYLEABLE_BLOCKS, type VideoSettings, VideoSettingsSchema, type WheelSlice, WheelSliceSchema, type WordGameBlockType, WordGameBlockTypeSchema, type WordSearchBlock, WordSearchBlockSchema, type WordSearchBlockTheme, WordSearchBlockThemeSchema, type WordSearchContent, WordSearchContentSchema, WordSearchDataSchema, type WordSearchDifficulty, WordSearchDifficultySchema, actionsV1toV2, applyItemPatch, createCanvasOpValidator, defineBlock, detectConflict, entitySignature, generateBlockReference, getAllBlockJsonSchemas, getBlockDefinition, getBlockJsonSchema, getCapabilitiesManifest, isKnownCanvasOp, listBlockTypes, mapLogicalThemeStyles, mergeTheme, migrateActivityContent, opConflictStamp, opTarget, parseMentions, realStyleKeysFor, resolveMentions, stableStringify, styleTargetsHelpFor, validateCanvasOp };