@ultrst-armada/kloks 1.4.3 → 1.4.4

package/packages/backend/dist/chunk-VQEFULWT.js

@@ -1,88 +0,0 @@
-import {
-  JobScheduler
-} from "./chunk-UPFKBBQI.js";
-
-// src/execution/OperationComponent.ts
-function createOperationComponent(name, handler) {
-  return {
-    name,
-    async execute(input) {
-      try {
-        return await handler(input);
-      } catch (err) {
-        throw new Error(
-          `[OperationComponent:${name}] Execution failure: ${err?.message || String(err)}`
-        );
-      }
-    }
-  };
-}
-
-// src/execution/ServiceDispatcher.ts
-var ServiceDispatcher = class {
-  constructor(name) {
-    this.name = name;
-  }
-  name;
-  operations = {};
-  registerOperation(opName, operation) {
-    this.operations[opName] = operation;
-    return this;
-  }
-  async execute(operationName, input) {
-    const op = this.operations[operationName];
-    if (!op) {
-      throw new Error(
-        `[ServiceDispatcher:${this.name}] Operation "${operationName}" not found.`
-      );
-    }
-    return await op.execute(input);
-  }
-};
-
-// src/execution/DependencyOrdering.ts
-var JobDependencyGraph = class {
-  scheduler;
-  constructor(maxConcurrency = 5) {
-    this.scheduler = new JobScheduler(maxConcurrency);
-  }
-  registerHandler(type, handler) {
-    this.scheduler.registerHandler(type, (job) => handler(job));
-    return this;
-  }
-  submitJob(type, payload, dependencies = [], idempotencyKey) {
-    return this.scheduler.submit({
-      type,
-      payload,
-      dependencies,
-      correlationId: idempotencyKey
-    });
-  }
-  getJob(jobId) {
-    return this.scheduler.status(jobId);
-  }
-  clear() {
-    this.scheduler.clear();
-  }
-};
-
-// src/execution/ResultFlowBridge.ts
-var ResultFlowBridge = class {
-  static formatStateUpdate(result) {
-    return {
-      type: "SKIPO_STATE_UPDATE",
-      correlationId: result.correlationId,
-      status: result.status,
-      data: result.data,
-      error: result.error,
-      timestamp: result.executionTimestamp
-    };
-  }
-};
-
-export {
-  createOperationComponent,
-  ServiceDispatcher,
-  JobDependencyGraph,
-  ResultFlowBridge
-};

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
-};