fika-editor 3.0.0 → 3.0.2

package/dist/types/configs/imageClip.d.ts

@@ -0,0 +1,30 @@
+export declare const enum ClipPathTypes {
+    RECT = "rect",
+    ELLIPSE = "ellipse",
+    POLYGON = "polygon"
+}
+export declare const enum ClipPaths {
+    RECT = "rect",
+    ROUNDRECT = "roundRect",
+    ELLIPSE = "ellipse",
+    TRIANGLE = "triangle",
+    PENTAGON = "pentagon",
+    RHOMBUS = "rhombus",
+    STAR = "star"
+}
+export interface ClipPathItem {
+    type: ClipPathTypes;
+    style: string;
+    radius?: string;
+    createPath?: (width: number, height: number) => string;
+}
+interface ClipPath {
+    [key: string]: ClipPathItem;
+}
+/** Locale-free clip path geometry. Resolve names via getClipPaths(). */
+export declare const CLIPPATHS: ClipPath;
+/** Clip paths with names in the active locale. */
+export declare function getClipPaths(): Record<string, ClipPathItem & {
+    name: string;
+}>;
+export {};

package/dist/types/configs/inkPaint.d.ts

@@ -0,0 +1,37 @@
+import type { Gradient } from '../types/slides';
+export type MagicalInkId = 'rainbow' | 'sunset' | 'aurora' | 'holographic';
+export type InkPaint = {
+    color: string;
+    gradient?: Gradient;
+    gradientId?: MagicalInkId;
+};
+export type MagicalInkGradient = {
+    id: MagicalInkId;
+    color: string;
+    gradient: Gradient;
+    css: string;
+};
+/** Compact marker palette: neutrals plus a full hue set (red → violet). */
+export declare const INK_SOLID_SWATCHES: string[];
+export declare const MAGICAL_INK_GRADIENTS: MagicalInkGradient[];
+export declare const solidPaint: (color: string) => InkPaint;
+export declare const paintFromPreset: (preset: MagicalInkGradient) => InkPaint;
+export declare const samePaint: (a: InkPaint, b: InkPaint) => boolean;
+export declare const paintKey: (paint: Pick<InkPaint, 'color' | 'gradientId'>) => string;
+export declare const cloneGradient: (gradient: Gradient) => Gradient;
+export declare const isLightColor: (color: string) => boolean;
+export declare const boundsFromPoints: (points: Array<{
+    x: number;
+    y: number;
+}>, pad?: number) => {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+};
+export declare const createCanvasPaint: (ctx: CanvasRenderingContext2D, paint: Pick<InkPaint, 'color' | 'gradient'>, box: {
+    minX: number;
+    minY: number;
+    maxX: number;
+    maxY: number;
+}) => string | CanvasGradient;

package/dist/types/configs/laser.d.ts

@@ -0,0 +1,10 @@
+export type ScreenTool = 'pen' | 'laser';
+export type LaserColorId = 'red' | 'green' | 'blue' | 'purple';
+export type LaserColor = {
+    id: LaserColorId;
+    hex: string;
+    rgb: [number, number, number];
+};
+export declare const LASER_COLORS: Record<LaserColorId, LaserColor>;
+export declare const LASER_COLOR_IDS: LaserColorId[];
+export declare const isLaserColorId: (value: unknown) => value is LaserColorId;

package/dist/types/configs/lines.d.ts

@@ -0,0 +1,21 @@
+import type { LinePoint, LineStyleType } from '../types/slides';
+export interface LinePoolItem {
+    path: string;
+    style: LineStyleType;
+    points: [LinePoint, LinePoint];
+    isBroken?: boolean;
+    isBroken2?: boolean;
+    isCurve?: boolean;
+    isCubic?: boolean;
+}
+export type LineCategoryKey = 'straight' | 'polyCurve';
+interface PresetLine {
+    type: LineCategoryKey;
+    children: LinePoolItem[];
+}
+/**
+ * Structural line presets. Category labels are resolved at render time via i18n
+ * (see LinePool) so they follow the active locale — not the locale at module load.
+ */
+export declare const LINE_LIST: PresetLine[];
+export {};

package/dist/types/configs/localeSwitcher.d.ts

@@ -0,0 +1,2 @@
+export declare function setFikaLocaleSwitcherEnabled(enabled?: boolean): void;
+export declare function isFikaLocaleSwitcherEnabled(): boolean;

package/dist/types/configs/mediaUpload.d.ts

@@ -0,0 +1,71 @@
+export type FikaMediaKind = 'image' | 'video' | 'audio';
+export interface FikaMediaUploadProgress {
+    loaded: number;
+    total: number;
+}
+export interface FikaMediaUploadRequest {
+    file: File;
+    kind: FikaMediaKind;
+    signal: AbortSignal;
+    onProgress: (progress: FikaMediaUploadProgress) => void;
+}
+export interface FikaMediaUploadResult {
+    /** URL stored on the slide element (https, data, or blob). */
+    src: string;
+    /** Optional extension for video/audio export (e.g. `mp4`). */
+    ext?: string;
+}
+export type FikaMediaUploader = (request: FikaMediaUploadRequest) => Promise<FikaMediaUploadResult | string>;
+export type FikaMediaSizeLimit = number | Partial<Record<FikaMediaKind, number>>;
+export interface FikaMediaConstraints {
+    /** Maximum files accepted in one picker session. Default: 12. */
+    maxFiles?: number;
+    /**
+     * Maximum size per file in bytes. Pass a number for a global cap, or a
+     * per-kind map. Unspecified kinds fall back to the global/`image` value.
+     */
+    maxFileSize?: FikaMediaSizeLimit;
+    /** Restrict which media kinds the picker accepts. Default: all three. */
+    kinds?: FikaMediaKind[];
+    /** Extra MIME allowlist (exact types, e.g. `image/png`). */
+    mimeTypes?: string[];
+    /** Extra extension allowlist without dots (`png`, `mp4`). */
+    extensions?: string[];
+    /**
+     * `accept` attribute for the file input. When omitted, it is derived from
+     * `kinds` / `mimeTypes` / `extensions`.
+     */
+    accept?: string;
+}
+export interface FikaMediaConfig {
+    constraints?: FikaMediaConstraints;
+    /**
+     * Optional host upload. When omitted, images become data URLs and
+     * audio/video become blob URLs (fine for demos, not for persistence).
+     */
+    upload?: FikaMediaUploader;
+    /** Parallel uploads when `upload` is set. Default: 3. */
+    concurrency?: number;
+}
+export interface FikaXhrMediaUploaderOptions {
+    url: string;
+    method?: 'POST' | 'PUT';
+    fieldName?: string;
+    headers?: Record<string, string> | (() => Record<string, string> | Promise<Record<string, string>>);
+    formData?: Record<string, string> | ((file: File, kind: FikaMediaKind) => Record<string, string>);
+    withCredentials?: boolean;
+    timeoutMs?: number;
+    parseResponse?: (response: unknown, file: File, kind: FikaMediaKind) => FikaMediaUploadResult | string;
+}
+export declare const DEFAULT_MEDIA_CONSTRAINTS: Required<Omit<FikaMediaConstraints, 'mimeTypes' | 'extensions' | 'accept'>> & Pick<FikaMediaConstraints, 'mimeTypes' | 'extensions' | 'accept'>;
+export declare function setFikaMediaConfig(config?: FikaMediaConfig | null): void;
+export declare function getFikaMediaConfig(): FikaMediaConfig;
+export declare function getMediaConstraints(): FikaMediaConstraints;
+export declare function getMediaUploader(): FikaMediaUploader | undefined;
+export declare function getMediaConcurrency(): number;
+/**
+ * Build a progress-aware `upload` callback for typical FormData endpoints.
+ * Hosts that need signed URLs or multipart policies can still pass a custom
+ * `FikaMediaUploader` instead.
+ */
+export declare function createFikaMediaUploader(options: FikaXhrMediaUploaderOptions): FikaMediaUploader;

package/dist/types/configs/mime.d.ts

@@ -0,0 +1,4 @@
+export declare const MIME_MAP: Record<string, string>;
+export declare const IMAGE_EXTENSIONS: readonly ['png', 'jpg', 'jpeg', 'gif', 'webp', 'svg', 'bmp', 'avif', 'ico'];
+export declare const VIDEO_EXTENSIONS: readonly ['mp4', 'webm', 'ogv', 'ogg', 'mov', 'm4v', 'mpeg', 'avi'];
+export declare const AUDIO_EXTENSIONS: readonly ['mp3', 'wav', 'ogg', 'oga', 'm4a', 'aac', 'flac', 'weba', 'aif', 'wma'];

package/dist/types/configs/shapes.d.ts

@@ -0,0 +1,26 @@
+import { ShapePathFormulasKeys } from '../types/slides';
+export type ShapeCategoryKey = 'rectangle' | 'common' | 'arrow' | 'other' | 'line';
+export interface ShapePoolItem {
+    viewBox: [number, number];
+    path: string;
+    special?: boolean;
+    pathFormula?: ShapePathFormulasKeys;
+    outlined?: boolean;
+    pptxShapeType?: string;
+    title?: string;
+    withborder?: boolean;
+}
+export interface ShapeListItem {
+    categoryKey: ShapeCategoryKey;
+    children: ShapePoolItem[];
+}
+export interface ShapePathFormula {
+    editable?: boolean;
+    defaultValue?: number[];
+    range?: [number, number][];
+    relative?: string[];
+    getBaseSize?: ((width: number, height: number) => number)[];
+    formula: (width: number, height: number, values?: number[]) => string;
+}
+export declare const SHAPE_PATH_FORMULAS: Record<string, ShapePathFormula>;
+export declare const SHAPE_LIST: ShapeListItem[];

package/dist/types/configs/starterPresentation.d.ts

@@ -0,0 +1,32 @@
+import type { TranslationFunctions } from '../i18n/i18n-types';
+import type { Slide, SlideTheme } from '../types/slides';
+export interface StarterPresentationOptions {
+    title?: string;
+    titlePlaceholder?: string;
+    subtitlePlaceholder?: string;
+    bodyPlaceholder?: string;
+    /** Title-slide (cover) title size. Matches the Large title preset. */
+    titleFontSize?: number;
+    /** Title-slide (cover) subtitle size. Matches the Small title preset. */
+    subtitleFontSize?: number;
+    /** Content-slide title size. PowerPoint default ≈ 28. */
+    contentTitleFontSize?: number;
+    /** Content-slide body (level 1) size. PowerPoint default ≈ 20. */
+    bodyFontSize?: number;
+    placeholderColor?: string;
+    fontName?: string;
+    fontColor?: string;
+    backgroundColor?: string;
+}
+export interface StarterPresentationDocument {
+    title: string;
+    slides: Slide[];
+    theme?: Partial<SlideTheme>;
+}
+export declare const buildTitleSlide: (LL: TranslationFunctions, options?: StarterPresentationOptions) => Slide;
+export declare const buildContentSlide: (LL: TranslationFunctions, options?: StarterPresentationOptions) => Slide;
+export declare const buildContentsSlide: (LL: TranslationFunctions, options?: StarterPresentationOptions) => Slide;
+export declare const buildTransitionSlide: (LL: TranslationFunctions, options?: StarterPresentationOptions) => Slide;
+export declare const buildEndSlide: (LL: TranslationFunctions, options?: StarterPresentationOptions) => Slide;
+export declare const buildTwoColumnSlide: (LL: TranslationFunctions, options?: StarterPresentationOptions) => Slide;
+export declare const buildStarterPresentation: (LL: TranslationFunctions, options?: StarterPresentationOptions) => StarterPresentationDocument;

package/dist/types/configs/storage.d.ts

@@ -0,0 +1 @@
+export declare const LOCALSTORAGE_KEY_DISCARDED_DB = "FIKA_DISCARDED_DB";

package/dist/types/configs/symbol/arrow.d.ts

@@ -0,0 +1,2 @@
+declare const arrow: string[][];
+export default arrow;

package/dist/types/configs/symbol/emoji/action.d.ts

@@ -0,0 +1,2 @@
+declare const action: string[];
+export default action;

package/dist/types/configs/symbol/emoji/activity.d.ts

@@ -0,0 +1,2 @@
+declare const activity: string[];
+export default activity;

package/dist/types/configs/symbol/emoji/expression.d.ts

@@ -0,0 +1,2 @@
+declare const expression: string[];
+export default expression;

package/dist/types/configs/symbol/emoji/faunaFlora.d.ts

@@ -0,0 +1,2 @@
+declare const faunaFlora: string[];
+export default faunaFlora;

package/dist/types/configs/symbol/emoji/food.d.ts

@@ -0,0 +1,2 @@
+declare const food: string[];
+export default food;

package/dist/types/configs/symbol/emoji/objects.d.ts

@@ -0,0 +1,2 @@
+declare const objects: string[];
+export default objects;

package/dist/types/configs/symbol/emoji/symbols.d.ts

@@ -0,0 +1,2 @@
+declare const symbols: string[];
+export default symbols;

package/dist/types/configs/symbol/emoji/travel.d.ts

@@ -0,0 +1,2 @@
+declare const travel: string[];
+export default travel;

package/dist/types/configs/symbol/graph.d.ts

@@ -0,0 +1,2 @@
+declare const graph: string[][];
+export default graph;

package/dist/types/configs/symbol/index.d.ts

@@ -0,0 +1,8 @@
+export type SymbolCategoryKey = 'emoji' | 'letter' | 'number' | 'math' | 'arrow' | 'graph';
+export type EmojiTypeKey = 'expression' | 'action' | 'faunaFlora' | 'food' | 'travel' | 'activity' | 'objects' | 'symbols';
+export declare const SYMBOL_CATEGORY_KEYS: readonly SymbolCategoryKey[];
+export declare const EMOJI_TYPE_KEYS: readonly EmojiTypeKey[];
+export declare const EMOJI_TYPE_ICONS: Record<EmojiTypeKey, string>;
+export declare const getCachedSymbolItems: (category: SymbolCategoryKey, emojiType?: EmojiTypeKey) => string[] | undefined;
+export declare const loadSymbolItems: (category: SymbolCategoryKey, emojiType?: EmojiTypeKey) => Promise<string[]>;
+export declare const prefetchSymbolItems: (category: SymbolCategoryKey, emojiType?: EmojiTypeKey) => void;

package/dist/types/configs/symbol/letter.d.ts

@@ -0,0 +1,2 @@
+declare const letter: string[][];
+export default letter;

package/dist/types/configs/symbol/math.d.ts

@@ -0,0 +1,2 @@
+declare const math: string[][];
+export default math;

package/dist/types/configs/symbol/number.d.ts

@@ -0,0 +1,2 @@
+declare const number: string[][];
+export default number;

package/dist/types/configs/table.d.ts

@@ -0,0 +1,15 @@
+import type { PPTElementOutline, TableTheme } from '../types/slides';
+/** Charcoal header fill and default table theme color. */
+export declare const TABLE_INK = "#18181b";
+/** Light gray type on ink headers. */
+export declare const TABLE_ON_INK = "#fafafa";
+/** Cool zinc paper body. */
+export declare const TABLE_PAPER = "#fafafa";
+/** Cool zinc stripe. */
+export declare const TABLE_PAPER_STRIPE = "#f4f4f5";
+export declare const DEFAULT_TABLE_OUTLINE: PPTElementOutline;
+export declare const DEFAULT_TABLE_THEME: TableTheme;
+export declare const DEFAULT_TABLE_CELL_WIDTH = 108;
+export declare const DEFAULT_TABLE_CELL_MIN_HEIGHT = 44;
+export declare const DEFAULT_TABLE_ROW_COUNT = 2;
+export declare const DEFAULT_TABLE_COL_COUNT = 2;

package/dist/types/configs/templates.d.ts

@@ -0,0 +1,15 @@
+import type { TranslationFunctions } from '../i18n/i18n-types';
+import type { Slide, SlideTheme } from '../types/slides';
+export interface TemplatePayload {
+    title?: string;
+    width?: number;
+    height?: number;
+    slides: Slide[];
+    theme?: Partial<SlideTheme>;
+}
+export type TemplatePayloadLoader = () => Promise<TemplatePayload | Slide[]>;
+export declare const setCustomTemplateLoaders: (loaders?: Record<string, TemplatePayloadLoader>) => void;
+export declare const listCustomTemplateIds: () => string[];
+export declare const isKnownTemplateId: (id: string) => any;
+export declare const loadConfiguredTemplate: (id: string) => Promise<Slide[] | TemplatePayload>;
+export declare const normalizeTemplatePayload: (payload: TemplatePayload | Slide[], LL: TranslationFunctions) => TemplatePayload;

package/dist/types/configs/textPresets.d.ts

@@ -0,0 +1,85 @@
+import type { TextAlign } from '../types/slides';
+export declare const TEXT_PRESET_LARGE_TITLE: {
+    fontSize: number;
+    bold: boolean;
+    align: 'center';
+};
+export declare const TEXT_PRESET_SMALL_TITLE: {
+    fontSize: number;
+    bold: boolean;
+    align: 'center';
+};
+export declare const TEXT_PRESET_BODY: {
+    fontSize: number;
+};
+export declare const TEXT_PRESET_BODY_SMALL: {
+    fontSize: number;
+};
+export declare const TEXT_PRESET_CAPTION: {
+    fontSize: number;
+    italic: boolean;
+};
+/** Empty cover title prompt (66 × 0.55). Do not derive this from the typed size. */
+export declare const COVER_TITLE_PROMPT_SIZE = 36;
+/** First typed cover title: Large title size, without the heavy-bold preset. */
+export declare const COVER_TITLE_TYPED_SIZE = 66;
+/** Title placeholder: one step above regular, not extra-bold 600/700. */
+export declare const PLACEHOLDER_TITLE_WEIGHT = 500;
+/** Subtitle and body prompts stay regular. */
+export declare const PLACEHOLDER_PROMPT_WEIGHT = 400;
+/** Typed body/list when the slot is marked bold. Titles and subtitles skip this. */
+export declare const PLACEHOLDER_FILLED_WEIGHT = 600;
+export declare const placeholderWeightOf: (el: {
+    textType?: string;
+    placeholderBold?: boolean;
+}, empty: boolean) => 400 | 500 | 600;
+export declare const placeholderPromptFontSize: (contentFontSize: number) => number;
+export declare const placeholderContentFontSize: (fontSize?: number) => number;
+export declare const isCoverTitlePlaceholder: (el: {
+    textType?: string;
+    placeholderFontSize?: number;
+}) => boolean;
+export declare const placeholderPromptSizeOf: (el: {
+    textType?: string;
+    placeholderFontSize?: number;
+}) => number;
+export declare const placeholderTypedSizeOf: (el: {
+    textType?: string;
+    placeholderFontSize?: number;
+}) => number;
+export declare const isPlaceholderPromptFontSize: (el: {
+    textType?: string;
+    placeholderFontSize?: number;
+}, size: number) => boolean;
+/**
+ * Empty ghost keeps the original quiet prompt. Typed cover titles step up to
+ * COVER_TITLE_TYPED_SIZE without the heavy title weight. The slot fits both.
+ */
+export declare const LIST_PLACEHOLDER_TYPES: Set<string>;
+export declare const isListPlaceholderType: (textType?: string) => boolean;
+export declare const placeholderAlignOf: (el: {
+    placeholderAlign?: TextAlign;
+    textType?: string;
+}) => TextAlign;
+export declare const placeholderBoxTypography: (el: {
+    placeholder?: string;
+    placeholderFontSize?: number;
+    placeholderBold?: boolean;
+    placeholderItalic?: boolean;
+    placeholderAlign?: TextAlign;
+    textType?: string;
+}, empty: boolean) => {
+    fontSize?: undefined;
+    fontWeight?: undefined;
+    fontStyle?: undefined;
+    textAlign?: undefined;
+    '--text-fit-base-size'?: undefined;
+    '--placeholder-weight'?: undefined;
+} | {
+    fontSize: string;
+    fontWeight: number;
+    fontStyle: "italic" | "normal";
+    textAlign: TextAlign;
+    '--text-fit-base-size': string;
+    '--placeholder-weight': number;
+};

package/dist/types/configs/theme.d.ts

@@ -0,0 +1,44 @@
+import type { Gradient, PPTElementOutline, PPTElementShadow, Slide, SlideBackground, SlideType } from '../types/slides';
+/** Default accent swatches: 8 hues so Color + None + neutrals + custom fill a 7×2 grid. */
+export declare const DEFAULT_THEME_COLORS: string[];
+export interface PresetTheme {
+    id?: string;
+    name?: string;
+    background: string;
+    fontColor: string;
+    featureFontColor?: string;
+    fontname: string;
+    colors: string[];
+    /** Series palette when `colors` includes near-background swatches (Ink #171717). */
+    chartColors?: string[];
+    borderColor?: string;
+    outline?: PPTElementOutline;
+    shadow?: PPTElementShadow;
+    contentBackground?: SlideBackground;
+    featureBackground?: SlideBackground;
+    altBackground?: SlideBackground;
+    /** Matching vibe gradients. Layouts cycle these instead of light variants. */
+    backgrounds?: SlideBackground[];
+}
+/** Unstyled deck: white slide, default accents. Not in the Themes grid. */
+export declare const DEFAULT_PRESET_THEME: PresetTheme;
+export declare const gradientToCss: (gradient: Gradient) => string;
+export declare const slideBackgroundToStyle: (background?: SlideBackground, fallback?: string) => Record<string, string>;
+export declare const FEATURE_SLIDE_TYPES: SlideType[];
+export declare const isFeatureSlide: (type?: SlideType) => boolean;
+/**
+ * Duplicating the title slide copies `type: 'cover'` onto every copy, so theme
+ * apply cannot trust cover/end after the first. Re-infer from position + layout.
+ * Keep explicit `contents` / `transition` types.
+ */
+export declare const inferThemeSlideType: (slide: Slide, index: number, count: number) => SlideType;
+export declare const themeBackgroundCycle: (theme: PresetTheme) => SlideBackground[];
+export declare const resolvePresetBackground: (theme: PresetTheme, slideType?: SlideType, index?: number) => SlideBackground;
+export declare const resolvePresetFontColor: (theme: PresetTheme, _slideType?: SlideType) => string;
+export declare const themeChartColors: (theme: Pick<PresetTheme, 'colors' | 'chartColors'>) => string[];
+export declare const matchPresetTheme: (themeColors: string[]) => PresetTheme | undefined;
+/** Paint a layout preview/insert with the active preset's type-specific background and type. */
+export declare const applyPresetToLayoutSlide: (slide: Slide, theme: PresetTheme, index?: number) => void;
+export declare const sameSlideBackground: (a?: SlideBackground, b?: SlideBackground) => boolean;
+export declare const matchThemeBackgroundIndex: (theme: PresetTheme, background?: SlideBackground) => number;
+export declare const PRESET_THEMES: PresetTheme[];

package/dist/types/directive/tooltip.d.ts

@@ -0,0 +1,5 @@
+import 'tippy.js/dist/tippy.css';
+import 'tippy.js/animations/scale.css';
+import './tooltip.scss';
+declare const TooltipDirective: any;
+export default TooltipDirective;

package/dist/types/embed/EmbedRoot.d.ts

@@ -0,0 +1,5 @@
+import type { FikaMountOptions } from './types';
+export type IEmbedRootProps = {
+    init: FikaMountOptions;
+};
+export default function EmbedRoot({ init }: IEmbedRootProps): import("react").JSX.Element;

package/dist/types/embed/agentic/composition.d.ts

@@ -0,0 +1,84 @@
+/**
+ * Composition anchors + a deterministic deck-level composition sequencer.
+ *
+ * An "anchor" is the spatial center of gravity of a slide — where the eye is
+ * pulled. Layout variants each declare an anchor; the sequencer plans a
+ * non-repeating, rhythmic anchor sequence for a whole deck so consecutive
+ * slides never share the same spatial approach (the #1 cause of the "samey"
+ * look). It also designates exactly one "loud" slide (full-bleed / high
+ * intensity) so the deck has a single visual climax rather than a flat line.
+ *
+ * The sequencer is pure and deterministic: given a slide count, per-slide
+ * content hints, and the active style, it returns an ordered plan the agent
+ * follows slide-by-slide. Nothing here touches the store.
+ */
+/** Spatial center of gravity for a slide's composition. */
+export type CompositionAnchor = 'centered' | 'leftHeavy' | 'rightHeavy' | 'edgeAligned' | 'split' | 'fullBleed';
+/** Coarse content density, used to alternate busy and quiet slides. */
+export type CompositionDensity = 'sparse' | 'balanced' | 'dense';
+/** A per-slide composition assignment returned by the sequencer. */
+export interface CompositionPlanEntry {
+    /**
+     * Slide number. The agentic API returns this 1-based (first slide = 1).
+     * Internally the sequencer still stores 0-based positions and converts on the way out.
+     */
+    index: number;
+    /** The anchor to build this slide around. */
+    anchor: CompositionAnchor;
+    /** Target density — keep dense slides apart. */
+    density: CompositionDensity;
+    /** True for the single high-intensity "loud" slide of the deck. */
+    loud: boolean;
+    /** One-line rationale the agent can read aloud / log. */
+    note: string;
+}
+/** Optional per-slide hint the caller can pass to bias the plan. */
+export interface CompositionSlideHint {
+    /** Suggested anchor (e.g. the caller knows this slide is a full-bleed hero). */
+    anchor?: CompositionAnchor;
+    /** True to force this to be the loud slide. */
+    loud?: boolean;
+    /** Hint at density so the sequencer can space out busy slides. */
+    density?: CompositionDensity;
+}
+/** The full composition plan for a deck. */
+export interface CompositionPlan {
+    /** Ordered per-slide assignments (length = slideCount). */
+    slides: CompositionPlanEntry[];
+    /** 1-based slide number of the loud slide when returned over the API, or -1 when none. */
+    loudIndex: number;
+    /** The style id this plan was sequenced for (affects anchor preference). */
+    styleId: string;
+    /** Human-readable rhythm summary (e.g. "centered → leftHeavy → split → …"). */
+    rhythm: string;
+}
+/**
+ * Sequence a non-repeating composition plan for `slideCount` slides.
+ *
+ * Guarantees:
+ *  - No two consecutive slides share the same anchor.
+ *  - Dense slides are spaced out (never two dense anchors back to back).
+ *  - Exactly one loud slide (fullBleed) when the deck has ≥ 4 slides.
+ *  - Slide 0 is never loud; the final slide is quiet (centered/edgeAligned).
+ *
+ * Caller hints bias specific positions but never break the no-repeat rule —
+ * a hinted anchor that would repeat its neighbour is nudged to the next
+ * contrasting anchor in the style's bias order. Multiple `loud: true` hints
+ * collapse to the first valid middle index.
+ */
+export declare function sequenceComposition(slideCount: number, styleId: string, hints?: CompositionSlideHint[]): CompositionPlan;
+/** List the anchors a layout family supports, used to match a plan to a variant. */
+export declare function anchorsCompatible(preferred: CompositionAnchor, supported: CompositionAnchor[]): boolean;
+export interface NearestAnchorPick {
+    anchor: CompositionAnchor;
+    /** Exact match vs nearest-neighbor fallback. */
+    exact: boolean;
+}
+/**
+ * Pick the best available anchor from `supported` for a planned `preferred`.
+ * Returns null when the family cannot approximate at all (e.g. fullBleed-only
+ * request on a family with no fullBleed).
+ */
+export declare function pickNearestAnchor(preferred: CompositionAnchor, supported: CompositionAnchor[]): NearestAnchorPick | null;
+/** Convert an internal 0-based plan to the 1-based numbers agents send and receive. */
+export declare function toApiCompositionPlan(plan: CompositionPlan): CompositionPlan;

package/dist/types/embed/agentic/createAgenticApi.d.ts

@@ -0,0 +1,11 @@
+import { applyLocale } from '../localeBridge';
+import type { FikaAgentApi } from './types';
+interface AgenticRuntime {
+    api: FikaAgentApi;
+    stop(): void;
+}
+export declare function createAgenticApi(options?: {
+    setLocale?: (locale: Parameters<typeof applyLocale>[0]) => Promise<void>;
+    unmount?: () => void;
+}): AgenticRuntime;
+export {};

package/dist/types/embed/agentic/fixtures.d.ts

@@ -0,0 +1,30 @@
+import type { PPTElement } from '../../types/slides';
+import type { FikaDocument } from '../types';
+export declare const agenticBridgeGoldenElementTypes: PPTElement['type'][];
+export declare const agenticBridgeGoldenIds: {
+    readonly slide: 'slide_fixture_all_elements';
+    readonly section: 'section_fixture';
+    readonly note: 'note_fixture';
+    readonly noteReply: 'reply_fixture';
+    readonly animations: {
+        readonly textIn: 'animation_fixture_text_in';
+        readonly shapeAttention: 'animation_fixture_shape_attention';
+        readonly imageOut: 'animation_fixture_image_out';
+    };
+    readonly elements: {
+        readonly text: 'text_fixture';
+        readonly image: 'image_fixture';
+        readonly shape: 'shape_fixture';
+        readonly line: 'line_fixture';
+        readonly chart: 'chart_fixture';
+        readonly table: 'table_fixture';
+        readonly latex: 'latex_fixture';
+        readonly mermaid: 'mermaid_fixture';
+        readonly code: 'code_fixture';
+        readonly video: 'video_fixture';
+        readonly audio: 'audio_fixture';
+    };
+};
+export declare const agenticBridgeGoldenDocument: FikaDocument;
+export declare const agenticBridgeGoldenDocuments: FikaDocument[];
+export declare const agenticBridgeFixture: FikaDocument;