openxiangda 2.34.3 → 2.44.0

package/dist/browser/platform-client.js

@@ -1,5 +1,6 @@
 import { parseBusinessProcessResolution, parseBusinessProcessCommitResult } from 'openxiangda-contracts/browser';
 import { recoverManagedRead } from './managed-read-recovery';
+import { recoverRuntimeAuthorizationRead } from './runtime-authorization-recovery';
 import { normalizeWorkflowSurface, SCHEMA_VERSIONS, } from 'openxiangda-contracts/browser';
 import { useSyncExternalStore } from 'react';
 import { buildResourceWhere, } from './components/platform-fields/resource-query';
@@ -48,11 +49,17 @@ export function platformRequestDiagnostic(error) {
 }
 function responseRequestError(path, init, response, payload, fallback) {
     const context = requestContext(path, init, response, payload?.requestId);
-    const code = String(payload?.errorCode || payload?.code || `HTTP_${response.status}`);
+    const dataCode = payload?.data && typeof payload.data === 'object' && 'errorCode' in payload.data
+        && typeof payload.data.errorCode === 'string' ? payload.data.errorCode : undefined;
+    const code = String(payload?.errorCode || dataCode || payload?.code || `HTTP_${response.status}`);
     const retryAfter = response.headers.get('retry-after');
-    const retryAfterMs = retryAfter ? (/^\d+(?:\.\d+)?$/.test(retryAfter) ? Number(retryAfter) * 1000 : Date.parse(retryAfter) - Date.now()) : undefined;
+    const headerDelay = retryAfter ? (/^\d+(?:\.\d+)?$/.test(retryAfter) ? Number(retryAfter) * 1000 : Date.parse(retryAfter) - Date.now()) : undefined;
+    const dataDelay = payload?.data && typeof payload.data === 'object' && 'retryAfterMs' in payload.data
+        ? payload.data.retryAfterMs : undefined;
+    const delays = [headerDelay, payload?.retryAfterMs, dataDelay]
+        .filter((value) => typeof value === 'number' && Number.isFinite(value) && value >= 0);
     return new OpenXiangdaPlatformRequestError({ code, status: response.status,
-        retryAfterMs: retryAfterMs !== undefined && Number.isFinite(retryAfterMs) && retryAfterMs >= 0 ? retryAfterMs : undefined,
+        retryAfterMs: delays.length ? Math.max(...delays) : undefined,
         message: response.status >= 400 && response.status < 500 && typeof payload?.message === 'string' && payload.message.trim()
             ? payload.message
             : `${code}: ${payload?.message || fallback}${context.requestId ? ` (requestId: ${context.requestId})` : ''}`,
@@ -253,7 +260,16 @@ export async function requestApplicationApi(path, init) {
 }
 let activeIdentity;
 let runtimeAuthorizationLoad;
+let runtimeAuthorizationKey;
 let runtimeAuthorizationGeneration = 0;
+function clearRuntimeAuthorization() {
+    const previous = runtimeAuthorizationLoad;
+    runtimeAuthorizationGeneration += 1;
+    activeIdentity = undefined;
+    runtimeAuthorizationLoad = undefined;
+    runtimeAuthorizationKey = undefined;
+    previous?.controller.abort(new DOMException('登录身份已变化', 'AbortError'));
+}
 function applicationServiceBase() {
     return `/service/openxiangda-api/v2/applications/${applicationCode()}`;
 }
@@ -264,17 +280,20 @@ let applicationCsrfToken = '';
 // A workflow command is bound to the header used to issue its one-time surface.
 const workflowCommandCsrf = new Map();
 function bindWorkflowCsrf(surface, csrf) {
+    bindWorkflowCommandCsrf(surface.commandToken, surface.commandTokenExpiresAt, csrf);
+    return surface;
+}
+function bindWorkflowCommandCsrf(commandToken, expiration, csrf) {
     const now = Date.now();
     for (const [key, value] of workflowCommandCsrf)
         if (value.expiresAt <= now)
             workflowCommandCsrf.delete(key);
-    const expiresAt = Date.parse(surface.commandTokenExpiresAt || '');
-    if (surface.commandToken && Number.isFinite(expiresAt) && expiresAt > now) {
-        if (!workflowCommandCsrf.has(surface.commandToken) && workflowCommandCsrf.size >= 512)
+    const expiresAt = Date.parse(expiration || '');
+    if (commandToken && Number.isFinite(expiresAt) && expiresAt > now) {
+        if (!workflowCommandCsrf.has(commandToken) && workflowCommandCsrf.size >= 512)
             workflowCommandCsrf.delete(workflowCommandCsrf.keys().next().value);
-        workflowCommandCsrf.set(surface.commandToken, { csrf, expiresAt });
+        workflowCommandCsrf.set(commandToken, { csrf, expiresAt });
     }
-    return surface;
 }
 async function commandBoundCsrf(commandToken) {
     const binding = commandToken ? workflowCommandCsrf.get(commandToken) : undefined;
@@ -301,9 +320,7 @@ function isPlatformLogoutSignal(value) {
         typeof signal.payload.at === 'number');
 }
 function invalidatePlatformSession() {
-    runtimeAuthorizationGeneration += 1;
-    activeIdentity = undefined;
-    runtimeAuthorizationLoad = undefined;
+    clearRuntimeAuthorization();
     applicationCsrfToken = '';
     workflowCommandCsrf.clear();
     platformSessionListeners.forEach(listener => listener());
@@ -420,8 +437,7 @@ export async function passwordLoginApplication(input) {
                 : {}),
         }),
     });
-    activeIdentity = undefined;
-    runtimeAuthorizationLoad = undefined;
+    clearRuntimeAuthorization();
     return receipt;
 }
 async function startApplicationLoginRedirect(input) {
@@ -445,8 +461,7 @@ export async function completeApplicationDingTalkJsapi(input) {
         headers: { 'x-openxiangda-csrf-token': applicationCsrfToken },
         body: JSON.stringify({ code: input.code }),
     });
-    activeIdentity = undefined;
-    runtimeAuthorizationLoad = undefined;
+    clearRuntimeAuthorization();
     return receipt;
 }
 function validateRuntimeAuthorization(context) {
@@ -486,19 +501,35 @@ function validateRuntimeAuthorization(context) {
     };
     return { state: context.state, identity: activeIdentity };
 }
-async function requestRuntimeAuthorization(generation) {
+async function requestRuntimeAuthorization(generation, signal) {
     const mount = runtimeMount();
-    if (mount) {
-        const context = await requestRead(`${nativeBase()}/authz/current?environmentKey=${encodeURIComponent(mount.environmentKey)}`);
-        if (generation !== runtimeAuthorizationGeneration) {
+    const scope = runtimeAuthorizationScope();
+    const assertCurrent = () => {
+        if (signal.aborted)
+            throw signal.reason;
+        if (generation !== runtimeAuthorizationGeneration || runtimeAuthorizationScope() !== scope) {
             throw new Error('OPENXIANGDA_RUNTIME_AUTHORIZATION_SUPERSEDED');
         }
+    };
+    const assertObservedCurrent = () => {
+        assertCurrent();
+        if (runtimeAuthorizationLoad?.controller.signal !== signal || runtimeAuthorizationLoad.subscribers === 0) {
+            throw new DOMException('读取已取消', 'AbortError');
+        }
+    };
+    const read = async (path) => recoverRuntimeAuthorizationRead(async (signal) => {
+        assertCurrent();
+        const value = await request(path, { signal });
+        assertCurrent();
+        return value;
+    }, signal);
+    if (mount) {
+        const context = await read(`${nativeBase()}/authz/current?environmentKey=${encodeURIComponent(mount.environmentKey)}`);
+        assertObservedCurrent();
         return validateRuntimeAuthorization(context);
     }
-    const current = await requestRead(`${applicationServiceBase()}/dev-sessions/current`);
-    if (generation !== runtimeAuthorizationGeneration) {
-        throw new Error('OPENXIANGDA_RUNTIME_AUTHORIZATION_SUPERSEDED');
-    }
+    const current = await read(`${applicationServiceBase()}/dev-sessions/current`);
+    assertObservedCurrent();
     activeIdentity = {
         ...current.principal,
         identityScope: `connected-dev:${applicationCode()}:${current.environment.key}:${current.principal.userId}`,
@@ -508,28 +539,93 @@ async function requestRuntimeAuthorization(generation) {
     };
     return { state: 'active', identity: activeIdentity };
 }
-export async function loadRuntimeAuthorization(options = {}) {
-    if (options.refresh) {
-        runtimeAuthorizationGeneration += 1;
-        activeIdentity = undefined;
-        runtimeAuthorizationLoad = undefined;
-    }
-    if (runtimeAuthorizationLoad)
-        return await runtimeAuthorizationLoad;
-    const generation = runtimeAuthorizationGeneration;
-    const pending = (async () => {
-        return await requestRuntimeAuthorization(generation);
-    })();
-    runtimeAuthorizationLoad = pending;
+function runtimeAuthorizationScope() {
+    const mount = runtimeMount();
+    return JSON.stringify([applicationCode(), mount?.environmentKey || null, mount?.runtimeBase || null]);
+}
+export function isRuntimeAuthorizationIdentityRejection(error) {
+    return error instanceof OpenXiangdaPlatformRequestError && [401, 403, 409].includes(error.status) ||
+        error instanceof Error && /^OPENXIANGDA_RUNTIME_AUTHORIZATION_(?:INVALID|INACTIVE_INVALID|ACTIVE_INVALID|SUPERSEDED)$/.test(error.message);
+}
+function clearRuntimeEntryWait() {
     try {
-        return await pending;
-    }
-    catch (error) {
-        if (runtimeAuthorizationLoad === pending) {
-            runtimeAuthorizationLoad = undefined;
-        }
-        throw error;
+        if (typeof window !== 'undefined')
+            window.sessionStorage?.removeItem(`oxa-entry-wait:${window.location.pathname}`);
+    }
+    catch { /* Storage restrictions must not prevent a verified runtime from starting. */ }
+}
+function observeRuntimeAuthorization(owner, signal) {
+    owner.subscribers++;
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        const finish = () => {
+            if (finished)
+                return false;
+            finished = true;
+            signal?.removeEventListener('abort', abort);
+            owner.subscribers--;
+            return true;
+        };
+        const abort = () => {
+            if (!finish())
+                return;
+            const reason = signal?.reason || new DOMException('读取已取消', 'AbortError');
+            if (!owner.settled && owner.subscribers === 0) {
+                // StrictMode can resubscribe in this commit. A real departure still
+                // retires the owner in the next microtask, without extending its budget.
+                queueMicrotask(() => {
+                    if (owner.settled || owner.subscribers > 0)
+                        return;
+                    if (runtimeAuthorizationLoad === owner) {
+                        runtimeAuthorizationLoad = undefined;
+                        runtimeAuthorizationGeneration++;
+                    }
+                    owner.controller.abort(reason);
+                });
+            }
+            reject(reason);
+        };
+        if (signal?.aborted)
+            abort();
+        else
+            signal?.addEventListener('abort', abort, { once: true });
+        owner.promise.then(value => { if (finish())
+            resolve(value); }, reason => { if (finish())
+            reject(reason); });
+    });
+}
+export async function loadRuntimeAuthorization(options = {}) {
+    if (options.signal?.aborted)
+        throw options.signal.reason || new DOMException('读取已取消', 'AbortError');
+    const key = runtimeAuthorizationScope();
+    if (runtimeAuthorizationKey && runtimeAuthorizationKey !== key)
+        clearRuntimeAuthorization();
+    let owner = runtimeAuthorizationLoad;
+    if (!owner || (options.refresh && owner.settled)) {
+        const generation = ++runtimeAuthorizationGeneration;
+        owner = { controller: new AbortController(), key, subscribers: 0, settled: false,
+            promise: undefined };
+        runtimeAuthorizationLoad = owner;
+        runtimeAuthorizationKey = key;
+        const currentOwner = owner;
+        currentOwner.promise = requestRuntimeAuthorization(generation, currentOwner.controller.signal).then(value => {
+            currentOwner.settled = true;
+            if (runtimeAuthorizationLoad === currentOwner && !currentOwner.controller.signal.aborted)
+                clearRuntimeEntryWait();
+            return value;
+        }, error => {
+            currentOwner.settled = true;
+            if (runtimeAuthorizationLoad === currentOwner) {
+                runtimeAuthorizationLoad = undefined;
+                if (isRuntimeAuthorizationIdentityRejection(error)) {
+                    activeIdentity = undefined;
+                    workflowCommandCsrf.clear();
+                }
+            }
+            throw error;
+        });
     }
+    return await observeRuntimeAuthorization(owner, options.signal);
 }
 export async function logoutCurrentUser() {
     const device = typeof window !== 'undefined' &&
@@ -544,9 +640,7 @@ export async function logoutCurrentUser() {
         headers: { 'x-openxiangda-csrf-token': applicationCsrfToken },
         body: JSON.stringify({ environmentKey: runtimeEnvironmentKey(), device }),
     });
-    runtimeAuthorizationGeneration += 1;
-    activeIdentity = undefined;
-    runtimeAuthorizationLoad = undefined;
+    clearRuntimeAuthorization();
     applicationCsrfToken = '';
     workflowCommandCsrf.clear();
     publishPlatformLogout();
@@ -599,7 +693,8 @@ export function createManagedConcurrencyClient() {
     const scope = JSON.stringify([appCode, identity.environment.id, identity.userId]);
     const assertScope = () => {
         if (applicationCode() !== appCode || currentEnvironmentKey() !== environmentKey ||
-            activeIdentity?.userId !== identity.userId || activeIdentity?.environment.id !== identity.environment.id)
+            activeIdentity?.userId !== identity.userId || activeIdentity?.environment.id !== identity.environment.id ||
+            activeIdentity?.identityScope !== identity.identityScope)
             throw new OpenXiangdaPlatformRequestError({ code: 'CONCURRENCY_IDENTITY_CHANGED', status: 401, message: '用户或应用环境已变化，请重新打开原操作' });
     };
     const frozenCall = async (path, body, signal) => {
@@ -1256,9 +1351,30 @@ function roleManagementQuery(input = {}) {
 export async function loadRoleManagementCatalog() {
     return await request(`${roleManagementBase()}/catalog?${roleManagementQuery()}`);
 }
+export async function listRoleManagementScopeValues(dimensionCode, input = {}) {
+    return request(`${roleManagementBase()}/scope-values?${roleManagementQuery({ ...input, dimensionCode })}`);
+}
 export async function listRoleMemberships(input = {}) {
     return await request(`${roleManagementBase()}/memberships?${roleManagementQuery(input)}`);
 }
+/** Each item is independent; retain its operationId when recovering an unknown result. */
+export async function previewRoleMembershipBatch(input) {
+    return request(`${roleManagementBase()}/memberships/batch/preview`, {
+        method: 'POST', body: JSON.stringify({ ...input,
+            schemaVersion: 'openxiangda.native-role-membership-batch-request/v2', environmentKey: currentEnvironmentKey() }),
+    });
+}
+export async function executeRoleMembershipBatch(input) {
+    return request(`${roleManagementBase()}/memberships/batch/execute`, {
+        method: 'POST', body: JSON.stringify({ ...input,
+            schemaVersion: 'openxiangda.native-role-membership-batch-request/v2', environmentKey: currentEnvironmentKey() }),
+    });
+}
+/** Potential versioned nodes, authorized by the existing workflow management reader. */
+export async function loadWorkflowRoleReferences(roleCode, input = {}) {
+    const query = roleManagementQuery({ ...input, roleCode });
+    return request(`${applicationServiceBase()}/workflow/management/role-references?${query}`);
+}
 export async function searchRoleManagementUsers(input) {
     const query = roleManagementQuery({
         purpose: 'authorization-management',
@@ -1441,6 +1557,8 @@ export async function downloadDataFile(resource, fileId, fileName) {
     }
 }
 function workflowFileBase(binding, fileId) {
+    if (binding.taskId)
+        return `${workflowBase()}/tasks/${encodeURIComponent(binding.taskId)}/form-files/${encodeURIComponent(fileId)}?fieldCode=${encodeURIComponent(binding.fieldCode)}`;
     const query = new URLSearchParams({
         resourceCode: binding.resourceCode,
         recordId: binding.recordId,
@@ -1493,6 +1611,42 @@ export async function downloadWorkflowDataFile(binding, fileId, fileName) {
 function workflowBase() {
     return `${applicationServiceBase()}/workflow`;
 }
+function delegationManagementQuery(input = {}) {
+    if ('environmentKey' in input && input.environmentKey !== currentEnvironmentKey())
+        throw new Error('WORKFLOW_DELEGATION_ENVIRONMENT_MISMATCH');
+    const params = new URLSearchParams({ environmentKey: currentEnvironmentKey() });
+    for (const [key, value] of Object.entries(input))
+        if (value !== undefined && value !== '')
+            params.set(key, String(value));
+    return params;
+}
+export async function loadWorkflowDelegationCatalog() {
+    return requestRead(`${workflowBase()}/delegation-management/catalog?${delegationManagementQuery()}`);
+}
+export async function listWorkflowDelegations(input = {}) {
+    return requestRead(`${workflowBase()}/delegation-management?${delegationManagementQuery(input)}`);
+}
+export async function loadWorkflowDelegation(id) {
+    return requestRead(`${workflowBase()}/delegation-management/${encodeURIComponent(id)}?${delegationManagementQuery()}`);
+}
+export async function listWorkflowDelegationCandidates(input) {
+    return requestRead(`${workflowBase()}/delegation-management/candidates?${delegationManagementQuery(input)}`);
+}
+export async function loadWorkflowDelegationMutationReceipt(operationId) {
+    return requestRead(`${workflowBase()}/delegation-management/receipts/${encodeURIComponent(operationId)}?${delegationManagementQuery()}`);
+}
+async function delegationManagementMutation(input, mode) {
+    if (input.environmentKey !== currentEnvironmentKey())
+        throw new Error('WORKFLOW_DELEGATION_ENVIRONMENT_MISMATCH');
+    const csrfToken = await workflowCsrfToken();
+    return request(`${workflowBase()}/delegation-management/${mode}`, { method: 'POST', headers: { 'x-openxiangda-csrf-token': csrfToken }, body: JSON.stringify(input) });
+}
+export async function previewWorkflowDelegationMutation(input) {
+    return delegationManagementMutation(input, 'preview');
+}
+export async function executeWorkflowDelegationMutation(input) {
+    return delegationManagementMutation(input, 'execute');
+}
 export async function loadWorkflowLaunchSurface(workflowCode) {
     const query = new URLSearchParams({
         environmentKey: currentEnvironmentKey(),
@@ -1603,6 +1757,34 @@ export async function loadWorkflowTaskSurface(taskId) {
     const surface = await requestRead(`${workflowBase()}/tasks/${encodeURIComponent(taskId)}/surface`, { headers: { 'x-openxiangda-csrf-token': csrfToken } });
     return bindWorkflowCsrf(normalizeWorkflowSurface(surface), csrfToken);
 }
+/** Private values remain scoped to the current user and fixed actionable task. */
+export async function loadWorkflowTaskDrafts(taskId) {
+    return requestRead(`${workflowBase()}/tasks/${encodeURIComponent(taskId)}/form-drafts`);
+}
+export async function saveWorkflowTaskDraft(taskId, input) {
+    return request(`${workflowBase()}/tasks/${encodeURIComponent(taskId)}/form-drafts`, {
+        method: 'POST', headers: { 'x-openxiangda-csrf-token': await workflowCsrfToken() }, body: JSON.stringify(input),
+    });
+}
+export async function removeWorkflowTaskDraft(taskId, input) {
+    return request(`${workflowBase()}/tasks/${encodeURIComponent(taskId)}/form-drafts/delete`, {
+        method: 'POST', headers: { 'x-openxiangda-csrf-token': await workflowCsrfToken() }, body: JSON.stringify(input),
+    });
+}
+/** Fix the upload ID before this call. Retrying uses the same intent and task. */
+export async function initiateWorkflowTaskFileUpload(taskId, input) {
+    return request(`${workflowBase()}/tasks/${encodeURIComponent(taskId)}/form-files`, {
+        method: 'POST', headers: { 'x-openxiangda-csrf-token': await workflowCsrfToken() }, body: JSON.stringify(input),
+    });
+}
+export async function loadWorkflowTaskFileUploadPlan(taskId, fileId) {
+    return requestRead(`${workflowBase()}/tasks/${encodeURIComponent(taskId)}/form-files/${encodeURIComponent(fileId)}`);
+}
+export async function completeWorkflowTaskFileUpload(taskId, fileId) {
+    return request(`${workflowBase()}/tasks/${encodeURIComponent(taskId)}/form-files/${encodeURIComponent(fileId)}/complete`, {
+        method: 'POST', headers: { 'x-openxiangda-csrf-token': await workflowCsrfToken() }, body: '{}',
+    });
+}
 export async function loadWorkflowInstanceSurface(instanceId) {
     const csrfToken = await workflowCsrfToken();
     const surface = await requestRead(`${workflowBase()}/instances/${encodeURIComponent(instanceId)}/surface`, { headers: { 'x-openxiangda-csrf-token': csrfToken } });
@@ -1611,6 +1793,65 @@ export async function loadWorkflowInstanceSurface(instanceId) {
 export async function loadWorkflowTimeline(instanceId) {
     return await requestRead(`${workflowBase()}/instances/${encodeURIComponent(instanceId)}/timeline`);
 }
+/** Requires the same workflow management authority as the platform console. */
+export async function loadWorkflowDefinitionGraph(workflowCode, version) {
+    const result = await requestRead(`${workflowBase()}/management/definitions/${encodeURIComponent(workflowCode)}/versions/${version}`);
+    if (!result.graph || result.graph.definitionDigest !== result.definitionDigest)
+        throw new Error('WORKFLOW_V2_GRAPH_DIGEST_MISMATCH');
+    return result;
+}
+export async function loadWorkflowInstanceGraph(instanceId) {
+    const result = await requestRead(`${workflowBase()}/management/instances/${encodeURIComponent(instanceId)}/graph`);
+    if (!result.graph || result.graph.definitionDigest !== result.definitionDigest)
+        throw new Error('WORKFLOW_V2_GRAPH_DIGEST_MISMATCH');
+    return result;
+}
+export async function loadApplicationAdministrationContext() {
+    return requestRead(`${applicationServiceBase()}/admin/context?${new URLSearchParams({ environmentKey: currentEnvironmentKey() })}`);
+}
+/** Same administrator authority as the console; does not grant ordinary users repair access. */
+export async function loadWorkflowBusinessStepRecovery(instanceId) {
+    return requestRead(`${applicationServiceBase()}/admin/workflow-instances/${encodeURIComponent(instanceId)}/options?${new URLSearchParams({ environmentKey: currentEnvironmentKey() })}`);
+}
+export async function previewWorkflowBusinessStepRecovery(instanceId) {
+    const csrf = await workflowCsrfToken();
+    const preview = await request(`${applicationServiceBase()}/admin/workflow-instances/${encodeURIComponent(instanceId)}/preview`, {
+        method: 'POST', headers: { 'x-openxiangda-csrf-token': csrf },
+        body: JSON.stringify({ environmentKey: currentEnvironmentKey(), action: 'admin_retry_step' }),
+    });
+    bindWorkflowCommandCsrf(preview.commandToken, preview.expiresAt, csrf);
+    return preview;
+}
+/** Keep this exact token/input/key until the outcome is known. Never executes the external handler. */
+export async function executeWorkflowBusinessStepRecovery(instanceId, input) {
+    return request(`${applicationServiceBase()}/admin/workflow-instances/${encodeURIComponent(instanceId)}/commands/admin_retry_step`, {
+        method: 'POST', headers: { 'x-openxiangda-csrf-token': await commandBoundCsrf(input.commandToken) }, body: JSON.stringify(input),
+    });
+}
+export async function loadWorkflowNodeConfigurations(workflowCode) {
+    return requestRead(`${applicationServiceBase()}/admin/workflows/${encodeURIComponent(workflowCode)}/node-configurations?${new URLSearchParams({ environmentKey: currentEnvironmentKey() })}`);
+}
+/** Retain the same operationId and exact input while the write result is unknown. */
+export async function saveWorkflowNodeConfiguration(workflowCode, nodeId, input) {
+    return request(`${applicationServiceBase()}/admin/workflows/${encodeURIComponent(workflowCode)}/node-configurations/${encodeURIComponent(nodeId)}`, { method: 'POST', body: JSON.stringify({ ...input, environmentKey: currentEnvironmentKey() }) });
+}
+export async function loadWorkflowAssignmentRoutingCatalog(input = {}) {
+    const query = new URLSearchParams({ environmentKey: currentEnvironmentKey(), keyword: input.keyword || '', limit: String(input.limit ?? 20), offset: String(input.offset ?? 0) });
+    return request(`${applicationServiceBase()}/admin/workflow-assignment-routing?${query}`);
+}
+export async function loadWorkflowAssignmentRoutingConfiguration(policyCode) {
+    return request(`${applicationServiceBase()}/admin/workflow-assignment-routing/${encodeURIComponent(policyCode)}?environmentKey=${encodeURIComponent(currentEnvironmentKey())}`);
+}
+export async function loadWorkflowAssignmentRoutingHistory(policyCode, input = {}) {
+    const query = new URLSearchParams({ environmentKey: currentEnvironmentKey(), limit: String(input.limit ?? 20), offset: String(input.offset ?? 0) });
+    return request(`${applicationServiceBase()}/admin/workflow-assignment-routing/${encodeURIComponent(policyCode)}/history?${query}`);
+}
+/** Keep the exact mutation and operationId to recover an unknown write result. */
+export async function saveWorkflowAssignmentRoutingConfiguration(policyCode, input) {
+    return request(`${applicationServiceBase()}/admin/workflow-assignment-routing/${encodeURIComponent(policyCode)}`, {
+        method: 'POST', body: JSON.stringify({ ...input, environmentKey: currentEnvironmentKey() }),
+    });
+}
 function normalizeWorkflowDetailSurface(detail, csrfToken) {
     return {
         ...detail,
@@ -1685,6 +1926,10 @@ export async function executeWorkflowInstanceCommand(instanceId, command, input)
         body: JSON.stringify(input),
     });
 }
+/** A read does not consume a token or imply that an unobserved command failed. */
+export async function loadWorkflowTaskCommandReceipt(taskId, idempotencyKey, tokenDigest) {
+    return await request(`${workflowBase()}/tasks/${encodeURIComponent(taskId)}/commands/original?idempotencyKey=${encodeURIComponent(idempotencyKey)}${tokenDigest ? `&tokenDigest=${encodeURIComponent(tokenDigest)}` : ''}`);
+}
 /** Execute a server-issued Workflow operation without task/instance branching. */
 export async function executeWorkflowOperation(surface, operation, input = {}, options = {}) {
     if (operation.kind !== 'workflow_command' ||