@ultrst-armada/kloks 1.4.2 → 1.4.4

package/packages/backend/dist/execution/index.d.ts

@@ -1,124 +0,0 @@
-import { I as IdempotencyManager } from '../IdempotencyManager-B5MjK871.js';
-import { J as Job } from '../types-BERZJ93O.js';
-
-/**
- * @file types.ts
- * @description Formal TypeScript types for backend execution boundary.
- * Conforms to SKIPO::STATE_EXECUTION_ARCHITECTURE and L9 (<=200L).
- */
-interface ExecutionContext {
-    isWorkerContext: boolean;
-    workerId?: string;
-    timestamp: number;
-}
-interface BackendCommand<TPayload = unknown> {
-    id: string;
-    type: string;
-    payload: TPayload;
-    metadata?: Record<string, unknown>;
-    correlationId: string;
-    idempotencyKey?: string;
-    createdAt: number;
-}
-interface NormalizedResult<TData = unknown> {
-    correlationId: string;
-    status: 'COMPLETED' | 'FAILED';
-    data?: TData;
-    error?: string;
-    executionTimestamp: number;
-}
-interface OperationComponent<TInput = unknown, TOutput = unknown> {
-    name: string;
-    execute(input: TInput): Promise<TOutput>;
-}
-interface DomainService {
-    name: string;
-    operations: Record<string, OperationComponent<any, any>>;
-    execute(operationName: string, input: unknown): Promise<unknown>;
-}
-
-/**
- * @file OperationComponent.ts
- * @description Smallest deterministic executable domain operation.
- * Conforms to SKIPO::STATE_EXECUTION_ARCHITECTURE and L9 (<=200L).
- */
-
-declare function createOperationComponent<TInput = unknown, TOutput = unknown>(name: string, handler: (input: TInput) => Promise<TOutput> | TOutput): OperationComponent<TInput, TOutput>;
-
-/**
- * @file ServiceDispatcher.ts
- * @description Domain-level orchestration unit coordinating OperationComponents.
- * Conforms to SKIPO::STATE_EXECUTION_ARCHITECTURE and L9 (<=200L).
- */
-
-declare class ServiceDispatcher implements DomainService {
-    readonly name: string;
-    operations: Record<string, OperationComponent<any, any>>;
-    constructor(name: string);
-    registerOperation<TIn = unknown, TOut = unknown>(opName: string, operation: OperationComponent<TIn, TOut>): this;
-    execute(operationName: string, input: unknown): Promise<unknown>;
-}
-
-/**
- * @file BackendFacade.ts
- * @description Single Public Execution Interface for the backend plane.
- * Conforms to SKIPO::STATE_EXECUTION_ARCHITECTURE and L9 (<=200L).
- */
-
-declare class ExecutableBackendFacade {
-    readonly name: string;
-    private services;
-    private idempotency;
-    constructor(name: string, idempotency?: IdempotencyManager);
-    registerService(service: ServiceDispatcher): this;
-    executeCommand<T = unknown>(command: BackendCommand<any>, context: ExecutionContext): Promise<NormalizedResult<T>>;
-}
-
-/**
- * @file WorkerExecutionBoundary.ts
- * @description Worker execution boundary enforcing worker-only access to Backend Facade.
- * Conforms to SKIPO::STATE_EXECUTION_ARCHITECTURE and L9 (<=200L).
- */
-
-declare class WorkerExecutionBoundary {
-    readonly workerId: string;
-    private facade;
-    constructor(workerId: string, facade: ExecutableBackendFacade);
-    processJob<T = unknown>(command: BackendCommand<any>): Promise<NormalizedResult<T>>;
-    static assertWorkerContext(context?: ExecutionContext): void;
-}
-
-/**
- * @file DependencyOrdering.ts
- * @description Dependency graph ordering and race-condition prevention for jobs.
- * Conforms to SKIPO::STATE_EXECUTION_ARCHITECTURE and L9 (<=200L).
- */
-
-declare class JobDependencyGraph {
-    private scheduler;
-    constructor(maxConcurrency?: number);
-    registerHandler<TPayload = any, TResult = any>(type: string, handler: (job: Job<TPayload, TResult>) => Promise<TResult>): this;
-    submitJob<TPayload = any, TResult = any>(type: string, payload: TPayload, dependencies?: string[], idempotencyKey?: string): Job<TPayload, TResult>;
-    getJob(jobId: string): Job | undefined;
-    clear(): void;
-}
-
-/**
- * @file ResultFlowBridge.ts
- * @description Bridges execution results back to frontend state update streams.
- * Conforms to SKIPO::STATE_EXECUTION_ARCHITECTURE and L9 (<=200L).
- */
-
-interface StateUpdateEvent<T = unknown> {
-    type: 'SKIPO_STATE_UPDATE';
-    correlationId: string;
-    status: 'COMPLETED' | 'FAILED';
-    data?: T;
-    error?: string;
-    timestamp: number;
-}
-declare class ResultFlowBridge {
-    static formatStateUpdate<T = unknown>(result: NormalizedResult<T>): StateUpdateEvent<T>;
-}
-
-export { type BackendCommand, type DomainService, ExecutableBackendFacade, type ExecutionContext, JobDependencyGraph, type NormalizedResult, type OperationComponent, ResultFlowBridge, ServiceDispatcher, type StateUpdateEvent, WorkerExecutionBoundary, createOperationComponent };

package/packages/backend/dist/execution/index.js

@@ -1,20 +0,0 @@
-import {
-  JobDependencyGraph,
-  ResultFlowBridge,
-  ServiceDispatcher,
-  createOperationComponent
-} from "../chunk-VQEFULWT.js";
-import {
-  ExecutableBackendFacade,
-  WorkerExecutionBoundary
-} from "../chunk-QGHDJGYS.js";
-import "../chunk-UPFKBBQI.js";
-import "../chunk-3EPY34R6.js";
-export {
-  ExecutableBackendFacade,
-  JobDependencyGraph,
-  ResultFlowBridge,
-  ServiceDispatcher,
-  WorkerExecutionBoundary,
-  createOperationComponent
-};

package/packages/backend/dist/types-BERZJ93O.d.ts

@@ -1,110 +0,0 @@
-/**
- * @file types.ts
- * @description Canonical protocol types, messages, jobs, callbacks, and resolution interfaces.
- */
-type MessageType = 'COMMAND' | 'QUERY' | 'RESULT' | 'EVENT' | 'CALLBACK_REQUEST' | 'CALLBACK_RESULT' | 'JOB_SUBMIT' | 'JOB_PROGRESS' | 'JOB_RESULT' | 'ERROR' | 'ACK';
-interface AuthContext {
-    userId?: string;
-    role?: string;
-    permissions?: string[];
-    token?: string;
-}
-interface CapabilityContext {
-    domain: string;
-    capability: string;
-    scope?: string;
-}
-interface Message<T = unknown> {
-    id: string;
-    type: MessageType;
-    operation: string;
-    payload?: T;
-    sessionId?: string;
-    correlationId?: string;
-    causationId?: string;
-    sequence?: number;
-    timestamp: number;
-    authContext?: AuthContext;
-    capabilityContext?: CapabilityContext;
-    error?: {
-        code: string;
-        message: string;
-        details?: unknown;
-    };
-}
-interface CallbackHandle {
-    id: string;
-    sessionId: string;
-    capability: string;
-    expiration: number;
-}
-interface Delegation<T = unknown> {
-    target: string;
-    operation: string;
-    payload: T;
-    callbackHandle?: CallbackHandle;
-    eventChannel?: string;
-    sessionId?: string;
-    correlationId?: string;
-}
-type JobState = 'PENDING' | 'QUEUED' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELLED';
-type JobPriority = 'LOW' | 'NORMAL' | 'HIGH' | 'CRITICAL';
-interface Job<TPayload = unknown, TResult = unknown> {
-    id: string;
-    type: string;
-    payload: TPayload;
-    priority?: JobPriority;
-    sequence?: number;
-    sequenceKey?: string;
-    dependencies?: string[];
-    sessionId?: string;
-    correlationId?: string;
-    state: JobState;
-    progress?: number;
-    result?: TResult;
-    error?: string;
-    createdAt: number;
-    updatedAt: number;
-}
-type ResolutionStrategy = 'LOCAL' | 'REMOTE' | 'REMOTE_FIRST' | 'LOCAL_FIRST';
-interface ResourceVersion {
-    version: number;
-    updatedAt: number;
-    checksum?: string;
-}
-interface DistributedLock {
-    key: string;
-    ownerId: string;
-    leaseId: string;
-    expiration: number;
-}
-interface BackendInstance {
-    id: string;
-    url: string;
-    healthy: boolean;
-    capacity: number;
-    activeJobs: number;
-    activeConnections: number;
-    latencyMs: number;
-    lastHeartbeat: number;
-    weight?: number;
-}
-type RoutingStrategy = 'roundRobin' | 'weighted' | 'leastConnections' | 'latencyAware' | 'capacityAware';
-interface IdempotentRequest<T = unknown> {
-    id: string;
-    idempotencyKey: string;
-    operation: string;
-    payload: T;
-    timestamp: number;
-}
-interface BackendExecutor {
-    execute<T = unknown, R = unknown>(command: Message<T>): Promise<R>;
-    query<T = unknown, R = unknown>(query: Message<T>): Promise<R>;
-    subscribe(channel: string, handler: (event: Message) => void): () => void;
-    emit(event: Message): Promise<void>;
-    registerCallback(callback: (...args: unknown[]) => unknown): CallbackHandle;
-    delegate<T = unknown, R = unknown>(delegation: Delegation<T>): Promise<R>;
-    submitJob<T = unknown, R = unknown>(job: Partial<Job<T, R>>): Promise<Job<T, R>>;
-}
-
-export type { AuthContext as A, BackendExecutor as B, CallbackHandle as C, Delegation as D, IdempotentRequest as I, Job as J, Message as M, ResolutionStrategy as R, BackendInstance as a, CapabilityContext as b, DistributedLock as c, JobPriority as d, JobState as e, MessageType as f, ResourceVersion as g, RoutingStrategy as h };

package/packages/state-graph/dist/chunk-3RG5ZIWI.js

@@ -1,10 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-export {
-  __require
-};

package/packages/state-graph/dist/chunk-ZTHBPV24.js

@@ -1,267 +0,0 @@
-import {
-  SKIPO_STATE,
-  useSkipoState
-} from "./chunk-SHIBCPGQ.js";
-import {
-  __require
-} from "./chunk-3RG5ZIWI.js";
-
-// src/execution/BullMQAdapter.ts
-var BullMQAdapter = class {
-  queue;
-  worker;
-  inMemoryJobs = /* @__PURE__ */ new Map();
-  inMemoryResults = /* @__PURE__ */ new Map();
-  inMemoryListeners = /* @__PURE__ */ new Map();
-  isInMemory = false;
-  constructor(options) {
-    this.isInMemory = true;
-    if (typeof window === "undefined" && !options.useInMemory && options.connection) {
-      try {
-        const req = typeof __require !== "undefined" ? __require : null;
-        if (req) {
-          const { Queue } = req("bullmq");
-          this.queue = new Queue(options.queueName, { connection: options.connection });
-          this.isInMemory = false;
-        }
-      } catch {
-        this.isInMemory = true;
-      }
-    }
-  }
-  async enqueue(job) {
-    if (!this.isInMemory && this.queue) {
-      const priorityVal = this.getPriorityNumber(job.priority);
-      const bJob = await this.queue.add(job.command.type, job, {
-        jobId: job.id,
-        priority: priorityVal,
-        attempts: job.retryPolicy?.maxAttempts || 3,
-        backoff: job.retryPolicy ? { type: "exponential", delay: job.retryPolicy.backoffMs } : void 0
-      });
-      return bJob.id || job.id;
-    }
-    this.inMemoryJobs.set(job.id, { ...job, status: "QUEUED" });
-    return job.id;
-  }
-  async getJobStatus(jobId) {
-    if (!this.isInMemory && this.queue) {
-      const bJob = await this.queue.getJob(jobId);
-      if (!bJob) return void 0;
-      const state = await bJob.getState();
-      switch (state) {
-        case "completed":
-          return "COMPLETED";
-        case "failed":
-          return "FAILED";
-        case "active":
-          return "RUNNING";
-        case "waiting":
-        case "delayed":
-          return "QUEUED";
-        default:
-          return "PENDING";
-      }
-    }
-    return this.inMemoryJobs.get(jobId)?.status;
-  }
-  async getJobResult(jobId) {
-    if (!this.isInMemory && this.queue) {
-      const bJob = await this.queue.getJob(jobId);
-      if (!bJob) return void 0;
-      if (await bJob.isCompleted()) {
-        return { correlationId: bJob.data.correlationId, status: "COMPLETED", data: bJob.returnvalue };
-      }
-      if (await bJob.isFailed()) {
-        return { correlationId: bJob.data.correlationId, status: "FAILED", error: bJob.failedReason };
-      }
-      return void 0;
-    }
-    return this.inMemoryResults.get(jobId);
-  }
-  completeInMemoryJob(jobId, result) {
-    const job = this.inMemoryJobs.get(jobId);
-    if (job) {
-      job.status = result.status === "COMPLETED" ? "COMPLETED" : "FAILED";
-      job.updatedAt = Date.now();
-      this.inMemoryResults.set(jobId, result);
-      const listeners = this.inMemoryListeners.get(jobId) || [];
-      listeners.forEach((fn) => fn(result));
-      this.inMemoryListeners.delete(jobId);
-    }
-  }
-  subscribeInMemoryJob(jobId, listener) {
-    const existing = this.inMemoryResults.get(jobId);
-    if (existing) {
-      listener(existing);
-      return () => {
-      };
-    }
-    const current = this.inMemoryListeners.get(jobId) || [];
-    current.push(listener);
-    this.inMemoryListeners.set(jobId, current);
-    return () => {
-      const arr = this.inMemoryListeners.get(jobId) || [];
-      this.inMemoryListeners.set(jobId, arr.filter((fn) => fn !== listener));
-    };
-  }
-  getQueuedInMemoryJobs() {
-    return Array.from(this.inMemoryJobs.values()).filter((j) => j.status === "QUEUED").sort((a, b) => this.getPriorityNumber(b.priority) - this.getPriorityNumber(a.priority));
-  }
-  async cancel(jobId) {
-    if (!this.isInMemory && this.queue) {
-      const bJob = await this.queue.getJob(jobId);
-      if (bJob) {
-        await bJob.remove();
-        return true;
-      }
-      return false;
-    }
-    return this.inMemoryJobs.delete(jobId);
-  }
-  async close() {
-    if (this.worker) await this.worker.close();
-    if (this.queue) await this.queue.close();
-    this.inMemoryJobs.clear();
-    this.inMemoryResults.clear();
-  }
-  getPriorityNumber(priority) {
-    switch (priority) {
-      case "CRITICAL":
-        return 1;
-      case "HIGH":
-        return 2;
-      case "NORMAL":
-        return 3;
-      case "LOW":
-        return 4;
-      default:
-        return 3;
-    }
-  }
-};
-
-// src/execution/CommandBus.ts
-var CommandBus = class {
-  constructor(adapter) {
-    this.adapter = adapter;
-  }
-  adapter;
-  createCommand(type, payload, metadata, lifecycle) {
-    const timestamp = Date.now();
-    const id = `cmd_${timestamp}_${Math.random().toString(36).slice(2, 7)}`;
-    const correlationId = `corr_${timestamp}_${Math.random().toString(36).slice(2, 9)}`;
-    return {
-      id,
-      type,
-      payload,
-      metadata,
-      correlationId,
-      lifecycle,
-      createdAt: timestamp
-    };
-  }
-  async enqueue(command, options = {}) {
-    const now = Date.now();
-    const idempotencyKey = options.idempotencyKey || `idem_${command.type}_${command.correlationId}`;
-    const job = {
-      id: `job_${now}_${Math.random().toString(36).slice(2, 7)}`,
-      command,
-      idempotencyKey,
-      correlationId: options.correlationId || command.correlationId,
-      retryPolicy: options.retryPolicy || { maxAttempts: 3, backoffMs: 1e3 },
-      priority: options.priority || "NORMAL",
-      dependencies: options.dependencies || [],
-      status: "QUEUED",
-      attempts: 0,
-      createdAt: now,
-      updatedAt: now
-    };
-    await this.adapter.enqueue(job);
-    return job;
-  }
-};
-
-// src/execution/SkipoExecution.ts
-var SkipoExecutionEngine = class {
-  frontendQueue;
-  backendQueue;
-  commandBus;
-  constructor(options = {}) {
-    this.frontendQueue = new BullMQAdapter({
-      queueName: "FRONTEND_EXECUTION_QUEUE",
-      connection: options.redisConnection
-    });
-    this.backendQueue = new BullMQAdapter({
-      queueName: "BACKEND_EXECUTION_QUEUE",
-      connection: options.redisConnection
-    });
-    this.commandBus = new CommandBus(this.frontendQueue);
-  }
-  createCommand(type, payload, metadata, lifecycle) {
-    return this.commandBus.createCommand(type, payload, metadata, lifecycle);
-  }
-  async dispatch(type, payload, options = {}) {
-    const cmd = this.createCommand(type, payload, void 0, options.correlationId);
-    const job = await this.commandBus.enqueue(cmd, options);
-    const stateId = `execution_${job.correlationId}`;
-    SKIPO_STATE.create(
-      "SKIPO_EXECUTION",
-      { type: "APP" },
-      { status: "QUEUED", correlationId: job.correlationId, progress: 0 },
-      stateId
-    );
-    return job;
-  }
-  propagateResult(correlationId, result) {
-    const stateId = `execution_${correlationId}`;
-    if (SKIPO_STATE.get(stateId)) {
-      SKIPO_STATE.update(stateId, () => ({
-        status: result.status,
-        correlationId,
-        data: result.data,
-        error: result.error,
-        completedAt: Date.now()
-      }));
-    }
-  }
-  async close() {
-    await this.frontendQueue.close();
-    await this.backendQueue.close();
-  }
-};
-var SKIPO_EXECUTION = new SkipoExecutionEngine();
-
-// src/execution/hooks.ts
-import { useState, useCallback } from "react";
-function useCommand(type, defaultOptions = {}) {
-  const [activeCorrId, setActiveCorrId] = useState(null);
-  const [execState] = useSkipoState(
-    activeCorrId ? `execution_${activeCorrId}` : `execution_idle_${type}`,
-    { status: "IDLE" }
-  );
-  const dispatch = useCallback(
-    async (payload, options) => {
-      const mergedOptions = { ...defaultOptions, ...options };
-      const job = await SKIPO_EXECUTION.dispatch(type, payload, mergedOptions);
-      setActiveCorrId(job.correlationId);
-      return job;
-    },
-    [type, defaultOptions]
-  );
-  return {
-    dispatch,
-    status: execState.status,
-    isPending: execState.status === "QUEUED" || execState.status === "RUNNING",
-    result: execState.data,
-    error: execState.error,
-    correlationId: execState.correlationId
-  };
-}
-
-export {
-  BullMQAdapter,
-  CommandBus,
-  SkipoExecutionEngine,
-  SKIPO_EXECUTION,
-  useCommand
-};

package/packages/state-graph/dist/execution/index.d.ts

@@ -1,152 +0,0 @@
-/**
- * @file types.ts
- * @description Formal TypeScript types for SKIPO_EXECUTION system.
- * Conforms to SKIPO::STATE_EXECUTION_ARCHITECTURE and L9 (<=200L).
- */
-type JobPriority = 'LOW' | 'NORMAL' | 'HIGH' | 'CRITICAL';
-type JobStatus = 'PENDING' | 'QUEUED' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'RETRYING';
-interface RetryPolicy {
-    maxAttempts: number;
-    backoffMs: number;
-    jitter?: boolean;
-}
-interface SkipoCommand<TPayload = unknown> {
-    id: string;
-    type: string;
-    payload: TPayload;
-    metadata?: Record<string, unknown>;
-    correlationId: string;
-    lifecycle?: string;
-    createdAt: number;
-}
-interface ExecutionJob<TPayload = unknown> {
-    id: string;
-    command: SkipoCommand<TPayload>;
-    idempotencyKey: string;
-    correlationId: string;
-    retryPolicy?: RetryPolicy;
-    priority?: JobPriority;
-    dependencies?: string[];
-    status: JobStatus;
-    progress?: number;
-    attempts?: number;
-    createdAt: number;
-    updatedAt: number;
-}
-interface ExecutionResult<TResult = unknown> {
-    correlationId: string;
-    status: 'COMPLETED' | 'FAILED';
-    data?: TResult;
-    error?: string;
-    executionTimeMs?: number;
-}
-interface ExecutionQueueAdapter {
-    enqueue<T = unknown>(job: ExecutionJob<T>): Promise<string>;
-    getJobStatus(jobId: string): Promise<JobStatus | undefined>;
-    getJobResult<R = unknown>(jobId: string): Promise<ExecutionResult<R> | undefined>;
-    cancel(jobId: string): Promise<boolean>;
-    close(): Promise<void>;
-}
-
-/**
- * @file BullMQAdapter.ts
- * @description BullMQ Queue adapter with high-fidelity in-memory fallback.
- * Implements priority scheduling, retry policy, and concurrency control.
- */
-
-interface BullMQAdapterOptions {
-    queueName: string;
-    connection?: {
-        host?: string;
-        port?: number;
-        url?: string;
-    };
-    maxConcurrency?: number;
-    useInMemory?: boolean;
-}
-declare class BullMQAdapter implements ExecutionQueueAdapter {
-    private queue?;
-    private worker?;
-    private inMemoryJobs;
-    private inMemoryResults;
-    private inMemoryListeners;
-    private isInMemory;
-    constructor(options: BullMQAdapterOptions);
-    enqueue<T = unknown>(job: ExecutionJob<T>): Promise<string>;
-    getJobStatus(jobId: string): Promise<JobStatus | undefined>;
-    getJobResult<R = unknown>(jobId: string): Promise<ExecutionResult<R> | undefined>;
-    completeInMemoryJob(jobId: string, result: ExecutionResult<any>): void;
-    subscribeInMemoryJob(jobId: string, listener: (res: ExecutionResult<any>) => void): () => void;
-    getQueuedInMemoryJobs(): ExecutionJob<any>[];
-    cancel(jobId: string): Promise<boolean>;
-    close(): Promise<void>;
-    private getPriorityNumber;
-}
-
-/**
- * @file CommandBus.ts
- * @description Frontend Command factory & enqueue transport boundary.
- * Enforces Invariants I7-I10: all backend-bound operations MUST go through commands.
- */
-
-interface EnqueueOptions {
-    idempotencyKey?: string;
-    correlationId?: string;
-    priority?: JobPriority;
-    retryPolicy?: RetryPolicy;
-    dependencies?: string[];
-}
-declare class CommandBus {
-    private adapter;
-    constructor(adapter: BullMQAdapter);
-    createCommand<TPayload = unknown>(type: string, payload: TPayload, metadata?: Record<string, unknown>, lifecycle?: string): SkipoCommand<TPayload>;
-    enqueue<TPayload = unknown>(command: SkipoCommand<TPayload>, options?: EnqueueOptions): Promise<ExecutionJob<TPayload>>;
-}
-
-/**
- * @file SkipoExecution.ts
- * @description Canonical SKIPO_EXECUTION system orchestrator.
- * Connects BullMQ queues, CommandBus, and SKIPO_STATE result flow.
- */
-
-declare class SkipoExecutionEngine {
-    readonly frontendQueue: BullMQAdapter;
-    readonly backendQueue: BullMQAdapter;
-    readonly commandBus: CommandBus;
-    constructor(options?: {
-        redisConnection?: {
-            host?: string;
-            port?: number;
-            url?: string;
-        };
-    });
-    createCommand<TPayload = unknown>(type: string, payload: TPayload, metadata?: Record<string, unknown>, lifecycle?: string): SkipoCommand<TPayload>;
-    dispatch<TPayload = unknown>(type: string, payload: TPayload, options?: EnqueueOptions): Promise<ExecutionJob<TPayload>>;
-    propagateResult<TResult = unknown>(correlationId: string, result: ExecutionResult<TResult>): void;
-    close(): Promise<void>;
-}
-declare const SKIPO_EXECUTION: SkipoExecutionEngine;
-
-/**
- * @file hooks.ts
- * @description React integration hooks for SKIPO_EXECUTION.
- * Routes all frontend mutations through BullMQ commands and reflects updates into SKIPO_STATE.
- */
-
-interface CommandExecutionState<TResult = unknown> {
-    status: 'IDLE' | 'QUEUED' | 'RUNNING' | 'COMPLETED' | 'FAILED';
-    correlationId?: string;
-    data?: TResult;
-    error?: string;
-    completedAt?: number;
-}
-declare function useCommand<TPayload = unknown, TResult = unknown>(type: string, defaultOptions?: EnqueueOptions): {
-    dispatch: (payload: TPayload, options?: Partial<EnqueueOptions>) => Promise<ExecutionJob<TPayload>>;
-    status: "QUEUED" | "RUNNING" | "COMPLETED" | "FAILED" | "IDLE";
-    isPending: boolean;
-    result: TResult;
-    error: string;
-    correlationId: string;
-};
-
-export { BullMQAdapter, type BullMQAdapterOptions, CommandBus, type CommandExecutionState, type EnqueueOptions, type ExecutionJob, type ExecutionQueueAdapter, type ExecutionResult, type JobPriority, type JobStatus, type RetryPolicy, SKIPO_EXECUTION, type SkipoCommand, SkipoExecutionEngine, useCommand };