@orangecatai/adgen-canvas 0.0.32 → 0.0.34

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

@@ -1 +1 @@
-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};
+import{a,b,c,d}from"./chunk-Z5NKEFVG.js";import"./chunk-KFCCNTO2.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-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};
+import{a as r,c as t}from"./chunk-Z5NKEFVG.js";import"./chunk-KFCCNTO2.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/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

@@ -0,0 +1,53 @@
+/**
+ * Payload-size normalisation for images sent to the chat API.
+ *
+ * Every `image_url` content block in a chat request travels as a base64 data
+ * URL embedded in JSON. Base64 inflates bytes by 4/3, and the host proxy runs
+ * on Vercel, whose platform-level request cap is 4.5 MB — enforced at the edge
+ * *before* the route handler runs, so it surfaces as an opaque 413 that never
+ * reaches any of our error handling.
+ *
+ * Rather than budget-and-drop (which loses the user's images, the one thing
+ * they actually asked the model to look at), every image is downscaled to a
+ * size where the whole request comfortably fits. A 1280px-long-edge JPEG at
+ * q0.78 lands around 100-150KB, so a request carrying the full complement of
+ * user uploads + brand references + frame screenshot sits near 1MB — roughly
+ * a quarter of the cap, with room for prompt text and tool schemas.
+ *
+ * This runs at payload-assembly time, not upload time, which is deliberate:
+ * conversation history persisted before this existed still holds raw
+ * multi-megabyte data URLs, and those are re-sent on every subsequent turn.
+ * Normalising here fixes existing conversations, not just new uploads.
+ */
+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.
+ *
+ * Three escalating passes, so the common case costs nothing and the worst case
+ * still succeeds rather than 413ing:
+ *
+ *  1. Downscale every image to {@link MAX_EDGE_PX}. Almost always sufficient —
+ *     a full request of 9 images lands near 1MB.
+ *  2. If still over (many images, or images that resisted re-encoding),
+ *     re-encode at successively lower quality.
+ *  3. Only if *still* over, drop the oldest images — newest are the ones the
+ *     user is actually asking about. Images on the final message are never
+ *     dropped.
+ *
+ * Mutates the parts in place and returns the message array for convenience.
+ */
+export declare function normalizeRequestImages<T extends {
+    role: string;
+}>(messages: T[]): Promise<T[]>;
+/**
+ * Build a user-facing message from a failed chat-proxy response.
+ *
+ * The previous handling assumed every non-OK status came from OpenRouter and
+ * carried an OpenRouter-shaped JSON error. Platform-level rejections (notably
+ * Vercel's 413 at the edge) return plain text, so `response.json()` threw and
+ * the raw fallback `OpenRouter error 413` reached the user — naming the wrong
+ * system and offering no action.
+ */
+export declare function describeChatError(response: Response): Promise<string>;

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/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];

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

@@ -0,0 +1,138 @@
+/**
+ * Ranked slot allocation for the reference images attached to an image
+ * generation request.
+ *
+ * ## Why this exists
+ *
+ * The previous rule was a single boolean: if the user attached ANY reference,
+ * the brand logo, both font specimens, and every host-injected brand asset were
+ * deleted. Unconditionally — no size check, no count check. That made
+ * "replace their logo with ours" unsatisfiable, because the logo the prompt
+ * asked for was never attached.
+ *
+ * The real constraint was never "brand assets compete with the user" — it is
+ * the host proxy's platform request cap (Vercel rejects bodies over 4.5 MB at
+ * the edge with an opaque 413). Competition is solved by ORDER and by the
+ * prompt's precedence rules, not by deletion.
+ *
+ * ## The contract
+ *
+ * Priority, highest first:
+ *
+ *   1. `user`        — references the user attached themselves (max 6)
+ *   2. `source`      — the image being edited or resized (quick edit, resize)
+ *   3. `logo`        — the brand logo
+ *   4. `brandAsset`  — product / lifestyle photos from the brand bank
+ *   5. `adReference` — existing ad creatives and template thumbnails
+ *
+ * Everything is sent when it fits. Truncation happens ONLY when the count or
+ * byte budget is exceeded, and always from the bottom up — never touching
+ * `user`, and never touching `logo` unless the caller marks it droppable
+ * (quick edit and resize, where the source image matters more).
+ *
+ * Brand assets and ad references degrade gracefully: surplus copies go first,
+ * so one of each survives as long as possible, and only then is a whole tier
+ * given up — ad references before brand assets, per the priority order.
+ *
+ * The floor is therefore 6 user references + the logo.
+ *
+ * ## Compression first, always
+ *
+ * Dropping a reference is the last resort, not the first. `prepareReferences`
+ * downscales everything, then escalates compression on the largest offenders,
+ * and only starts shedding slots if the payload is *still* over budget.
+ */
+/** 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];
+export interface ReferenceSlot {
+    tier: ReferenceTier;
+    /**
+     * The image itself. Empty string marks a *placeholder* — a slot the host
+     * proxy will fill from the brand database, which the SDK can only reserve
+     * room for because it never sees the bytes. `bytes` carries the reservation.
+     */
+    dataUrl: string;
+    /** Human label used in the reference manifest. */
+    label?: string;
+    /** Wire-byte estimate. Derived from `dataUrl` when omitted. */
+    bytes?: number;
+}
+export interface DroppedSlot {
+    tier: ReferenceTier;
+    label?: string;
+    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.
+ *
+ * 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.
+ */
+export declare const HOST_ASSET_BYTE_RESERVATION: number;
+/** Sort into priority order, stable within a tier. */
+export declare function orderByPriority(slots: ReferenceSlot[]): ReferenceSlot[];
+/**
+ * The order in which slots may be shed, first to go listed first.
+ *
+ * `user` and `source` never appear — they are the request. `logo` appears only
+ * when `protectLogo` is false, and always last, so it outlives every brand
+ * asset.
+ */
+export declare function shedOrder(slots: ReferenceSlot[], protectLogo: boolean): ReferenceSlot[];
+export interface AllocateOptions {
+    /** Count ceiling. Defaults to {@link MAX_REFERENCE_IMAGES}. */
+    maxImages?: number;
+    /** Byte ceiling for images. Defaults to {@link REFERENCE_WIRE_BUDGET_BYTES}. */
+    maxBytes?: number;
+    /** Non-image payload (prompt, schemas) to charge against `maxBytes`. */
+    reservedBytes?: number;
+    /**
+     * False on surfaces where the source image outranks the logo — quick edit and
+     * resize. On generate flows the logo is part of the protected core.
+     */
+    protectLogo?: boolean;
+}
+export interface Allocation {
+    kept: ReferenceSlot[];
+    dropped: DroppedSlot[];
+    bytes: number;
+    /**
+     * True when the protected core alone still exceeds the budget. The caller
+     * should send anyway — a 413 with the user's own images is a better failure
+     * than silently generating without them.
+     */
+    overBudget: boolean;
+}
+/**
+ * Pure allocation: order, cap the user tier, then shed bottom-up until the
+ * count and byte budgets are met. No compression — see `prepareReferences`.
+ */
+export declare function allocateReferences(slots: ReferenceSlot[], options?: AllocateOptions): Allocation;
+/**
+ * Compress everything, escalate on the largest offenders, and only then shed
+ * slots. This is the entry point every image-generation surface should use.
+ *
+ * Placeholder slots (`dataUrl === ""`) are carried through untouched — the host
+ * compresses those on its side against {@link HOST_ASSET_BYTE_RESERVATION}.
+ */
+export declare function prepareReferences(slots: ReferenceSlot[], options?: AllocateOptions): Promise<Allocation>;

package/package.json

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