@instructure/platform-block-content-editor 0.3.1 → 1.1.0

package/dist/contexts/BlockEditorApiContext.d.ts

@@ -1,3 +1,4 @@
+import { ComponentType } from 'react';
 /**
  * A resolved image asset. `url` is the direct, displayable file URL (rendered
  * in `<img>`); `undefined` while loading or on error.
@@ -25,8 +26,111 @@ export interface ResolvedVideo {
     isProcessing?: boolean;
     isError: boolean;
 }
+/** The props `WidgetBlock` renders a host widget with. */
+export interface WidgetComponentProps {
+    /**
+     * The identifier the block stored, handed back so one parameterised host component
+     * can serve several widget names. Without it such a host would have to wrap the
+     * component per name, and the natural wrapper is the fresh arrow the stability rule
+     * below forbids. Optional so a host whose widgets take no props stays assignable;
+     * the block always passes it. A *change* of name remounts the widget rather than
+     * updating it in place — a different name is a different widget — so such a
+     * component reads this once and never has to transition between widgets.
+     */
+    widgetType?: string;
+}
+/**
+ * A resolved widget. `Component` is the host's own component for the requested
+ * widget; `undefined` while loading or when the host does not recognise the
+ * identifier.
+ *
+ * `Component` must be a **stable reference** for a given `widgetType` — resolve it
+ * from a module-level map, not an arrow function built inside the hook. React
+ * remounts on component identity, so a fresh reference each render throws away
+ * whatever state the widget holds, on every render of the block.
+ *
+ * A widget that throws while rendering — or a `useWidget` that throws, which runs inside
+ * the same boundary — is contained to its own block, which shows the error placeholder
+ * in its place. That guard exists because the alternative is the
+ * whole page unmounting, not because the package can handle the failure: it catches
+ * only the widget and reports nowhere, so a host that wants widget failures in its
+ * telemetry keeps its own error boundary above the provider.
+ */
+export interface ResolvedWidget {
+    Component?: ComponentType<WidgetComponentProps>;
+    isLoading: boolean;
+    isError: boolean;
+}
 export type UseImageUrl = (assetId: string) => ResolvedImage;
 export type UseVideoUrl = (assetId: string) => ResolvedVideo;
+/**
+ * `widgetType` is an opaque host identifier, like an `assetId`: the package never
+ * owns the vocabulary of widget names, so an unrecognised one is an error result,
+ * not an invalid value.
+ */
+export type UseWidget = (widgetType: string) => ResolvedWidget;
+/**
+ * A resolved uploaded file, as the settings-form uploaders need it for their *preview*
+ * (not the block's rendered/embed URL — that's `useImageUrl`/`useVideoUrl`). `url` is the
+ * displayable file URL; `displayName` labels the preview. For a video still processing,
+ * `mediaEntryId` may be absent and `isProcessing` true. `undefined`/false flags with a
+ * populated `url` means "ready".
+ */
+export interface ResolvedUploadedFile {
+    url?: string;
+    displayName?: string;
+    mediaEntryId?: string;
+    isLoading: boolean;
+    isProcessing?: boolean;
+    isError: boolean;
+}
+/** Resolve an `asset_id` to its uploaded-file preview data. `''` = nothing to resolve. */
+export type UseUploadedFile = (assetId: string) => ResolvedUploadedFile;
+/** Arguments the uploader hands the host's create-file mutation. */
+export interface CreateFileArgs {
+    file: File;
+    displayName?: string;
+}
+/**
+ * The host's file-upload mutation. The package passes only `{ file, displayName }` and
+ * stores the returned `id` as the block's `asset_id`; all host scoping (course/account,
+ * folder resolution, entity type) lives inside the host's implementation. `upload` rejects
+ * on failure — the uploader catches and surfaces an error message.
+ */
+export interface CreateFileHandle {
+    upload: (args: CreateFileArgs) => Promise<{
+        id: string;
+    }>;
+    isUploading: boolean;
+    error?: unknown;
+}
+export type UseCreateFile = () => CreateFileHandle;
+/** Arguments the host's delete-file mutation takes — a single stored asset id. */
+export interface DeleteFileArgs {
+    fileId: string;
+}
+/**
+ * The host's file-delete mutation, for cleaning up an asset a block no longer references.
+ * Unprovided, deletion is a silent no-op (cleanup is best-effort), rather than an error.
+ */
+export interface DeleteFileHandle {
+    deleteFile: (args: DeleteFileArgs) => Promise<void>;
+}
+export type UseDeleteFile = () => DeleteFileHandle;
+/** Arguments the host's asset-bytes fetch takes — a single stored asset id. */
+export interface FetchAssetArgs {
+    assetId: string;
+}
+/**
+ * The host's asset-bytes fetch: reads a stored `asset_id` back to a `Blob` on the host's own
+ * transport (credentials/CSRF/telemetry), so the package never fetches host content directly. The
+ * alt-text generator uses it to obtain the image bytes it sends to the AI. `fetchAsset` rejects on
+ * failure — the caller catches and surfaces an error message.
+ */
+export interface FetchAssetHandle {
+    fetchAsset: (args: FetchAssetArgs) => Promise<Blob>;
+}
+export type UseFetchAsset = () => FetchAssetHandle;
 /**
  * The host-injected data hooks the blocks call to resolve an opaque `asset_id`
  * to the URL they render. The host owns the fetch (e.g. Canvas Files API via
@@ -44,15 +148,36 @@ export type UseVideoUrl = (assetId: string) => ResolvedVideo;
  * stable value).
  *
  * Calling unconditionally also means an unconfigured block passes an empty
- * `assetId`, so a hook must treat `''` as "nothing to resolve": don't fetch, and
- * report neither loading nor error (`{isLoading: false, isError: false}` with no
- * `url` — with react-query, `enabled: !!assetId`). The block ignores that result:
- * an unconfigured block renders the authoring placeholder inside the editor canvas
+ * identifier — `assetId`, or `widgetType` for `useWidget` — so a hook must treat
+ * `''` as "nothing to resolve": don't fetch, and report neither loading nor error
+ * (`{isLoading: false, isError: false}` with no `url`/`Component` — with
+ * react-query, `enabled: !!assetId`). The block ignores that result: an
+ * unconfigured block renders the authoring placeholder inside the editor canvas
  * and nothing outside it, so a hook that fetches for `''` only wastes a request.
+ *
+ * For any other identifier, though, a result that reports neither loading nor
+ * anything resolved reads as a failure: the blocks show the error placeholder. A hook
+ * that can sit idle for a real identifier (a query not yet enabled, say) must report
+ * `isLoading: true` until it settles, or the block flashes an error it will replace.
+ *
+ * A hook **reports** failure rather than raising it: `isError`, never a throw and never
+ * a suspend. `WidgetBlock` happens to run its hook inside its own error boundary, so a
+ * throw there degrades to the error placeholder instead of the page, but the other
+ * blocks have no such guard, and nothing here provides the `Suspense` a suspending hook
+ * needs (a react-query resolver wants `throwOnError: false` and a plain `useQuery`).
  */
 export interface BlockEditorApi {
     useImageUrl?: UseImageUrl;
     useVideoUrl?: UseVideoUrl;
+    useWidget?: UseWidget;
+    /** Resolve a stored `asset_id` to preview data for the settings-form uploaders. */
+    useUploadedFile?: UseUploadedFile;
+    /** The host's file-upload mutation, driving the settings-form uploaders. */
+    useCreateFile?: UseCreateFile;
+    /** The host's file-delete mutation, for cleaning up orphaned uploads. */
+    useDeleteFile?: UseDeleteFile;
+    /** The host's asset-bytes fetch, reading a stored `asset_id` to a `Blob` for the alt-text AI. */
+    useFetchAsset?: UseFetchAsset;
 }
 export declare const BlockEditorApiContext: import('react').Context<BlockEditorApi>;
 export declare const BlockEditorApiProvider: import('react').Provider<BlockEditorApi>;
@@ -60,4 +185,14 @@ export declare const BlockEditorApiProvider: import('react').Provider<BlockEdito
 export declare const useImageUrl: (assetId: string) => ResolvedImage;
 /** Resolve a video asset id via the host-provided `useVideoUrl` hook. */
 export declare const useVideoUrl: (assetId: string) => ResolvedVideo;
+/** Resolve a widget identifier to the host's component via the `useWidget` hook. */
+export declare const useWidget: (widgetType: string) => ResolvedWidget;
+/** Resolve an uploaded file's preview data via the host-provided `useUploadedFile` hook. */
+export declare const useUploadedFile: (assetId: string) => ResolvedUploadedFile;
+/** Obtain the host's file-upload mutation via the `useCreateFile` hook. */
+export declare const useCreateFile: () => CreateFileHandle;
+/** Obtain the host's file-delete mutation via the `useDeleteFile` hook. */
+export declare const useDeleteFile: () => DeleteFileHandle;
+/** Obtain the host's asset-bytes fetch via the `useFetchAsset` hook. */
+export declare const useFetchAsset: () => FetchAssetHandle;
 //# sourceMappingURL=BlockEditorApiContext.d.ts.map

package/dist/contexts/BlockEditorApiContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BlockEditorApiContext.d.ts","sourceRoot":"","sources":["../../src/contexts/BlockEditorApiContext.tsx"],"names":[],"mappings":"AAoBA;;;GAGG;AACH,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,OAAO,CAAA;IAClB,OAAO,EAAE,OAAO,CAAA;CACjB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,aAAa;IAC5B,GAAG,CAAC,EAAE,MAAM,CAAA;IACZ,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,OAAO,CAAA;IAClB,YAAY,CAAC,EAAE,OAAO,CAAA;IACtB,OAAO,EAAE,OAAO,CAAA;CACjB;AAED,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,aAAa,CAAA;AAC5D,MAAM,MAAM,WAAW,GAAG,CAAC,OAAO,EAAE,MAAM,KAAK,aAAa,CAAA;AAE5D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,WAAW,cAAc;IAC7B,WAAW,CAAC,EAAE,WAAW,CAAA;IACzB,WAAW,CAAC,EAAE,WAAW,CAAA;CAC1B;AAMD,eAAO,MAAM,qBAAqB,yCAAoC,CAAA;AAEtE,eAAO,MAAM,sBAAsB,0CAAiC,CAAA;AAEpE,0EAA0E;AAC1E,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,KAAG,aAG7C,CAAA;AAED,yEAAyE;AACzE,eAAO,MAAM,WAAW,GAAI,SAAS,MAAM,KAAG,aAG7C,CAAA"}
+{"version":3,"file":"BlockEditorApiContext.d.ts","sourceRoot":"","sources":["../../src/contexts/BlockEditorApiContext.tsx"],"names":[],"mappings":"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"}

package/dist/contexts/BlockTranslationsContext.d.ts

@@ -0,0 +1,47 @@
+import { ReactNode } from 'react';
+/**
+ * Strings for one block, supplied by the host when it registers that block
+ * (`create<Name>Block({ translations })`). Scoping them this way is what lets a host
+ * translate only the blocks it actually uses — an unregistered block never asks for
+ * anything.
+ */
+export type BlockTranslationValues = Record<string, string>;
+export interface BlockTranslationsProviderProps<T> {
+    value: T;
+    children: ReactNode;
+}
+/**
+ * Wraps a single block. Placed by `create<Name>Block`, not by the renderer, so every
+ * consumer — this package's viewer, a host's designer, or a bare `<Text />` — behaves the
+ * same.
+ */
+export declare function BlockTranslationsProvider<T extends AllStringValues<T>>({ value, children, }: BlockTranslationsProviderProps<T>): import("react/jsx-runtime").JSX.Element;
+/**
+ * "Every property is a string", expressed so that an `interface` satisfies it.
+ * `Record<string, string>` would not: an interface gets no implicit index signature, so
+ * every block's `<Name>Translations` — and every host block's — would be rejected.
+ */
+export type AllStringValues<T> = {
+    [K in keyof T]: string;
+};
+export interface BlockTranslations<T> {
+    /** Fully resolved strings — every key present, whatever the host supplied. */
+    translations: T;
+    /** Resolve a key and substitute its `%{…}` placeholders. */
+    translate: (key: keyof T & string, vars?: Record<string, unknown>) => string;
+}
+/**
+ * Resolves a block's strings: the English bundled with this package, overridden by
+ * whatever a `BlockTranslationsProvider` above supplies — which in practice is what the
+ * host passed to `create<Name>Block({ translations })`.
+ *
+ * The English fallback means a bare `<Text />` renders with no provider at all, so tests,
+ * stories and direct use need no setup, and a host that forgets a key degrades to English
+ * rather than showing a raw key.
+ *
+ * Nothing else is needed for strings the *package* owns outside any block (designer
+ * chrome, say): give them their own slice and call this hook with it. There is
+ * deliberately no separate "base translations" provider — this one already generalises.
+ */
+export declare function useBlockTranslations<T extends AllStringValues<T>>(fallback: T): BlockTranslations<T>;
+//# sourceMappingURL=BlockTranslationsContext.d.ts.map

package/dist/contexts/BlockTranslationsContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockTranslationsContext.d.ts","sourceRoot":"","sources":["../../src/contexts/BlockTranslationsContext.tsx"],"names":[],"mappings":"AAkBA,OAAO,EAAiB,KAAK,SAAS,EAAuB,MAAM,OAAO,CAAA;AAE1E;;;;;GAKG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAI3D,MAAM,WAAW,8BAA8B,CAAC,CAAC;IAC/C,KAAK,EAAE,CAAC,CAAA;IACR,QAAQ,EAAE,SAAS,CAAA;CACpB;AAED;;;;GAIG;AACH,wBAAgB,yBAAyB,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAAE,EACtE,KAAK,EACL,QAAQ,GACT,EAAE,8BAA8B,CAAC,CAAC,CAAC,2CAMnC;AAcD;;;;GAIG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,IAAI;KAAG,CAAC,IAAI,MAAM,CAAC,GAAG,MAAM;CAAE,CAAA;AAE3D,MAAM,WAAW,iBAAiB,CAAC,CAAC;IAClC,8EAA8E;IAC9E,YAAY,EAAE,CAAC,CAAA;IACf,4DAA4D;IAC5D,SAAS,EAAE,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,MAAM,CAAA;CAC7E;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,eAAe,CAAC,CAAC,CAAC,EAC/D,QAAQ,EAAE,CAAC,GACV,iBAAiB,CAAC,CAAC,CAAC,CAoBtB"}

package/dist/contexts/RichTextEditorContext.d.ts

@@ -0,0 +1,28 @@
+import { ComponentType } from 'react';
+/**
+ * The props the settings form hands a host-injected rich-text *editor* — the write-path
+ * twin of `RichTextRendererContext`'s read-path renderer. The contract is deliberately
+ * host-agnostic: host-specific wiring (Canvas course/context, RCE plugin config, JWT) is
+ * closed over by the host inside its own component, never passed across this seam.
+ */
+export interface RichTextEditorProps {
+    /** Current HTML value. */
+    value: string;
+    /** Called with the new HTML whenever the editor's content changes. */
+    onChange: (html: string) => void;
+    /** Accessible label for the editor's textarea. */
+    label: string;
+    /** Stable id for the editor's textarea, derived from the field name. */
+    id: string;
+    /** Optional editor height (CSS length), e.g. `"400px"`. */
+    height?: string;
+}
+export type RichTextEditorComponent = ComponentType<RichTextEditorProps>;
+/**
+ * The host's rich-text editor, or `undefined` when none is provided — in which case the
+ * settings form falls back to a plain `TextArea`. A host (e.g. Canvas) injects its own RCE
+ * here; stories, tests and hosts without an editor leave it `undefined`.
+ */
+export declare const RichTextEditorContext: import('react').Context<RichTextEditorComponent | undefined>;
+export declare const useRichTextEditor: () => RichTextEditorComponent | undefined;
+//# sourceMappingURL=RichTextEditorContext.d.ts.map

package/dist/contexts/RichTextEditorContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RichTextEditorContext.d.ts","sourceRoot":"","sources":["../../src/contexts/RichTextEditorContext.tsx"],"names":[],"mappings":"AAkBA,OAAO,EAAE,KAAK,aAAa,EAA6B,MAAM,OAAO,CAAA;AAErE;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB;IAClC,0BAA0B;IAC1B,KAAK,EAAE,MAAM,CAAA;IACb,sEAAsE;IACtE,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;IAChC,kDAAkD;IAClD,KAAK,EAAE,MAAM,CAAA;IACb,wEAAwE;IACxE,EAAE,EAAE,MAAM,CAAA;IACV,2DAA2D;IAC3D,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,MAAM,uBAAuB,GAAG,aAAa,CAAC,mBAAmB,CAAC,CAAA;AAExE;;;;GAIG;AACH,eAAO,MAAM,qBAAqB,8DAAgE,CAAA;AAElG,eAAO,MAAM,iBAAiB,QAAO,uBAAuB,GAAG,SAC5B,CAAA"}

package/dist/contexts/RichTextRendererContext.d.ts

@@ -0,0 +1,21 @@
+import { ReactNode } from 'react';
+/**
+ * Renders a rich-text HTML string into React nodes. A host injects one to run
+ * RCE-authored content through its own pipeline (e.g. Canvas file-link
+ * rewriting, inline file previews, media enhancement, MathJax) instead of the
+ * blocks' plain sanitized-HTML fallback.
+ *
+ * SECURITY: the renderer receives the **raw, unsanitized** HTML — the blocks do
+ * not sanitize on this path. A host that injects a renderer owns sanitization
+ * and MUST sanitize the html itself, or it opens an XSS hole.
+ */
+export type RichTextRenderer = (html: string) => ReactNode;
+/**
+ * The host's rich-text renderer, or `undefined` when none is provided — in which
+ * case the blocks fall back to `sanitizeHtml` + `dangerouslySetInnerHTML`. The
+ * host (e.g. a learner page) provides the value; consumers that don't need a
+ * custom pipeline (storybook, the designer, a bare render) leave it `undefined`.
+ */
+export declare const RichTextRendererContext: import('react').Context<RichTextRenderer | undefined>;
+export declare const useRichTextRenderer: () => RichTextRenderer | undefined;
+//# sourceMappingURL=RichTextRendererContext.d.ts.map

package/dist/contexts/RichTextRendererContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"RichTextRendererContext.d.ts","sourceRoot":"","sources":["../../src/contexts/RichTextRendererContext.tsx"],"names":[],"mappings":"AAkBA,OAAO,EAAiB,KAAK,SAAS,EAAc,MAAM,OAAO,CAAA;AAEjE;;;;;;;;;GASG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,IAAI,EAAE,MAAM,KAAK,SAAS,CAAA;AAE1D;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,uDAAyD,CAAA;AAE7F,eAAO,MAAM,mBAAmB,QAAO,gBAAgB,GAAG,SACrB,CAAA"}

package/dist/editor/BlockContentEditor.d.ts

@@ -0,0 +1,40 @@
+import { BlockRegistry } from '../registry';
+import { Tool } from './sidebar/panel/types';
+import { UseBlockEditorStateReturn } from './state/useBlockEditorState';
+/** The trays the package ships. A host appends its own tools (widget tray, AI assistant). */
+export declare const BUILT_IN_TOOL_IDS: readonly ["components", "interactive", "layout", "templates"];
+export type BuiltInToolId = (typeof BUILT_IN_TOOL_IDS)[number];
+export interface BlockContentEditorProps<HostToolId extends string = never> {
+    /** The host-owned editor state (from `useBlockEditorState`). The host keeps save / undo /
+     * dirty / DB↔package conversion; this component only composes the authoring UI over it. */
+    engine: UseBlockEditorStateReturn;
+    /** The registry the document's blocks resolve against (same one passed to `useBlockEditorState`). */
+    registry: BlockRegistry;
+    /** Host tools appended after the built-in trays — the host-tool slot (a widget tray, the
+     * IgniteAI Assistant). Block-level AI is gated on the `AIAction` seam, not on a tool. */
+    tools?: Tool<HostToolId>[];
+    /** Which built-in trays to render, as a subset of `BUILT_IN_TOOL_IDS`; defaults to all four.
+     * Rendered in the canonical order regardless of the order given (e.g. a dashboard passes
+     * `['components', 'layout']`). */
+    builtInToolIds?: BuiltInToolId[];
+    /** The tool open on first render. Defaults to the first rendered built-in tray (`components`
+     * unless excluded), then the first host tool. */
+    initialToolId?: BuiltInToolId | HostToolId;
+    /** Panel height; forwarded to `DesignerSideBar` (defaults to `100%`). */
+    height?: number | string;
+    /** Shows the sidebar's rail collapse/expand toggle once a tool has been opened. */
+    hasExpandPanelButton?: boolean;
+}
+/**
+ * The authoring editor: the tool-panel sidebar over the drag-and-drop canvas, wired to the
+ * host's state engine. It is one convenient composition of the package's primitives — a host
+ * that needs a different arrangement (the sidebar in a modal, a custom layout) composes
+ * `GridDndProvider` + `DesignerSideBar` + `DesignerCanvas` itself; nothing here is required.
+ *
+ * It holds only the panel's view/tool UI state; the document, selection, and history live in
+ * the `engine` the host owns. One shared `GridDndProvider` wraps both surfaces so tray drag
+ * sources reach the canvas droppables. It is authoring-only — the student preview
+ * (`PreviewArea`) is a separate export the host presents however it wants.
+ */
+export declare function BlockContentEditor<HostToolId extends string = never>({ engine, registry, tools: hostTools, builtInToolIds, initialToolId, height, hasExpandPanelButton, }: BlockContentEditorProps<HostToolId>): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=BlockContentEditor.d.ts.map

package/dist/editor/BlockContentEditor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockContentEditor.d.ts","sourceRoot":"","sources":["../../src/editor/BlockContentEditor.tsx"],"names":[],"mappings":"AA4BA,OAAO,EAAE,KAAK,aAAa,EAAqB,MAAM,aAAa,CAAA;AAOnE,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,uBAAuB,CAAA;AAQjD,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,6BAA6B,CAAA;AAE5E,6FAA6F;AAC7F,eAAO,MAAM,iBAAiB,+DAAgE,CAAA;AAC9F,MAAM,MAAM,aAAa,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAmC9D,MAAM,WAAW,uBAAuB,CAAC,UAAU,SAAS,MAAM,GAAG,KAAK;IACxE;+FAC2F;IAC3F,MAAM,EAAE,yBAAyB,CAAA;IACjC,qGAAqG;IACrG,QAAQ,EAAE,aAAa,CAAA;IACvB;6FACyF;IACzF,KAAK,CAAC,EAAE,IAAI,CAAC,UAAU,CAAC,EAAE,CAAA;IAC1B;;sCAEkC;IAClC,cAAc,CAAC,EAAE,aAAa,EAAE,CAAA;IAChC;qDACiD;IACjD,aAAa,CAAC,EAAE,aAAa,GAAG,UAAU,CAAA;IAC1C,yEAAyE;IACzE,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,CAAA;IACxB,mFAAmF;IACnF,oBAAoB,CAAC,EAAE,OAAO,CAAA;CAC/B;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,UAAU,SAAS,MAAM,GAAG,KAAK,EAAE,EACpE,MAAM,EACN,QAAQ,EACR,KAAK,EAAE,SAAS,EAChB,cAAuC,EACvC,aAAa,EACb,MAAM,EACN,oBAAoB,GACrB,EAAE,uBAAuB,CAAC,UAAU,CAAC,2CA0NrC"}

package/dist/editor/ai/BlockAIMenu.d.ts

@@ -0,0 +1,17 @@
+import { BlockRegistry } from '../../registry';
+export interface BlockAIMenuProps {
+    componentType: string;
+    componentData: Record<string, unknown>;
+    /** Component instance ID, used to pick the edited entry from the AI's response. */
+    componentId?: string;
+    isOpen: boolean;
+    onOpen: () => void;
+    onApply: (newProps: Record<string, unknown>) => void;
+    onClose: () => void;
+    /** Composed by the host — needed to render the before/after preview and to resolve the block. */
+    componentRegistry: BlockRegistry;
+    /** Fires when the menu popover OR the preview modal is open, so the canvas can hold selection. */
+    onActiveChange?: (active: boolean) => void;
+}
+export declare const BlockAIMenu: ({ componentType, componentData, componentId, isOpen, onOpen, onApply, onClose, componentRegistry, onActiveChange, }: BlockAIMenuProps) => import("react/jsx-runtime").JSX.Element | null;
+//# sourceMappingURL=BlockAIMenu.d.ts.map

package/dist/editor/ai/BlockAIMenu.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockAIMenu.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/BlockAIMenu.tsx"],"names":[],"mappings":"AA+BA,OAAO,KAAK,EAAE,aAAa,EAA4B,MAAM,gBAAgB,CAAA;AAQ7E,MAAM,WAAW,gBAAgB;IAC/B,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,mFAAmF;IACnF,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,MAAM,EAAE,OAAO,CAAA;IACf,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IACpD,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,iGAAiG;IACjG,iBAAiB,EAAE,aAAa,CAAA;IAChC,kGAAkG;IAClG,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,CAAA;CAC3C;AAED,eAAO,MAAM,WAAW,GAAI,qHAUzB,gBAAgB,mDAkIlB,CAAA"}

package/dist/editor/ai/BlockAIMenuContent.d.ts

@@ -0,0 +1,17 @@
+export type MenuView = 'root' | 'prompt' | 'change-tone' | 'change-length' | 'change-reading-level';
+export interface BlockAIMenuContentProps {
+    view: MenuView;
+    onSetView: (view: MenuView) => void;
+    onQuickAction: (instruction: string) => void;
+    activeInstruction?: string | null;
+    prompt: string;
+    onPromptChange: (value: string) => void;
+    isThinking: boolean;
+    error?: string | null;
+    previewFirst: boolean;
+    onPreviewFirstChange: (value: boolean) => void;
+    onSend: () => void;
+    onStop: () => void;
+}
+export declare const BlockAIMenuContent: ({ view, onSetView, onQuickAction, activeInstruction, prompt, onPromptChange, isThinking, error, previewFirst, onPreviewFirstChange, onSend, onStop, }: BlockAIMenuContentProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=BlockAIMenuContent.d.ts.map

package/dist/editor/ai/BlockAIMenuContent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"BlockAIMenuContent.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/BlockAIMenuContent.tsx"],"names":[],"mappings":"AAsCA,MAAM,MAAM,QAAQ,GAAG,MAAM,GAAG,QAAQ,GAAG,aAAa,GAAG,eAAe,GAAG,sBAAsB,CAAA;AAkDnG,MAAM,WAAW,uBAAuB;IACtC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,IAAI,CAAA;IACnC,aAAa,EAAE,CAAC,WAAW,EAAE,MAAM,KAAK,IAAI,CAAA;IAC5C,iBAAiB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IAEjC,MAAM,EAAE,MAAM,CAAA;IACd,cAAc,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACvC,UAAU,EAAE,OAAO,CAAA;IACnB,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,CAAA;IACrB,YAAY,EAAE,OAAO,CAAA;IACrB,oBAAoB,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAA;IAC9C,MAAM,EAAE,MAAM,IAAI,CAAA;IAClB,MAAM,EAAE,MAAM,IAAI,CAAA;CACnB;AAED,eAAO,MAAM,kBAAkB,GAAI,uJAahC,uBAAuB,4CAyLzB,CAAA"}

package/dist/editor/ai/PreviewBlockModal.d.ts

@@ -0,0 +1,29 @@
+import { BlockRegistry, LayoutNode, TemplateData, UnresolvedBlock } from '../../registry';
+export interface PreviewBlockModalProps {
+    open: boolean;
+    onClose: () => void;
+    onReplace: () => void;
+    onRegenerate: (refinementText: string) => void;
+    isRegenerating?: boolean;
+    /** FOUND-62: the refinement/regenerate field is hidden by default. */
+    showRefinement?: boolean;
+    beforeLayout: LayoutNode[];
+    beforeData?: TemplateData;
+    afterLayout: LayoutNode[];
+    afterData?: TemplateData;
+    /** Composed by the host — same contract as `Viewer`; renders both diff panels. */
+    componentRegistry: BlockRegistry;
+    /** Forwarded to both `Viewer`s. */
+    onUnresolvedBlock?: (block: UnresolvedBlock) => void;
+}
+/**
+ * A fullscreen before/after diff of an AI-proposed block change: the current block ("Before")
+ * beside the AI's version ("After"), a Both/After/Before switch, an optional refinement field,
+ * and Cancel / Accept-and-replace. The two panels are the read-path `Viewer` run with designer
+ * mode off (so blocks show their student state), reached through the modal portal — brand color,
+ * translations and host data hooks come from the host's providers above, as everywhere else. The
+ * source's IgniteAI gradient is dropped for a neutral, themeable surface; the AI accent is the
+ * colored icon in the header.
+ */
+export declare const PreviewBlockModal: ({ open, onClose, onReplace, onRegenerate, isRegenerating, showRefinement, beforeLayout, beforeData, afterLayout, afterData, componentRegistry, onUnresolvedBlock, }: PreviewBlockModalProps) => import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=PreviewBlockModal.d.ts.map

package/dist/editor/ai/PreviewBlockModal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PreviewBlockModal.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/PreviewBlockModal.tsx"],"names":[],"mappings":"AA6BA,OAAO,KAAK,EAAE,aAAa,EAAE,UAAU,EAAE,YAAY,EAAE,eAAe,EAAE,MAAM,gBAAgB,CAAA;AAS9F,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,OAAO,CAAA;IACb,OAAO,EAAE,MAAM,IAAI,CAAA;IACnB,SAAS,EAAE,MAAM,IAAI,CAAA;IACrB,YAAY,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAA;IAC9C,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,sEAAsE;IACtE,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,UAAU,EAAE,CAAA;IAC1B,UAAU,CAAC,EAAE,YAAY,CAAA;IACzB,WAAW,EAAE,UAAU,EAAE,CAAA;IACzB,SAAS,CAAC,EAAE,YAAY,CAAA;IACxB,kFAAkF;IAClF,iBAAiB,EAAE,aAAa,CAAA;IAChC,mCAAmC;IACnC,iBAAiB,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,IAAI,CAAA;CACrD;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,iBAAiB,GAAI,qKAa/B,sBAAsB,4CA4KxB,CAAA"}

package/dist/editor/ai/aiMenuStyles.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The block-level AI menu's chrome CSS: the popover card, its interactive menu-item rows
+ * (hover/focus/disabled) and the free-text prompt row. None of it is expressible in InstUI
+ * props — it needs `:hover`/`:focus-visible`/`:disabled` states and a borderless input — so it
+ * is injected once as a global stylesheet keyed by stable class names, the same way the canvas
+ * and preview chrome are. The source's `theme.gradients.igniteAI` branding is neutralized to
+ * plain InstUI surface tokens; the AI accent lives in the colored AI icon on the trigger.
+ */
+export declare const AI_CLASS: {
+    readonly root: "bce-ai-menu-root";
+    readonly card: "bce-ai-menu-card";
+    readonly list: "bce-ai-menu-list";
+    readonly item: "bce-ai-menu-item";
+    readonly itemLabel: "bce-ai-menu-item-label";
+    readonly subHeader: "bce-ai-menu-subheader";
+    readonly input: "bce-ai-menu-input";
+    readonly footer: "bce-ai-menu-footer";
+    readonly thinkingBody: "bce-ai-menu-thinking";
+    readonly thinkingStatus: "bce-ai-menu-thinking-status";
+};
+/** Mounts the AI menu chrome stylesheet once, under the menu popover. */
+export declare function AIMenuStyles(): import("react/jsx-runtime").JSX.Element;
+//# sourceMappingURL=aiMenuStyles.d.ts.map

package/dist/editor/ai/aiMenuStyles.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiMenuStyles.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/aiMenuStyles.tsx"],"names":[],"mappings":"AAoBA;;;;;;;GAOG;AAEH,eAAO,MAAM,QAAQ;;;;;;;;;;;CAWX,CAAA;AAmBV,yEAAyE;AACzE,wBAAgB,YAAY,4CA+G3B"}

package/dist/editor/ai/aiTranslations.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Strings the package owns for the block-level AI chrome — the per-block AI menu, the
+ * before/after preview, and the "Generate alt text" affordance. Consumed via
+ * `useBlockTranslations(DesignerAIEnglish)`, the same mechanism blocks use; there is
+ * deliberately no second translation context. The host overrides by placing a
+ * `BlockTranslationsProvider` above the editor; anything it omits falls back to the English
+ * below. Bundled English is intentionally product-neutral ("AI", not a brand name) — a host
+ * brands it through its own translations.
+ *
+ * Only the visible labels/chrome live here. The *instruction* strings the menu sends to the AI
+ * (e.g. "Make the tone more formal") are model prompts, not UI copy, so they stay as literals in
+ * `BlockAIMenuContent` and are not translated.
+ */
+export interface DesignerAITranslations {
+    /** Accessible label for the AI menu trigger on a block. `%{componentType}` is the block name. */
+    aiAssistFor: string;
+    /** Tooltip on the AI menu trigger. */
+    aiActions: string;
+    /** Back link from a submenu to the root menu. */
+    backToMenu: string;
+    /** Root action + prompt-view header: open a free-text regenerate prompt. */
+    regenerateWithPrompt: string;
+    /** Root action: open the tone submenu. */
+    changeTone: string;
+    /** Root action: open the length submenu. */
+    changeLength: string;
+    /** Root action: open the reading-level submenu. */
+    changeReadingLevel: string;
+    /** Tone submenu item labels. */
+    toneMoreFormal: string;
+    toneMoreFun: string;
+    toneMoreCasual: string;
+    toneMoreTechnical: string;
+    /** Length submenu item labels. */
+    lengthShorter: string;
+    lengthLonger: string;
+    /** Reading-level submenu item labels. */
+    readingBeginning: string;
+    readingNovice: string;
+    readingIntermediate: string;
+    readingAdvanced: string;
+    /** Prompt input label/placeholder. */
+    promptPlaceholder: string;
+    /** Toggle: show the before/after preview before applying. */
+    previewFirst: string;
+    /** Send the prompt. */
+    send: string;
+    /** In-flight status while the AI generates. */
+    thinking: string;
+    /** Stop an in-flight generation. */
+    stop: string;
+    /** Error shown in the AI menu when a generation fails or returns nothing usable. */
+    generationFailed: string;
+    /** Preview modal title. */
+    previewBlock: string;
+    /** Accessible group label for the Both/After/Before comparison switch. */
+    compareLabel: string;
+    /** Comparison switch options + panel headings. */
+    both: string;
+    before: string;
+    after: string;
+    /** Preview modal buttons. */
+    previewCancel: string;
+    acceptAndReplace: string;
+    /** Refinement field label/placeholder + its buttons (field hidden by default). */
+    refinementPlaceholder: string;
+    regenerate: string;
+    regenerating: string;
+    /** "Generate alt text" affordance on the alt-text field. */
+    generateAltText: string;
+    generating: string;
+    /** Errors surfaced by the alt-text affordance. */
+    failedToLoadImage: string;
+    failedToGenerate: string;
+    noDescription: string;
+}
+/** English bundled with this package — also the source for `locales/en.json`. */
+export declare const DesignerAIEnglish: DesignerAITranslations;
+//# sourceMappingURL=aiTranslations.d.ts.map

package/dist/editor/ai/aiTranslations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiTranslations.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/aiTranslations.ts"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,sBAAsB;IACrC,iGAAiG;IACjG,WAAW,EAAE,MAAM,CAAA;IACnB,sCAAsC;IACtC,SAAS,EAAE,MAAM,CAAA;IACjB,iDAAiD;IACjD,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,oBAAoB,EAAE,MAAM,CAAA;IAC5B,0CAA0C;IAC1C,UAAU,EAAE,MAAM,CAAA;IAClB,4CAA4C;IAC5C,YAAY,EAAE,MAAM,CAAA;IACpB,mDAAmD;IACnD,kBAAkB,EAAE,MAAM,CAAA;IAC1B,gCAAgC;IAChC,cAAc,EAAE,MAAM,CAAA;IACtB,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;IACtB,iBAAiB,EAAE,MAAM,CAAA;IACzB,kCAAkC;IAClC,aAAa,EAAE,MAAM,CAAA;IACrB,YAAY,EAAE,MAAM,CAAA;IACpB,yCAAyC;IACzC,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;IACrB,mBAAmB,EAAE,MAAM,CAAA;IAC3B,eAAe,EAAE,MAAM,CAAA;IACvB,sCAAsC;IACtC,iBAAiB,EAAE,MAAM,CAAA;IACzB,6DAA6D;IAC7D,YAAY,EAAE,MAAM,CAAA;IACpB,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAA;IACZ,+CAA+C;IAC/C,QAAQ,EAAE,MAAM,CAAA;IAChB,oCAAoC;IACpC,IAAI,EAAE,MAAM,CAAA;IACZ,oFAAoF;IACpF,gBAAgB,EAAE,MAAM,CAAA;IACxB,2BAA2B;IAC3B,YAAY,EAAE,MAAM,CAAA;IACpB,0EAA0E;IAC1E,YAAY,EAAE,MAAM,CAAA;IACpB,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,6BAA6B;IAC7B,aAAa,EAAE,MAAM,CAAA;IACrB,gBAAgB,EAAE,MAAM,CAAA;IACxB,kFAAkF;IAClF,qBAAqB,EAAE,MAAM,CAAA;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,4DAA4D;IAC5D,eAAe,EAAE,MAAM,CAAA;IACvB,UAAU,EAAE,MAAM,CAAA;IAClB,kDAAkD;IAClD,iBAAiB,EAAE,MAAM,CAAA;IACzB,gBAAgB,EAAE,MAAM,CAAA;IACxB,aAAa,EAAE,MAAM,CAAA;CACtB;AAED,iFAAiF;AACjF,eAAO,MAAM,iBAAiB,EAAE,sBAuC/B,CAAA"}

package/dist/editor/ai/aiTypes.d.ts

@@ -0,0 +1,13 @@
+/**
+ * The `inline_manipulate_template_content` tool's response payload, as it comes back over the
+ * wire from the AI. Deliberately the agent's **array** shape (`{ id, props }[]`), NOT the engine's
+ * flat `TemplateData` Record: the hook reads it with `.find(e => e.id === componentId)` to pick the
+ * edited block, so it must stay an array — converting it to a Record would break that lookup.
+ */
+export interface AIInlineTemplateContentPayload {
+    templateData: {
+        id: string;
+        props: Record<string, unknown>;
+    }[];
+}
+//# sourceMappingURL=aiTypes.d.ts.map

package/dist/editor/ai/aiTypes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"aiTypes.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/aiTypes.ts"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,MAAM,WAAW,8BAA8B;IAC7C,YAAY,EAAE;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;KAAE,EAAE,CAAA;CAC/D"}

package/dist/editor/ai/constants.d.ts

@@ -0,0 +1,8 @@
+/** The three panes of the before/after AI preview comparison. */
+export declare const PREVIEW_BLOCK_VIEWS: {
+    readonly BOTH: "both";
+    readonly AFTER: "after";
+    readonly BEFORE: "before";
+};
+export type PreviewBlockView = (typeof PREVIEW_BLOCK_VIEWS)[keyof typeof PREVIEW_BLOCK_VIEWS];
+//# sourceMappingURL=constants.d.ts.map

package/dist/editor/ai/constants.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"constants.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/constants.ts"],"names":[],"mappings":"AAkBA,iEAAiE;AACjE,eAAO,MAAM,mBAAmB;;;;CAItB,CAAA;AAEV,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,OAAO,mBAAmB,CAAC,CAAA"}

package/dist/editor/ai/index.d.ts

@@ -0,0 +1,7 @@
+export { BlockAIMenu, type BlockAIMenuProps } from './BlockAIMenu';
+export { PreviewBlockModal, type PreviewBlockModalProps } from './PreviewBlockModal';
+export { useGenerateAltText } from './useGenerateAltText';
+export { PREVIEW_BLOCK_VIEWS, type PreviewBlockView } from './constants';
+export { type DesignerAITranslations, DesignerAIEnglish } from './aiTranslations';
+export type { AIInlineTemplateContentPayload } from './aiTypes';
+//# sourceMappingURL=index.d.ts.map

package/dist/editor/ai/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/index.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,WAAW,EAAE,KAAK,gBAAgB,EAAE,MAAM,eAAe,CAAA;AAClE,OAAO,EAAE,iBAAiB,EAAE,KAAK,sBAAsB,EAAE,MAAM,qBAAqB,CAAA;AACpF,OAAO,EAAE,kBAAkB,EAAE,MAAM,sBAAsB,CAAA;AAEzD,OAAO,EAAE,mBAAmB,EAAE,KAAK,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACxE,OAAO,EAAE,KAAK,sBAAsB,EAAE,iBAAiB,EAAE,MAAM,kBAAkB,CAAA;AACjF,YAAY,EAAE,8BAA8B,EAAE,MAAM,WAAW,CAAA"}

package/dist/editor/ai/useBlockAIPopover.d.ts

@@ -0,0 +1,30 @@
+interface UseBlockAIPopoverProps {
+    componentType: string;
+    componentData: Record<string, unknown>;
+    componentId?: string;
+    onApply: (newProps: Record<string, unknown>) => void;
+    onClose: () => void;
+}
+/**
+ * The shared brain behind the block-level AI menu: prompt/thinking/preview state, aborting, and
+ * the AI-action call plus its response extraction. Host-agnostic — it reads the injected
+ * `useAIAction()` seam (the host closes over course/chat context) and preserves the abort signal
+ * for `handleStop`. If no seam is provided it is inert.
+ */
+export declare const useBlockAIPopover: ({ componentType, componentData, componentId, onApply, onClose, }: UseBlockAIPopoverProps) => {
+    prompt: string;
+    setPrompt: import('react').Dispatch<import('react').SetStateAction<string>>;
+    isThinking: boolean;
+    error: string | null;
+    clearError: () => void;
+    previewFirst: boolean;
+    setPreviewFirst: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    pendingProps: Record<string, unknown> | null;
+    handleSend: (instruction?: string) => Promise<void>;
+    handleStop: () => void;
+    handleRegenerate: (refinementText: string) => Promise<void>;
+    handleApply: () => void;
+    handleCancelPreview: () => void;
+};
+export {};
+//# sourceMappingURL=useBlockAIPopover.d.ts.map

package/dist/editor/ai/useBlockAIPopover.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useBlockAIPopover.d.ts","sourceRoot":"","sources":["../../../src/editor/ai/useBlockAIPopover.ts"],"names":[],"mappings":"AAyBA,UAAU,sBAAsB;IAC9B,aAAa,EAAE,MAAM,CAAA;IACrB,aAAa,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IACtC,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,EAAE,CAAC,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;IACpD,OAAO,EAAE,MAAM,IAAI,CAAA;CACpB;AAED;;;;;GAKG;AACH,eAAO,MAAM,iBAAiB,GAAI,kEAM/B,sBAAsB;;;;;;;;;+BAoDiB,MAAM;;uCAwBE,MAAM;;;CAgDvD,CAAA"}

package/dist/editor/ai/useGenerateAltText.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Generates image alt text via the injected AI-action seam: reads a `File`/`Blob` to base64 and
+ * sends the `generate_alt_text` tool, returning the `alt_text` string. Reports failure through
+ * `error` rather than throwing. Inert (returns null) when no seam is provided.
+ */
+export declare function useGenerateAltText(): {
+    isLoading: boolean;
+    error: string | null;
+    generateAltText: (file: File | Blob) => Promise<string | null>;
+};
+//# sourceMappingURL=useGenerateAltText.d.ts.map