@orangecatai/adgen-canvas 0.0.30 → 0.0.32

package/dist/prod/subset-shared.chunk.js

@@ -1 +1 @@
-import{a,b,c,d}from"./chunk-Z5NKEFVG.js";import"./chunk-SZMIDXG6.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};
+import{a,b,c,d}from"./chunk-Z5NKEFVG.js";import"./chunk-452N23ZE.js";import"./chunk-SRAX5OIU.js";export{a as Commands,b as subsetToBase64,c as subsetToBinary,d as toBase64};

package/dist/prod/subset-worker.chunk.js

@@ -1 +1 @@
-import{a as r,c as t}from"./chunk-Z5NKEFVG.js";import"./chunk-SZMIDXG6.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};
+import{a as r,c as t}from"./chunk-Z5NKEFVG.js";import"./chunk-452N23ZE.js";import"./chunk-SRAX5OIU.js";var s=import.meta.url?new URL(import.meta.url):void 0;typeof window>"u"&&typeof self<"u"&&(self.onmessage=async e=>{switch(e.data.command){case r.Subset:let a=await t(e.data.arrayBuffer,e.data.codePoints);self.postMessage(a,{transfer:[a]});break}});export{s as WorkerUrl};

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

@@ -1,5 +1,5 @@
 import React from "react";
-import { type ToolAction } from "./ai-chat/agentLoop";
+import { type ToolAction, type FrameGenerationMeta } from "./ai-chat/agentLoop";
 import "./AIChatPanel.scss";
 import type { ReviewerFeedback } from "./ai-chat/reviewerAgent";
 import type { ExcalidrawImperativeAPI } from "../types";
@@ -18,6 +18,16 @@ export type ChatMessage = {
     }>;
     /** Reviewer feedback attached to an assistant message after HTML ad generation */
     reviewFeedback?: ReviewerFeedback;
+    /**
+     * Set on an assistant message that generated/regenerated an image for a
+     * frame. Persisted so that on reload / session switch,
+     * resetAndSeedFrameGenerationMemory can rebuild canvasTools' in-memory
+     * frame-continuity state (original prompt anchor, reference-image reuse,
+     * "frames generated in this conversation" list) from chat history — none
+     * of that survives a reload on its own since it lives in a JS module, not
+     * the DB. See FrameGenerationMeta in agentLoop.ts.
+     */
+    generatedFrame?: FrameGenerationMeta;
 };
 export type ChatSession = {
     id: string;
@@ -121,8 +131,8 @@ export type AIChatPanelProps = {
     transcribeUrl?: string;
     /**
      * OpenRouter model ID used by the agent's generate_image tool.
-     * @default "google/gemini-3.1-flash-image-preview"
-     * @example "google/gemini-2.5-flash-image"
+     * @default "openai/gpt-image-2"
+     * @example "google/gemini-3.1-flash-image-preview"
      */
     agentImageModel?: string;
     /**

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

@@ -11,6 +11,7 @@ import { LaserTrails } from "../laser-trails";
 import { isOverScrollBars } from "../scene/scrollbars";
 import { LassoTrail } from "../lasso";
 import { EraserTrail } from "../eraser";
+import { type ElementPickerState } from "./elementPicker";
 import type { ExcalidrawElement, NonDeleted, ExcalidrawImageElement, NonDeletedExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawIframeElement, ExcalidrawEmbeddableElement, Ordered, SceneElementsMap } from "@orangecatai/element/types";
 import type { Mutable } from "@orangecatai/common/utility-types";
 import type { ExportedElements } from "../data";
@@ -239,6 +240,13 @@ declare class App extends React.Component<AppProps, AppState> {
     missingPointerEventCleanupEmitter: Emitter<[event: PointerEvent | null]>;
     onRemoveEventListenersEmitter: Emitter<[]>;
     constructor(props: AppProps);
+    /**
+     * Arms (or disarms) canvas element picking. While armed, the next canvas
+     * pointer-down resolves the element under the cursor instead of changing
+     * selection — see `handleCanvasPointerDown` and `elementPicker.ts` for why
+     * selection must not move.
+     */
+    setElementPicker: (picker: ElementPickerState | null) => void;
     updateEditorAtom: <Value, Args extends unknown[], Result>(atom: WritableAtom<Value, Args, Result>, ...args: Args) => Result;
     private onWindowMessage;
     private handleSkipBindMode;

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

@@ -0,0 +1,14 @@
+import React from "react";
+import "./ChipSourceMenu.scss";
+export declare const ChipSourceMenu: React.FC<{
+    onUpload: () => void;
+    onPickFromCanvas: () => void;
+    onClose: () => void;
+    /** Label for the canvas option — videos are not always eligible. */
+    pickLabel?: string;
+}>;
+/** Asks which frame of a picked video should fill the chip. */
+export declare const VideoFrameChoiceMenu: React.FC<{
+    onChoose: (which: "first" | "last") => void;
+    onCancel: () => void;
+}>;

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

@@ -0,0 +1,8 @@
+import React from "react";
+import "./ElementPickHighlight.scss";
+import type { ExcalidrawElement } from "@orangecatai/element/types";
+import type { AppState } from "../types";
+export declare const ElementPickHighlight: React.FC<{
+    element: ExcalidrawElement | null;
+    appState: AppState;
+}>;

package/dist/types/excalidraw/components/ai-chat/agentLoop.d.ts

@@ -56,9 +56,26 @@ export type AgentUpdate = {
     message: string;
     feedback: import("./reviewerAgent").ReviewerFeedback;
 };
+/**
+ * Metadata about a frame this turn generated an image for. The caller
+ * (AIChatPanel) attaches this to the persisted assistant ChatMessage so that
+ * on a later page load / session switch, canvasTools' in-memory
+ * frameGenerationMemory / chatCreatedFrames (which otherwise reset with the
+ * page) can be reconstructed from chat history via
+ * resetAndSeedFrameGenerationMemory — without this, "fix the previous image"
+ * only works within the same unreloaded tab, which defeats the point.
+ */
+export type FrameGenerationMeta = {
+    frameId: string;
+    prompt: string;
+    referenceImageIndex?: number;
+    userBrief: string;
+};
 export type AgentResult = {
     reply: string;
     toolActions: ToolAction[];
+    /** Set when this turn generated (or regenerated) an image for a frame. */
+    frameGeneration?: FrameGenerationMeta;
 };
 export type FileAttachment = {
     name: string;
@@ -107,7 +124,7 @@ export declare function runAgentLoop(opts: {
      * Maximum number of reviewer rounds per banner.
      * After this many rounds the reviewer is skipped and the outer MAX_ITERATIONS
      * cap handles loop termination.
-     * @default 2
+     * @default 1
      */
     maxReviewRounds?: number;
 }): Promise<AgentResult>;

package/dist/types/excalidraw/components/ai-chat/canvasTools.d.ts

@@ -1,5 +1,11 @@
 import type { ExcalidrawElement } from "@orangecatai/element/types";
 import type { ExcalidrawImperativeAPI, BrandContext } from "../../types";
+/**
+ * Image model the chat agent's `generate_image` tool falls back to when the host
+ * does not pass `agentImageModel`. Hosts should pass the prop — this only keeps
+ * the SDK usable standalone.
+ */
+export declare const DEFAULT_AGENT_IMAGE_MODEL = "openai/gpt-image-2";
 /** The only video model the chat agent can drive. */
 export declare const CHAT_VIDEO_MODEL = "google/veo-3.1-fast";
 export declare const VIDEO_TOOLS: ({
@@ -12,11 +18,21 @@ export declare const VIDEO_TOOLS: ({
             properties: {
                 first_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas, or to continue from an existing clip. When it names a video, first_frame_which selects which frame of that clip is taken.";
+                };
+                first_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when first_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last', which is what continuing a clip needs.";
                 };
                 last_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element on the canvas to use as the video's closing frame. Optional.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element on the canvas to use as the video's closing frame. Optional.";
+                };
+                last_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when last_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last'.";
                 };
                 first_frame_attachment_index: {
                     readonly type: "number";
@@ -68,7 +84,12 @@ export declare const VIDEO_TOOLS: ({
                 };
                 first_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas, or to continue from an existing clip. When it names a video, first_frame_which selects which frame of that clip is taken.";
+                };
+                first_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when first_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last', which is what continuing a clip needs.";
                 };
                 first_frame_attachment_index: {
                     readonly type: "number";
@@ -257,11 +278,21 @@ export declare const CANVAS_TOOLS: readonly [{
             properties: {
                 first_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas, or to continue from an existing clip. When it names a video, first_frame_which selects which frame of that clip is taken.";
+                };
+                first_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when first_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last', which is what continuing a clip needs.";
                 };
                 last_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element on the canvas to use as the video's closing frame. Optional.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element on the canvas to use as the video's closing frame. Optional.";
+                };
+                last_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when last_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last'.";
                 };
                 first_frame_attachment_index: {
                     readonly type: "number";
@@ -313,7 +344,12 @@ export declare const CANVAS_TOOLS: readonly [{
                 };
                 first_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas, or to continue from an existing clip. When it names a video, first_frame_which selects which frame of that clip is taken.";
+                };
+                first_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when first_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last', which is what continuing a clip needs.";
                 };
                 first_frame_attachment_index: {
                     readonly type: "number";
@@ -435,11 +471,21 @@ export declare const BANNER_TOOLS: readonly [...({
             properties: {
                 first_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas, or to continue from an existing clip. When it names a video, first_frame_which selects which frame of that clip is taken.";
+                };
+                first_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when first_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last', which is what continuing a clip needs.";
                 };
                 last_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element on the canvas to use as the video's closing frame. Optional.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element on the canvas to use as the video's closing frame. Optional.";
+                };
+                last_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when last_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last'.";
                 };
                 first_frame_attachment_index: {
                     readonly type: "number";
@@ -491,7 +537,12 @@ export declare const BANNER_TOOLS: readonly [...({
                 };
                 first_frame_element_id: {
                     readonly type: "string";
-                    readonly description: "ID of an existing IMAGE element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas.";
+                    readonly description: "ID of an existing IMAGE or VIDEO element already on the canvas to use as the video's opening frame (image-to-video). Use this to animate an image the user can see on the canvas, or to continue from an existing clip. When it names a video, first_frame_which selects which frame of that clip is taken.";
+                };
+                first_frame_which: {
+                    readonly type: "string";
+                    readonly enum: readonly ["first", "last"];
+                    readonly description: "Only meaningful when first_frame_element_id names a VIDEO. Which frame of that clip to use. Defaults to 'last', which is what continuing a clip needs.";
                 };
                 first_frame_attachment_index: {
                     readonly type: "number";
@@ -1011,6 +1062,18 @@ export type ToolExecutionContext = {
      * failure mode for private Vercel Blob URLs.
      */
     _templateJsonCache?: Map<string, string>;
+    /**
+     * The user's own first message, verbatim (not the LLM's paraphrase of it).
+     * generate_image's `prompt` argument is always authored fresh by the chat
+     * model — nothing forces it to preserve specific subject/scene/action
+     * details the user actually typed (only on-image copy is instructed to be
+     * verbatim). execGenerateImage appends this raw text to every image-gen
+     * call for a frame as a fidelity backstop, so a model that quietly drops or
+     * substitutes a described detail (e.g. "boy playing guitar" -> "boy
+     * walking") doesn't silently ship — the image model sees the user's exact
+     * words either way.
+     */
+    originalUserBrief?: string;
 };
 export type ToolResult = {
     success: boolean;
@@ -1019,3 +1082,44 @@ export type ToolResult = {
     statusMessage: string;
 };
 export declare function executeCanvasTool(toolName: string, rawArgs: string, ctx: ToolExecutionContext): Promise<ToolResult>;
+/**
+ * Renders `chatCreatedFrames` as a system-message string for injection into
+ * the agent loop, or "" if this session hasn't generated anything yet (in
+ * which case the caller should skip adding a message at all).
+ */
+export declare function getChatCreatedFramesContext(): string;
+/**
+ * Rebuilds `frameGenerationMemory` and `chatCreatedFrames` from persisted
+ * chat history (the assistant messages' `generatedFrame` metadata — see
+ * `FrameGenerationMeta` in agentLoop.ts). Both are in-memory module state
+ * that would otherwise be empty after a page reload or a chat-session
+ * switch, silently breaking "fix the previous image" the moment the tab
+ * isn't the one that generated it. Call this whenever chat history is
+ * (re)loaded — on mount and on every session switch — BEFORE the next
+ * message is sent.
+ *
+ * Always clears first: this also fixes the memory leaking across sessions —
+ * without a reset, switching to a different chat would keep the previous
+ * session's frames in the "generated in this conversation" list.
+ *
+ * Takes a loosely-typed array (not the SDK's `ChatMessage[]`) to avoid a
+ * circular import — `AIChatPanel.tsx` imports FROM this file already.
+ */
+export declare function resetAndSeedFrameGenerationMemory(messages: Array<{
+    generatedFrame?: {
+        frameId: string;
+        prompt: string;
+        referenceImageIndex?: number;
+        userBrief: string;
+    };
+}>): void;
+/**
+ * Fits a generated image to its frame, returning the size to place it at and
+ * its offset from the frame's top-left corner.
+ */
+export declare function fitGeneratedImageToFrame(actualW: number, actualH: number, frameW: number, frameH: number): {
+    width: number;
+    height: number;
+    offsetX: number;
+    offsetY: number;
+};

package/dist/types/excalidraw/components/ai-chat/reviewerAgent.d.ts

@@ -62,7 +62,13 @@ export declare function runReviewerAgent(opts: {
         width: number;
         height: number;
     };
-    /** Original user request — first message only, not full conversation history */
+    /**
+     * All of the user's text turns in the conversation, concatenated — not
+     * just the first message. The actual creative brief is often not
+     * userMessages[0] (e.g. "hi" -> clarifying questions -> the message that
+     * actually describes the ad), so anchoring to only the first message can
+     * silently drop the real brief.
+     */
     userBrief: string;
     /**
      * The original user-supplied reference image used to generate this frame

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

@@ -152,6 +152,12 @@ export declare function enforceMinProductBox({ x, y, width, height, targetW, tar
     width: number;
     height: number;
 };
+export declare function buildAutoResizeImagePrompt(srcW: number, srcH: number, tgtW: number, tgtH: number, aspectRatio: string, brandImages?: {
+    logo?: string;
+    fontPreview?: string;
+    fontUrl?: string;
+    name?: string;
+}, sourceTextColors?: string[]): string;
 export type PreCreatedFrameInfo = {
     frameId: string;
     x: number;

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

@@ -0,0 +1,33 @@
+import type { ExcalidrawElement } from "@orangecatai/element/types";
+/** Which element types a given pick will accept. */
+export type PickerAccept = "image" | "imageOrVideo";
+export type ElementPickerState = {
+    accept: PickerAccept;
+    /** Fired with the picked element. The picker is disarmed first. */
+    onPick: (element: ExcalidrawElement) => void;
+    /** Fired on Esc, or when the arming component unmounts. */
+    onCancel: () => void;
+    /**
+     * Fired when the user clicks canvas that holds nothing pickable. The picker
+     * stays armed — a stray click should not force the user to re-arm.
+     */
+    onMiss?: () => void;
+    /**
+     * Fired as the pointer moves with the element currently under it (or null).
+     * The arming component draws the highlight, so App never re-renders the
+     * editor on hover.
+     */
+    onHover?: (element: ExcalidrawElement | null) => void;
+};
+export declare const elementPickerAtom: import("jotai/vanilla/atom").PrimitiveAtom<ElementPickerState | null> & {
+    init: ElementPickerState | null;
+};
+export declare const isPickable: (element: ExcalidrawElement, accept: PickerAccept) => boolean;
+/**
+ * Returns the topmost pickable element containing the given scene point, or
+ * null. Deliberately does its own hit test rather than reusing
+ * `App.getElementAtPosition`: that method is private, weighs z-index against
+ * selection and bound text, and considers every element type — whereas a pick
+ * only ever targets images and videos, both plain rectangles.
+ */
+export declare const pickElementAt: (elements: readonly ExcalidrawElement[], x: number, y: number, accept: PickerAccept) => ExcalidrawElement | null;

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

@@ -1,4 +1,4 @@
-import type { ElementsMapOrArray, ExcalidrawFrameLikeElement, ExcalidrawVideoElement } from "@orangecatai/element/types";
+import type { ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawVideoElement } from "@orangecatai/element/types";
 export type FrameToolbarVariant = "frame" | "video";
 export type FrameToolbarVariantResult = {
     variant: FrameToolbarVariant;
@@ -21,3 +21,16 @@ export type FrameToolbarVariantResult = {
  * Campaign on one would present an action that is guaranteed to fail.
  */
 export declare const getFrameToolbarVariant: (frame: ExcalidrawFrameLikeElement, elements: ElementsMapOrArray) => FrameToolbarVariantResult | null;
+/**
+ * Resolves the frame that Resize should act on when an *image* is selected.
+ *
+ * An ad frame is covered edge to edge by its generated image, so clicking the
+ * artwork selects that child image, not the frame — and the child shows
+ * `ImageEditToolbar`, which has no Resize. From the user's side the button
+ * simply vanishes depending on where they clicked. This lets the image toolbar
+ * offer the same Resize action, targeting the parent frame.
+ *
+ * Returns null unless the parent frame would itself show the full "frame"
+ * toolbar, so the child never surfaces an action the frame does not have.
+ */
+export declare const getResizeTargetFrame: (element: ExcalidrawElement, elements: readonly ExcalidrawElement[]) => ExcalidrawFrameLikeElement | null;

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

@@ -0,0 +1,28 @@
+import type { PickerAccept } from "./elementPicker";
+import type { VideoFrameChoice } from "../utils/videoFrameSource";
+import type { AppClassProperties } from "../types";
+import type { ExcalidrawElement, ExcalidrawVideoElement } from "@orangecatai/element/types";
+/**
+ * `slot` is opaque to the hook — panels use it to route the resolved data URL
+ * back to the right chip ("first", "last", "reference", …).
+ */
+export type CanvasFramePicker = {
+    /** Slot currently awaiting a canvas click, or null. */
+    pickingSlot: string | null;
+    /** Video awaiting a first/last choice, or null. */
+    pendingVideo: {
+        slot: string;
+        element: ExcalidrawVideoElement;
+    } | null;
+    /** True while a video frame is being downloaded and decoded. */
+    isResolving: boolean;
+    error: string | null;
+    /** True when the last canvas click landed on nothing pickable. */
+    missed: boolean;
+    /** Element currently under the pointer while picking, for the highlight. */
+    hoveredElement: ExcalidrawElement | null;
+    begin: (slot: string, accept: PickerAccept) => void;
+    cancel: () => void;
+    chooseVideoFrame: (which: VideoFrameChoice) => void;
+};
+export declare const useCanvasFramePicker: (app: AppClassProperties, onResolved: (slot: string, dataUrl: string) => void) => CanvasFramePicker;

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 "google/gemini-3.1-flash-image-preview"
-     * @example "google/gemini-2.5-flash-image"
+     * @default "openai/gpt-image-2"
+     * @example "google/gemini-3.1-flash-image-preview"
      */
     agentImageModel?: string;
     /**
@@ -923,6 +923,7 @@ export type AppClassProperties = {
     editorInterface: App["editorInterface"];
     scene: App["scene"];
     syncActionResult: App["syncActionResult"];
+    setElementPicker: App["setElementPicker"];
     fonts: App["fonts"];
     pasteFromClipboard: App["pasteFromClipboard"];
     id: App["id"];

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

@@ -17,9 +17,16 @@ export declare function buildBrandContextMessage(ctx: BrandContext): string;
  * block before the prompt. This function only appends the per-asset mandatory
  * instructions that reference the visual attachments by position.
  */
-export declare function buildImageGenSafePrompt(prompt: string, brandContext: BrandContext, dimensions?: {
-    width: number;
-    height: number;
+export declare function buildImageGenSafePrompt(prompt: string, brandContext: BrandContext, opts?: {
+    /**
+     * True when the user attached their own reference images. The brand logo
+     * and font specimens are then not attached at all (see imageApi), so the
+     * mandates that point at them — "embed the logo VERBATIM", "render ALL text
+     * in this exact typeface" — must go too: they would order the model to
+     * reproduce images it can no longer see, and they compete with the
+     * reference the user actually chose.
+     */
+    hasUserReferences?: boolean;
 }): string;
 /**
  * Augments a video prompt with brand direction reframed for motion.
@@ -41,4 +48,10 @@ export declare function buildImageGenSafePrompt(prompt: string, brandContext: Br
  */
 export declare function buildVideoBrandPrompt(prompt: string, ctx: BrandContext, opts?: {
     hasLogoReference?: boolean;
+    /**
+     * How many of the attached references the user supplied themselves. They
+     * are attached ahead of the brand logo, so this also fixes the logo's
+     * position in the numbered manifest below.
+     */
+    userReferenceCount?: number;
 }): string;

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

@@ -1,4 +1,27 @@
-export declare function callOpenRouterImageAPI(prompt: string, modelId: string, aspectRatio: string, imageSize: string | null, textOutput: boolean, imageGenUrl: string, referenceImageDataUrl?: string, signal?: AbortSignal, brandImages?: {
+/**
+ * Hard cap on user-supplied reference images per generation. Providers differ on
+ * how many references they accept; six covers every realistic ad brief and keeps
+ * the request well inside the limits of the models we route to.
+ */
+export declare const MAX_USER_REFERENCE_IMAGES = 6;
+/**
+ * Describes each attached reference image by its real 1-based position, and
+ * states the precedence rule between them.
+ *
+ * This exists because attachment order alone does not steer the model — it
+ * follows whichever image the prompt names. Previously only the brand assets
+ * were named ("the first reference image is the exact brand logo"), so a
+ * user-supplied reference sat in the array unmentioned and was ignored.
+ *
+ * When the user attaches anything, their references are the authority: the
+ * brand kit, stored logo, and reference ads are explicitly demoted so a
+ * contradiction resolves in the user's favour rather than the brand's.
+ *
+ * Returns "" when there is nothing worth numbering, so prompts that carry no
+ * attachments are left byte-identical to before.
+ */
+export declare function buildReferenceManifest(userReferenceCount: number, brandLabels: string[]): string;
+export declare function callOpenRouterImageAPI(prompt: string, modelId: string, aspectRatio: string, imageSize: string | null, textOutput: boolean, imageGenUrl: string, referenceImageDataUrl?: string | string[], signal?: AbortSignal, brandImages?: {
     logo?: string;
     fontPreview?: string;
     /** Optional second font preview (brand body typeface) shown as a reference. */
@@ -16,4 +39,21 @@ export declare function callOpenRouterImageAPI(prompt: string, modelId: string,
      * prepended to the prompt so the model applies brand guidelines to the image.
      */
     brandContextText?: string;
+}, options?: {
+    /**
+     * How to treat `referenceImageDataUrl`.
+     *
+     * "user-priority" — the references came from the end user. They are
+     * attached FIRST, named individually in the reference manifest, and
+     * explicitly overrule the brand kit, stored logo, and brand reference ads
+     * on any contradiction. Used by the surfaces where the user picks the
+     * reference themselves: image generation, quick edit, and canvas chat.
+     *
+     * "legacy-positional" (default) — the reference is a pipeline input rather
+     * than a user choice (e.g. the auto-resize source ad), and the caller has
+     * already written its own numbered reference list into the prompt assuming
+     * brand assets come first. Preserves the original ordering and emits no
+     * manifest, so those callers are unaffected by this option.
+     */
+    referenceMode?: "user-priority" | "legacy-positional";
 }): Promise<string>;

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

@@ -0,0 +1,17 @@
+import type { ExcalidrawVideoElement } from "@orangecatai/element/types";
+export type VideoFrameChoice = "first" | "last";
+/**
+ * Downloads the video bytes. Routes through the host's download proxy for the
+ * same reason playback does — presigned URLs expire on long-lived canvases —
+ * while `blob:` URLs are fetched directly (they resolve only in this tab, and
+ * the proxy could not reach them anyway).
+ */
+export declare const fetchVideoBlob: (videoUrl: string, videoDownloadProxyUrl?: string) => Promise<Blob>;
+/**
+ * Resolves one frame of a canvas video element to a PNG/JPEG data URL.
+ *
+ * The first frame is already cached on the element as `thumbnailDataUrl`, so
+ * that case avoids the download entirely; only a last-frame pick (or a video
+ * whose thumbnail never materialised) pays for the fetch and decode.
+ */
+export declare const extractFrameFromVideoElement: (element: ExcalidrawVideoElement, which: VideoFrameChoice, videoDownloadProxyUrl?: string) => Promise<string>;

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

@@ -1,14 +1,14 @@
 export type AudioPolicy = "first-only" | "none";
 /**
- * Decodes the final frame of a video and returns it as a lossless PNG data
- * URL, suitable as the next chain segment's `firstFrameDataUrl`.
- *
- * Uses `CanvasSink.getCanvas(Infinity)` rather than seeking a `<video>`
- * element to `duration - epsilon`: a time-based seek can land on a keyframe
- * boundary or a black tail frame depending on the encoder, which poisons the
- * next segment's starting state.
+ * Decodes the final frame of a video, suitable as the next chain segment's
+ * `firstFrameDataUrl`.
  */
 export declare function extractLastFrame(video: Blob): Promise<string>;
+/**
+ * Decodes the opening frame of a video. Used when linking an existing canvas
+ * video into a generator panel's start/end frame chip.
+ */
+export declare function extractFirstFrame(video: Blob): Promise<string>;
 /**
  * Stream-copy concatenates segments produced by the same model at the same
  * codec/resolution/fps into one MP4. No re-encode — packets are demuxed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@orangecatai/adgen-canvas",
-  "version": "0.0.30",
+  "version": "0.0.32",
   "type": "module",
   "types": "./dist/types/excalidraw/index.d.ts",
   "main": "./dist/prod/index.js",

package/dist/prod/data/image-B2RV64CG.js

@@ -1 +0,0 @@
-import{S as a,T as b,U as c}from"../chunk-GTYNSLQE.js";import"../chunk-SZMIDXG6.js";import"../chunk-SRAX5OIU.js";export{c as decodePngMetadata,b as encodePngMetadata,a as getTEXtChunk};