@jumoo/processing 17.5.1 → 17.5.3

package/dist/api/client/client.gen.js

@@ -19,10 +19,7 @@ export const createClient = (config = {}) => {
             serializedBody: undefined,
         };
         if (opts.security) {
-            await setAuthParams({
-                ...opts,
-                security: opts.security,
-            });
+            await setAuthParams(opts);
         }
         if (opts.requestValidator) {
             await opts.requestValidator(opts);
@@ -39,149 +36,134 @@ export const createClient = (config = {}) => {
         return { opts: resolvedOpts, url };
     };
     const request = async (options) => {
-        const { opts, url } = await beforeRequest(options);
-        const requestInit = {
-            redirect: 'follow',
-            ...opts,
-            body: getValidRequestBody(opts),
-        };
-        let request = new Request(url, requestInit);
-        for (const fn of interceptors.request.fns) {
-            if (fn) {
-                request = await fn(request, opts);
-            }
-        }
-        // fetch must be assigned here, otherwise it would throw the error:
-        // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
-        const _fetch = opts.fetch;
+        const throwOnError = options.throwOnError ?? _config.throwOnError;
+        const responseStyle = options.responseStyle ?? _config.responseStyle;
+        let request;
         let response;
         try {
-            response = await _fetch(request);
-        }
-        catch (error) {
-            // Handle fetch exceptions (AbortError, network errors, etc.)
-            let finalError = error;
-            for (const fn of interceptors.error.fns) {
+            const { opts, url } = await beforeRequest(options);
+            const requestInit = {
+                redirect: 'follow',
+                ...opts,
+                body: getValidRequestBody(opts),
+            };
+            request = new Request(url, requestInit);
+            for (const fn of interceptors.request.fns) {
                 if (fn) {
-                    finalError = (await fn(error, undefined, request, opts));
+                    request = await fn(request, opts);
                 }
             }
-            finalError = finalError || {};
-            if (opts.throwOnError) {
-                throw finalError;
-            }
-            // Return error response
-            return opts.responseStyle === 'data'
-                ? undefined
-                : {
-                    error: finalError,
-                    request,
-                    response: undefined,
-                };
-        }
-        for (const fn of interceptors.response.fns) {
-            if (fn) {
-                response = await fn(response, request, opts);
+            // fetch must be assigned here, otherwise it would throw the error:
+            // TypeError: Failed to execute 'fetch' on 'Window': Illegal invocation
+            const _fetch = opts.fetch;
+            response = await _fetch(request);
+            for (const fn of interceptors.response.fns) {
+                if (fn) {
+                    response = await fn(response, request, opts);
+                }
             }
-        }
-        const result = {
-            request,
-            response,
-        };
-        if (response.ok) {
-            const parseAs = (opts.parseAs === 'auto'
-                ? getParseAs(response.headers.get('Content-Type'))
-                : opts.parseAs) ?? 'json';
-            if (response.status === 204 || response.headers.get('Content-Length') === '0') {
-                let emptyData;
+            const result = {
+                request,
+                response,
+            };
+            if (response.ok) {
+                const parseAs = (opts.parseAs === 'auto'
+                    ? getParseAs(response.headers.get('Content-Type'))
+                    : opts.parseAs) ?? 'json';
+                if (response.status === 204 || response.headers.get('Content-Length') === '0') {
+                    let emptyData;
+                    switch (parseAs) {
+                        case 'arrayBuffer':
+                        case 'blob':
+                        case 'text':
+                            emptyData = await response[parseAs]();
+                            break;
+                        case 'formData':
+                            emptyData = new FormData();
+                            break;
+                        case 'stream':
+                            emptyData = response.body;
+                            break;
+                        case 'json':
+                        default:
+                            emptyData = {};
+                            break;
+                    }
+                    return opts.responseStyle === 'data'
+                        ? emptyData
+                        : {
+                            data: emptyData,
+                            ...result,
+                        };
+                }
+                let data;
                 switch (parseAs) {
                     case 'arrayBuffer':
                     case 'blob':
+                    case 'formData':
                     case 'text':
-                        emptyData = await response[parseAs]();
+                        data = await response[parseAs]();
                         break;
-                    case 'formData':
-                        emptyData = new FormData();
+                    case 'json': {
+                        // Some servers return 200 with no Content-Length and empty body.
+                        // response.json() would throw; read as text and parse if non-empty.
+                        const text = await response.text();
+                        data = text ? JSON.parse(text) : {};
                         break;
+                    }
                     case 'stream':
-                        emptyData = response.body;
-                        break;
-                    case 'json':
-                    default:
-                        emptyData = {};
-                        break;
+                        return opts.responseStyle === 'data'
+                            ? response.body
+                            : {
+                                data: response.body,
+                                ...result,
+                            };
+                }
+                if (parseAs === 'json') {
+                    if (opts.responseValidator) {
+                        await opts.responseValidator(data);
+                    }
+                    if (opts.responseTransformer) {
+                        data = await opts.responseTransformer(data);
+                    }
                 }
                 return opts.responseStyle === 'data'
-                    ? emptyData
+                    ? data
                     : {
-                        data: emptyData,
+                        data,
                         ...result,
                     };
             }
-            let data;
-            switch (parseAs) {
-                case 'arrayBuffer':
-                case 'blob':
-                case 'formData':
-                case 'text':
-                    data = await response[parseAs]();
-                    break;
-                case 'json': {
-                    // Some servers return 200 with no Content-Length and empty body.
-                    // response.json() would throw; read as text and parse if non-empty.
-                    const text = await response.text();
-                    data = text ? JSON.parse(text) : {};
-                    break;
-                }
-                case 'stream':
-                    return opts.responseStyle === 'data'
-                        ? response.body
-                        : {
-                            data: response.body,
-                            ...result,
-                        };
+            const textError = await response.text();
+            let jsonError;
+            try {
+                jsonError = JSON.parse(textError);
             }
-            if (parseAs === 'json') {
-                if (opts.responseValidator) {
-                    await opts.responseValidator(data);
-                }
-                if (opts.responseTransformer) {
-                    data = await opts.responseTransformer(data);
+            catch {
+                // noop
+            }
+            throw jsonError ?? textError;
+        }
+        catch (error) {
+            let finalError = error;
+            for (const fn of interceptors.error.fns) {
+                if (fn) {
+                    finalError = await fn(finalError, response, request, options);
                 }
             }
-            return opts.responseStyle === 'data'
-                ? data
+            finalError = finalError || {};
+            if (throwOnError) {
+                throw finalError;
+            }
+            // TODO: we probably want to return error and improve types
+            return responseStyle === 'data'
+                ? undefined
                 : {
-                    data,
-                    ...result,
+                    error: finalError,
+                    request,
+                    response,
                 };
         }
-        const textError = await response.text();
-        let jsonError;
-        try {
-            jsonError = JSON.parse(textError);
-        }
-        catch {
-            // noop
-        }
-        const error = jsonError ?? textError;
-        let finalError = error;
-        for (const fn of interceptors.error.fns) {
-            if (fn) {
-                finalError = (await fn(error, response, request, opts));
-            }
-        }
-        finalError = finalError || {};
-        if (opts.throwOnError) {
-            throw finalError;
-        }
-        // TODO: we probably want to return error and improve types
-        return opts.responseStyle === 'data'
-            ? undefined
-            : {
-                error: finalError,
-                ...result,
-            };
     };
     const makeMethodFn = (method) => (options) => request({ ...options, method });
     const makeSseFn = (method) => async (options) => {
@@ -189,7 +171,6 @@ export const createClient = (config = {}) => {
         return createSseClient({
             ...opts,
             body: opts.body,
-            headers: opts.headers,
             method,
             onRequest: async (url, init) => {
                 let request = new Request(url, init);

package/dist/api/client/index.d.ts

@@ -3,6 +3,8 @@ export type { QuerySerializerOptions } from '../core/bodySerializer.gen';
 export { formDataBodySerializer, jsonBodySerializer, urlSearchParamsBodySerializer, } from '../core/bodySerializer.gen';
 export { buildClientParams } from '../core/params.gen';
 export { serializeQueryKeyValue } from '../core/queryKeySerializer.gen';
+export type { ServerSentEventsResult } from '../core/serverSentEvents.gen';
+export type { ClientMeta } from '../core/types.gen';
 export { createClient } from './client.gen';
 export type { Client, ClientOptions, Config, CreateClientConfig, Options, RequestOptions, RequestResult, ResolvedRequestOptions, ResponseStyle, TDataShape, } from './types.gen';
 export { createConfig, mergeHeaders } from './utils.gen';

package/dist/api/client/types.gen.d.ts

@@ -63,6 +63,7 @@ export interface RequestOptions<TData = unknown, TResponseStyle extends Response
     url: Url;
 }
 export interface ResolvedRequestOptions<TResponseStyle extends ResponseStyle = 'fields', ThrowOnError extends boolean = boolean, Url extends string = string> extends RequestOptions<unknown, TResponseStyle, ThrowOnError, Url> {
+    headers: Headers;
     serializedBody?: string;
 }
 export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extends boolean = boolean, TResponseStyle extends ResponseStyle = 'fields'> = ThrowOnError extends true ? Promise<TResponseStyle extends 'data' ? TData extends Record<string, unknown> ? TData[keyof TData] : TData : {
@@ -76,8 +77,10 @@ export type RequestResult<TData = unknown, TError = unknown, ThrowOnError extend
     data: undefined;
     error: TError extends Record<string, unknown> ? TError[keyof TError] : TError;
 }) & {
-    request: Request;
-    response: Response;
+    /** request may be undefined, because error may be from building the request object itself */
+    request?: Request;
+    /** response may be undefined, because error may be from building the request object itself or from a network error */
+    response?: Response;
 }>;
 export interface ClientOptions {
     baseUrl?: string;
@@ -85,7 +88,7 @@ export interface ClientOptions {
     throwOnError?: boolean;
 }
 type MethodFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
-type SseFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData, TError>>;
+type SseFn = <TData = unknown, _TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<never, TResponseStyle, ThrowOnError>, 'method'>) => Promise<ServerSentEventsResult<TData>>;
 type RequestFn = <TData = unknown, TError = unknown, ThrowOnError extends boolean = false, TResponseStyle extends ResponseStyle = 'fields'>(options: Omit<RequestOptions<TData, TResponseStyle, ThrowOnError>, 'method'> & Pick<Required<RequestOptions<TData, TResponseStyle, ThrowOnError>>, 'method'>) => RequestResult<TData, TError, ThrowOnError, TResponseStyle>;
 type BuildUrlFn = <TData extends {
     body?: unknown;

package/dist/api/client/utils.gen.d.ts

@@ -1,17 +1,21 @@
 import type { QuerySerializerOptions } from '../core/bodySerializer.gen';
 import type { Client, ClientOptions, Config, RequestOptions } from './types.gen';
-export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => (queryParams: T) => string;
+export declare const createQuerySerializer: <T = unknown>({ parameters, ...args }?: QuerySerializerOptions) => ((queryParams: T) => string);
 /**
  * Infers parseAs value from provided Content-Type header.
  */
 export declare const getParseAs: (contentType: string | null) => Exclude<Config["parseAs"], "auto">;
-export declare const setAuthParams: ({ security, ...options }: Pick<Required<RequestOptions>, "security"> & Pick<RequestOptions, "auth" | "query"> & {
+export declare function setAuthParams(options: Pick<RequestOptions, 'auth' | 'query' | 'security'> & {
     headers: Headers;
-}) => Promise<void>;
+}): Promise<void>;
 export declare const buildUrl: Client['buildUrl'];
 export declare const mergeConfigs: (a: Config, b: Config) => Config;
 export declare const mergeHeaders: (...headers: Array<Required<Config>["headers"] | undefined>) => Headers;
-type ErrInterceptor<Err, Res, Req, Options> = (error: Err, response: Res, request: Req, options: Options) => Err | Promise<Err>;
+type ErrInterceptor<Err, Res, Req, Options> = (error: Err, 
+/** response may be undefined due to a network error where no response object is produced */
+response: Res | undefined, 
+/** request may be undefined, because error may be from building the request object itself */
+request: Req | undefined, options: Options) => Err | Promise<Err>;
 type ReqInterceptor<Req, Options> = (request: Req, options: Options) => Req | Promise<Req>;
 type ResInterceptor<Res, Req, Options> = (response: Res, request: Req, options: Options) => Res | Promise<Res>;
 declare class Interceptors<Interceptor> {

package/dist/api/client/utils.gen.js

@@ -90,8 +90,8 @@ const checkForExistence = (options, name) => {
     }
     return false;
 };
-export const setAuthParams = async ({ security, ...options }) => {
-    for (const auth of security) {
+export async function setAuthParams(options) {
+    for (const auth of options.security ?? []) {
         if (checkForExistence(options, auth.name)) {
             continue;
         }
@@ -116,7 +116,7 @@ export const setAuthParams = async ({ security, ...options }) => {
                 break;
         }
     }
-};
+}
 export const buildUrl = (options) => getUrl({
     baseUrl: options.baseUrl,
     path: options.path,

package/dist/api/client.gen.d.ts

@@ -1,4 +1,4 @@
-import { type ClientOptions, type Config } from './client';
+import { type Client, type ClientOptions, type Config } from './client';
 import type { ClientOptions as ClientOptions2 } from './types.gen';
 /**
  * The `createClientConfig()` function will be called on client initialization
@@ -9,4 +9,4 @@ import type { ClientOptions as ClientOptions2 } from './types.gen';
  * to ensure your client always has the correct values.
  */
 export type CreateClientConfig<T extends ClientOptions = ClientOptions2> = (override?: Config<ClientOptions & T>) => Config<Required<ClientOptions> & T>;
-export declare const client: import("./client").Client;
+export declare const client: Client;

package/dist/api/client.gen.js

@@ -1,4 +1,3 @@
 // This file is auto-generated by @hey-api/openapi-ts
-import { createClientConfig } from '../hey-api';
 import { createClient, createConfig } from './client';
-export const client = createClient(createClientConfig(createConfig({ baseUrl: 'http://localhost:41839', throwOnError: true })));
+export const client = createClient(createConfig({ baseUrl: 'http://localhost:41839', throwOnError: true }));

package/dist/api/core/auth.gen.d.ts

@@ -6,6 +6,13 @@ export interface Auth {
      * @default 'header'
      */
     in?: 'header' | 'query' | 'cookie';
+    /**
+     * A unique identifier for the security scheme.
+     *
+     * Defined only when there are multiple security schemes whose `Auth`
+     * shape would otherwise be identical.
+     */
+    key?: string;
     /**
      * Header or query parameter name.
      *

package/dist/api/core/params.gen.d.ts

@@ -34,10 +34,10 @@ export interface Fields {
 }
 export type FieldsConfig = ReadonlyArray<Field | Fields>;
 interface Params {
-    body: unknown;
+    body?: unknown;
     headers: Record<string, unknown>;
     path: Record<string, unknown>;
     query: Record<string, unknown>;
 }
-export declare const buildClientParams: (args: ReadonlyArray<unknown>, fields: FieldsConfig) => Params;
+export declare function buildClientParams(args: ReadonlyArray<unknown>, fields: FieldsConfig): Params;
 export {};

package/dist/api/core/params.gen.js

@@ -6,7 +6,7 @@ const extraPrefixesMap = {
     $query_: 'query',
 };
 const extraPrefixes = Object.entries(extraPrefixesMap);
-const buildKeyMap = (fields, map) => {
+function buildKeyMap(fields, map) {
     if (!map) {
         map = new Map();
     }
@@ -29,22 +29,31 @@ const buildKeyMap = (fields, map) => {
         }
     }
     return map;
-};
-const stripEmptySlots = (params) => {
+}
+function stripEmptySlots(params) {
     for (const [slot, value] of Object.entries(params)) {
+        if (slot === 'body')
+            continue;
         if (value && typeof value === 'object' && !Array.isArray(value) && !Object.keys(value).length) {
             delete params[slot];
         }
     }
-};
-export const buildClientParams = (args, fields) => {
+}
+export function buildClientParams(args, fields) {
     const params = {
-        body: {},
-        headers: {},
-        path: {},
-        query: {},
+        headers: Object.create(null),
+        path: Object.create(null),
+        query: Object.create(null),
     };
     const map = buildKeyMap(fields);
+    function writeSlot(slot, key, value) {
+        let record = params[slot];
+        if (record === undefined) {
+            record = Object.create(null);
+            params[slot] = record;
+        }
+        record[key] = value;
+    }
     let config;
     for (const [index, arg] of args.entries()) {
         if (fields[index]) {
@@ -58,7 +67,7 @@ export const buildClientParams = (args, fields) => {
                 const field = map.get(config.key);
                 const name = field.map || config.key;
                 if (field.in) {
-                    params[field.in][name] = arg;
+                    writeSlot(field.in, name, arg);
                 }
             }
             else {
@@ -71,7 +80,7 @@ export const buildClientParams = (args, fields) => {
                 if (field) {
                     if (field.in) {
                         const name = field.map || key;
-                        params[field.in][name] = value;
+                        writeSlot(field.in, name, value);
                     }
                     else {
                         params[field.map] = value;
@@ -81,12 +90,12 @@ export const buildClientParams = (args, fields) => {
                     const extra = extraPrefixes.find(([prefix]) => key.startsWith(prefix));
                     if (extra) {
                         const [prefix, slot] = extra;
-                        params[slot][key.slice(prefix.length)] = value;
+                        writeSlot(slot, key.slice(prefix.length), value);
                     }
                     else if ('allowExtra' in config && config.allowExtra) {
                         for (const [slot, allowed] of Object.entries(config.allowExtra)) {
                             if (allowed) {
-                                params[slot][key] = value;
+                                writeSlot(slot, key, value);
                                 break;
                             }
                         }
@@ -97,4 +106,4 @@ export const buildClientParams = (args, fields) => {
     }
     stripEmptySlots(params);
     return params;
-};
+}

package/dist/api/core/queryKeySerializer.gen.d.ts

@@ -7,7 +7,7 @@ export type JsonValue = null | string | number | boolean | JsonValue[] | {
 /**
  * Replacer that converts non-JSON values (bigint, Date, etc.) to safe substitutes.
  */
-export declare const queryKeyJsonReplacer: (_key: string, value: unknown) => {} | null | undefined;
+export declare const queryKeyJsonReplacer: (_key: string, value: unknown) => unknown | undefined;
 /**
  * Safely stringifies a value and parses it back into a JsonValue.
  */

package/dist/api/core/serverSentEvents.gen.d.ts

@@ -68,4 +68,4 @@ export interface StreamEvent<TData = unknown> {
 export type ServerSentEventsResult<TData = unknown, TReturn = void, TNext = unknown> = {
     stream: AsyncGenerator<TData extends Record<string, unknown> ? TData[keyof TData] : TData, TReturn, TNext>;
 };
-export declare const createSseClient: <TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions) => ServerSentEventsResult<TData>;
+export declare function createSseClient<TData = unknown>({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }: ServerSentEventsOptions): ServerSentEventsResult<TData>;

package/dist/api/core/serverSentEvents.gen.js

@@ -1,5 +1,5 @@
 // This file is auto-generated by @hey-api/openapi-ts
-export const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) => {
+export function createSseClient({ onRequest, onSseError, onSseEvent, responseTransformer, responseValidator, sseDefaultRetryDelay, sseMaxRetryAttempts, sseMaxRetryDelay, sseSleepFn, url, ...options }) {
     let lastEventId;
     const sleep = sseSleepFn ?? ((ms) => new Promise((resolve) => setTimeout(resolve, ms)));
     const createStream = async function* () {
@@ -53,8 +53,7 @@ export const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTra
                         if (done)
                             break;
                         buffer += value;
-                        // Normalize line endings: CRLF -> LF, then CR -> LF
-                        buffer = buffer.replace(/\r\n/g, '\n').replace(/\r/g, '\n');
+                        buffer = buffer.replace(/\r\n?/g, '\n'); // normalize line endings
                         const chunks = buffer.split('\n\n');
                         buffer = chunks.pop() ?? '';
                         for (const chunk of chunks) {
@@ -130,4 +129,4 @@ export const createSseClient = ({ onRequest, onSseError, onSseEvent, responseTra
     };
     const stream = createStream();
     return { stream };
-};
+}

package/dist/api/core/types.gen.d.ts

@@ -71,6 +71,11 @@ export interface Config {
      */
     responseValidator?: (data: unknown) => Promise<unknown>;
 }
+/**
+ * Arbitrary metadata passed through the `meta` request option.
+ */
+export interface ClientMeta {
+}
 type IsExactlyNeverOrNeverUndefined<T> = [T] extends [never] ? true : [T] extends [never | undefined] ? [undefined] extends [T] ? false : true : false;
 export type OmitNever<T extends Record<string, unknown>> = {
     [K in keyof T as IsExactlyNeverOrNeverUndefined<T[K]> extends true ? never : K]: T[K];

package/dist/api/sdk.gen.d.ts

@@ -1,4 +1,4 @@
-import type { Client, Options as Options2, TDataShape } from './client';
+import type { Client, ClientMeta, Options as Options2, RequestResult, TDataShape } from './client';
 import type { CancelPipelineData, CancelPipelineErrors, CancelPipelineResponses, ClearPipelineData, ClearPipelineErrors, ClearPipelineResponses, CreatePipelineData, CreatePipelineErrors, CreatePipelineResponses, DeleteData, DeleteErrors, DeleteResponses, GetPipelineData, GetPipelineErrors, GetPipelineResponses, GetProcessorsData, GetProcessorsErrors, GetProcessorsResponses, GetResultsData, GetResultsErrors, GetResultsResponses, ListPipelinesByStrategyData, ListPipelinesByStrategyErrors, ListPipelinesByStrategyResponses, ListPipelinesData, ListPipelinesErrors, ListPipelinesResponses, ListQueueData, ListQueueErrors, ListQueueResponses, PeekItemData, PeekItemErrors, PeekItemResponses, PipelineStatusData, PipelineStatusErrors, PipelineStatusResponses, ProcessData, ProcessErrors, ProcessPipelineData, ProcessPipelineErrors, ProcessPipelineResponses, ProcessResponses, ReattachPipelineData, ReattachPipelineErrors, ReattachPipelineResponses, StartPipelineData, StartPipelineErrors, StartPipelineResponses, UpdatePipelineData, UpdatePipelineErrors, UpdatePipelineResponses } from './types.gen';
 export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends boolean = boolean, TResponse = unknown> = Options2<TData, ThrowOnError, TResponse> & {
     /**
@@ -11,32 +11,32 @@ export type Options<TData extends TDataShape = TDataShape, ThrowOnError extends
      * You can pass arbitrary values through the `meta` object. This can be
      * used to access values that aren't defined as part of the SDK function.
      */
-    meta?: Record<string, unknown>;
+    meta?: keyof ClientMeta extends never ? Record<string, unknown> : ClientMeta;
 };
 export declare class PipelinesService {
-    static cancelPipeline<ThrowOnError extends boolean = true>(options: Options<CancelPipelineData, ThrowOnError>): import("./client").RequestResult<CancelPipelineResponses, CancelPipelineErrors, ThrowOnError, "fields">;
-    static clearPipeline<ThrowOnError extends boolean = true>(options: Options<ClearPipelineData, ThrowOnError>): import("./client").RequestResult<ClearPipelineResponses, ClearPipelineErrors, ThrowOnError, "fields">;
-    static createPipeline<ThrowOnError extends boolean = true>(options?: Options<CreatePipelineData, ThrowOnError>): import("./client").RequestResult<CreatePipelineResponses, CreatePipelineErrors, ThrowOnError, "fields">;
-    static getPipeline<ThrowOnError extends boolean = true>(options: Options<GetPipelineData, ThrowOnError>): import("./client").RequestResult<GetPipelineResponses, GetPipelineErrors, ThrowOnError, "fields">;
-    static getProcessors<ThrowOnError extends boolean = true>(options?: Options<GetProcessorsData, ThrowOnError>): import("./client").RequestResult<GetProcessorsResponses, GetProcessorsErrors, ThrowOnError, "fields">;
-    static getResults<ThrowOnError extends boolean = true>(options: Options<GetResultsData, ThrowOnError>): import("./client").RequestResult<GetResultsResponses, GetResultsErrors, ThrowOnError, "fields">;
-    static listPipelines<ThrowOnError extends boolean = true>(options: Options<ListPipelinesData, ThrowOnError>): import("./client").RequestResult<ListPipelinesResponses, ListPipelinesErrors, ThrowOnError, "fields">;
-    static listPipelinesByStrategy<ThrowOnError extends boolean = true>(options: Options<ListPipelinesByStrategyData, ThrowOnError>): import("./client").RequestResult<ListPipelinesByStrategyResponses, ListPipelinesByStrategyErrors, ThrowOnError, "fields">;
-    static pipelineStatus<ThrowOnError extends boolean = true>(options: Options<PipelineStatusData, ThrowOnError>): import("./client").RequestResult<PipelineStatusResponses, PipelineStatusErrors, ThrowOnError, "fields">;
-    static processPipeline<ThrowOnError extends boolean = true>(options: Options<ProcessPipelineData, ThrowOnError>): import("./client").RequestResult<ProcessPipelineResponses, ProcessPipelineErrors, ThrowOnError, "fields">;
-    static reattachPipeline<ThrowOnError extends boolean = true>(options: Options<ReattachPipelineData, ThrowOnError>): import("./client").RequestResult<ReattachPipelineResponses, ReattachPipelineErrors, ThrowOnError, "fields">;
-    static startPipeline<ThrowOnError extends boolean = true>(options?: Options<StartPipelineData, ThrowOnError>): import("./client").RequestResult<StartPipelineResponses, StartPipelineErrors, ThrowOnError, "fields">;
-    static updatePipeline<ThrowOnError extends boolean = true>(options: Options<UpdatePipelineData, ThrowOnError>): import("./client").RequestResult<UpdatePipelineResponses, UpdatePipelineErrors, ThrowOnError, "fields">;
+    static cancelPipeline<ThrowOnError extends boolean = true>(options: Options<CancelPipelineData, ThrowOnError>): RequestResult<CancelPipelineResponses, CancelPipelineErrors, ThrowOnError>;
+    static clearPipeline<ThrowOnError extends boolean = true>(options: Options<ClearPipelineData, ThrowOnError>): RequestResult<ClearPipelineResponses, ClearPipelineErrors, ThrowOnError>;
+    static createPipeline<ThrowOnError extends boolean = true>(options?: Options<CreatePipelineData, ThrowOnError>): RequestResult<CreatePipelineResponses, CreatePipelineErrors, ThrowOnError>;
+    static getPipeline<ThrowOnError extends boolean = true>(options: Options<GetPipelineData, ThrowOnError>): RequestResult<GetPipelineResponses, GetPipelineErrors, ThrowOnError>;
+    static getProcessors<ThrowOnError extends boolean = true>(options?: Options<GetProcessorsData, ThrowOnError>): RequestResult<GetProcessorsResponses, GetProcessorsErrors, ThrowOnError>;
+    static getResults<ThrowOnError extends boolean = true>(options: Options<GetResultsData, ThrowOnError>): RequestResult<GetResultsResponses, GetResultsErrors, ThrowOnError>;
+    static listPipelines<ThrowOnError extends boolean = true>(options: Options<ListPipelinesData, ThrowOnError>): RequestResult<ListPipelinesResponses, ListPipelinesErrors, ThrowOnError>;
+    static listPipelinesByStrategy<ThrowOnError extends boolean = true>(options: Options<ListPipelinesByStrategyData, ThrowOnError>): RequestResult<ListPipelinesByStrategyResponses, ListPipelinesByStrategyErrors, ThrowOnError>;
+    static pipelineStatus<ThrowOnError extends boolean = true>(options: Options<PipelineStatusData, ThrowOnError>): RequestResult<PipelineStatusResponses, PipelineStatusErrors, ThrowOnError>;
+    static processPipeline<ThrowOnError extends boolean = true>(options: Options<ProcessPipelineData, ThrowOnError>): RequestResult<ProcessPipelineResponses, ProcessPipelineErrors, ThrowOnError>;
+    static reattachPipeline<ThrowOnError extends boolean = true>(options: Options<ReattachPipelineData, ThrowOnError>): RequestResult<ReattachPipelineResponses, ReattachPipelineErrors, ThrowOnError>;
+    static startPipeline<ThrowOnError extends boolean = true>(options?: Options<StartPipelineData, ThrowOnError>): RequestResult<StartPipelineResponses, StartPipelineErrors, ThrowOnError>;
+    static updatePipeline<ThrowOnError extends boolean = true>(options: Options<UpdatePipelineData, ThrowOnError>): RequestResult<UpdatePipelineResponses, UpdatePipelineErrors, ThrowOnError>;
 }
 export declare class QueuesService {
-    static delete<ThrowOnError extends boolean = true>(options: Options<DeleteData, ThrowOnError>): import("./client").RequestResult<DeleteResponses, DeleteErrors, ThrowOnError, "fields">;
-    static listQueue<ThrowOnError extends boolean = true>(options?: Options<ListQueueData, ThrowOnError>): import("./client").RequestResult<ListQueueResponses, ListQueueErrors, ThrowOnError, "fields">;
+    static delete<ThrowOnError extends boolean = true>(options: Options<DeleteData, ThrowOnError>): RequestResult<DeleteResponses, DeleteErrors, ThrowOnError>;
+    static listQueue<ThrowOnError extends boolean = true>(options?: Options<ListQueueData, ThrowOnError>): RequestResult<ListQueueResponses, ListQueueErrors, ThrowOnError>;
     /**
      * Peek an item from the queue
      */
-    static peekItem<ThrowOnError extends boolean = true>(options?: Options<PeekItemData, ThrowOnError>): import("./client").RequestResult<PeekItemResponses, PeekItemErrors, ThrowOnError, "fields">;
+    static peekItem<ThrowOnError extends boolean = true>(options?: Options<PeekItemData, ThrowOnError>): RequestResult<PeekItemResponses, PeekItemErrors, ThrowOnError>;
     /**
      * Takes an item off the queue, removes the schedule date and puts it back
      */
-    static process<ThrowOnError extends boolean = true>(options: Options<ProcessData, ThrowOnError>): import("./client").RequestResult<ProcessResponses, ProcessErrors, ThrowOnError, "fields">;
+    static process<ThrowOnError extends boolean = true>(options: Options<ProcessData, ThrowOnError>): RequestResult<ProcessResponses, ProcessErrors, ThrowOnError>;
 }

package/dist/api/types.gen.d.ts

@@ -56,7 +56,8 @@ export type PipelineRunRejected = {
 export declare enum PipelineRunRejectedReason {
     NOT_FOUND = "NotFound",
     ALREADY_RUNNING = "AlreadyRunning",
-    INVALID = "Invalid"
+    INVALID = "Invalid",
+    NOT_WAITING = "NotWaiting"
 }
 export type PipelineRunRequest = {
     processor: string;

package/dist/api/types.gen.js

@@ -4,6 +4,7 @@ export var PipelineRunRejectedReason;
     PipelineRunRejectedReason["NOT_FOUND"] = "NotFound";
     PipelineRunRejectedReason["ALREADY_RUNNING"] = "AlreadyRunning";
     PipelineRunRejectedReason["INVALID"] = "Invalid";
+    PipelineRunRejectedReason["NOT_WAITING"] = "NotWaiting";
 })(PipelineRunRejectedReason || (PipelineRunRejectedReason = {}));
 export var PipelineRunState;
 (function (PipelineRunState) {

package/dist/index.js

@@ -6,7 +6,15 @@ import './api/index.js';
 import { manifests as modals } from './pipeline/modal/manifest.js';
 import { manifests as pipelines } from './pipeline/workspace/manifest.js';
 import { manifests as localizations } from './lang/manifest.js';
+import { UMB_AUTH_CONTEXT } from '@umbraco-cms/backoffice/auth';
+import { client } from './api/client.gen.js';
 export * from './exports.js';
-export const onInit = (_host, extensions) => {
+export const onInit = async (host, extensions) => {
     extensions.registerMany([...modals, ...pipelines, ...localizations]);
+    const authContext = await host.getContext(UMB_AUTH_CONTEXT);
+    if (!authContext) {
+        console.warn('UMB_AUTH_CONTEXT not available — extension API client will not be authenticated');
+        return;
+    }
+    authContext.configureClient(client);
 };

package/dist/lang/files/en.d.ts

@@ -24,6 +24,8 @@ declare const _default: {
         messageWaiting: string;
         headlineScheduled: string;
         messageScheduled: string;
+        checked: string;
+        tryAgain: string;
         status: string;
         startedBy: string;
         queued: string;
@@ -38,6 +40,11 @@ declare const _default: {
         stateCompleted: string;
         stateFailed: string;
         stateCancelled: string;
+        stalled: string;
+        clear: string;
+        clearHeadline: string;
+        clearConfirm: string;
+        clearConfirmLabel: string;
     };
     jumooProcBackground: {
         completed: string;

package/dist/lang/files/en.js

@@ -15,15 +15,17 @@ export default {
     },
     jumooProcConflict: {
         headline: 'Already in progress',
-        message: 'Another process is already in progress for this target. Wait for it to finish, or cancel it, then try again.',
+        message: 'Another process is already in progress for this target. Try again once it has finished.',
         headlineRunning: 'Already running',
-        messageRunning: 'Another process is already running for this target. Wait for it to finish, or cancel it, then try again.',
+        messageRunning: 'Another process is already running for this target. Try again once it has finished.',
         headlineQueued: 'Already queued',
-        messageQueued: 'Another process for this target is queued and will start shortly. Wait for it to finish, or cancel it, then try again.',
+        messageQueued: 'Another process for this target is queued and will start shortly. Try again once it has finished.',
         headlineWaiting: 'Waiting to continue',
-        messageWaiting: 'Another process for this target is paused and waiting to continue. Finish or cancel it, then try again.',
+        messageWaiting: 'Another process for this target is paused, waiting for whoever started it to continue. Try again once it has been finished or cancelled.',
         headlineScheduled: 'Already scheduled',
-        messageScheduled: 'Another process for this target is scheduled. Cancel it, or wait for it to run, then try again.',
+        messageScheduled: 'Another process for this target is scheduled. Try again once it has run.',
+        checked: 'Checked',
+        tryAgain: 'Try again',
         status: 'Status',
         startedBy: 'Started by',
         queued: 'Queued',
@@ -38,6 +40,11 @@ export default {
         stateCompleted: 'Completed',
         stateFailed: 'Failed',
         stateCancelled: 'Cancelled',
+        stalled: "It hasn't moved for a while, so it has probably stopped (a closed browser, or an error). You can clear it and start again.",
+        clear: 'Clear it',
+        clearHeadline: 'Clear the other process?',
+        clearConfirm: 'This removes the other process so this one can start. If it is still working, it stops part way through.',
+        clearConfirmLabel: 'Clear and start',
     },
     jumooProcBackground: {
         completed: 'This process has completed in the background',

package/dist/pipeline/pipeline.context.d.ts

@@ -22,6 +22,12 @@ export declare class PipelineContext extends UmbControllerBase {
     private isMessage;
     private isState;
     createPipeline(processor: string, strategy: string, options: ProcessingOptions | undefined): Promise<void>;
+    /**
+     * @description clears the pipeline holding the key, so a create can be tried again. For a
+     * holder that has stopped moving - the server only lets go of a browser-driven run once it
+     * has been idle for the concurrency key idle timeout.
+     */
+    clearConflictHolder(): Promise<void>;
     loadPipeline(id: string): Promise<void>;
     getPipeline(id: string): Promise<import("@jumoo/processing").Pipeline>;
     fetchPipeline(id: string): Promise<import("@jumoo/processing").Pipeline>;

package/dist/pipeline/pipeline.context.js

@@ -92,14 +92,27 @@ export class PipelineContext extends UmbControllerBase {
         return message !== undefined;
     }
     async createPipeline(processor, strategy, options) {
-        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(undefined);
+        // a retry keeps the current conflict showing until there's a new answer.
         const { data, error } = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").tryCreate(processor, strategy, options);
         if (error) {
             await __classPrivateFieldGet(this, _PipelineContext_instances, "m", _PipelineContext_setConflict).call(this, error);
             return;
         }
+        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(undefined);
         __classPrivateFieldGet(this, _PipelineContext_pipeline, "f").setValue(data);
     }
+    /**
+     * @description clears the pipeline holding the key, so a create can be tried again. For a
+     * holder that has stopped moving - the server only lets go of a browser-driven run once it
+     * has been idle for the concurrency key idle timeout.
+     */
+    async clearConflictHolder() {
+        const conflict = __classPrivateFieldGet(this, _PipelineContext_conflict, "f").value;
+        if (!conflict)
+            return;
+        await __classPrivateFieldGet(this, _PipelineContext_repository, "f").clear(conflict.runningPipelineId);
+        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(undefined);
+    }
     async loadPipeline(id) {
         const pipeline = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").Get(id);
         if (!pipeline)
@@ -285,10 +298,8 @@ async function _PipelineContext_setConflict(error) {
     const conflict = getPipelineConflict(error);
     if (!conflict)
         return false;
-    __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(conflict);
     const holder = await __classPrivateFieldGet(this, _PipelineContext_repository, "f").getRunStatus(conflict.runningPipelineId);
-    if (holder)
-        __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue({ ...conflict, holder });
+    __classPrivateFieldGet(this, _PipelineContext_conflict, "f").setValue(holder ? { ...conflict, holder } : conflict);
     return true;
 };
 export default PipelineContext;

package/dist/pipeline/pipeline.element.d.ts

@@ -13,6 +13,7 @@ import { ProcessingOptions } from '@jumoo/processing';
  * process is already running for the same target (detail is the PipelineConflict).
  */
 export declare class JumooPipelineElement extends UmbLitElement {
+    #private;
     private context?;
     /**
      * @description The processor to use for the pipeline
@@ -38,6 +39,12 @@ export declare class JumooPipelineElement extends UmbLitElement {
     private message;
     private backgroundState;
     private conflict;
+    /**
+     * @description when the conflict was last checked. The panel doesn't update by itself, so it
+     * shows how old its answer is.
+     */
+    private conflictCheckedAt;
+    private retrying;
     constructor();
     connectedCallback(): void;
     private process;
@@ -61,6 +68,20 @@ export declare class JumooPipelineElement extends UmbLitElement {
     private onLastAction;
     render(): import("lit-html").TemplateResult<1>;
     private renderConflict;
+    /**
+     * @description only a conflict from creating this pipeline can be tried again from here -
+     * one from an existing pipeline has nothing to recreate.
+     * @returns true when the panel should offer to try again.
+     */
+    private canRetry;
+    /**
+     * @description a running holder that has stopped moving can be cleared, but only when the
+     * conflict came from creating this pipeline - that's the one we know how to try again.
+     * The holder is only there when the user can see it (its owner, or an admin).
+     * @param holder the holder's status.
+     * @returns true when the panel should offer to clear it.
+     */
+    private canClear;
     /**
      * @description the time worth showing for the holder: when it was queued, when it last
      * moved, how long it has been paused, or when it is due.

package/dist/pipeline/pipeline.element.js

@@ -4,8 +4,15 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _JumooPipelineElement_instances, _JumooPipelineElement_onRetryConflict, _JumooPipelineElement_onClearConflict;
 import { css, customElement, html, nothing, property, state, } from '@umbraco-cms/backoffice/external/lit';
 import { UmbLitElement } from '@umbraco-cms/backoffice/lit-element';
+import { umbConfirmModal } from '@umbraco-cms/backoffice/modal';
 import { PipelineStatus, JUMOO_PROCESSING_CONTEXT, } from '@jumoo/processing';
 import { PipelineRunState } from '../api/index.js';
 /**
@@ -25,6 +32,12 @@ function conflictSuffix(status) {
             return '';
     }
 }
+/**
+ * @description how long a running holder goes without moving before the conflict panel offers
+ * to clear it. A browser-driven run saves after every step, so one this quiet has most likely
+ * lost its browser.
+ */
+const CLEAR_AFTER_IDLE_MS = 5 * 60 * 1000;
 /**
  * @property {string} processor - the processor to use for the pipeline
  * @property {string} strategy - the strategy to use for the pipeline
@@ -40,10 +53,12 @@ function conflictSuffix(status) {
 let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
     constructor() {
         super();
+        _JumooPipelineElement_instances.add(this);
         /**
          * @description - show debug information
          */
         this.debug = false;
+        this.retrying = false;
         this.consumeContext(JUMOO_PROCESSING_CONTEXT, (context) => {
             if (!context)
                 return;
@@ -96,6 +111,7 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
             this.observe(this.context.conflict, (conflict) => {
                 const isNew = conflict && !this.conflict;
                 this.conflict = conflict;
+                this.conflictCheckedAt = conflict ? new Date() : undefined;
                 if (isNew) {
                     this.dispatchEvent(new CustomEvent('pipeline-conflict', {
                         bubbles: true,
@@ -209,11 +225,69 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
 												>
 											</dt>
 											<dd>${Math.round(holder.progress.percentage)}%</dd>`
+                : nothing}
+							${this.conflictCheckedAt
+                ? html `<dt>
+												<umb-localize key="jumooProcConflict_checked"
+													>Checked</umb-localize
+												>
+											</dt>
+											<dd>
+												${this.localize.date(this.conflictCheckedAt, {
+                    timeStyle: 'medium',
+                })}
+											</dd>`
                 : nothing}
 						</dl>`
+            : nothing}
+			${holder && this.canClear(holder)
+            ? html `<p>${this.localize.term('jumooProcConflict_stalled')}</p>`
+            : nothing}
+			${this.canRetry()
+            ? html `<div class="actions">
+							<uui-button
+								look="secondary"
+								label=${this.localize.term('jumooProcConflict_tryAgain')}
+								.state=${this.retrying ? 'waiting' : undefined}
+								?disabled=${this.retrying}
+								@click=${__classPrivateFieldGet(this, _JumooPipelineElement_instances, "m", _JumooPipelineElement_onRetryConflict)}></uui-button>
+							${holder && this.canClear(holder)
+                ? html `<uui-button
+											look="primary"
+											color="warning"
+											label=${this.localize.term('jumooProcConflict_clear')}
+											?disabled=${this.retrying}
+											@click=${__classPrivateFieldGet(this, _JumooPipelineElement_instances, "m", _JumooPipelineElement_onClearConflict)}></uui-button>`
+                : nothing}
+						</div>`
             : nothing}
 		</div>`;
     }
+    /**
+     * @description only a conflict from creating this pipeline can be tried again from here -
+     * one from an existing pipeline has nothing to recreate.
+     * @returns true when the panel should offer to try again.
+     */
+    canRetry() {
+        return !this._pipelineId && !!this.processor && !!this.strategy;
+    }
+    /**
+     * @description a running holder that has stopped moving can be cleared, but only when the
+     * conflict came from creating this pipeline - that's the one we know how to try again.
+     * The holder is only there when the user can see it (its owner, or an admin).
+     * @param holder the holder's status.
+     * @returns true when the panel should offer to clear it.
+     */
+    canClear(holder) {
+        if (!this.canRetry())
+            return false;
+        if (holder.status !== PipelineRunState.RUNNING)
+            return false;
+        const lastActivity = holder.modified ?? holder.created;
+        if (!lastActivity)
+            return false;
+        return Date.now() - new Date(lastActivity).getTime() > CLEAR_AFTER_IDLE_MS;
+    }
     /**
      * @description the time worth showing for the holder: when it was queued, when it last
      * moved, how long it has been paused, or when it is due.
@@ -307,6 +381,43 @@ let JumooPipelineElement = class JumooPipelineElement extends UmbLitElement {
 		`;
     }
 };
+_JumooPipelineElement_instances = new WeakSet();
+_JumooPipelineElement_onRetryConflict = 
+/**
+ * @description tries the create again: starts if the other process has gone, otherwise the
+ * panel redraws with its latest status (which may now offer to clear it).
+ */
+async function _JumooPipelineElement_onRetryConflict() {
+    if (!this.processor || !this.strategy)
+        return;
+    this.retrying = true;
+    try {
+        await this.context?.createPipeline(this.processor, this.strategy, this.setup);
+    }
+    finally {
+        this.retrying = false;
+    }
+    // an unchanged answer doesn't reach the conflict observer, so stamp it here too.
+    if (this.conflict)
+        this.conflictCheckedAt = new Date();
+};
+_JumooPipelineElement_onClearConflict = async function _JumooPipelineElement_onClearConflict() {
+    try {
+        await umbConfirmModal(this, {
+            headline: this.localize.term('jumooProcConflict_clearHeadline'),
+            content: this.localize.term('jumooProcConflict_clearConfirm'),
+            color: 'danger',
+            confirmLabel: this.localize.term('jumooProcConflict_clearConfirmLabel'),
+        });
+    }
+    catch {
+        return; // closed the dialog.
+    }
+    if (!this.processor || !this.strategy)
+        return;
+    await this.context?.clearConflictHolder();
+    await this.context?.createPipeline(this.processor, this.strategy, this.setup);
+};
 JumooPipelineElement.styles = css `
 		.wrapper,
 		umb-extension-slot {
@@ -346,6 +457,11 @@ JumooPipelineElement.styles = css `
 		.conflict dd {
 			margin: 0;
 		}
+
+		.conflict .actions {
+			display: flex;
+			gap: var(--uui-size-space-3);
+		}
 	`;
 __decorate([
     property({ type: String })
@@ -383,6 +499,12 @@ __decorate([
 __decorate([
     state()
 ], JumooPipelineElement.prototype, "conflict", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "conflictCheckedAt", void 0);
+__decorate([
+    state()
+], JumooPipelineElement.prototype, "retrying", void 0);
 JumooPipelineElement = __decorate([
     customElement('jumoo-pipeline')
 ], JumooPipelineElement);

package/dist/queue/queue.context.js

@@ -24,7 +24,9 @@ export class QueueContext extends UmbControllerBase {
     }
     async loadQueue() {
         const queue = await __classPrivateFieldGet(this, _QueueContext_repository, "f").list();
-        __classPrivateFieldGet(this, _QueueContext_queue, "f").setValue(queue);
+        // undefined means the request failed, so keep the last list rather than clearing it.
+        if (queue)
+            __classPrivateFieldGet(this, _QueueContext_queue, "f").setValue(queue);
         return queue;
     }
     async process(key) {

package/dist/queue/queue.repository.js

@@ -1,32 +1,33 @@
 import { UmbControllerBase } from '@umbraco-cms/backoffice/class-api';
+import { tryExecute } from '@umbraco-cms/backoffice/resources';
 import { QueuesService } from '../api';
 export class QueueRepository extends UmbControllerBase {
     constructor(host) {
         super(host);
     }
     async list() {
-        return (await QueuesService.listQueue()).data;
+        return (await tryExecute(this, QueuesService.listQueue())).data;
     }
     async peek(key) {
-        return (await QueuesService.peekItem({
+        return (await tryExecute(this, QueuesService.peekItem({
             query: {
                 key: key,
             },
-        })).data;
+        }))).data;
     }
     async delete(key) {
-        return (await QueuesService.delete({
+        return (await tryExecute(this, QueuesService.delete({
             path: {
                 key: key,
             },
-        })).data;
+        }))).data;
     }
     async process(key) {
-        return (await QueuesService.process({
+        return (await tryExecute(this, QueuesService.process({
             path: {
                 key: key,
             },
-        })).data;
+        }))).data;
     }
 }
 export default QueueRepository;

package/package.json

@@ -1,7 +1,7 @@
 {
 	"name": "@jumoo/processing",
 	"licence": "custom",
-	"version": "17.5.1",
+	"version": "17.5.3",
 	"type": "module",
 	"description": "Jumoo processing library",
 	"exports": {
@@ -38,7 +38,7 @@
 	},
 	"devDependencies": {
 		"@eslint/js": "^10.0.1",
-		"@hey-api/openapi-ts": "^0.95.0",
+		"@hey-api/openapi-ts": "^0.99.0",
 		"@microsoft/signalr": "^10.0.0",
 		"@umbraco-cms/backoffice": "^17.3.0",
 		"eslint": "^10.13.0",
@@ -46,7 +46,7 @@
 		"lit": "^3.3.2",
 		"prettier": "^3.9.10",
 		"typescript": "^6.0.3",
-		"typescript-eslint": "^8.72.0",
+		"typescript-eslint": "^8.72.1",
 		"vite": "^8.3.5",
 		"vite-plugin-dts": "^5.1.2"
 	},

package/dist/hey-api.d.ts

@@ -1,11 +0,0 @@
-import type { CreateClientConfig } from './api/client.gen';
-/**
- * Pre-configure the generated client by copying the Umbraco HTTP client's config.
- *
- * Called automatically by the generated client during initialization (via runtimeConfigPath).
- * Inherits baseUrl, credentials, auth, and headers from umbHttpClient — which is already
- * configured by the backoffice before extensions load.
- *
- * @see https://heyapi.dev/openapi-ts/clients/fetch#configuration
- */
-export declare const createClientConfig: CreateClientConfig;

package/dist/hey-api.js

@@ -1,14 +0,0 @@
-import { umbHttpClient } from '@umbraco-cms/backoffice/http-client';
-/**
- * Pre-configure the generated client by copying the Umbraco HTTP client's config.
- *
- * Called automatically by the generated client during initialization (via runtimeConfigPath).
- * Inherits baseUrl, credentials, auth, and headers from umbHttpClient — which is already
- * configured by the backoffice before extensions load.
- *
- * @see https://heyapi.dev/openapi-ts/clients/fetch#configuration
- */
-export const createClientConfig = (config) => ({
-    ...config,
-    ...umbHttpClient.getConfig(),
-});