@orangecatai/adgen-canvas 0.0.39 → 0.1.0

package/dist/types/excalidraw/components/auto-resize/resizeLayout.d.ts

@@ -0,0 +1,33 @@
+import type { ImageBounds } from "./imageBounds";
+import type { ExcalidrawElement } from "@orangecatai/element/types";
+export declare const RESIZE_MODEL = "x-ai/grok-4.6";
+export declare const MAX_RESIZE_RETRIES = 2;
+export declare class LayoutContractError extends Error {
+}
+export type LayerMetadata = {
+    id: string;
+    role: "background" | "headline" | "body" | "legal" | "logo" | "product" | "cta" | "decoration";
+    label: string;
+    relatedTo: string[];
+};
+export type LayoutPatch = {
+    id: string;
+    x?: number;
+    y?: number;
+    width?: number;
+    height?: number;
+    fontSize?: number;
+};
+export declare function parseMetadata(value: unknown, layers: readonly ExcalidrawElement[]): LayerMetadata[];
+export declare function parsePatches(value: unknown, layers: readonly ExcalidrawElement[]): LayoutPatch[];
+export declare function applyPatches(layers: readonly ExcalidrawElement[], patches: LayoutPatch[]): ExcalidrawElement[];
+export declare function reuseLayout(layers: readonly ExcalidrawElement[], sourceW: number, sourceH: number, targetW: number, targetH: number): ExcalidrawElement[] | null;
+export declare function scaleLayout(layers: readonly ExcalidrawElement[], sourceW: number, sourceH: number, targetW: number, targetH: number): ExcalidrawElement[];
+export declare function validateLayout(layers: readonly ExcalidrawElement[], metadata: LayerMetadata[], width: number, height: number, imageBounds?: Record<string, ImageBounds>): string[];
+/** One initial candidate plus at most two repairs. Every returned candidate is verified. */
+export declare function runVerifiedLayout<T>(opts: {
+    initial: T;
+    propose: (previous: T, issues: string[], attempt: number) => Promise<T>;
+    inspect: (candidate: T, attempt: number) => Promise<string[]>;
+    signal?: AbortSignal;
+}): Promise<T>;

package/dist/types/excalidraw/components/icons.d.ts

@@ -10,6 +10,7 @@ export declare const createIcon: (d: string | React.ReactNode, opts?: number | O
 export declare const PlusPromoIcon: import("react/jsx-runtime").JSX.Element;
 export declare const LibraryIcon: import("react/jsx-runtime").JSX.Element;
 export declare const PlusIcon: import("react/jsx-runtime").JSX.Element;
+export declare const MinusIcon: import("react/jsx-runtime").JSX.Element;
 export declare const DotsIcon: import("react/jsx-runtime").JSX.Element;
 export declare const DotsHorizontalIcon: import("react/jsx-runtime").JSX.Element;
 export declare const PinIcon: import("react/jsx-runtime").JSX.Element;
@@ -107,6 +108,11 @@ export declare const FillSolidIcon: import("react/jsx-runtime").JSX.Element;
 export declare const StrokeWidthBaseIcon: import("react/jsx-runtime").JSX.Element;
 export declare const StrokeWidthBoldIcon: import("react/jsx-runtime").JSX.Element;
 export declare const StrokeWidthExtraBoldIcon: import("react/jsx-runtime").JSX.Element;
+export declare const TextBoldIcon: import("react/jsx-runtime").JSX.Element;
+export declare const TextItalicIcon: import("react/jsx-runtime").JSX.Element;
+export declare const TextUnderlineIcon: import("react/jsx-runtime").JSX.Element;
+export declare const TextStrikethroughIcon: import("react/jsx-runtime").JSX.Element;
+export declare const TextHighlightIcon: import("react/jsx-runtime").JSX.Element;
 export declare const StrokeStyleSolidIcon: React.MemoExoticComponent<({ theme }: {
     theme: Theme;
 }) => import("react/jsx-runtime").JSX.Element>;

package/dist/types/excalidraw/components/template-builder/TemplateBuilderTray.d.ts

@@ -439,6 +439,7 @@ export declare const getTemplateBuilderFrame: (elements: readonly SceneElement[]
     lineHeight: number & {
         _brand: "unitlessLineHeight";
     };
+    styleRanges?: readonly import("@orangecatai/element/types").TextStyleRange[];
 }> & {
     index: import("@orangecatai/element/types").FractionalIndex;
 }) | (Readonly<{

package/dist/types/excalidraw/index.d.ts

@@ -49,13 +49,22 @@ export { DiagramToCodePlugin } from "./components/DiagramToCodePlugin/DiagramToC
 export { getDataURL } from "./data/blob";
 export { isElementLink } from "@orangecatai/element";
 export { setCustomTextMetricsProvider } from "@orangecatai/element";
+export type { TextRunStyle, TextStyleRange } from "@orangecatai/element/types";
+export { applyStyleToRange, getCommonStyleInRange, getStyleAtOffset, normalizeStyleRanges, splitTextIntoRuns, parseHtmlToStyledText, styledTextToHtml, } from "@orangecatai/element";
 export { CommandPalette } from "./components/CommandPalette/CommandPalette";
 export { AIChatPanel } from "./components/AIChatPanel";
 export type { AIChatPanelProps, AIChatPanelRef, ChatMessage, ChatSession, } from "./components/AIChatPanel";
 export type { ExcalidrawImperativeAPI } from "./types";
+export { ActivityTimeline } from "./components/ai-chat/ActivityTimeline";
+export type { ActivityTimelineProps } from "./components/ai-chat/ActivityTimeline";
+export { applyAgentUpdate, createReducerContext, finalizeSteps, humanizeToolLabel, stepsFromLegacyToolActions, summarizeSteps, upsertStep, } from "./components/ai-chat/activitySteps";
+export type { ActivityStep, ActivityStepStatus, ActivityReducerContext, } from "./components/ai-chat/activitySteps";
+export type { AgentUpdate, ToolAction, AgentResult, } from "./components/ai-chat/agentLoop";
 export type { AppState, BinaryFiles, BinaryFileData, ExcalidrawProps, ExcalidrawInitialDataState, LibraryItem, LibraryItems, SceneData, UnsubscribeCallback, } from "./types";
 export type { ExcalidrawElement, NonDeletedExcalidrawElement, NonDeleted, OrderedExcalidrawElement, ExcalidrawElementType, ExcalidrawVideoElement, } from "@orangecatai/element/types";
 export type { ImageEditToolbarCallbacks } from "./components/ImageEditToolbar";
 export type { CustomFontSpec, BrandContext } from "./types";
 export type { CampaignSummary, AddToCampaignPayload } from "./types";
 export type { ReviewerFeedback, ReviewIssue, } from "./components/ai-chat/reviewerAgent";
+export { ALL_MODEL_CAPABILITIES, AUTO_DURATION, IMAGE_MODEL_CAPABILITIES, VIDEO_MODEL_CAPABILITIES, effectiveUserReferenceLimit, getCapabilities, groupImages, normalizeInputs, registeredModelIds, validateInputs, } from "./modelCapabilities";
+export type { AspectRatioMode, AssetCapabilities, AudioMode, CapabilityConstraint, ControlCapabilities, FrameCapabilities, InputAsset, InputCapabilityError, InputCapabilityErrorCode, ModelInputCapabilities, NormalizedGenerationInputs, RawGenerationInputs, ReferenceCapabilities, ReferenceGroup, ReferenceGrouping, RequestedControls, } from "./modelCapabilities";

package/dist/types/excalidraw/modelCapabilities/index.d.ts

@@ -0,0 +1,17 @@
+import type { ModelInputCapabilities } from "./types";
+export * from "./types";
+export * from "./validate";
+export { IMAGE_MODEL_CAPABILITIES } from "./registry.image";
+export { VIDEO_MODEL_CAPABILITIES } from "./registry.video";
+export declare const ALL_MODEL_CAPABILITIES: readonly ModelInputCapabilities[];
+/**
+ * Resolve the capability record for a model id, or null when the model is not
+ * registered. The host MUST resolve through this rather than trusting any
+ * capability values sent by the client.
+ *
+ * OpenRouter's web-search variant appends ":online" to a model id; strip it
+ * before looking up, mirroring `isModelAllowed` on the host.
+ */
+export declare function getCapabilities(modelId: string | null | undefined): ModelInputCapabilities | null;
+/** Every registered model id, for allowlist parity checks. */
+export declare function registeredModelIds(): string[];

package/dist/types/excalidraw/modelCapabilities/registry.image.d.ts

@@ -0,0 +1,2 @@
+import type { ModelInputCapabilities } from "./types";
+export declare const IMAGE_MODEL_CAPABILITIES: readonly ModelInputCapabilities[];

package/dist/types/excalidraw/modelCapabilities/registry.video.d.ts

@@ -0,0 +1,2 @@
+import type { ModelInputCapabilities } from "./types";
+export declare const VIDEO_MODEL_CAPABILITIES: readonly ModelInputCapabilities[];

package/dist/types/excalidraw/modelCapabilities/shared.d.ts

@@ -0,0 +1,24 @@
+import type { AssetCapabilities, FrameCapabilities } from "./types";
+export declare const MB: number;
+/** Image models have no frame slots at all. */
+export declare const NO_FRAMES: FrameCapabilities;
+/**
+ * Per-asset dimension/size fields left UNCHECKED because the provider does not
+ * document them.
+ *
+ * Conservative defaults cut two different ways, and the distinction matters:
+ *
+ *   - For COUNTS and COMBINATIONS, the safest default is restrictive. Sending
+ *     one reference too many, or an unsupported refs+frames mix, means a paid
+ *     request that fails upstream. So an undocumented cap becomes the tightest
+ *     documented-adjacent value (MAI Image -> 1 image; Veo refs+frames -> not
+ *     allowed).
+ *
+ *   - For per-asset DIMENSION bounds, the safest default is no check at all.
+ *     Inventing a ceiling would reject images the provider would have accepted,
+ *     turning a missing doc into a broken feature. The transport guard
+ *     (REFERENCE_WIRE_BUDGET_BYTES) still bounds the payload.
+ *
+ * Every field defaulted this way is listed in the record's `unknownFields`.
+ */
+export declare const unchecked: Pick<AssetCapabilities, "maxImageBytes" | "minEdgePx" | "maxEdgePx" | "inputPixels" | "inputAspectRatioRange">;

package/dist/types/excalidraw/modelCapabilities/types.d.ts

@@ -0,0 +1,276 @@
+/**
+ * Hard cap on user-supplied reference images per generation. Six covers every
+ * realistic ad brief. This is a product/transport decision, NOT a provider
+ * limit — `ModelInputCapabilities.references.maxImages` carries those.
+ */
+export declare const MAX_USER_REFERENCE_IMAGES = 6;
+/**
+ * Ceiling on total attached references across all tiers.
+ * 6 user + 1 source + 1 logo + 2 brand assets + 2 ad references.
+ */
+export declare const MAX_REFERENCE_IMAGES = 12;
+/**
+ * Wire-byte budget for the attached images alone. Vercel rejects at 4.5 MB;
+ * this leaves headroom for the prompt, brand context and JSON envelope.
+ */
+export declare const REFERENCE_WIRE_BUDGET_BYTES: number;
+/**
+ * What the SDK assumes a host-injected brand asset costs on the wire, and the
+ * ceiling the host compresses each one to before injecting it.
+ */
+export declare const HOST_ASSET_BYTE_RESERVATION: number;
+export type CapabilityCondition = {
+    kind: "hasReferences";
+} | {
+    kind: "hasStartFrame";
+} | {
+    kind: "hasEndFrame";
+} | {
+    kind: "hasAnyFrame";
+} | {
+    kind: "resolutionIn";
+    values: readonly string[];
+};
+export type CapabilityRequirement = {
+    kind: "durationMustBe";
+    seconds: number;
+} | {
+    kind: "resolutionAtMost";
+    value: string;
+} | {
+    kind: "aspectRatioMustBe";
+    value: string;
+};
+export interface CapabilityConstraint {
+    /** Fires when ANY of these conditions holds. */
+    whenAny: readonly CapabilityCondition[];
+    requires: CapabilityRequirement;
+    /** User-readable explanation, quoting the provider rule where possible. */
+    message: string;
+}
+/**
+ * Ordering used by `resolutionAtMost`. Lower rank = smaller output.
+ * Keys are compared case-insensitively.
+ */
+export declare const RESOLUTION_RANK: Readonly<Record<string, number>>;
+export type Modality = "image" | "video";
+/**
+ * How a model groups reference images.
+ *
+ * `flat`     — a plain list of images (Seedream, Seedance, Wan, Grok, Veo).
+ * `elements` — nested subjects, each built from several views of one subject.
+ *              Kling 3.0 only: max 3 Elements, each 1 frontal image plus 1-3
+ *              additional angles. A flat count cannot express this.
+ */
+export type ReferenceGrouping = "flat" | "elements";
+export interface ReferenceCapabilities {
+    supported: boolean;
+    grouping: ReferenceGrouping;
+    /** Max reference IMAGES. For `elements`, the total across all groups. */
+    maxImages: number;
+    /** `elements` only: max number of subjects. */
+    maxGroups?: number;
+    /** `elements` only: images permitted per subject, frontal image included. */
+    imagesPerGroup?: {
+        min: number;
+        max: number;
+    };
+    maxVideos: number;
+    maxAudios: number;
+    /** Provider-side ceiling across every reference asset type, when documented. */
+    maxTotalAssets?: number;
+    acceptsImageAndVideoReferences: boolean;
+    /**
+     * Whether references may accompany a start/end frame. This is the field the
+     * providers disagree on most sharply: ByteDance and Alibaba forbid the
+     * combination outright, xAI explicitly permits it, and Google documents
+     * neither (so Veo takes the conservative `false`).
+     */
+    canCombineWithStartFrame: boolean;
+    canCombineWithEndFrame: boolean;
+}
+export interface FrameSlotCapability {
+    supported: boolean;
+    maxImages: 0 | 1;
+}
+export interface FrameCapabilities {
+    start: FrameSlotCapability;
+    end: FrameSlotCapability;
+    allowsStartAndEndTogether: boolean;
+    /**
+     * True when an end frame is only accepted alongside a start frame.
+     * Veo 3.1: `lastFrame` "must be used in combination with the image
+     * parameter". Kling 3.0: "last-frame-only video generation is not
+     * supported".
+     */
+    endFrameRequiresStartFrame: boolean;
+}
+export interface AssetCapabilities {
+    /** Lower-case MIME types the provider documents for input images. */
+    imageMimeTypes: readonly string[];
+    maxImageBytes: number | null;
+    minEdgePx: number | null;
+    maxEdgePx: number | null;
+    /**
+     * Permitted total pixel count (width x height) of an INPUT image. Several
+     * providers bound the product rather than either edge -- Seedream allows
+     * [196, 36,000,000] regardless of how the pixels are distributed.
+     */
+    inputPixels: {
+        min: number;
+        max: number;
+    } | null;
+    /** Permitted width/height ratio of an INPUT image, as [min, max]. */
+    inputAspectRatioRange: readonly [number, number] | null;
+    /** Provider cap on the whole request body. */
+    maxRequestBytes: number | null;
+}
+/**
+ * How the provider treats an explicit output aspect ratio.
+ *
+ * `settable`                 — accepts an explicit value in every mode.
+ * `forcedAdaptiveWithFrames` — accepts a value for text-to-video, but requires
+ *                              `adaptive` once a frame is attached, deriving the
+ *                              ratio from the first frame (Seedance 2.x).
+ * `notApplicableWithFrames`  — the image-to-video endpoint has no aspect-ratio
+ *                              parameter at all, though text-to-video does
+ *                              (Kling 3.0).
+ * `notApplicable`            — no aspect-ratio parameter in any mode.
+ */
+export type AspectRatioMode = "settable" | "forcedAdaptiveWithFrames" | "notApplicableWithFrames" | "notApplicable";
+/** The value providers use to mean "derive the ratio from the input media". */
+export declare const ADAPTIVE_ASPECT_RATIO = "adaptive";
+export type AudioMode = "always-on" | "toggle-default-on" | "toggle-default-off" | "none";
+export interface ControlCapabilities {
+    aspectRatioMode: AspectRatioMode;
+    aspectRatios: readonly string[];
+    resolutions: readonly string[];
+    /** Discrete allowed durations. Mutually exclusive with min/max. */
+    durationsSeconds?: readonly number[];
+    minDurationSeconds?: number;
+    maxDurationSeconds?: number;
+    /** Whether the provider accepts `-1` / auto duration. */
+    supportsAutoDuration?: boolean;
+    audio: AudioMode;
+    supportsNegativePrompt: boolean;
+    supportsSeed: boolean;
+    /** Output pixel envelope, where the provider documents one. */
+    outputPixels?: {
+        min: number;
+        max: number;
+    };
+    /** Output edge constraints, where documented. */
+    outputEdge?: {
+        min?: number;
+        max?: number;
+        multipleOf?: number;
+    };
+    /** Max ratio of longer edge to shorter edge for the OUTPUT. */
+    maxOutputEdgeRatio?: number;
+}
+export interface VerificationRecord {
+    /** First-party doc URL(s) the values were transcribed from. */
+    sources: readonly string[];
+    /** ISO date the transcription was checked. */
+    checkedOn: string;
+}
+export interface ModelInputCapabilities {
+    modelId: string;
+    modality: Modality;
+    verified: VerificationRecord;
+    /**
+     * Dotted paths of fields holding a CONSERVATIVE DEFAULT because the
+     * first-party docs do not state the value. Never empty-by-omission: a field
+     * absent from this list is a transcribed, verified value.
+     */
+    unknownFields: readonly string[];
+    /** Why each unknown field defaults the way it does, keyed by the same path. */
+    unknownNotes?: Readonly<Record<string, string>>;
+    references: ReferenceCapabilities;
+    frames: FrameCapabilities;
+    assets: AssetCapabilities;
+    controls: ControlCapabilities;
+    constraints: readonly CapabilityConstraint[];
+    /** Provider rules we cannot check client-side, surfaced for messaging. */
+    providerCaveats?: readonly string[];
+}
+export interface InputAsset {
+    /** Data URL or remote URL. Empty string marks a host-filled placeholder. */
+    dataUrl: string;
+    mimeType?: string;
+    bytes?: number;
+    widthPx?: number;
+    heightPx?: number;
+    label?: string;
+}
+/**
+ * A reference "subject" for `elements` grouping: one frontal view plus
+ * additional angles of the same subject.
+ */
+export interface ReferenceGroup {
+    frontal: InputAsset;
+    additional: InputAsset[];
+    label?: string;
+}
+/**
+ * Every request is normalized into explicit slots before validation. The
+ * validator must keep these categories distinct: a start frame is not an
+ * ordinary reference image unless the provider docs say it is counted as one,
+ * and the same holds for an end frame and a Quick Edit source image.
+ */
+export interface NormalizedGenerationInputs {
+    startFrame: InputAsset | null;
+    endFrame: InputAsset | null;
+    /**
+     * How many images the caller actually supplied for each frame slot. Every
+     * registered model accepts at most one, so anything above that is reported
+     * rather than silently truncated.
+     */
+    startFrameCount: number;
+    endFrameCount: number;
+    referenceImages: InputAsset[];
+    referenceVideos: InputAsset[];
+    referenceAudios: InputAsset[];
+    /** `elements` grouping only. */
+    referenceGroups: ReferenceGroup[];
+    sourceImage: InputAsset | null;
+    brandLogo: InputAsset | null;
+    /** Host-injected brand/ad references the SDK only reserves room for. */
+    hostReferences: InputAsset[];
+}
+/**
+ * What callers hand to `normalizeInputs`. Every field is optional, and the
+ * frame slots accept either a single asset or an array so an over-supply is
+ * visible to the validator.
+ */
+export interface RawGenerationInputs {
+    startFrame?: InputAsset | InputAsset[] | null;
+    endFrame?: InputAsset | InputAsset[] | null;
+    referenceImages?: InputAsset[];
+    referenceVideos?: InputAsset[];
+    referenceAudios?: InputAsset[];
+    referenceGroups?: ReferenceGroup[];
+    sourceImage?: InputAsset | null;
+    brandLogo?: InputAsset | null;
+    hostReferences?: InputAsset[];
+}
+/** The control values accompanying a request, for constraint evaluation. */
+export interface RequestedControls {
+    aspectRatio?: string;
+    resolution?: string;
+    durationSeconds?: number;
+    audio?: boolean;
+    seed?: number;
+    negativePrompt?: string;
+}
+export type InputCapabilityErrorCode = "UNKNOWN_MODEL_CAPABILITIES" | "START_FRAME_NOT_SUPPORTED" | "END_FRAME_NOT_SUPPORTED" | "TOO_MANY_START_FRAMES" | "TOO_MANY_END_FRAMES" | "END_FRAME_REQUIRES_START_FRAME" | "START_AND_END_FRAME_NOT_SUPPORTED_TOGETHER" | "FRAME_REFERENCE_COMBINATION_NOT_SUPPORTED" | "REFERENCE_FRAME_COMBINATION_UNVERIFIED" | "REFERENCES_NOT_SUPPORTED" | "TOO_MANY_REFERENCE_IMAGES" | "TOO_MANY_REFERENCE_VIDEOS" | "TOO_MANY_REFERENCE_AUDIOS" | "TOO_MANY_REFERENCE_ASSETS" | "TOO_MANY_REFERENCE_GROUPS" | "INVALID_REFERENCE_GROUP_SIZE" | "UNSUPPORTED_MEDIA_TYPE" | "UNSUPPORTED_DIMENSIONS" | "REQUEST_TOO_LARGE" | "UNSUPPORTED_CONTROL" | "CONTROL_CONSTRAINT_VIOLATED";
+export interface InputCapabilityError {
+    code: InputCapabilityErrorCode;
+    message: string;
+    modelId: string;
+    /** Which input category or control caused the rejection. */
+    field?: string;
+    /** The permitted value, count, or set of values. */
+    allowed?: number | string | readonly string[];
+    received?: number | string;
+}

package/dist/types/excalidraw/modelCapabilities/validate.d.ts

@@ -0,0 +1,48 @@
+import type { InputAsset, InputCapabilityError, ModelInputCapabilities, NormalizedGenerationInputs, RawGenerationInputs, ReferenceGroup, RequestedControls } from "./types";
+/** The sentinel providers use for "pick a duration for me". */
+export declare const AUTO_DURATION = -1;
+/**
+ * Normalize a request into explicit slots. The categories stay distinct: a
+ * start frame is never folded into the reference list, and neither is a Quick
+ * Edit source image, because providers count them separately.
+ */
+export declare function normalizeInputs(raw: RawGenerationInputs): NormalizedGenerationInputs;
+/** Every image in a reference group, frontal view first. */
+export declare function groupImages(group: ReferenceGroup): InputAsset[];
+/**
+ * How many user-supplied reference images this model can actually take.
+ *
+ * The transport guard and the provider limit are different things and either
+ * may bind: most providers accept far more than we ever send (Seedance allows
+ * 30), while two accept fewer (MAI Image 1, Grok Imagine Image 5).
+ *
+ * `reserved` is the number of provider-counted inputs already spoken for — a
+ * Quick Edit source image, a logo, a host-injected brand asset.
+ */
+export declare function effectiveUserReferenceLimit(caps: ModelInputCapabilities, reserved: number, globalLimit?: number): number;
+/**
+ * The duration a model's own constraints force for this request, or null when
+ * nothing is forced.
+ *
+ * Veo 3.1 is the case that matters: reference images, 1080p and 4K each
+ * require an 8 second duration. The UI needs this to pick a valid default and
+ * to coerce the duration when the user changes resolution, rather than
+ * letting the two controls drift into a combination the provider rejects.
+ */
+export declare function requiredDurationFor(caps: ModelInputCapabilities | null | undefined, inputs: NormalizedGenerationInputs, controls: RequestedControls): number | null;
+/**
+ * The highest resolution this request may use, given the model's constraints,
+ * or null when nothing is capped. Grok Imagine Video caps reference-to-video
+ * at 720p even though the model itself supports 1080p.
+ */
+export declare function maxResolutionFor(caps: ModelInputCapabilities | null | undefined, inputs: NormalizedGenerationInputs, controls: RequestedControls): string | null;
+/** Resolutions from `caps` that are usable for this request. */
+export declare function allowedResolutionsFor(caps: ModelInputCapabilities | null | undefined, inputs: NormalizedGenerationInputs, controls: RequestedControls): readonly string[];
+/**
+ * Validate a normalized request against a capability record.
+ *
+ * `caps` is nullable on purpose: an unregistered model must be rejected, not
+ * waved through, and the host resolves the record itself rather than trusting
+ * anything the client sent.
+ */
+export declare function validateInputs(caps: ModelInputCapabilities | null | undefined, inputs: NormalizedGenerationInputs, controls: RequestedControls): InputCapabilityError[];

package/dist/types/excalidraw/types.d.ts

@@ -761,8 +761,8 @@ export interface ExcalidrawProps {
      * background regeneration and the agent chat `generate_image` tool.
      * Pass the same value here and to `AIChatPanel.agentImageModel` to keep
      * both surfaces on the same model with a single configuration.
-     * @default "openai/gpt-image-2"
-     * @example "google/gemini-3.1-flash-image-preview"
+     * @default "openai/gpt-image-2.5-flare"
+     * @example "google/gemini-3.1-flash-lite-image"
      */
     agentImageModel?: string;
     /**
@@ -787,9 +787,9 @@ export interface ExcalidrawProps {
      * model at all.
      *
      * Must support extreme aspect ratios (4:1, 1:4, 8:1, 1:8) and be callable
-     * from `chat/completions`. `openai/gpt-image-2` satisfies NEITHER — it is
+     * from `chat/completions`. GPT Image models satisfy neither — they are
      * generation-only on OpenRouter and its ratio enum stops at 3:1 / 1:3.
-     * @default "google/gemini-3.1-flash-image-preview"
+     * @default "google/gemini-3.1-flash-lite-image"
      */
     outpaintModel?: string;
     /**

package/dist/types/excalidraw/utils/imageApi.d.ts

@@ -102,4 +102,7 @@ aspectRatio: string | null, imageSize: string | null, textOutput: boolean, image
      */
     hostBrandAssetSlots?: number;
     hostAdReferenceSlots?: number;
+    quality?: "auto" | "low" | "medium" | "high" | "xhigh" | "max";
+    background?: "auto" | "opaque" | "transparent";
+    outputFormat?: "png" | "webp";
 }): Promise<string>;

package/dist/types/excalidraw/utils/referenceBudget.d.ts

@@ -42,6 +42,7 @@
  * downscales everything, then escalates compression on the largest offenders,
  * and only starts shedding slots if the payload is *still* over budget.
  */
+import { HOST_ASSET_BYTE_RESERVATION, MAX_REFERENCE_IMAGES, MAX_USER_REFERENCE_IMAGES, REFERENCE_WIRE_BUDGET_BYTES } from "../modelCapabilities/types";
 /** Reference tiers in descending priority. Index === priority rank. */
 export declare const REFERENCE_TIERS: readonly ["user", "source", "logo", "brandAsset", "adReference"];
 export type ReferenceTier = typeof REFERENCE_TIERS[number];
@@ -64,31 +65,19 @@ export interface DroppedSlot {
     reason: "count" | "bytes";
 }
 /**
- * Hard cap on user-supplied reference images per generation. Six covers every
- * realistic ad brief and keeps the request inside the limits of the models we
- * route to.
- */
-export declare const MAX_USER_REFERENCE_IMAGES = 6;
-/**
- * Ceiling on total attached references. 6 user + 1 source + 1 logo + 2 brand
- * assets + 2 ad references. Comfortably under the ~20 images-per-request cap
- * observed on OpenRouter.
- */
-export declare const MAX_REFERENCE_IMAGES = 12;
-/**
- * Wire-byte budget for the attached images alone.
+ * These four are TRANSPORT guards — our own limits, not any provider's — and
+ * they now live alongside the capability contract so both enforcement layers
+ * read the same numbers. Re-exported here because this module has been their
+ * import site for a long time.
  *
- * Vercel rejects at 4.5 MB. This leaves ~1.3 MB of headroom for the prompt,
- * the brand context block, and the JSON envelope — all of which the caller can
- * further reserve against via `reservedBytes`.
- */
-export declare const REFERENCE_WIRE_BUDGET_BYTES: number;
-/**
- * What the SDK assumes a host-injected brand asset costs on the wire, and the
- * ceiling the host compresses each one down to before injecting it. Keeping
- * both sides on the same number is what makes the SDK's reservation honest.
+ * A transport guard and a provider limit are different things and either may
+ * bind. Most providers accept far more than we send (Seedance allows 30
+ * references and a 64 MB body), but two accept fewer — MAI Image takes one
+ * input image, Grok Imagine Image five — so a count that clears these guards
+ * can still be invalid. Use `effectiveUserReferenceLimit` from
+ * ../modelCapabilities, which takes the smaller of the two.
  */
-export declare const HOST_ASSET_BYTE_RESERVATION: number;
+export { HOST_ASSET_BYTE_RESERVATION, MAX_REFERENCE_IMAGES, MAX_USER_REFERENCE_IMAGES, REFERENCE_WIRE_BUDGET_BYTES, };
 /** Sort into priority order, stable within a tier. */
 export declare function orderByPriority(slots: ReferenceSlot[]): ReferenceSlot[];
 /**

package/dist/types/excalidraw/utils/videoApi.d.ts

@@ -1,14 +1,34 @@
+/**
+ * One reference SUBJECT for models whose references are nested rather than a
+ * flat list. Kling 3.0 calls these "Elements": each is built from one frontal
+ * reference image plus 1-3 other angles or close-ups of the same subject.
+ *
+ * See ELEMENTS_TRANSPORT_ENABLED in VideoGeneratorPanel for why this is not
+ * yet sent on the wire.
+ */
+export interface VideoReferenceSubject {
+    frontalDataUrl: string;
+    additionalDataUrls: string[];
+}
 export interface VideoJobParams {
     model: string;
     prompt: string;
-    aspectRatio: string;
+    /**
+     * Omitted entirely for models whose image-to-video endpoint has no
+     * aspect-ratio parameter (Kling 3.0), and sent as "adaptive" where the
+     * provider requires the ratio to follow the first frame (Seedance 2.x).
+     */
+    aspectRatio?: string;
     duration?: number;
     resolution?: string;
     firstFrameDataUrl?: string;
     lastFrameDataUrl?: string;
     audio?: boolean;
     negativePrompt?: string;
+    /** Flat reference images, for providers that take a plain list. */
     inputReferences?: string[];
+    /** Nested reference subjects, for providers that group them (Kling). */
+    referenceSubjects?: VideoReferenceSubject[];
     seed?: number;
 }
 export interface VideoJobResult {

package/dist/types/excalidraw/wysiwyg/richTextEditable.d.ts

@@ -0,0 +1,36 @@
+import { getCommonStyleInRange } from "@orangecatai/element";
+import type { ExcalidrawTextElement, TextRunStyle, TextStyleRange } from "@orangecatai/element/types";
+/**
+ * The WYSIWYG text editor surface.
+ *
+ * It's a `contenteditable` (a textarea can't show mixed formatting) that
+ * exposes the slice of the `HTMLTextAreaElement` API the editor was written
+ * against — `value`, `selectionStart`, `selectionEnd`, `select()` — so that
+ * indent/outdent, paste, submit and blur handling keep working unchanged, and
+ * so host code that pokes at `.excalidraw-wysiwyg` doesn't have to care.
+ *
+ * On top of that it owns the per-range styles: the DOM is rendered from
+ * `{ value, styleRanges }` and re-read back after every edit, which is what
+ * keeps style offsets correct across typing, deleting and pasting without any
+ * manual index bookkeeping.
+ */
+export type RichTextEditable = HTMLDivElement & {
+    value: string;
+    selectionStart: number;
+    selectionEnd: number;
+    select: () => void;
+    setSelectionRange: (start: number, end: number) => void;
+    /** per-range styles, indexed against `value` */
+    styleRanges: readonly TextStyleRange[] | undefined;
+    /** applies a style patch to the current selection (no-op if collapsed) */
+    applyStyleToSelection: (patch: TextRunStyle) => void;
+    /** the style shared by the current selection, for the properties panel */
+    getSelectionStyle: () => ReturnType<typeof getCommonStyleInRange>;
+    /** replaces the selection with styled text (used by paste) */
+    insertStyledText: (text: string, ranges?: readonly TextStyleRange[]) => void;
+    /** re-renders the DOM, e.g. after the element's base style changed */
+    refresh: () => void;
+};
+/** base (element-level) style the runs are layered on top of */
+export type RichTextBaseStyle = Pick<ExcalidrawTextElement, "fontSize" | "fontFamily" | "strokeColor">;
+export declare const createRichTextEditable: (getBaseStyle: () => RichTextBaseStyle) => RichTextEditable;

package/dist/types/excalidraw/wysiwyg/textSelectionStyles.d.ts

@@ -0,0 +1,32 @@
+import type { TextRunStyle } from "@orangecatai/element/types";
+import type { RichTextEditable } from "./richTextEditable";
+/**
+ * Bridge between the properties panel and the open text editor.
+ *
+ * When text is being edited and part of it is highlighted, style changes from
+ * the panel apply to that range only (Canva/Docs behaviour) instead of to the
+ * whole element. The editor owns the text and its style ranges while it's
+ * open, so panel changes are routed through it — the resulting `input` event
+ * persists them onto the element the same way typing does.
+ */
+export declare const getActiveTextEditor: () => RichTextEditable | null;
+/** the highlighted range in the open editor, if any */
+export declare const getActiveTextSelection: () => {
+    editor: RichTextEditable;
+    start: number;
+    end: number;
+} | null;
+/**
+ * Applies a style patch to the highlighted text, returning whether it did.
+ * A `false` return means the caller should fall back to changing the property
+ * on the whole element.
+ */
+export declare const applyStyleToActiveTextSelection: (patch: TextRunStyle) => boolean;
+/**
+ * The style shared by the highlighted text, for rendering the panel's own
+ * state (a field that differs across the range comes back in `mixed`).
+ */
+export declare const getActiveTextSelectionStyle: () => {
+    style: TextRunStyle;
+    mixed: import("@orangecatai/element").TextRunStyleKey[];
+} | null;