@giveitsmaller/sdk 0.15.0 → 0.17.0

package/dist/ergonomic/presets/index.js

@@ -41,7 +41,7 @@ export { DocumentOfficeCompressPresetOptions, } from './document_office_compress
 export { DocumentOdfCompressPresetOptions, } from './document_odf_compress.js';
 export { DocumentEpubCompressPresetOptions, } from './document_epub_compress.js';
 // Re-export ergonomic enums for callers (single canonical path).
-export { OptimizeFor, ImageMode, ImageMetadataPolicy, IccProfilePolicy, ImageFormat, VideoCodec, VideoPreset, VideoFit, AudioBitrate, AudioCodec, AudioSampleRate, PdfProfile, PdfColorspace, } from '../../generated/sdk_spec/enums.js';
+export { OptimizeFor, ImageMetadataPolicy, ImageFormat, VideoCodec, VideoPreset, VideoFit, AudioBitrate, AudioCodec, AudioSampleRate, PdfProfile, PdfColorspace, } from '../../generated/sdk_spec/enums.js';
 function cellKeyOf(media, op) {
     return `${media}_${op}`;
 }
@@ -55,8 +55,8 @@ function cellKeyOf(media, op) {
  *
  * `definedFieldsOf` filters undefined values out of each instance
  * BEFORE the merge: with TS `useDefineForClassFields` (the ES2022
- * default), `readonly mode?: ImageMode` declarations initialise the
- * field as an enumerable own property with value `undefined` BEFORE
+ * default), `readonly outputFormat?: ImageFormat` declarations initialise
+ * the field as an enumerable own property with value `undefined` BEFORE
  * the ctor body runs. A naive `Object.assign({}, parent, child)`
  * therefore lets child's `undefined` overwrite parent's defined value
  * — caught by CI on PR #125 first run. Filter-then-spread restores
@@ -64,7 +64,7 @@ function cellKeyOf(media, op) {
  *
  * @internal
  */
-function definedFieldsOf(opts) {
+export function definedFieldsOf(opts) {
     const out = {};
     for (const key of Object.keys(opts)) {
         const value = opts[key];

package/dist/errors.d.ts

@@ -461,3 +461,28 @@ export declare class GislSinkError extends GislError {
         readonly reason: GislSinkErrorReason;
     });
 }
+/**
+ * A terminal item failure in {@link RunResult.failed} — an input whose job did
+ * not reach `completed`. Stored in `ItemFailure.error` so a caller can branch on
+ * the failure reason WITHOUT string-parsing.
+ *
+ * - `state`: the terminal lifecycle state (`failed` / `expired` / `cancelled` /
+ *   `partially_failed` / `paused_insufficient_credits`, or a per-job
+ *   non-`completed` status).
+ * - `errorMessage` / `errorCode`: the human + machine fields read from the first
+ *   failing operation (`OperationResponse.error_message` / `.error_code`). BOTH
+ *   are absent for non-`failed` terminal states — cancel / expire / credit-pause
+ *   carry only the bare `state`.
+ *
+ * `message` is `state` optionally suffixed `: errorMessage`, preserving the
+ * pre-typed string exactly (an empty-string `errorMessage` still adds the colon).
+ *
+ * Mirrors the PHP `Gisl\Sdk\Errors\GislItemFailedError`.
+ */
+export declare class GislItemFailedError extends GislError {
+    readonly key: string | null;
+    readonly state: string;
+    readonly errorMessage?: string;
+    readonly errorCode?: string;
+    constructor(key: string | null, state: string, errorMessage?: string, errorCode?: string);
+}

package/dist/errors.js

@@ -503,3 +503,37 @@ export class GislSinkError extends GislError {
         this.reason = options.reason;
     }
 }
+/**
+ * A terminal item failure in {@link RunResult.failed} — an input whose job did
+ * not reach `completed`. Stored in `ItemFailure.error` so a caller can branch on
+ * the failure reason WITHOUT string-parsing.
+ *
+ * - `state`: the terminal lifecycle state (`failed` / `expired` / `cancelled` /
+ *   `partially_failed` / `paused_insufficient_credits`, or a per-job
+ *   non-`completed` status).
+ * - `errorMessage` / `errorCode`: the human + machine fields read from the first
+ *   failing operation (`OperationResponse.error_message` / `.error_code`). BOTH
+ *   are absent for non-`failed` terminal states — cancel / expire / credit-pause
+ *   carry only the bare `state`.
+ *
+ * `message` is `state` optionally suffixed `: errorMessage`, preserving the
+ * pre-typed string exactly (an empty-string `errorMessage` still adds the colon).
+ *
+ * Mirrors the PHP `Gisl\Sdk\Errors\GislItemFailedError`.
+ */
+export class GislItemFailedError extends GislError {
+    key;
+    state;
+    errorMessage;
+    errorCode;
+    constructor(key, state, errorMessage, errorCode) {
+        super(state + (errorMessage !== undefined ? `: ${errorMessage}` : ''));
+        this.name = 'GislItemFailedError';
+        this.key = key;
+        this.state = state;
+        if (errorMessage !== undefined)
+            this.errorMessage = errorMessage;
+        if (errorCode !== undefined)
+            this.errorCode = errorCode;
+    }
+}

package/dist/file-first.d.ts

@@ -9,9 +9,11 @@
  *
  * Mirrors `packages/php/src/FileFirst/*`.
  */
+import { GislItemFailedError } from './errors.js';
 import { type ProgressEvent } from './builder.js';
 import type { GislClient } from './client.js';
 import type { OperationDownload, WorkflowStatusResponse } from '@giveitsmaller/contracts/openapi';
+import type { ConvertOptions, ThumbnailOptions, TextWatermarkOptions, WatermarkOptions, OutputOptions, OutputFit } from './ergonomic/option_types.js';
 import { OptimizeFor } from './generated/sdk_spec/enums.js';
 import type { PresetDefaults } from './ergonomic/presets/index.js';
 import type { WorkflowCreatePayload } from './types.js';
@@ -66,15 +68,16 @@ export interface ItemResult {
     readonly outputs: readonly OutputFile[];
 }
 /**
- * One failed entry in {@link RunResult.failed}: an input that did not
- * produce a deliverable, paired with the cause. One bad input does not sink
- * the rest of a multi-input run. `error` is `unknown` (mirroring the PHP
- * `\Throwable`) so the caller narrows with `instanceof`. Mirrors the PHP
- * `ItemFailure`.
+ * One failed entry in {@link RunResult.failed}: an input that did not produce a
+ * deliverable, paired with the cause. One bad input does not sink the rest of a
+ * multi-input run. `error` is a typed {@link GislItemFailedError} carrying the
+ * terminal `state` plus the failing operation's `errorMessage`/`errorCode` (when
+ * present), so the caller can branch on the failure WITHOUT string-parsing.
+ * Mirrors the PHP `ItemFailure`.
  */
 export interface ItemFailure {
     readonly key: string | null;
-    readonly error: unknown;
+    readonly error: GislItemFailedError;
 }
 /**
  * Return value of {@link RunResult.downloadTo} — the local paths written,
@@ -159,27 +162,13 @@ export declare class RunResult {
         failed: readonly {
             key: string | null;
             error: string;
+            state: string;
+            errorMessage?: string;
+            errorCode?: string;
         }[];
     };
     private requireDownloader;
 }
-/**
- * Flatten the terminal workflow status + its downloads into a {@link RunResult}.
- *
- * Shared by {@link Recipe.run} (passes its recipe key) and the file-first
- * {@link Handle} reattach surface (`Handle.wait()`/`Handle.result()`, FF5a —
- * passes `null` because a reattached handle carries no recipe key).
- *
- * **Partition invariant (carries a prior codex-review fix — do NOT let it
- * drift):** success is ONLY `state === 'completed'`. Every other terminal
- * state — `failed`, `partially_failed`, `cancelled`, `expired`,
- * `paused_insufficient_credits` — partitions into `failed[]` so a caller's
- * `ok`/`succeeded` check can never treat a cancelled/expired/paused run as a
- * clean result.
- *
- * @internal Exported for reuse by the file-first `Handle`; not part of the
- *   caller-facing fluent surface.
- */
 export declare function projectDownloadsToRunResult(workflowId: string, finalStatus: WorkflowStatusResponse, jobDownloads: readonly {
     files: readonly OperationDownload[];
 }[], key: string | null, downloader?: Downloader): RunResult;
@@ -249,6 +238,19 @@ export declare function isMergeStatus(finalStatus: WorkflowStatusResponse): bool
  * @internal Exported for the file-first `Handle`; not part of the public API.
  */
 export declare function isArchiveStatus(finalStatus: WorkflowStatusResponse): boolean;
+/**
+ * True when a terminal status describes a fluent `file(...).watermark(overlay)`
+ * — at least one job ref `watermark` and every OTHER job ref is `src_{i}` (the
+ * ids the {@link WatermarkedRecipe} lowering assigns: `src_0` base, `src_1`
+ * overlay). Lets {@link Handle.wait}/{@link Handle.result} AND
+ * {@link WatermarkedRecipe.run} project ONLY the watermark output — filtering
+ * the `src_*` passthrough plumbing — even after a `client.workflow(id)` reattach.
+ * Mutually exclusive with {@link isFanoutStatus} / {@link isMergeStatus} /
+ * {@link isArchiveStatus}.
+ *
+ * @internal Exported for the file-first `Handle`; not part of the public API.
+ */
+export declare function isWatermarkStatus(finalStatus: WorkflowStatusResponse): boolean;
 /**
  * The primary file a {@link Recipe} operates on — the "subject" of the
  * file-first surface. A discriminated union over the ways a caller names an
@@ -293,7 +295,7 @@ export declare const fileInput: {
 };
 /** One step in a {@link Recipe}'s chain — an op kind + captured ergonomic args. */
 interface RecipeStep {
-    readonly opType: 'compress' | 'convert' | 'thumbnail' | 'text_watermark';
+    readonly opType: 'compress' | 'convert' | 'thumbnail' | 'text_watermark' | 'output';
     readonly options: Readonly<Record<string, unknown>>;
 }
 /**
@@ -339,22 +341,55 @@ export declare class Recipe {
      * option (the convert op's wire key per the contract); `options` carries any
      * additional per-op convert options.
      */
-    convert(format: string, options?: Record<string, unknown>): Recipe;
+    convert(format: string, options?: ConvertOptions): Recipe;
     /**
-     * Generate a preview. Width and/or height in pixels; any additional per-op
-     * thumbnail options pass through. An omitted (`undefined`) value is dropped
-     * from the wire options (not sent as `undefined`).
+     * Generate a preview / resize. `width` AND `height` are required (the contract
+     * marks both required for image/video/document); any additional per-op
+     * thumbnail option passes through. An omitted (`undefined`) optional value is
+     * dropped from the wire options (not sent as `undefined`).
      */
-    thumbnail(options?: {
-        width?: number;
-        height?: number;
-    } & Record<string, unknown>): Recipe;
+    thumbnail(options: ThumbnailOptions): Recipe;
+    /**
+     * Produce ONE transformed image: keep or change format, plus quality, resize
+     * and route-honored controls. The single user-facing image transform — the SDK
+     * resolves the route from `(input format, output_format)` against the contract's
+     * image-output-routes projection and lowers to that route's wire op:
+     * same-format → `compress` (optimiser, `output_format: 'original'`), format-change
+     * → `convert` (transcoder, `output_format: <fmt>`). Only options the resolved
+     * route honors are sent; a planned or not-honored option throws BEFORE upload.
+     * Resize (`width`/`height`/`fit`, via `options` or {@link resize}) stays on the
+     * SAME op — one output, never a separate thumbnail.
+     *
+     * `format` omitted → keep the input format (same-format optimiser route).
+     */
+    output(format?: string, options?: OutputOptions): Recipe;
+    /**
+     * Resize as part of the Output transform. Merges `width`/`height`/`fit` into the
+     * PRECEDING `output()` step (one artifact); if no Output step precedes, appends a
+     * same-format Output step carrying the resize. Never emits a `thumbnail` op.
+     * `height` is optional — width-only resize preserves aspect ratio. Resize is
+     * raster-only (e.g. an SVG input has no resize on its route → throws at lower).
+     */
+    resize(width: number, height?: number, fit?: OutputFit): Recipe;
     /**
      * Apply a text watermark. Single-input (the text is an option, not a
      * secondary file) — lowers to the `text_watermark` op with a `text` option;
      * `options` carries any additional per-op watermark options.
      */
-    textWatermark(text: string, options?: Record<string, unknown>): Recipe;
+    textWatermark(text: string, options?: TextWatermarkOptions): Recipe;
+    /**
+     * Composite an image OVERLAY onto this file (a multi-input op). `overlay` is a
+     * secondary file-NODE (a {@link Recipe} — e.g. `client.file('logo.png')`),
+     * itself optionally processed first. Routes by THIS file's effective media:
+     * image base → `image_watermark` (stable), video base → `video_watermark`
+     * (beta). Audio/document/animated-GIF/unsupported-subtype/undetectable bases
+     * throw locally BEFORE any upload (the planned-op gate). `options` carries the
+     * wire watermark options (`anchor`, `opacity`, `margin_x`, `margin_y`,
+     * `overlay_width`). Returns a {@link WatermarkedRecipe} (chain post-watermark
+     * `compress`/`convert`/`thumbnail`, then `run`/`submit`). Distinct from
+     * {@link textWatermark} (single-input text overlay).
+     */
+    watermark(overlay: Recipe, options?: WatermarkOptions): WatermarkedRecipe;
     /**
      * Lower this recipe to a workflow-create payload against a resolved upload
      * id. Single-input chain → ONE job, `source: upload(fileId)`, ordered
@@ -380,6 +415,13 @@ export declare class Recipe {
      * @internal
      */
     get recipeSteps(): readonly RecipeStep[];
+    /**
+     * The primary input this recipe operates on. Read by {@link WatermarkedRecipe}
+     * to lift an overlay Recipe's input (for upload + media inference + src-job
+     * lowering) without making the ctor field public.
+     * @internal
+     */
+    get recipeInput(): FileInput;
     /**
      * Execute the recipe end-to-end: upload the input (when required), create
      * the workflow, await a terminal state (SSE with poll fallback), then
@@ -432,10 +474,78 @@ export declare class Recipe {
     private _uploadAndCreate;
     private withStep;
     private lowerStep;
+    /**
+     * Lower an `output` step to its route's wire op. Resolves the route from the
+     * (chain-folded) input format token + the requested `output_format`, then emits
+     * `compress` (same_format) or `convert` (format_change) carrying only the
+     * route-honored options. A planned option (e.g. `lossless`), an option not
+     * honored on the resolved route (e.g. `progressive` on a format-change), a
+     * planned per-value (e.g. `metadata: 'keep'`), or an unrepresentable route all
+     * throw a typed {@link GislConfigError} BEFORE upload. Resize (`width`/`height`/
+     * `fit`) is input-keyed (raster only) and rides whichever op the route selects.
+     */
+    private lowerOutputStep;
+    /**
+     * The input format token an `output` step at `uptoIndex` operates on — the
+     * original input's token, FOLDED through preceding `convert`/`output` steps that
+     * change the format (mirrors {@link compressMediaHint}). Undefined when the input
+     * media is not inferable (a bare upload id / unnamed, untyped Blob).
+     */
+    private outputInputToken;
+    /** The original input's image format token (path ext / Blob type / Blob name). */
+    private inputFormatToken;
     private lowerCompressOptions;
+    /** Media of the original input (no chain context) — used by the probe gate. */
+    private inputMedia;
+    /**
+     * The media class a `compress` step at `uptoIndex` actually operates on. With no
+     * chain context (`uptoIndex` undefined) this is the original input's media. With
+     * context, FOLD the preceding `convert` steps: each `convert(output_format)` changes
+     * the media the next step sees (56N4chXY / N8eESzQN — a chain like
+     * `mp3 -> convert(flac) -> compress` must resolve against flac, not mp3). Reuses the
+     * synthetic-filename detection precedent from {@link MergedRecipe} (`merged.<ext>`).
+     */
     private compressMediaHint;
+    /**
+     * Whether the media a `compress` step at `uptoIndex` operates on is lossless audio.
+     * Determined by the most recent preceding `convert` target (`flac`/`wav` -> lossless)
+     * when there is one, else by the original input. Lossless is unaffected by the
+     * video/ogg guard (ogg is never lossless either way).
+     */
     private compressAudioLossless;
 }
+/**
+ * The single SDK-side source of truth for which `(wire op, base mime)`
+ * combinations the file-first `watermark()` verb may emit, and their
+ * availability. The generated typed metadata sidecar does NOT carry the
+ * supported-mime allowlist (`MimeGroupMetadata` has no `mimes` field and
+ * `per_mime_availability` is empty for these ops), so this hand table is the
+ * gate's source — PINNED to the generated `availability.json` by a conformance
+ * test (mirrors the wire-key-conformance pattern): a contract regen that
+ * changes the supported mimes or availability of `image_watermark` /
+ * `video_watermark` fails that test. The gate reads ONLY this table.
+ * @internal
+ */
+export declare const WATERMARK_CAPABILITY: {
+    readonly image_watermark: {
+        readonly image: {
+            readonly mimes: readonly ["image/jpeg", "image/png", "image/webp"];
+            readonly availability: "stable";
+        };
+        readonly image_gif: {
+            readonly mimes: readonly ["image/gif"];
+            readonly availability: "planned";
+        };
+    };
+    readonly video_watermark: {
+        readonly video: {
+            readonly mimes: readonly ["video/mp4", "video/webm"];
+            readonly availability: "beta";
+        };
+    };
+};
+/** Wire op types the file-first `watermark()` verb can route to. */
+export type WatermarkWireOp = 'image_watermark' | 'video_watermark';
 /**
  * The homogeneous fan-out builder value (FF3a). `client.files([a, b, c])`
  * returns a `FilesRecipe`; the op-chain methods (`compress`, `convert`,
@@ -474,15 +584,12 @@ export declare class FilesRecipe {
      * lowering builds an internal Recipe that throws the same `GislConfigError`.
      */
     compress(optimize?: OptimizeFor, options?: Record<string, unknown>): FilesRecipe;
-    /** Change every input's format. `format` lowers to the contract `output_format` wire key (via {@link Recipe.convert}), NOT `format`. */
-    convert(format: string, options?: Record<string, unknown>): FilesRecipe;
-    /** Generate a preview of every input. Omitted dimensions are dropped from the wire options. */
-    thumbnail(options?: {
-        width?: number;
-        height?: number;
-    } & Record<string, unknown>): FilesRecipe;
-    /** Apply the same text watermark to every input. */
-    textWatermark(text: string, options?: Record<string, unknown>): FilesRecipe;
+    /** Change every input's format. `format` lowers to the contract `output_format` wire key (via {@link Recipe.convert}), NOT `format`. Option keys are validated (via the base {@link Recipe}) before any upload. */
+    convert(format: string, options?: ConvertOptions): FilesRecipe;
+    /** Generate a preview of every input. `width` AND `height` are required; validated via the base {@link Recipe} before any upload. */
+    thumbnail(options: ThumbnailOptions): FilesRecipe;
+    /** Apply the same text watermark to every input. Option keys validated via the base {@link Recipe}. */
+    textWatermark(text: string, options?: TextWatermarkOptions): FilesRecipe;
     /**
      * Combine the inputs into ONE output (N→1), in array order (FF3b). Returns a
      * single-output {@link MergedRecipe} you chain further ops on
@@ -613,13 +720,10 @@ export declare class MergedRecipe {
     constructor(inputs: readonly FileInput[], mergeOptions: MergeOptions, postSteps?: readonly RecipeStep[], presetDefaults?: PresetDefaults | undefined, scopedPresetDefaults?: PresetDefaults | undefined, client?: GislClient | undefined);
     /** Reduce the merged output's size. See {@link Recipe.compress}. */
     compress(optimize?: OptimizeFor, options?: Record<string, unknown>): MergedRecipe;
-    /** Change the merged output's format. See {@link Recipe.convert}. */
-    convert(format: string, options?: Record<string, unknown>): MergedRecipe;
-    /** Thumbnail the merged output. Omitted dimensions are dropped from the wire options. */
-    thumbnail(options?: {
-        width?: number;
-        height?: number;
-    } & Record<string, unknown>): MergedRecipe;
+    /** Change the merged output's format. See {@link Recipe.convert}. Option keys validated pre-upload. */
+    convert(format: string, options?: ConvertOptions): MergedRecipe;
+    /** Thumbnail the merged output. `width` AND `height` are required; validated pre-upload. */
+    thumbnail(options: ThumbnailOptions): MergedRecipe;
     /**
      * Lower to the merge DAG: one `passthrough` source job per input + one
      * `merge` job whose `operations[]` is `[merge, ...post-combine ops]`. The
@@ -776,4 +880,92 @@ export declare class ArchivedRecipe {
      */
     private wireArchiveOptions;
 }
+/**
+ * The single-output recipe you're in AFTER `file(base).watermark(overlay, …)`
+ * (FF4a). Composites an image OVERLAY onto the base (image_watermark for image
+ * bases, video_watermark for video bases — routed at lowering by the base's
+ * effective media). A multi-input op: base + overlay each enter via their own
+ * `passthrough` source job (`src_0` base, `src_1` overlay; their own preceding
+ * steps lower into those jobs), and the `watermark` job consumes them via
+ * `job_output` inputs tagged `role: base` / `role: overlay`. Post-watermark
+ * `compress`/`convert`/`thumbnail` chain onto the watermark output. Mirrors
+ * {@link MergedRecipe}. `textWatermark` is intentionally NOT a post-verb here.
+ */
+export declare class WatermarkedRecipe {
+    private readonly baseInput;
+    private readonly baseSteps;
+    private readonly overlay;
+    private readonly watermarkOptions;
+    private readonly postSteps;
+    private readonly presetDefaults?;
+    private readonly scopedPresetDefaults?;
+    private readonly client?;
+    constructor(baseInput: FileInput, baseSteps: readonly RecipeStep[], overlay: Recipe, watermarkOptions: WatermarkOptions, postSteps?: readonly RecipeStep[], presetDefaults?: PresetDefaults | undefined, scopedPresetDefaults?: PresetDefaults | undefined, client?: GislClient | undefined);
+    /** Reduce the watermarked output's size. See {@link Recipe.compress}. */
+    compress(optimize?: OptimizeFor, options?: Record<string, unknown>): WatermarkedRecipe;
+    /** Change the watermarked output's format. See {@link Recipe.convert}. Option keys validated pre-upload. */
+    convert(format: string, options?: ConvertOptions): WatermarkedRecipe;
+    /** Thumbnail the watermarked output. `width` AND `height` are required; validated pre-upload. */
+    thumbnail(options: ThumbnailOptions): WatermarkedRecipe;
+    /**
+     * Lower to the watermark DAG: a `src_0` passthrough/base-steps job + a `src_1`
+     * passthrough/overlay-steps job + one `watermark` job whose `inputs[]` consume
+     * them via `job_output` (role base/overlay) and whose `operations[]` is
+     * `[image_watermark|video_watermark, ...post-watermark ops]`. `fileIds` is
+     * `[baseId, overlayId]` (upload order). Throws pre-lowering if the base media
+     * is undetectable/unsupported (the planned-op gate).
+     *
+     * @internal Consumed by {@link run}/{@link submit} (after upload) + the parity harness.
+     */
+    toWorkflowPayload(fileIds: readonly string[], callbackUrl?: string): WorkflowCreatePayload;
+    /** The number of post-watermark ops chained so far (introspection / tests). */
+    get stepCount(): number;
+    /**
+     * Execute end-to-end: upload base + overlay, create the watermark workflow,
+     * await terminal (SSE with poll fallback), then resolve ONLY the watermark
+     * output into a {@link RunResult}. Requires a client bound at construction.
+     * Mirrors {@link MergedRecipe.run}.
+     */
+    run(options?: {
+        maxWait?: string | number;
+        onProgress?: (event: ProgressEvent) => void;
+        signal?: AbortSignal;
+        pollIntervalMs?: number;
+        probeBeforeCreate?: boolean;
+        probeTimeoutMs?: number;
+    }): Promise<RunResult>;
+    /**
+     * Fire-and-forget: upload base + overlay + create the watermark workflow
+     * (wiring `webhook` into `callback_url` when given), return a client-bound
+     * {@link Handle}. Does NOT wait for terminal status. Mirrors {@link MergedRecipe.submit}.
+     */
+    submit(webhook?: string, options?: {
+        probeBeforeCreate?: boolean;
+        probeTimeoutMs?: number;
+    }): Promise<Handle>;
+    /** Base + overlay inputs, in upload/lowering order (`[base, overlay]`). */
+    private inputsInOrder;
+    /**
+     * Validate the watermark BEFORE any upload: the base must route to a shippable
+     * wire op (throws for undetectable/unsupported/planned bases), and the overlay
+     * must be an image. Shared by {@link run}/{@link submit}. Mirrors
+     * {@link MergedRecipe.validatePreUpload}.
+     */
+    private validatePreUpload;
+    /**
+     * Upload base + overlay (verbatim for a pre-uploaded id; uploading a path /
+     * blob otherwise) then create ONE watermark workflow. Validates pre-upload.
+     * Shared first half of {@link run} + {@link submit}; mirrors
+     * {@link MergedRecipe._uploadAllAndCreate}.
+     */
+    private _uploadAllAndCreate;
+    /**
+     * Lower the post-watermark chain over a synthetic input whose extension
+     * matches the watermark OUTPUT media (image→png, video→mp4) so
+     * `compress(optimize)` resolves the correct preset — mirrors
+     * {@link MergedRecipe.lowerPostSteps}.
+     */
+    private lowerPostSteps;
+    private withStep;
+}
 export {};