@giveitsmaller/sdk 0.11.0 → 0.12.1

package/dist/builder.d.ts

@@ -41,6 +41,20 @@ import type { PresetDefaults, PresetMedia } from './ergonomic/presets/index.js';
  * @internal — exported for tests + the preset resolver.
  */
 export declare function _detectCompressMedia(input: string | Blob): PresetMedia | undefined;
+/**
+ * Best-effort classification of whether an audio input is LOSSLESS
+ * (flac/wav) vs lossy. The worker rejects `bitrate` on lossless audio
+ * (compress.yaml / contracts iakhSy3E), so the preset resolver uses this
+ * to drop the shipped-preset bitrate for clear-cut lossless inputs.
+ *
+ * Detection is filename/MIME only — it CANNOT probe the actual codec, so
+ * any ambiguous or unknown input classifies as lossy (keep bitrate). The
+ * worker stays authoritative: a user-supplied bitrate on a lossless file
+ * still reaches the wire and earns a deliberate 422.
+ *
+ * @internal — exported for tests + the preset resolver.
+ */
+export declare function _detectAudioLossless(input: string | Blob): boolean;
 /**
  * Lightweight artifact reference passed to a `.mapEach(...)` fn. Mirrors
  * the subset of `Artifact` a fan-out callback can use to construct the

package/dist/builder.js

@@ -103,6 +103,59 @@ export function _detectCompressMedia(input) {
         return 'document_office';
     return undefined;
 }
+// LOSSLESS audio per the compress.yaml contract (contracts iakhSy3E) —
+// flac/wav ONLY. Everything else audio (mp3/mpeg, aac, ogg, m4a/mp4, opus)
+// and any unknown input is treated as lossy so the shipped-preset bitrate is
+// kept. `aiff` is deliberately absent — not a contract audio format.
+const LOSSLESS_AUDIO_MIMES = new Set([
+    'audio/flac',
+    'audio/x-flac',
+    'audio/wav',
+    'audio/x-wav',
+    'audio/wave',
+]);
+const LOSSLESS_AUDIO_EXTENSIONS = new Set(['flac', 'wav']);
+/**
+ * Best-effort classification of whether an audio input is LOSSLESS
+ * (flac/wav) vs lossy. The worker rejects `bitrate` on lossless audio
+ * (compress.yaml / contracts iakhSy3E), so the preset resolver uses this
+ * to drop the shipped-preset bitrate for clear-cut lossless inputs.
+ *
+ * Detection is filename/MIME only — it CANNOT probe the actual codec, so
+ * any ambiguous or unknown input classifies as lossy (keep bitrate). The
+ * worker stays authoritative: a user-supplied bitrate on a lossless file
+ * still reaches the wire and earns a deliberate 422.
+ *
+ * @internal — exported for tests + the preset resolver.
+ */
+export function _detectAudioLossless(input) {
+    let filename;
+    let mime;
+    if (typeof input === 'string') {
+        filename = input;
+    }
+    else {
+        mime = input.type !== '' ? input.type : undefined;
+        const named = input.name;
+        if (typeof named === 'string')
+            filename = named;
+    }
+    // MIME-first if a recognised audio MIME is present — Blob.type is canonical.
+    // Strip any MIME parameters (`audio/flac; codecs=flac`) before the exact-set
+    // lookup so a parameterised type still classifies as lossless — `media` is
+    // already `audio` via the prefix check, so a miss would wrongly keep the
+    // bitrate (codex 18b6b684).
+    if (mime !== undefined && mime.startsWith('audio/')) {
+        const bareMime = mime.split(';')[0].trim().toLowerCase();
+        return LOSSLESS_AUDIO_MIMES.has(bareMime);
+    }
+    if (filename === undefined)
+        return false;
+    const ext = filename.toLowerCase().split('.').pop();
+    if (ext === undefined)
+        return false;
+    return LOSSLESS_AUDIO_EXTENSIONS.has(ext);
+}
 // ---------------------------------------------------------------------------
 // OperationBuilder
 // ---------------------------------------------------------------------------
@@ -177,6 +230,9 @@ export class OperationBuilder {
             op: 'compress',
             explicitOptions,
         };
+        if (media === 'audio') {
+            input.audioLossless = _detectAudioLossless(this.input);
+        }
         if (this.presetDefaults !== undefined) {
             input.presetDefaults = this.presetDefaults;
         }

package/dist/ergonomic/preset_resolver.d.ts

@@ -36,6 +36,12 @@ export interface ResolveCompressOptionsInput {
      * layer.
      */
     readonly explicitOptions: Readonly<Record<string, unknown>>;
+    /**
+     * Classifier result from media detection. When `true` on audio, the
+     * shipped-preset (sdkDefault) bitrate is dropped — the worker rejects
+     * `bitrate` on lossless outputs (flac/wav — contracts iakhSy3E).
+     */
+    readonly audioLossless?: boolean;
 }
 /**
  * Output of {@link resolveCompressOptions}. `wireOptions` is the

package/dist/ergonomic/preset_resolver.js

@@ -432,7 +432,7 @@ function computePresetConfigHash(clientDefault, scopedDefault, callPresetOverrid
  * `optimize` unset ⇒ layer 1 contributes nothing; `resolvedOptions.preset = null`.
  */
 export function resolveCompressOptions(input) {
-    const { media, op, presetDefaults, scopedPresetDefaults, presetOverrides, optimize, explicitOptions } = input;
+    const { media, op, presetDefaults, scopedPresetDefaults, presetOverrides, optimize, explicitOptions, audioLossless } = input;
     if (op !== 'compress') {
         throw new GislConfigError(`Preset resolution is only wired for compress operations today; got op='${op}'.`, { reason: 'unsupported_op' });
     }
@@ -510,6 +510,15 @@ export function resolveCompressOptions(input) {
             acc.winners.set('encoding_mode', crfSource);
         }
     }
+    // audio_compress bakes a bitrate (Size 96 / Balanced 192 / Quality 320); the
+    // worker rejects `bitrate` on lossless outputs (flac/wav — contracts iakhSy3E).
+    // Drop ONLY the shipped-preset (sdkDefault) bitrate for clear-cut lossless
+    // audio; any user-supplied bitrate (client/scoped default, per-call override
+    // or explicit) is left for the worker to reject — no silent-ignore.
+    if (media === 'audio' && audioLossless === true && acc.winners.get('bitrate') === 'sdkDefault') {
+        delete acc.merged.bitrate;
+        acc.winners.delete('bitrate');
+    }
     // 7. Validate the merged payload (post-merge — catches cross-layer
     // disagreements). May throw GislConfigError with resolvedSnapshot.
     const explicitWireKeys = new Set();

package/dist/errors.d.ts

@@ -342,6 +342,18 @@ export declare class GislChainCardinalityMismatchError extends GislConfigError {
     readonly attemptedOperation: string;
     constructor(previousOperation: string, attemptedOperation: string);
 }
+/**
+ * Thrown by `.bundle(...)` when the target builder's terminal job is already an
+ * `archive` op — double-bundle prevention (a builder that already produces an
+ * archive cannot be bundled again). No HTTP: raised during lowering, before any
+ * upload. Per the lowering spec
+ * (`docs/plans/sdk-ergonomics/lowering.md:484`, id `bundle_already_archived_error`).
+ * Dormant until `.bundle()` ships (wpHoJhuo) — the type lands here so that PR is
+ * a pure addition.
+ */
+export declare class GislBundleAlreadyArchivedError extends GislConfigError {
+    constructor();
+}
 export declare class GislTimeoutError extends GislError {
     constructor(message: string);
 }

package/dist/errors.js

@@ -349,6 +349,22 @@ export class GislChainCardinalityMismatchError extends GislConfigError {
         this.attemptedOperation = attemptedOperation;
     }
 }
+/**
+ * Thrown by `.bundle(...)` when the target builder's terminal job is already an
+ * `archive` op — double-bundle prevention (a builder that already produces an
+ * archive cannot be bundled again). No HTTP: raised during lowering, before any
+ * upload. Per the lowering spec
+ * (`docs/plans/sdk-ergonomics/lowering.md:484`, id `bundle_already_archived_error`).
+ * Dormant until `.bundle()` ships (wpHoJhuo) — the type lands here so that PR is
+ * a pure addition.
+ */
+export class GislBundleAlreadyArchivedError extends GislConfigError {
+    constructor() {
+        super('This builder already produces an archive (bundle); .bundle() cannot be ' +
+            'applied to an already-bundled builder.');
+        this.name = 'GislBundleAlreadyArchivedError';
+    }
+}
 export class GislTimeoutError extends GislError {
     constructor(message) {
         super(message);

package/dist/file-first.d.ts

@@ -329,23 +329,32 @@ export declare class Recipe {
     /**
      * Reduce file size. `optimize` selects a per-media preset (resolved to
      * concrete wire fields at lower-time, exactly as `client.compress()` does).
+     * `options` carries the full per-op options bag (mirrors
+     * `client.compress(input, options)`); the explicit `optimize` param wins
+     * over any `optimize` key in the bag.
      */
-    compress(optimize?: OptimizeFor): Recipe;
-    /** Change format. `format` is lowered verbatim to the `format` wire option. */
-    convert(format: string): Recipe;
+    compress(optimize?: OptimizeFor, options?: Record<string, unknown>): Recipe;
     /**
-     * Generate a preview. Width and/or height in pixels; an omitted dimension is
-     * dropped from the wire options (not sent as `undefined`).
+     * Change format. The `format` shorthand lowers to the `output_format` wire
+     * 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;
+    /**
+     * 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`).
      */
     thumbnail(options?: {
         width?: number;
         height?: number;
-    }): Recipe;
+    } & Record<string, unknown>): 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.
+     * secondary file) — lowers to the `text_watermark` op with a `text` option;
+     * `options` carries any additional per-op watermark options.
      */
-    textWatermark(text: string): Recipe;
+    textWatermark(text: string, options?: Record<string, unknown>): Recipe;
     /**
      * Lower this recipe to a workflow-create payload against a resolved upload
      * id. Single-input chain → ONE job, `source: upload(fileId)`, ordered
@@ -417,6 +426,7 @@ export declare class Recipe {
     private lowerStep;
     private lowerCompressOptions;
     private compressMediaHint;
+    private compressAudioLossless;
 }
 /**
  * The homogeneous fan-out builder value (FF3a). `client.files([a, b, c])`
@@ -455,16 +465,16 @@ export declare class FilesRecipe {
      * preset). Reuses {@link Recipe}'s validation — a directly-constructed
      * lowering builds an internal Recipe that throws the same `GislConfigError`.
      */
-    compress(optimize?: OptimizeFor): FilesRecipe;
+    compress(optimize?: OptimizeFor, options?: Record<string, unknown>): FilesRecipe;
     /** Change every input's format. `format` lowers verbatim to the `format` option. */
-    convert(format: string): FilesRecipe;
+    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;
-    }): FilesRecipe;
+    } & Record<string, unknown>): FilesRecipe;
     /** Apply the same text watermark to every input. */
-    textWatermark(text: string): FilesRecipe;
+    textWatermark(text: string, options?: Record<string, unknown>): FilesRecipe;
     /**
      * Combine the inputs into ONE output (N→1), in array order (FF3b). Returns a
      * single-output {@link MergedRecipe} you chain further ops on
@@ -587,14 +597,14 @@ export declare class MergedRecipe {
     private readonly client?;
     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): MergedRecipe;
+    compress(optimize?: OptimizeFor, options?: Record<string, unknown>): MergedRecipe;
     /** Change the merged output's format. See {@link Recipe.convert}. */
-    convert(format: string): MergedRecipe;
+    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;
-    }): MergedRecipe;
+    } & Record<string, unknown>): MergedRecipe;
     /**
      * Lower to the merge DAG: one `passthrough` source job per input + one
      * `merge` job whose `operations[]` is `[merge, ...post-combine ops]`. The

package/dist/file-first.js

@@ -10,7 +10,7 @@
  * Mirrors `packages/php/src/FileFirst/*`.
  */
 import { GislConfigError, GislNetworkError, GislNoSuchKeyError, GislSinkError, GislTimeoutError, SseEndedWithoutTerminal } from './errors.js';
-import { _detectCompressMedia, _consumeSseToTerminal, _pollToTerminal, _parseMaxWait, _checkAborted, } from './builder.js';
+import { _detectCompressMedia, _detectAudioLossless, _consumeSseToTerminal, _pollToTerminal, _parseMaxWait, _checkAborted, } from './builder.js';
 import { LazyHttpDownloader } from './lazy-downloader.js';
 import { resolveCompressOptions, } from './ergonomic/preset_resolver.js';
 import { OptimizeFor } from './generated/sdk_spec/enums.js';
@@ -421,36 +421,56 @@ export class Recipe {
     /**
      * Reduce file size. `optimize` selects a per-media preset (resolved to
      * concrete wire fields at lower-time, exactly as `client.compress()` does).
+     * `options` carries the full per-op options bag (mirrors
+     * `client.compress(input, options)`); the explicit `optimize` param wins
+     * over any `optimize` key in the bag.
      */
-    compress(optimize) {
+    compress(optimize, options = {}) {
         if (optimize !== undefined && !Object.values(OptimizeFor).includes(optimize)) {
             const allowed = Object.values(OptimizeFor).join(', ');
             throw new GislConfigError(`compress 'optimize' must be one of ${allowed}; got '${String(optimize)}'.`, { reason: 'invalid_optimize', conflictingFields: ['optimize'] });
         }
-        return this.withStep({ opType: 'compress', options: optimize === undefined ? {} : { optimize } });
+        return this.withStep({
+            opType: 'compress',
+            options: { ...options, ...(optimize !== undefined ? { optimize } : {}) },
+        });
     }
-    /** Change format. `format` is lowered verbatim to the `format` wire option. */
-    convert(format) {
-        return this.withStep({ opType: 'convert', options: { format } });
+    /**
+     * Change format. The `format` shorthand lowers to the `output_format` wire
+     * option (the convert op's wire key per the contract); `options` carries any
+     * additional per-op convert options.
+     */
+    convert(format, options = {}) {
+        // The convert op's wire key is `output_format` (contract: convert.yaml,
+        // required, all media), NOT `format`. Spread options FIRST so the explicit
+        // shorthand wins over an `output_format` key in the bag.
+        // The shorthand owns the format → a stray legacy `format` key in the bag is
+        // not a valid convert option; drop it so the wire never carries both keys.
+        const rest = { ...options };
+        delete rest.format;
+        return this.withStep({ opType: 'convert', options: { ...rest, output_format: format } });
     }
     /**
-     * Generate a preview. Width and/or height in pixels; an omitted dimension is
-     * dropped from the wire options (not sent as `undefined`).
+     * 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`).
      */
     thumbnail(options = {}) {
         const wire = {};
-        if (options.width !== undefined)
-            wire.width = options.width;
-        if (options.height !== undefined)
-            wire.height = options.height;
+        for (const [key, value] of Object.entries(options)) {
+            if (value !== undefined)
+                wire[key] = value;
+        }
         return this.withStep({ opType: 'thumbnail', options: wire });
     }
     /**
      * 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.
+     * secondary file) — lowers to the `text_watermark` op with a `text` option;
+     * `options` carries any additional per-op watermark options.
      */
-    textWatermark(text) {
-        return this.withStep({ opType: 'text_watermark', options: { text } });
+    textWatermark(text, options = {}) {
+        // Spread options FIRST so the explicit `text` argument is authoritative.
+        return this.withStep({ opType: 'text_watermark', options: { ...options, text } });
     }
     /**
      * Lower this recipe to a workflow-create payload against a resolved upload
@@ -636,21 +656,55 @@ export class Recipe {
             ? { type: step.opType }
             : { type: step.opType, options };
     }
-    lowerCompressOptions(options) {
-        const optimize = options.optimize;
+    lowerCompressOptions(stepOptions) {
+        // Mirror the op-first resolver precedence (OperationBuilder._resolve in
+        // builder.ts): optimize = preset layer, presetOverrides = callPresetOverride
+        // layer, the rest = explicit layer.
+        const { optimize, presetOverrides, ...explicitOptions } = stepOptions;
+        // Validate the special bag keys at this chokepoint (every compress lowers
+        // through here). The chain methods' shorthand-param guard only covers a
+        // PARAM-supplied optimize; a bag-supplied optimize / presetOverrides must be
+        // validated too, so a bad value raises the typed SDK error rather than
+        // surfacing as a raw preset-lookup error or TypeError downstream. Mirrors
+        // PHP coerceOptimize + OperationBuilder::normalisePresetOverrides.
+        if (optimize !== undefined && !Object.values(OptimizeFor).includes(optimize)) {
+            const allowed = Object.values(OptimizeFor).join(', ');
+            throw new GislConfigError(`compress 'optimize' must be one of ${allowed}; got '${String(optimize)}'.`, { reason: 'invalid_optimize', conflictingFields: ['optimize'] });
+        }
+        if (presetOverrides !== undefined &&
+            (presetOverrides === null || typeof presetOverrides !== 'object' || Array.isArray(presetOverrides))) {
+            const got = Array.isArray(presetOverrides)
+                ? 'array'
+                : presetOverrides === null
+                    ? 'null'
+                    : typeof presetOverrides;
+            throw new GislConfigError(`compress 'presetOverrides' must be a *CompressPresetOptions object; got ${got}.`, { reason: 'invalid_preset_overrides', conflictingFields: ['presetOverrides'] });
+        }
         const media = this.compressMediaHint();
         if (media === undefined) {
             // Cannot infer a media class (a Blob without a recognised name, or a
             // bare upload id) → preset resolution is impossible. Fail FAST rather
             // than silently dropping an explicit `optimize`; bare compress() is fine.
+            // When no optimize is set, pass any explicit options through verbatim
+            // (exactly as op-first `_resolve` does when media is undefined).
             if (optimize !== undefined) {
                 throw new GislConfigError(`compress(optimize: ${String(optimize)}) needs a media type to resolve the preset, but the ` +
                     'input has no inferable media (a pre-uploaded file id or unnamed Blob carries no extension). ' +
                     'Use a path with a file extension, or call compress() without optimize.', { reason: 'media_unknown', conflictingFields: ['optimize'] });
             }
-            return {};
+            // presetOverrides override a resolved preset; with no media there is no
+            // preset to override, so fail fast rather than silently dropping them.
+            if (presetOverrides !== undefined) {
+                throw new GislConfigError('compress(presetOverrides) needs a media type to resolve the preset to override, but the ' +
+                    'input has no inferable media (a pre-uploaded file id or unnamed Blob carries no extension). ' +
+                    'Use a path with a file extension.', { reason: 'media_unknown', conflictingFields: ['presetOverrides'] });
+            }
+            return { ...explicitOptions };
+        }
+        const input = { media, op: 'compress', explicitOptions };
+        if (media === 'audio') {
+            input.audioLossless = this.compressAudioLossless();
         }
-        const input = { media, op: 'compress', explicitOptions: {} };
         if (this.presetDefaults !== undefined) {
             input.presetDefaults = this.presetDefaults;
         }
@@ -658,6 +712,11 @@ export class Recipe {
             input.scopedPresetDefaults =
                 this.scopedPresetDefaults;
         }
+        if (presetOverrides !== undefined) {
+            // Validated above to be a non-null, non-array object.
+            input.presetOverrides =
+                presetOverrides;
+        }
         if (optimize !== undefined) {
             input.optimize = optimize;
         }
@@ -672,6 +731,13 @@ export class Recipe {
         }
         return undefined;
     }
+    compressAudioLossless() {
+        if (this.input.kind === 'path')
+            return _detectAudioLossless(this.input.path);
+        if (this.input.kind === 'blob')
+            return _detectAudioLossless(this.input.blob);
+        return false;
+    }
 }
 /**
  * The homogeneous fan-out builder value (FF3a). `client.files([a, b, c])`
@@ -716,20 +782,20 @@ export class FilesRecipe {
      * preset). Reuses {@link Recipe}'s validation — a directly-constructed
      * lowering builds an internal Recipe that throws the same `GislConfigError`.
      */
-    compress(optimize) {
-        return this.withStep(this.baseRecipe().compress(optimize));
+    compress(optimize, options = {}) {
+        return this.withStep(this.baseRecipe().compress(optimize, options));
     }
     /** Change every input's format. `format` lowers verbatim to the `format` option. */
-    convert(format) {
-        return this.withStep(this.baseRecipe().convert(format));
+    convert(format, options = {}) {
+        return this.withStep(this.baseRecipe().convert(format, options));
     }
     /** Generate a preview of every input. Omitted dimensions are dropped from the wire options. */
     thumbnail(options = {}) {
         return this.withStep(this.baseRecipe().thumbnail(options));
     }
     /** Apply the same text watermark to every input. */
-    textWatermark(text) {
-        return this.withStep(this.baseRecipe().textWatermark(text));
+    textWatermark(text, options = {}) {
+        return this.withStep(this.baseRecipe().textWatermark(text, options));
     }
     /**
      * Combine the inputs into ONE output (N→1), in array order (FF3b). Returns a
@@ -981,24 +1047,34 @@ export class MergedRecipe {
         this.client = client;
     }
     /** Reduce the merged output's size. See {@link Recipe.compress}. */
-    compress(optimize) {
+    compress(optimize, options = {}) {
         if (optimize !== undefined && !Object.values(OptimizeFor).includes(optimize)) {
             const allowed = Object.values(OptimizeFor).join(', ');
             throw new GislConfigError(`compress 'optimize' must be one of ${allowed}; got '${String(optimize)}'.`, { reason: 'invalid_optimize', conflictingFields: ['optimize'] });
         }
-        return this.withStep({ opType: 'compress', options: optimize === undefined ? {} : { optimize } });
+        return this.withStep({
+            opType: 'compress',
+            options: { ...options, ...(optimize !== undefined ? { optimize } : {}) },
+        });
     }
     /** Change the merged output's format. See {@link Recipe.convert}. */
-    convert(format) {
-        return this.withStep({ opType: 'convert', options: { format } });
+    convert(format, options = {}) {
+        // The convert op's wire key is `output_format` (contract: convert.yaml,
+        // required, all media), NOT `format`. Spread options FIRST so the explicit
+        // shorthand wins over an `output_format` key in the bag.
+        // The shorthand owns the format → a stray legacy `format` key in the bag is
+        // not a valid convert option; drop it so the wire never carries both keys.
+        const rest = { ...options };
+        delete rest.format;
+        return this.withStep({ opType: 'convert', options: { ...rest, output_format: format } });
     }
     /** Thumbnail the merged output. Omitted dimensions are dropped from the wire options. */
     thumbnail(options = {}) {
         const wire = {};
-        if (options.width !== undefined)
-            wire.width = options.width;
-        if (options.height !== undefined)
-            wire.height = options.height;
+        for (const [key, value] of Object.entries(options)) {
+            if (value !== undefined)
+                wire[key] = value;
+        }
         return this.withStep({ opType: 'thumbnail', options: wire });
     }
     /**

package/dist/index.core.d.ts

@@ -3,7 +3,7 @@ export { parseSseStream } from './sse.js';
 export type { CreditsUsageOptions, ListWorkflowsOptions, GetSchemaOptions, GetSchemaResult, PreflightClipError, PreflightClipsResult, GislClientConfig, GislSseEvent, UploadOptions, WaitOptions, WorkflowCreatePayload, OperationDef, WorkflowSourcePayload, MultiInputSourcePayload, UploadSourcePayload, JobOutputSourcePayload, ExternalImportSourcePayload, ConnectionSourcePayload, JobInputV2Payload, JobDefinitionPayload, ExternalDestinationPayload, DeliveryPayload, DeliveryModePayload, DeliveryBundleFormatPayload, DeliverySelectionPayload, DeliverySelectionTypePayload, DeliveryOutputRefPayload, WorkflowProcessingPayload, ProcessingClassHintPayload, MultipartCheckpointState, _Sdk3HandCodedUploadedPart, _Sdk3HandCodedMultipartStatusResult, _Sdk3HandCodedPresignedPart, _Sdk3HandCodedPresignPartsResult, _Sdk3HandCodedKeepaliveResult, } from './types.js';
 export { uploadSource, jobOutputSource, externalImportSource, connectionSource, } from './types.js';
 export type { GislConfigErrorMetadata } from './errors.js';
-export { GislError, GislApiError, GislValidationError, GislBalanceExhaustedError, GislTierRestrictedError, GislFeatureTierRestrictedError, GislFeatureNotAvailableError, GislWorkflowExpiredError, GislProbePendingError, GislAuthError, GislUploadCapExceededError, GislMultipartPartError, GislMultipartPartCountError, GislMultipartSessionNotFoundError, GislMultipartSessionOwnershipError, GislMultipartSessionAuthRequiredError, GislTimeoutError, GislAbortError, GislNetworkError, GislConfigError, GislMissingCredentialsError, GislFeatureRequiresAuthError, GislUndeclaredAssetError, GislUnusedAssetError, GislPerInputOptionsNotSupportedError, GislChainCardinalityMismatchError, GislNoSuchKeyError, GislSinkError, GislResultNotReadyError, } from './errors.js';
+export { GislError, GislApiError, GislValidationError, GislBalanceExhaustedError, GislTierRestrictedError, GislFeatureTierRestrictedError, GislFeatureNotAvailableError, GislWorkflowExpiredError, GislProbePendingError, GislAuthError, GislUploadCapExceededError, GislMultipartPartError, GislMultipartPartCountError, GislMultipartSessionNotFoundError, GislMultipartSessionOwnershipError, GislMultipartSessionAuthRequiredError, GislTimeoutError, GislAbortError, GislNetworkError, GislConfigError, GislMissingCredentialsError, GislFeatureRequiresAuthError, GislUndeclaredAssetError, GislUnusedAssetError, GislPerInputOptionsNotSupportedError, GislChainCardinalityMismatchError, GislBundleAlreadyArchivedError, GislNoSuchKeyError, GislSinkError, GislResultNotReadyError, } from './errors.js';
 export type { GislApiErrorOptions, GislUploadCapKind } from './errors.js';
 export { RunResult } from './file-first.js';
 export type { OutputFile, ItemResult, ItemFailure, Manifest, Downloader, } from './file-first.js';

package/dist/index.core.js

@@ -23,6 +23,9 @@ GislUndeclaredAssetError, GislUnusedAssetError, GislPerInputOptionsNotSupportedE
 // methods on OperationBuilder ship; type + audit registration land
 // here so the future chain-method PR is a pure addition).
 GislChainCardinalityMismatchError, 
+// P4d / hv3FpLjm — double-bundle prevention; raised by `.bundle()` (wpHoJhuo).
+// Dormant until `.bundle()` ships, so the type lands here as a pure addition.
+GislBundleAlreadyArchivedError, 
 // FF1 / 3BIxEnfR — file-first result sink errors.
 GislNoSuchKeyError, GislSinkError, 
 // FF5a / Ao8RPVxD — thrown by the file-first Handle.result() when the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@giveitsmaller/sdk",
-  "version": "0.11.0",
+  "version": "0.12.1",
   "description": "Node.js SDK for the GISL (Give It Smaller) file compression and processing API",
   "license": "MIT",
   "type": "module",