@orangecatai/adgen-canvas 0.0.33 → 0.0.35

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

@@ -1 +1 @@
-import{a,b,c,d}from"./chunk-Z5NKEFVG.js";import"./chunk-DB27YYNM.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-TE4JIU3E.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-DB27YYNM.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-TE4JIU3E.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/element/src/frame.d.ts

@@ -20,6 +20,22 @@ export declare const groupsAreCompletelyOutOfFrame: (elements: readonly NonDelet
  */
 export declare const groupByFrameLikes: (elements: readonly ExcalidrawElement[]) => Map<string, ExcalidrawElement[]>;
 export declare const getFrameChildren: (allElements: ElementsMapOrArray, frameId: string) => ExcalidrawElement[];
+/**
+ * Frames are containers, not artwork: a frame drawn above the elements sitting
+ * on or near it hides them behind its fill and steals clicks meant for them,
+ * which reads to the user as "my image disappeared". Element order is z-order,
+ * so this pushes every frame-like element below every other element.
+ *
+ * Applied at the presentation layer only — rendering and hit testing — never to
+ * the scene itself: the scene array is mirrored by fractional indices that the
+ * store, history and collab reconciliation all reason about, and rewriting them
+ * on every scene update fights undo/redo. Relative order within each bucket is
+ * preserved, so frame-vs-frame and image-vs-image stacking survives untouched.
+ *
+ * Returns the passed array unchanged (same reference) when it already satisfies
+ * the invariant, which is the common case.
+ */
+export declare const orderFramesToBack: <T extends ExcalidrawElement>(elements: readonly T[]) => readonly T[];
 export declare const getFrameLikeElements: (allElements: ExcalidrawElementsIncludingDeleted) => ExcalidrawFrameLikeElement[];
 /**
  * Returns ExcalidrawFrameElements and non-frame-children elements.

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

@@ -87,6 +87,21 @@ export declare function getDimensions(model: ModelName, ratio: string, resolutio
     width: number;
     height: number;
 };
+/**
+ * Turn the panel's picked ratio + resolution into the request fields the model
+ * actually accepts.
+ *
+ * gpt-image-* is the awkward one: its `aspect_ratio` enum does NOT accept 4:5
+ * or 5:4 at the 2K/4K tiers, and `supportsImageSize: false` meant the picked
+ * resolution was dropped on the floor — so "4:5 at 2K" silently asked for a
+ * ratio the API rejects and gave no size at all. The panel already knows the
+ * exact pixel dimensions for every ratio/resolution pair, so hand those over
+ * as an authoritative `size` and skip the enum entirely.
+ */
+export declare function resolveRequestSize(model: ModelName, ratio: string, resolution: Resolution): {
+    aspectRatio: string | null;
+    imageSize: string | null;
+};
 export declare const ImageGeneratorPanel: ({ element, app, onBeforeImageGen, onAfterImageGen, }: {
     element: NonDeletedExcalidrawElement & ExcalidrawFrameLikeElement;
     app: AppClassProperties;

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

@@ -19,25 +19,8 @@
  * multi-megabyte data URLs, and those are re-sent on every subsequent turn.
  * Normalising here fixes existing conversations, not just new uploads.
  */
-/** Estimated wire size of a data URL: the base64 payload is what gets sent. */
-export declare function dataUrlWireBytes(dataUrl: string): number;
-/**
- * Whether a data URL is a raster format safe to send as an `image_url` block.
- * SVG is commonly rejected outright by vision models, and canvas re-encoding
- * of an SVG is unreliable across browsers, so it is neither shrunk nor sent.
- */
-export declare function isRasterImageDataUrl(dataUrl: string): boolean;
-/**
- * Downscale + re-encode a raster data URL so it is safe to embed in a request.
- *
- * Never throws: on any failure (decode error, no canvas context, non-raster
- * input) the original data URL is returned unchanged. Callers treat this as
- * best-effort normalisation, with `enforceImagePayloadBudget` as the backstop
- * for anything that could not be shrunk.
- */
-export declare function shrinkImageDataUrl(dataUrl: string): Promise<string>;
-/** Shrink a batch in parallel, preserving order. */
-export declare function shrinkImageDataUrls(dataUrls: string[]): Promise<string[]>;
+import { dataUrlWireBytes, isRasterImageDataUrl, shrinkImageDataUrl, shrinkImageDataUrls } from "../../utils/imageCompression";
+export { dataUrlWireBytes, isRasterImageDataUrl, shrinkImageDataUrl, shrinkImageDataUrls, };
 /**
  * Normalise every image in an outgoing request so the body cannot exceed the
  * platform request cap.

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

@@ -1,7 +1,7 @@
 import "./AutoResizePanel.scss";
 import type { ExcalidrawFrameLikeElement, NonDeletedExcalidrawElement } from "@orangecatai/element/types";
 import type { AppClassProperties } from "../../types";
-export declare const AutoResizePanel: ({ element, app, onClose, onBeforeAutoResize, onAfterAutoResize, onRunningChange, autoResizeUrl, customResizeUrl, tier1CropUrl, chatModel, agentImageModel, }: {
+export declare const AutoResizePanel: ({ element, app, onClose, onBeforeAutoResize, onAfterAutoResize, onRunningChange, autoResizeUrl, chatModel, reviewerModel, outpaintModel, }: {
     element: NonDeletedExcalidrawElement & ExcalidrawFrameLikeElement;
     app: AppClassProperties;
     onClose: () => void;
@@ -12,8 +12,7 @@ export declare const AutoResizePanel: ({ element, app, onClose, onBeforeAutoResi
     onAfterAutoResize?: () => void;
     onRunningChange?: (running: boolean) => void;
     autoResizeUrl: string;
-    customResizeUrl?: string;
-    tier1CropUrl?: string;
     chatModel: string;
-    agentImageModel?: string;
+    reviewerModel?: string;
+    outpaintModel?: string;
 }) => import("react/jsx-runtime").JSX.Element;

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

@@ -152,6 +152,19 @@ export declare function enforceMinProductBox({ x, y, width, height, targetW, tar
     width: number;
     height: number;
 };
+/**
+ * Checks generated HTML against the strict contract in `buildAutoResizePrompt`
+ * BEFORE handing it to the parser.
+ *
+ * The parser is deliberately narrow — absolutely-positioned divs, no flex, no
+ * grid, no transforms — because that is what maps cleanly onto Excalidraw
+ * elements. Models drift off strict DOM contracts, and a violation shows up as
+ * silently mangled geometry rather than an error. Catching it here buys one
+ * targeted retry instead of a wrong layout.
+ *
+ * Returns the list of violations; empty means the HTML conforms.
+ */
+export declare function validateHtmlContract(html: string, expectedChildCount: number): string[];
 export declare function buildAutoResizeImagePrompt(srcW: number, srcH: number, tgtW: number, tgtH: number, aspectRatio: string, brandImages?: {
     logo?: string;
     fontPreview?: string;
@@ -171,10 +184,11 @@ export declare function runAutoResize(opts: {
     targetDimensions: TargetDimension[];
     app: AppClassProperties;
     autoResizeUrl: string;
-    customResizeUrl?: string;
-    tier1CropUrl?: string;
     chatModel?: string;
-    agentImageModel?: string;
+    /** Vision model for the layout critique loop. Falls back to `chatModel`. */
+    reviewerModel?: string;
+    /** Image model used ONLY to outpaint photographic backgrounds. */
+    outpaintModel?: string;
     customFontMap?: Record<string, number>;
     onBeforeAutoResize?: () => Promise<{
         allowed: boolean;
@@ -185,16 +199,5 @@ export declare function runAutoResize(opts: {
     signal?: AbortSignal;
     /** Pass the result of preCreateAllFrames() to skip redundant frame creation */
     preCreatedFrameInfos?: PreCreatedFrameInfo[];
-    /**
-     * Brand assets handed to the image model so the recomposed ad keeps the brand
-     * logo, typeface, and (for font-aware models) the real font file. Sourced from
-     * `app.state.brandContext` by the panel.
-     */
-    brandImages?: {
-        logo?: string;
-        fontPreview?: string;
-        fontUrl?: string;
-        name?: string;
-    };
 }): Promise<DimensionResult[]>;
 export {};

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

@@ -0,0 +1,105 @@
+export type BgKind = "solid" | "texture" | "panels" | "gradient" | "photo";
+export type PixelBuffer = {
+    data: Uint8ClampedArray;
+    width: number;
+    height: number;
+};
+export type Rect = {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+};
+/** Where a panel boundary sits, as a fraction (0-1) along `axis`. */
+export type BgSplit = {
+    axis: "x" | "y";
+    at: number;
+};
+export type BgClassification = {
+    kind: BgKind;
+    /** Present only for `kind: "panels"`. */
+    split?: BgSplit;
+    /** Present for `kind: "solid"` — the plate's average colour as hex. */
+    solidColor?: string;
+    /** Per-region verdicts; length 2 when a split was found, else 1. */
+    regions: RegionStats[];
+};
+export type RegionStats = {
+    rect: Rect;
+    /** Mean luminance stdev within patches — how "busy" the region is. */
+    textureEnergy: number;
+    /** Spread of patch MEANS — how much the region changes across itself. */
+    meanSpread: number;
+    /** True when patch means march in one direction along x or y. */
+    monotonic: boolean;
+    meanColor: {
+        r: number;
+        g: number;
+        b: number;
+    };
+    verdict: "solid" | "texture" | "gradient" | "photo";
+};
+export declare function toHex({ r, g, b, }: {
+    r: number;
+    g: number;
+    b: number;
+}): string;
+/**
+ * Finds the single strongest panel boundary, if any. Deliberately detects at
+ * most ONE split — that covers the dominant real-world ad layout (a two-panel
+ * composition) without overfitting to noise in busier plates.
+ */
+export declare function detectSplit(buf: PixelBuffer): BgSplit | null;
+/** Patch-grid statistics for one region, and the verdict they imply. */
+export declare function analyzeRegion(buf: PixelBuffer, rect: Rect): RegionStats;
+/** Full classification: split detection, then per-region analysis. */
+export declare function classifyBackground(buf: PixelBuffer): BgClassification;
+export declare function loadImageElement(dataUrl: string): Promise<HTMLImageElement>;
+/**
+ * Reads an image into a pixel buffer, downscaled to at most `maxSide` on its
+ * long edge. Classification only needs coarse statistics, and a 4K plate would
+ * otherwise cost tens of megabytes of ImageData for no extra accuracy.
+ */
+export declare function imageToPixelBuffer(dataUrl: string, maxSide?: number): Promise<PixelBuffer>;
+export type BackgroundSource = {
+    type: "solid";
+    color: string;
+    elementId?: string;
+} | {
+    type: "image";
+    dataUrl: string;
+    elementId?: string;
+} | {
+    type: "none";
+};
+export type BackgroundResult = {
+    kind: "none";
+} | {
+    kind: "solid";
+    color: string;
+} | {
+    kind: "image";
+    dataUrl: string;
+    strategy: BgKind | "scaled";
+};
+export type BuildBackgroundOpts = {
+    /**
+     * Called ONLY for photographic plates that cannot be extended locally.
+     * Supplied by the caller so this module stays free of network concerns and
+     * fully unit-testable. Returning null falls back to edge-extension.
+     */
+    outpaint?: (args: {
+        dataUrl: string;
+        targetWidth: number;
+        targetHeight: number;
+    }) => Promise<string | null>;
+    /** When false, skip analysis and just cover-scale (small AR delta). */
+    needsExtension: boolean;
+    onProgress?: (phase: string) => void;
+};
+/**
+ * Produces a background sized EXACTLY to the target frame. The caller inserts
+ * the result 1:1 — no cover-crop afterwards, unlike the old image-gen path
+ * where the model returned approximate dimensions.
+ */
+export declare function buildTargetBackground(bg: BackgroundSource, tgtW: number, tgtH: number, opts: BuildBackgroundOpts): Promise<BackgroundResult>;

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

@@ -0,0 +1,16 @@
+import type { ExcalidrawElement, ExcalidrawFrameLikeElement } from "@orangecatai/element/types";
+/** Live (non-deleted) children of a frame. */
+export declare function getLiveFrameChildren(elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement): readonly ExcalidrawElement[];
+/**
+ * True when this frame holds separable layers Auto Resize can re-arrange.
+ *
+ * Any ONE of these is sufficient:
+ *  - more than one live child  → there is something to arrange
+ *  - a child tagged `decomposeType` → came from "Make editable"
+ *  - a text child → real editable copy, so the frame is not a flat render
+ *
+ * False for the flat case: zero or one child (typically one full-bleed image).
+ */
+export declare function isStructuredFrame(elements: readonly ExcalidrawElement[], frame: ExcalidrawFrameLikeElement): boolean;
+/** Human-readable reason shown when Auto Resize is unavailable. */
+export declare const AUTO_RESIZE_FLAT_FRAME_REASON = "Make this ad editable first \u2014 Auto Resize needs separate layers to re-lay-out.";

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

@@ -1,4 +1,4 @@
-import type { ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawVideoElement } from "@orangecatai/element/types";
+import type { ElementsMapOrArray, ExcalidrawElement, ExcalidrawFrameLikeElement, ExcalidrawImageElement, ExcalidrawVideoElement } from "@orangecatai/element/types";
 export type FrameToolbarVariant = "frame" | "video";
 export type FrameToolbarVariantResult = {
     variant: FrameToolbarVariant;
@@ -34,3 +34,36 @@ export declare const getFrameToolbarVariant: (frame: ExcalidrawFrameLikeElement,
  * toolbar, so the child never surfaces an action the frame does not have.
  */
 export declare const getResizeTargetFrame: (element: ExcalidrawElement, elements: readonly ExcalidrawElement[]) => ExcalidrawFrameLikeElement | null;
+/**
+ * Resolves the image a *frame's* toolbar should act on.
+ *
+ * A generated ad covers its frame edge to edge, so whether a click lands on the
+ * frame or on the artwork is arbitrary from the user's side — but only the
+ * artwork carries the image actions (Quick Edit, and the host's Make editable).
+ * This lets a selected frame offer those same actions, targeting its artwork,
+ * so they no longer come and go with where the user happened to click. It is
+ * the mirror of `getResizeTargetFrame`, which lets a selected image reach the
+ * frame's Resize.
+ *
+ * When a frame holds several images (artwork plus a logo overlay, say), the
+ * largest one is the artwork.
+ */
+export declare const getFrameChildImage: (frame: ExcalidrawFrameLikeElement, elements: ElementsMapOrArray) => ExcalidrawImageElement | null;
+export type AutoResizeAvailability = {
+    /** False when the frame is a flat render with nothing to re-arrange. */
+    enabled: boolean;
+    /** Tooltip text — the reason when disabled, the action when enabled. */
+    title: string;
+};
+/**
+ * Whether Auto Resize can act on this frame, and what to say if it cannot.
+ *
+ * Auto Resize re-lays-out an ad by repositioning its individual layers, so it
+ * needs a frame that HAS layers. A freshly generated ad is one flat image; the
+ * button stays visible but disabled, pointing at "Make editable", rather than
+ * silently vanishing.
+ *
+ * Shared by both entry points (a selected frame, and a selected image resolved
+ * to its parent frame) so the rule cannot drift between them.
+ */
+export declare const getAutoResizeAvailability: (frame: ExcalidrawFrameLikeElement | null, elements: readonly ExcalidrawElement[]) => AutoResizeAvailability;

package/dist/types/excalidraw/components/video/pendingVideoGenerations.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Pending video generation state — module-level so a run survives the panel
+ * unmounting. VideoGeneratorPanel is rendered only while its frame is
+ * selected (see App.tsx), so clicking empty canvas mid-generation tears the
+ * component down; without this store the spinner, progress and prompt would
+ * vanish and reselecting the frame would show an idle panel even though the
+ * request is still in flight.
+ *
+ * Mirrors image-generation/pendingGenerations.ts. Flow:
+ * 1. Generate → startPendingVideoGeneration(frameId, prompt, controller).
+ * 2. The panel seeds its local state from getPendingVideoState(frameId) on
+ *    mount and subscribes for the rest, so a remount picks the run back up.
+ * 3. Status/progress updates flow through the store, so the in-flight closure
+ *    (which may belong to an already-unmounted instance) and whichever panel
+ *    is currently mounted stay in sync.
+ * 4. On success → clearVideoGenerationState(frameId) so reselecting the frame
+ *    shows a clean prompt. On error the entry is kept so the message survives.
+ * 5. Stop button → abortPendingVideoGeneration(frameId).
+ *
+ * Subscribers are tracked separately from entries so a panel can subscribe
+ * before any generation has started on its frame.
+ */
+export type PendingVideoStatus = "submitting" | "polling" | "done" | "error";
+export interface PendingVideoState {
+    prompt: string;
+    status: PendingVideoStatus;
+    progress: number;
+    error: string | null;
+}
+export type VideoGenerationUpdateCallback = (state: PendingVideoState | null) => void;
+export declare function startPendingVideoGeneration(frameId: string, prompt: string, controller: AbortController): void;
+export declare function setPendingVideoStatus(frameId: string, status: PendingVideoStatus): void;
+export declare function setPendingVideoProgress(frameId: string, progress: number): void;
+/**
+ * Terminal update. `null` → success and `"aborted"` → stopped both drop the
+ * entry (nothing left to show); any other string parks the entry in "error"
+ * so a panel remounted afterwards still explains what happened.
+ */
+export declare function finishPendingVideoGeneration(frameId: string, error: string | null): void;
+export declare function subscribeVideoGeneration(frameId: string, fn: VideoGenerationUpdateCallback): void;
+export declare function unsubscribeVideoGeneration(frameId: string, fn: VideoGenerationUpdateCallback): void;
+export declare function clearVideoGenerationState(frameId: string): void;
+export declare function abortPendingVideoGeneration(frameId: string): void;
+export declare function hasPendingVideoGeneration(frameId: string): boolean;
+export declare function getPendingVideoState(frameId: string): PendingVideoState | null;
+export declare function getPendingVideoPrompt(frameId: string): string;

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

@@ -2,4 +2,4 @@ import type { NonDeletedExcalidrawElement } from "@orangecatai/element/types";
 import type { RenderableElementsMap, SVGRenderConfig } from "../scene/types";
 import type { BinaryFiles } from "../types";
 import type { RoughSVG } from "roughjs/bin/svg";
-export declare const renderSceneToSvg: (elements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, renderConfig: SVGRenderConfig) => void;
+export declare const renderSceneToSvg: (unorderedElements: readonly NonDeletedExcalidrawElement[], elementsMap: RenderableElementsMap, rsvg: RoughSVG, svgRoot: SVGElement, files: BinaryFiles, renderConfig: SVGRenderConfig) => void;

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

@@ -767,12 +767,31 @@ export interface ExcalidrawProps {
     agentImageModel?: string;
     /**
      * OpenRouter model tag used by the auto-resize engine for HTML layout
-     * generation. This is the LLM call that figures out how to reflow the ad
-     * content into the target dimensions before Gemini regenerates the background.
-     * @default "google/gemini-3.1-flash-lite-preview"
-     * @example "openai/gpt-4o"
+     * generation — the LLM call that decides how to reflow the ad's layers into
+     * the target dimensions. Must be a chat model.
+     * @default "x-ai/grok-4.6"
      */
     chatModel?: string;
+    /**
+     * Vision model for the auto-resize layout critique loop. Falls back to
+     * `chatModel` when omitted, so pass a cheap fast vision model here — the
+     * reviewer only compares a screenshot against the brief, it does not carry
+     * an agentic conversation.
+     * @example "openai/gpt-5.6-luna"
+     */
+    reviewerModel?: string;
+    /**
+     * Image model used ONLY to outpaint a photographic background when the
+     * aspect-ratio change is too large to cover-crop. Solid, textured and
+     * two-panel backgrounds are extended locally on a canvas and never reach a
+     * 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
+     * generation-only on OpenRouter and its ratio enum stops at 3:1 / 1:3.
+     * @default "google/gemini-3.1-flash-image-preview"
+     */
+    outpaintModel?: string;
     /**
      * Show the Library sidebar trigger button. Defaults to `false`.
      * Set to `true` to show the library icon in the top-right area.

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

@@ -19,12 +19,17 @@ export declare function buildBrandContextMessage(ctx: BrandContext): string;
  */
 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.
+     * True when the user attached their own reference images (or, on quick
+     * edit, when there is a source image).
+     *
+     * This no longer suppresses the logo and font mandates. Brand assets are
+     * always attached now — the budget in utils/referenceBudget sheds them only
+     * under real payload pressure, not because the user supplied something —
+     * so the mandates still point at images the model can see.
+     *
+     * What it still does is demote brand *direction*: the "this ad is for brand
+     * X, everything must reflect it" line, which genuinely does fight a
+     * user-chosen reference for subject and style.
      */
     hasUserReferences?: boolean;
 }): string;

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

@@ -1,9 +1,25 @@
+import { MAX_USER_REFERENCE_IMAGES } from "./referenceBudget";
+export { MAX_USER_REFERENCE_IMAGES };
+/** True for OpenAI's Images-API models, which are routed and shaped differently. */
+export declare const isOpenAIImageModel: (modelId: string) => boolean;
+/** Nearest preset ratio to `frameW / frameH`. */
+export declare function nearestPresetAspectRatio(frameW: number, frameH: number): string;
 /**
- * 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.
+ * Picks the output size for a frame.
+ *
+ * For gpt-image-* this returns an exact `"1088x1360"` size matching the frame's
+ * real aspect ratio, so a 1080×1350 (4:5) frame no longer comes back as a 3:4
+ * image that has to be letterboxed to 1013×1350. It travels in the request's
+ * `size` field, NOT `resolution` — see the Images API body below. `aspectRatio`
+ * is null in that case: an exact size is authoritative and OpenRouter 400s if a
+ * ratio is sent alongside it (4:5 is not a valid preset anyway).
+ *
+ * Every other model keeps the preset-snapping behaviour it has always had.
  */
-export declare const MAX_USER_REFERENCE_IMAGES = 6;
+export declare function resolveImageOutputSize(modelId: string, frameW: number, frameH: number): {
+    aspectRatio: string | null;
+    imageSize: string | null;
+};
 /**
  * Describes each attached reference image by its real 1-based position, and
  * states the precedence rule between them.
@@ -20,8 +36,18 @@ export declare const MAX_USER_REFERENCE_IMAGES = 6;
  * 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?: {
+export declare function buildReferenceManifest(userReferenceCount: number, brandLabels: string[], 
+/** The brand logo survived the budget and is attached. */
+logoIsAttached?: boolean, 
+/** A source image (quick edit / resize) is attached below the user's refs. */
+hasSourceImage?: boolean): string;
+export declare function callOpenRouterImageAPI(prompt: string, modelId: string, 
+/**
+ * Preset ratio label ("4:5" is NOT one). Pass null when `imageSize` carries an
+ * exact `WIDTHxHEIGHT` resolution — that is authoritative, and sending a
+ * conflicting (or unsupported) ratio alongside it only muddies the request.
+ */
+aspectRatio: string | null, 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. */
@@ -56,4 +82,24 @@ export declare function callOpenRouterImageAPI(prompt: string, modelId: string,
      * manifest, so those callers are unaffected by this option.
      */
     referenceMode?: "user-priority" | "legacy-positional";
+    /**
+     * The image being edited or resized. Ranks directly below the user's own
+     * references and above the logo — on those surfaces the source IS the
+     * subject, so it must never be shed, and the logo becomes droppable.
+     */
+    sourceImageDataUrl?: string;
+    /**
+     * Whether the logo is part of the protected core. True on generate flows
+     * (the floor is 6 user references + the logo); false on quick edit and
+     * resize, where the source image outranks it.
+     */
+    protectLogo?: boolean;
+    /**
+     * How many brand-bank assets / ad references the host proxy may append.
+     * The SDK cannot see those images, so it reserves
+     * {@link HOST_ASSET_BYTE_RESERVATION} of budget per slot and tells the host
+     * how many survived; the host compresses each one to fit its reservation.
+     */
+    hostBrandAssetSlots?: number;
+    hostAdReferenceSlots?: number;
 }): Promise<string>;

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

@@ -0,0 +1,46 @@
+/**
+ * Shared image-compression primitives.
+ *
+ * Extracted from `components/ai-chat/imagePayload` so the image-generation
+ * surfaces (canvas chat, generator panel, quick edit, auto-resize) can use the
+ * same downscaling the chat request path has always used. Previously only chat
+ * shrank its images, which is why an image-gen request could still carry a raw
+ * 1 MB PNG straight at the host proxy's 4.5 MB platform cap.
+ *
+ * Everything here is best-effort and never throws: on any failure the original
+ * data URL is returned unchanged, and the caller's budget pass is the backstop.
+ */
+/** Long-edge cap in CSS pixels. Well above what vision models resolve. */
+export declare const MAX_EDGE_PX = 1280;
+/** JPEG quality for re-encoded images. */
+export declare const JPEG_QUALITY = 0.78;
+/**
+ * Images already smaller than this are passed through untouched — re-encoding
+ * a 40KB thumbnail costs a canvas round-trip and can make it *larger*.
+ */
+export declare const PASSTHROUGH_BYTES: number;
+/** Estimated wire size of a data URL: the base64 payload is what gets sent. */
+export declare function dataUrlWireBytes(dataUrl: string): number;
+/**
+ * Whether a data URL is a raster format safe to send as an `image_url` block.
+ * SVG is commonly rejected outright by vision models, and canvas re-encoding
+ * of an SVG is unreliable across browsers, so it is neither shrunk nor sent.
+ */
+export declare function isRasterImageDataUrl(dataUrl: string): boolean;
+/**
+ * Downscale + re-encode a raster data URL so it is safe to embed in a request.
+ *
+ * Never throws: on any failure (decode error, no canvas context, non-raster
+ * input) the original data URL is returned unchanged.
+ */
+export declare function shrinkImageDataUrl(dataUrl: string): Promise<string>;
+/** Shrink a batch in parallel, preserving order. */
+export declare function shrinkImageDataUrls(dataUrls: string[]): Promise<string[]>;
+/**
+ * Force a re-encode at a specific long-edge cap, ignoring the passthrough rule.
+ * Used to escalate compression when a request is still over budget after the
+ * standard downscale — always preferable to dropping a reference outright.
+ */
+export declare function reencodeAtEdge(dataUrl: string, edge: number, quality?: number): Promise<string>;
+/** Escalation ladder used when the standard downscale is not enough. */
+export declare const ESCALATION_EDGES: readonly [960, 720, 512];