@giveitsmaller/sdk 0.19.0 → 0.21.0

package/dist/index.core.js

@@ -9,7 +9,7 @@ export { GislClient, DEFAULT_MULTIPART_FIRST_CHUNK_SIZE } from './client.js';
 export { parseSseStream } from './sse.js';
 export { uploadSource, jobOutputSource, externalImportSource, connectionSource, } from './types.js';
 // Errors
-export { GislError, GislApiError, GislValidationError, GislBalanceExhaustedError, GislTierRestrictedError, GislFeatureTierRestrictedError, GislFeatureNotAvailableError, GislWorkflowExpiredError, GislProbePendingError, GislAuthError, GislUploadCapExceededError, GislMultipartPartError, GislMultipartPartCountError, 
+export { GislError, GislApiError, GislValidationError, GislBalanceExhaustedError, GislLongFormConcurrencyError, GislTierRestrictedError, GislFeatureTierRestrictedError, GislFeatureNotAvailableError, GislWorkflowExpiredError, GislProbePendingError, GislAuthError, GislUploadCapExceededError, GislMultipartPartError, GislMultipartPartCountError, 
 // SDK-3 (Wb6ebOMM) — typed errors for the 3 resume-support endpoints.
 GislMultipartSessionNotFoundError, GislMultipartSessionOwnershipError, GislMultipartSessionAuthRequiredError, GislTimeoutError, GislAbortError, 
 // FF2b / tywwynmN — transport-level failure (mirrors PHP GislNetworkError);
@@ -55,6 +55,11 @@ export { ArchivedRecipe } from './file-first.js';
 // post-watermark ops on, then run()/submit(). Routes image_watermark / video_watermark
 // by base media; gates planned/unsupported bases locally pre-upload.
 export { WatermarkedRecipe } from './file-first.js';
+// File-first keyed multi-recipe batch (FF7 / MFaCjL8d) — `client.batch([r1, r2, …])`
+// runs N DISTINCT single-input keyed recipes as ONE workflow; run() partitions the
+// RunResult by each entry's caller key. v1 = single-input keyed, run()-only; the
+// multi-input builders are rejected pre-upload.
+export { BatchRecipe } from './file-first.js';
 // `HttpDownloader` (Node streaming downloader) is re-exported from the Node-only
 // entry `index.ts`, NOT here — it statically imports node:fs/node:stream.
 // `projectDownloadsToRunResult` is intentionally NOT re-exported here — it is an
@@ -72,7 +77,7 @@ export { gisl, create } from './gisl.js';
 // Ergonomic preset defaults (T4a / VhIj4S7T) — typed leaf DTOs + immutable
 // `PresetDefaults` builder + `presetDefaults()` factory + ergonomic enum
 // re-exports. Resolver wiring (T4b) consumes `PresetDefaults.cellFor()`.
-export { presetDefaults, PresetDefaults, ImageCompressPresetOptions, AudioCompressPresetOptions, VideoCompressPresetOptions, DocumentPdfCompressPresetOptions, DocumentOfficeCompressPresetOptions, DocumentOdfCompressPresetOptions, DocumentEpubCompressPresetOptions, OptimizeFor, ImageMetadataPolicy, ImageFormat, VideoCodec, VideoPreset, VideoFit, AudioBitrate, AudioCodec, AudioSampleRate, PdfProfile, PdfColorspace, } from './ergonomic/presets/index.js';
+export { presetDefaults, PresetDefaults, ImageCompressPresetOptions, AudioCompressPresetOptions, VideoCompressPresetOptions, DocumentOfficeCompressPresetOptions, DocumentOdfCompressPresetOptions, DocumentEpubCompressPresetOptions, OptimizeFor, ImageMetadataPolicy, ImageFormat, VideoCodec, VideoPreset, VideoFit, AudioBitrate, AudioCodec, AudioSampleRate, } from './ergonomic/presets/index.js';
 // Operation-builder surface (T2 / xVDTIm8C) — `client.compress/convert/thumbnail`
 // returns an `OperationBuilder`; `.run()` projects to a flat `Result` /
 // `.submit({webhook})` returns a `Handle`. Progress events are the
@@ -109,4 +114,7 @@ AudioToVideoAudioOutputResolution, AudioToVideoAudioImageFit, AudioToVideoAudioO
 // surfaces as `GislFeatureNotAvailableError`).
 export { archiveMetadata, audioOverlayMetadata, audioWatermarkMetadata, compressMetadata, convertMetadata, customLumaMetadata, imageWatermarkMetadata, mergeMetadata, textWatermarkMetadata, thumbnailMetadata, 
 // New planned operation metadata sidecars — contracts v2.15 (AJCLLGaG).
-audioToVideoMetadata, videoWatermarkMetadata, videoTextWatermarkMetadata, splitMetadata, } from '@giveitsmaller/contracts/operations';
+audioToVideoMetadata, videoWatermarkMetadata, videoTextWatermarkMetadata, splitMetadata, 
+// transform is `availability: planned` — consumers can inspect this sidecar to
+// gate UI before submitting (the API otherwise returns feature_not_available/422). T4.
+transformMetadata, } from '@giveitsmaller/contracts/operations';

package/dist/merge.d.ts

@@ -90,13 +90,25 @@ export interface MergeOptions {
     readonly crossfadeDuration?: number;
     readonly gapDuration?: number;
     readonly normalizeAudio?: boolean;
+    /**
+     * Video re-encode policy (`auto` | `always` | `never`). Passed through
+     * verbatim — `codec`/`crf`/`preset`/`targetResolution`/`targetSize` are only
+     * honoured by the worker when re-encoding (`auto`/`always`); the server owns
+     * that dependency validation (the SDK is a passthrough allowlist, same as the
+     * pre-existing codec/crf/preset fields). Video merge only.
+     */
+    readonly reEncodeMode?: string;
     readonly codec?: string;
     readonly crf?: number;
     readonly preset?: string;
+    /** Video output dimensions `WxH` (e.g. `"1920x1080"`); omit to inherit from inputs. Video merge only. */
+    readonly targetResolution?: string;
     readonly targetSize?: string | number;
     readonly transitionDuration?: number;
     readonly fps?: number;
     readonly durationPerImage?: number;
+    /** Milliseconds between frames for an animated-GIF image merge (`output_type: gif`). Image merge only. */
+    readonly delay?: number;
     readonly loopCount?: number;
     readonly output?: string;
     readonly videoFormat?: string;

package/dist/merge.js

@@ -128,14 +128,14 @@ export class MergeBuilder {
         });
         // 5. Fetch downloads + project.
         if (Date.now() >= deadline) {
-            throw new GislTimeoutError(`Merge workflow ${created.workflowId} reached terminal status but maxWait elapsed before downloads could be fetched`);
+            throw new GislTimeoutError(`Merge workflow ${created.workflowId} reached terminal status but maxWait elapsed before downloads could be fetched`, created.workflowId);
         }
         const downloads = await this.client.getWorkflowDownloads(created.workflowId);
         // TDqmkWpX: the maxWait deadline also covers the downloads fetch itself —
         // re-check AFTER the call so a slow getWorkflowDownloads cannot return a
         // success past the advertised whole-run deadline.
         if (Date.now() >= deadline) {
-            throw new GislTimeoutError(`Merge workflow ${created.workflowId} downloads fetch completed after maxWait elapsed`);
+            throw new GislTimeoutError(`Merge workflow ${created.workflowId} downloads fetch completed after maxWait elapsed`, created.workflowId);
         }
         // p0SuJEeK — project ONLY the merge job's output. getWorkflowDownloads
         // returns a download group per terminal job, which now INCLUDES the
@@ -406,12 +406,16 @@ export class MergeBuilder {
             out.gapDuration = o.gapDuration;
         // Video only.
         if (mediaKind === 'video') {
+            if (o.reEncodeMode !== undefined)
+                out.reEncodeMode = o.reEncodeMode;
             if (o.codec !== undefined)
                 out.codec = o.codec;
             if (o.crf !== undefined)
                 out.crf = o.crf;
             if (o.preset !== undefined)
                 out.preset = o.preset;
+            if (o.targetResolution !== undefined)
+                out.targetResolution = o.targetResolution;
             if (o.targetSize !== undefined)
                 out.targetSize = o.targetSize;
         }
@@ -423,6 +427,8 @@ export class MergeBuilder {
                 out.fps = o.fps;
             if (o.durationPerImage !== undefined)
                 out.durationPerImage = o.durationPerImage;
+            if (o.delay !== undefined)
+                out.delay = o.delay;
             if (o.loopCount !== undefined)
                 out.loopCount = o.loopCount;
             if (o.videoFormat !== undefined)
@@ -519,12 +525,16 @@ export function wireMergeOptions(opts, mediaKind) {
         out.gap_duration = opts.gapDuration;
     // Video only.
     if (mediaKind === 'video') {
+        if (opts.reEncodeMode !== undefined)
+            out.re_encode_mode = opts.reEncodeMode;
         if (opts.codec !== undefined)
             out.codec = opts.codec;
         if (opts.crf !== undefined)
             out.crf = opts.crf;
         if (opts.preset !== undefined)
             out.preset = opts.preset;
+        if (opts.targetResolution !== undefined)
+            out.target_resolution = opts.targetResolution;
         if (opts.targetSize !== undefined) {
             out.target_size_bytes = typeof opts.targetSize === 'number'
                 ? opts.targetSize
@@ -540,6 +550,8 @@ export function wireMergeOptions(opts, mediaKind) {
             out.fps = opts.fps;
         if (opts.durationPerImage !== undefined)
             out.duration_per_image = opts.durationPerImage;
+        if (opts.delay !== undefined)
+            out.delay = opts.delay;
         if (opts.loopCount !== undefined)
             out.loop_count = opts.loopCount;
         if (opts.videoFormat !== undefined)

package/dist/retry-metadata.d.ts

@@ -0,0 +1,37 @@
+/**
+ * A rate-limit snapshot derived from the `x-ratelimit-*` response headers.
+ * `resetSeconds` is the server's seconds-to-reset value (`X-RateLimit-Reset`),
+ * NOT an absolute epoch — read {@link GislApiError.rateLimit} to obtain one.
+ */
+export interface RateLimitSnapshot {
+    readonly limit: number;
+    readonly remaining: number;
+    readonly resetSeconds: number;
+}
+/**
+ * Whether an HTTP status is retryable per the API-error taxonomy: request
+ * timeout (408), rate-limit (429), or any 5xx (500–599). BOUNDED at 599 — a
+ * non-standard 6xx-and-up status is NOT classified retryable.
+ *
+ * Now value-identical to the S3-PUT retry predicate (`isRetryableStatus`) in
+ * `client.ts` (both are `408 || 429 || 500-599` after qz7MjNTy), but kept
+ * DELIBERATELY SEPARATE: they guard different retry paths (S3-PUT chunk uploads
+ * vs the API-error taxonomy) and may diverge again, so they must NOT be merged.
+ */
+export declare function isApiRetryableStatus(status: number): boolean;
+export declare function parseRetryAfterMs(headerValue: string | undefined): number | undefined;
+/**
+ * The server-suggested back-off delay in WHOLE seconds, parsed from the
+ * `Retry-After` response header. Derived from {@link parseRetryAfterMs}
+ * (`Math.floor(ms / 1000)`) so the semantics mirror the retry-loop parser:
+ * absent / malformed / zero / past all collapse to `undefined`, as does a
+ * sub-second future HTTP-date (floors to zero → treated as absent).
+ */
+export declare function retryAfterSecondsFromHeaders(headers: Record<string, string> | undefined): number | undefined;
+/**
+ * A rate-limit snapshot parsed from the `x-ratelimit-*` response headers.
+ * Present ONLY when `x-ratelimit-limit`, `x-ratelimit-remaining`, and
+ * `x-ratelimit-reset` all parse as non-negative integers; otherwise
+ * `undefined` (a partial set is not a usable snapshot).
+ */
+export declare function rateLimitFromHeaders(headers: Record<string, string> | undefined): RateLimitSnapshot | undefined;

package/dist/retry-metadata.js

@@ -0,0 +1,86 @@
+// Shared HTTP retry-metadata helpers. Extracted here so `errors.ts` can consume
+// them WITHOUT importing `client.ts`: `client.ts` already imports `errors.ts`, so
+// pulling the module-private `parseRetryAfterMs` back out of `client.ts` would
+// form a `client → errors → client` circular import. The millisecond parser is
+// MOVED here verbatim; `client.ts` re-imports it so the retry-loop timing stays
+// byte-identical.
+/**
+ * Whether an HTTP status is retryable per the API-error taxonomy: request
+ * timeout (408), rate-limit (429), or any 5xx (500–599). BOUNDED at 599 — a
+ * non-standard 6xx-and-up status is NOT classified retryable.
+ *
+ * Now value-identical to the S3-PUT retry predicate (`isRetryableStatus`) in
+ * `client.ts` (both are `408 || 429 || 500-599` after qz7MjNTy), but kept
+ * DELIBERATELY SEPARATE: they guard different retry paths (S3-PUT chunk uploads
+ * vs the API-error taxonomy) and may diverge again, so they must NOT be merged.
+ */
+export function isApiRetryableStatus(status) {
+    return status === 408 || status === 429 || (status >= 500 && status <= 599);
+}
+// Parse an HTTP `Retry-After` header into milliseconds. Accepts the two RFC
+// 9110 forms: delta-seconds (e.g. "5") or an HTTP-date. Returns `undefined`
+// for an absent / unparseable / negative value (caller falls back to its own
+// backoff). A past HTTP-date clamps to 0.
+export function parseRetryAfterMs(headerValue) {
+    if (headerValue === undefined)
+        return undefined;
+    const trimmed = headerValue.trim();
+    if (trimmed === '')
+        return undefined;
+    let ms;
+    if (/^\d+$/.test(trimmed)) {
+        ms = Number(trimmed) * 1000;
+    }
+    else {
+        const when = Date.parse(trimmed);
+        if (Number.isNaN(when))
+            return undefined;
+        ms = when - Date.now();
+    }
+    // A non-positive Retry-After (e.g. "0" or a past HTTP-date) must NOT short-
+    // circuit the backoff to zero — treat it as absent so the caller falls back
+    // to jitter and the loop can't busy-poll until timeout.
+    return ms > 0 ? ms : undefined;
+}
+/**
+ * The server-suggested back-off delay in WHOLE seconds, parsed from the
+ * `Retry-After` response header. Derived from {@link parseRetryAfterMs}
+ * (`Math.floor(ms / 1000)`) so the semantics mirror the retry-loop parser:
+ * absent / malformed / zero / past all collapse to `undefined`, as does a
+ * sub-second future HTTP-date (floors to zero → treated as absent).
+ */
+export function retryAfterSecondsFromHeaders(headers) {
+    const ms = parseRetryAfterMs(headers?.['retry-after']);
+    if (ms === undefined)
+        return undefined;
+    const seconds = Math.floor(ms / 1000);
+    return seconds > 0 ? seconds : undefined;
+}
+// Parse a non-negative integer response header. Returns `undefined` for an
+// absent value or anything that isn't a bare run of decimal digits (so a
+// float, sign, or units suffix is rejected rather than silently truncated).
+function parseIntHeader(headerValue) {
+    if (headerValue === undefined)
+        return undefined;
+    const trimmed = headerValue.trim();
+    if (!/^\d+$/.test(trimmed))
+        return undefined;
+    return Number(trimmed);
+}
+/**
+ * A rate-limit snapshot parsed from the `x-ratelimit-*` response headers.
+ * Present ONLY when `x-ratelimit-limit`, `x-ratelimit-remaining`, and
+ * `x-ratelimit-reset` all parse as non-negative integers; otherwise
+ * `undefined` (a partial set is not a usable snapshot).
+ */
+export function rateLimitFromHeaders(headers) {
+    if (headers === undefined)
+        return undefined;
+    const limit = parseIntHeader(headers['x-ratelimit-limit']);
+    const remaining = parseIntHeader(headers['x-ratelimit-remaining']);
+    const resetSeconds = parseIntHeader(headers['x-ratelimit-reset']);
+    if (limit === undefined || remaining === undefined || resetSeconds === undefined) {
+        return undefined;
+    }
+    return { limit, remaining, resetSeconds };
+}

package/dist/sse.d.ts

@@ -1,4 +1,4 @@
-import type { GislSseEvent } from './types.js';
+import type { GislSseEvent, GislSseParseFailure } from './types.js';
 /**
  * Parse an SSE stream from a fetch Response into an AsyncIterable of typed events.
  *
@@ -27,4 +27,5 @@ import type { GislSseEvent } from './types.js';
  */
 export declare function parseSseStream(response: Response, opts?: {
     signal?: AbortSignal;
+    onParseError?: (diagnostic: GislSseParseFailure) => void;
 }): AsyncGenerator<GislSseEvent>;

package/dist/sse.js

@@ -76,15 +76,27 @@ export async function* parseSseStream(response, opts = {}) {
                     // Empty line = end of event
                     if (dataLines.length > 0) {
                         const rawData = dataLines.join('\n');
+                        const frameEvent = eventType || 'message';
                         let parsed;
                         try {
                             parsed = JSON.parse(rawData);
                         }
-                        catch {
-                            parsed = rawData;
+                        catch (err) {
+                            // TYNjcjpo — a malformed-JSON frame is SKIPPED (not yielded as a
+                            // raw string) so the stream stays resilient, but the failure is
+                            // surfaced via the optional onParseError diagnostic rather than
+                            // silently lost. Identical to the PHP `flushSseFrame` drop-path.
+                            opts.onParseError?.({
+                                raw: rawData,
+                                event: frameEvent,
+                                error: err instanceof Error ? err.message : String(err),
+                            });
+                            eventType = '';
+                            dataLines = [];
+                            continue;
                         }
                         yield {
-                            event: eventType || 'message',
+                            event: frameEvent,
                             data: parsed,
                         };
                     }
@@ -124,15 +136,23 @@ export async function* parseSseStream(response, opts = {}) {
         // not be yielded once the consumer has abandoned the stream.
         if (!aborted && dataLines.length > 0) {
             const rawData = dataLines.join('\n');
+            const frameEvent = eventType || 'message';
             let parsed;
             try {
                 parsed = JSON.parse(rawData);
             }
-            catch {
-                parsed = rawData;
+            catch (err) {
+                // TYNjcjpo — trailing-flush malformed frame: skip + diagnostic (same as
+                // the in-loop path above).
+                opts.onParseError?.({
+                    raw: rawData,
+                    event: frameEvent,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+                return;
             }
             yield {
-                event: eventType || 'message',
+                event: frameEvent,
                 data: parsed,
             };
         }

package/dist/types.d.ts

@@ -1,5 +1,5 @@
-import type { OperationType, OperationsSchemaResponse, CallbackEventType, SseEventType, SseOperationProgressData, SseOperationCompletedData, SseOperationFailedData, SseJobCompletedData, SseJobFailedData, SseWorkflowTerminalData, MultipartInitiateRequestMetadataHint, UploadProbeResponse } from '@giveitsmaller/contracts/openapi';
-import type { JobInputV2RoleEnum } from '@giveitsmaller/contracts/openapi';
+import type { OperationType, OperationsSchemaResponse, OperationCapability, OutputProperties, ImageEncodeCapabilities, CallbackEventType, SseEventType, SseOperationProgressData, SseOperationCompletedData, SseOperationFailedData, SseJobCompletedData, SseJobFailedData, SseWorkflowTerminalData, MultipartInitiateRequestMetadataHint, UploadProbeResponse } from '@giveitsmaller/contracts/openapi';
+import type { JobInputV2RoleEnum, NotifyConfig } from '@giveitsmaller/contracts/openapi';
 export interface GislClientConfig {
     baseUrl: string;
     apiKey?: string;
@@ -188,6 +188,14 @@ export interface WorkflowCreatePayload {
     export?: ExternalDestinationPayload;
     delivery?: DeliveryPayload;
     processing?: WorkflowProcessingPayload;
+    /**
+     * Per-job completion notification (contracts v2.164.0, `notify.email`).
+     * Opaque passthrough wire shape — the ergonomic `notifyEmail` surface
+     * (SubmitOptions/RunOptions + builder convenience) is a separate follow-up
+     * (card y6jsQCpb); this field only acknowledges the wire key so a
+     * hand-built payload can carry it. Mirrors `export`/`delivery`/`processing`.
+     */
+    notify?: NotifyConfig;
 }
 /**
  * Single source of truth for WorkflowCreatePayload's top-level wire keys.
@@ -196,7 +204,7 @@ export interface WorkflowCreatePayload {
  * only via deep imports and should not be treated as public API.
  * @internal
  */
-export declare const WORKFLOW_CREATE_PAYLOAD_KEYS: readonly ["jobs", "source", "operations", "workflow_edges", "callback_url", "callback_events", "export", "delivery", "processing"];
+export declare const WORKFLOW_CREATE_PAYLOAD_KEYS: readonly ["jobs", "source", "operations", "workflow_edges", "callback_url", "callback_events", "export", "delivery", "processing", "notify"];
 export interface GetSchemaOptions {
     /** Filter the schema to operations that accept this MIME type (e.g. `image/jpeg`). */
     mimeType?: string;
@@ -227,6 +235,32 @@ export type GetSchemaResult = {
     etag?: string;
     lastModified?: string;
 };
+/**
+ * Typed projection of the operation-capability surface returned by
+ * {@link ErgonomicClient.capabilities} (qUhxfDA5). Bundles the three v2.124
+ * capability fields of `OperationsSchemaResponse` — previously typed but with
+ * no ergonomic consumer — so a caller can read them without dropping to
+ * `getSchema()` and its not-modified union.
+ *
+ * Mirrors the PHP `Gisl\Sdk\Ergonomic\CapabilitiesSnapshot` value object.
+ */
+export interface CapabilitiesSnapshot {
+    /**
+     * Tier-scoped operation-capability matrix, keyed by operation type
+     * (`compress`, `convert`, …). Empty when the server omits the field.
+     */
+    readonly operations: Record<string, OperationCapability>;
+    /**
+     * Output-format property table (`hasAudioTrack` / `isAnimated`), keyed by
+     * `output_format`. Tier-invariant. Empty when the server omits the field.
+     */
+    readonly outputProperties: Record<string, OutputProperties>;
+    /**
+     * Pre-flight image-encode capability matrix (`webpQualitySupported`,
+     * `backgroundFlatten`). Tier-invariant. `undefined` when the server omits it.
+     */
+    readonly imageEncode?: ImageEncodeCapabilities;
+}
 export interface CreditsUsageOptions {
     /**
      * Page size. Server defaults to 20 and rejects values outside `[1, 100]`
@@ -296,7 +330,7 @@ export interface ReadCapabilityOptions {
 export interface WaitOptions {
     /** Poll interval in milliseconds (default: 2000) */
     intervalMs?: number;
-    /** Maximum wait time in milliseconds (default: 300000 = 5 min) */
+    /** Maximum wait time in milliseconds (default: 600000 = 10 min) */
     timeoutMs?: number;
     /** Called after each poll with current status */
     onPoll?: (status: string) => void;
@@ -373,6 +407,22 @@ export type GislSseEvent = {
     event: string;
     data: unknown;
 };
+/**
+ * A typed, non-throwing diagnostic surfaced when an SSE frame's `data:` body fails
+ * to JSON-parse (TYNjcjpo). The malformed frame is SKIPPED from the event stream —
+ * a long-running consumer must not break on one garbled server frame — but the
+ * failure is observable via the `onParseError` callback on `streamEvents` /
+ * `parseSseStream` rather than silently lost. Mirrors the PHP `GislSseParseFailure`
+ * value object; the shape is identical across the two SDKs (cross-SDK parity).
+ */
+export interface GislSseParseFailure {
+    /** The joined `data:` line(s) that failed to parse. */
+    readonly raw: string;
+    /** The frame's event type (or `'message'` when the frame had no `event:` field). */
+    readonly event: string;
+    /** The parse error message (e.g. the `JSON.parse` `SyntaxError` text). */
+    readonly error: string;
+}
 export interface UploadOptions {
     /** Called with bytes uploaded so far (only for multipart) */
     onProgress?: (uploadedBytes: number, totalBytes: number) => void;

package/dist/types.js

@@ -50,4 +50,5 @@ export const WORKFLOW_CREATE_PAYLOAD_KEYS = Object.freeze([
     'export',
     'delivery',
     'processing',
+    'notify',
 ]);

package/package.json

@@ -1,8 +1,8 @@
 {
   "name": "@giveitsmaller/sdk",
-  "version": "0.19.0",
+  "version": "0.21.0",
   "description": "Node.js SDK for the GISL (Give It Smaller) file compression and processing API",
-  "license": "MIT",
+  "license": "Apache-2.0",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -31,7 +31,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@giveitsmaller/contracts": "^0.50.0"
+    "@giveitsmaller/contracts": "^0.59.0"
   },
   "devDependencies": {
     "@types/node": "^22",

package/dist/ergonomic/presets/document_pdf_compress.d.ts

@@ -1,12 +0,0 @@
-import { PdfProfile, OptimizeFor } from '../../generated/sdk_spec/enums.js';
-export interface DocumentPdfCompressPresetOptionsInput {
-    readonly profile?: PdfProfile;
-    readonly grayscale?: boolean;
-}
-export declare class DocumentPdfCompressPresetOptions {
-    readonly profile?: PdfProfile;
-    readonly grayscale?: boolean;
-    private constructor();
-    static from(input: DocumentPdfCompressPresetOptionsInput): DocumentPdfCompressPresetOptions;
-    static shippedDefaultsFor(level: OptimizeFor): DocumentPdfCompressPresetOptions;
-}

package/dist/ergonomic/presets/document_pdf_compress.js

@@ -1,33 +0,0 @@
-// T4a — DocumentPdfCompressPresetOptions leaf DTO.
-//
-// Field set (2): profile, grayscale — the worker-honored stable PDF controls
-// (contracts v2.96.0 Acrobat-PDF realignment Lw1LseYr). The earlier
-// {profile, colorspace, flattenForms} set was retired: colorspace + flatten_forms
-// are `planned` (not read by the worker) so presets never emit them, and
-// `image_dpi` + `pages` are per-call knobs, not preset cells.
-import { shippedDefaultsFor as f3ShippedDefaultsFor } from '../../generated/sdk_spec/presets.js';
-import { translateEnum } from './_translate.js';
-export class DocumentPdfCompressPresetOptions {
-    profile;
-    grayscale;
-    constructor(input) {
-        if (input.profile !== undefined)
-            this.profile = input.profile;
-        if (input.grayscale !== undefined)
-            this.grayscale = input.grayscale;
-        Object.freeze(this);
-    }
-    static from(input) {
-        return new DocumentPdfCompressPresetOptions(input);
-    }
-    static shippedDefaultsFor(level) {
-        const cell = f3ShippedDefaultsFor('document_pdf_compress', level);
-        const input = {};
-        const mut = input;
-        if ('profile' in cell)
-            mut.profile = translateEnum('PdfProfile', cell.profile);
-        if ('grayscale' in cell)
-            mut.grayscale = cell.grayscale;
-        return new DocumentPdfCompressPresetOptions(input);
-    }
-}