@ultrst-armada/kloks 1.4.2 → 1.4.4

package/packages/backend/dist/chunk-3EPY34R6.js

@@ -1,67 +0,0 @@
-// src/connectivity/IdempotencyManager.ts
-var IdempotencyManager = class {
-  inFlight = /* @__PURE__ */ new Map();
-  completedCache = /* @__PURE__ */ new Map();
-  ttlMs;
-  constructor(ttlMs = 6e4) {
-    this.ttlMs = ttlMs;
-  }
-  async executeIdempotent(idempotencyKey, operation) {
-    const cached = this.completedCache.get(idempotencyKey);
-    if (cached) {
-      if (Date.now() - cached.timestamp < this.ttlMs) {
-        if (cached.status === "completed") {
-          return cached.result;
-        }
-        throw new Error(cached.error || "[IdempotencyManager] Previous execution failed.");
-      } else {
-        this.completedCache.delete(idempotencyKey);
-      }
-    }
-    const existingFlight = this.inFlight.get(idempotencyKey);
-    if (existingFlight) {
-      return await existingFlight;
-    }
-    const executionPromise = (async () => {
-      try {
-        const result = await operation();
-        this.completedCache.set(idempotencyKey, {
-          status: "completed",
-          result,
-          timestamp: Date.now()
-        });
-        return result;
-      } catch (err) {
-        this.completedCache.set(idempotencyKey, {
-          status: "failed",
-          error: err?.message || String(err),
-          timestamp: Date.now()
-        });
-        throw err;
-      } finally {
-        this.inFlight.delete(idempotencyKey);
-      }
-    })();
-    this.inFlight.set(idempotencyKey, executionPromise);
-    return await executionPromise;
-  }
-  has(idempotencyKey) {
-    return this.inFlight.has(idempotencyKey) || this.completedCache.has(idempotencyKey);
-  }
-  prune() {
-    const now = Date.now();
-    for (const [key, entry] of this.completedCache.entries()) {
-      if (now - entry.timestamp > this.ttlMs) {
-        this.completedCache.delete(key);
-      }
-    }
-  }
-  clear() {
-    this.inFlight.clear();
-    this.completedCache.clear();
-  }
-};
-
-export {
-  IdempotencyManager
-};

package/packages/backend/dist/chunk-7KNGX522.js

@@ -1,220 +0,0 @@
-// ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.2/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js
-var ServiceStateStore = class {
-  state;
-  listeners = /* @__PURE__ */ new Set();
-  constructor(initialState) {
-    this.state = { ...initialState };
-  }
-  getState() {
-    return Object.freeze({ ...this.state });
-  }
-  setState(mutation) {
-    this.state = { ...this.state, ...mutation };
-    const snapshot = this.getState();
-    for (const listener of this.listeners) {
-      listener(snapshot, mutation);
-    }
-  }
-  subscribe(listener) {
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  }
-  reset(newState) {
-    this.state = { ...newState || {} };
-  }
-};
-var ServiceEventBus = class {
-  handlers = /* @__PURE__ */ new Map();
-  on(event, handler) {
-    if (!this.handlers.has(event)) {
-      this.handlers.set(event, /* @__PURE__ */ new Set());
-    }
-    const set = this.handlers.get(event);
-    set.add(handler);
-    return () => {
-      set.delete(handler);
-    };
-  }
-  emit(event, payload) {
-    const set = this.handlers.get(event);
-    if (!set) return;
-    for (const handler of Array.from(set)) {
-      try {
-        handler(payload);
-      } catch (err) {
-        console.error(`[ServiceEventBus] Handler error for '${event}':`, err);
-      }
-    }
-  }
-  clear() {
-    this.handlers.clear();
-  }
-};
-var LifecycleManager = class {
-  status = "uninitialized";
-  getStatus() {
-    return this.status;
-  }
-  setStatus(next) {
-    this.status = next;
-  }
-  assertRunning(serviceName) {
-    if (this.status !== "running") {
-      throw new Error(`[Service:${serviceName}] Cannot invoke operation while status is '${this.status}' (expected 'running').`);
-    }
-  }
-};
-var ServiceInstance = class {
-  constructor(definition) {
-    this.definition = definition;
-    this.id = definition.id;
-    this.name = definition.name;
-    this.version = definition.version;
-    this.lifecycle = new LifecycleManager();
-    this.eventBus = new ServiceEventBus();
-    if (definition.state?.initial) {
-      this.stateStore = new ServiceStateStore(definition.state.initial);
-    }
-  }
-  definition;
-  id;
-  name;
-  version;
-  stateStore;
-  eventBus;
-  lifecycle;
-  getDefinition() {
-    return this.definition;
-  }
-  async start() {
-    this.lifecycle.setStatus("starting");
-    if (this.definition.lifecycle?.onInit) {
-      await this.definition.lifecycle.onInit();
-    }
-    if (this.definition.lifecycle?.onStart) {
-      await this.definition.lifecycle.onStart();
-    }
-    this.lifecycle.setStatus("running");
-  }
-  async stop() {
-    this.lifecycle.setStatus("stopping");
-    if (this.definition.lifecycle?.onStop) {
-      await this.definition.lifecycle.onStop();
-    }
-    if (this.definition.lifecycle?.onDispose) {
-      await this.definition.lifecycle.onDispose();
-    }
-    this.lifecycle.setStatus("stopped");
-  }
-  async call(op, input, ctx = {}) {
-    this.lifecycle.assertRunning(this.name);
-    const operation = this.definition.operations[op];
-    if (!operation) {
-      throw new Error(`[Service:${this.name}] Operation '${op}' not found.`);
-    }
-    return await operation.handler(input, ctx);
-  }
-  getState() {
-    if (!this.stateStore) {
-      return Object.freeze({});
-    }
-    return this.stateStore.getState();
-  }
-  setState(mutation) {
-    if (!this.stateStore) {
-      this.stateStore = new ServiceStateStore(mutation);
-      return;
-    }
-    this.stateStore.setState(mutation);
-  }
-  on(event, handler) {
-    return this.eventBus.on(event, handler);
-  }
-  emit(event, payload) {
-    this.eventBus.emit(event, payload);
-  }
-};
-var ServiceProxy = class {
-  constructor(definition, adapter, endpoint) {
-    this.definition = definition;
-    this.adapter = adapter;
-    this.endpoint = endpoint;
-    this.id = definition.id;
-    this.name = definition.name;
-    this.version = definition.version;
-    this.stateCache = definition.state?.initial || {};
-  }
-  definition;
-  adapter;
-  endpoint;
-  id;
-  name;
-  version;
-  stateCache;
-  eventHandlers = /* @__PURE__ */ new Map();
-  getDefinition() {
-    return this.definition;
-  }
-  async start() {
-  }
-  async stop() {
-  }
-  async call(op, input, ctx = {}) {
-    if (!this.adapter.send) {
-      throw new Error(`[ServiceProxy:${this.name}] Adapter does not support send().`);
-    }
-    const envelope = {
-      id: `req-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`,
-      type: "request",
-      operation: op,
-      payload: input,
-      timestamp: Date.now()
-    };
-    const response = await this.adapter.send(this.endpoint, envelope);
-    if (response.error) {
-      throw new Error(`[ServiceProxy:${this.name}] Remote error: ${response.error}`);
-    }
-    return response.payload;
-  }
-  getState() {
-    return Object.freeze({ ...this.stateCache });
-  }
-  setState(mutation) {
-    this.stateCache = { ...this.stateCache, ...mutation };
-  }
-  on(event, handler) {
-    if (!this.eventHandlers.has(event)) {
-      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
-    }
-    const handlers = this.eventHandlers.get(event);
-    handlers.add(handler);
-    return () => {
-      handlers.delete(handler);
-    };
-  }
-  emit(event, payload) {
-    const handlers = this.eventHandlers.get(event);
-    if (handlers) {
-      for (const handler of Array.from(handlers)) {
-        handler(payload);
-      }
-    }
-  }
-};
-function createServiceDefinition(definition) {
-  return definition;
-}
-function createService(definition) {
-  return new ServiceInstance(definition);
-}
-function createServiceProxy(definition, adapter, endpoint) {
-  return new ServiceProxy(definition, adapter, endpoint);
-}
-
-export {
-  createServiceDefinition,
-  createService,
-  createServiceProxy
-};

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

@@ -1,15 +0,0 @@
-// src/workspace/WorkspaceCanonical.ts
-function formatCanonicalWorkspaceFolderName(appName, userName, workspaceName) {
-  const safeApp = appName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  const safeUser = userName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  const safeWs = workspaceName.replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  return `ultrst_${safeApp}_${safeUser}_${safeWs}`;
-}
-function sanitizeWorkspaceName(name) {
-  return name.replace(/[^a-zA-Z0-9-_\s]/g, "").trim();
-}
-
-export {
-  formatCanonicalWorkspaceFolderName,
-  sanitizeWorkspaceName
-};

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

@@ -1,92 +0,0 @@
-import {
-  IdempotencyManager
-} from "./chunk-3EPY34R6.js";
-
-// src/execution/BackendFacade.ts
-var ExecutableBackendFacade = class {
-  constructor(name, idempotency) {
-    this.name = name;
-    this.idempotency = idempotency || new IdempotencyManager();
-  }
-  name;
-  services = /* @__PURE__ */ new Map();
-  idempotency;
-  registerService(service) {
-    this.services.set(service.name, service);
-    return this;
-  }
-  async executeCommand(command, context) {
-    const startTime = Date.now();
-    if (!context || !context.isWorkerContext) {
-      return {
-        correlationId: command.correlationId,
-        status: "FAILED",
-        error: "[BackendFacade] DIRECT_COMPONENT -> BACKEND_FACADE is strictly FORBIDDEN. Access allowed for WORKER_ONLY.",
-        executionTimestamp: startTime
-      };
-    }
-    const runCore = async () => {
-      try {
-        const parts = command.type.split(".");
-        if (parts.length < 2) {
-          throw new Error(
-            `[BackendFacade] Invalid command type "${command.type}". Expected "service.operation".`
-          );
-        }
-        const [serviceName, operationName] = parts;
-        const service = this.services.get(serviceName);
-        if (!service) {
-          throw new Error(`[BackendFacade] Service "${serviceName}" not registered.`);
-        }
-        const data = await service.execute(operationName, command.payload);
-        return {
-          correlationId: command.correlationId,
-          status: "COMPLETED",
-          data,
-          executionTimestamp: Date.now()
-        };
-      } catch (err) {
-        return {
-          correlationId: command.correlationId,
-          status: "FAILED",
-          error: err?.message || String(err),
-          executionTimestamp: Date.now()
-        };
-      }
-    };
-    if (command.idempotencyKey) {
-      return await this.idempotency.executeIdempotent(command.idempotencyKey, runCore);
-    }
-    return await runCore();
-  }
-};
-
-// src/execution/WorkerExecutionBoundary.ts
-var WorkerExecutionBoundary = class {
-  constructor(workerId, facade) {
-    this.workerId = workerId;
-    this.facade = facade;
-  }
-  workerId;
-  facade;
-  async processJob(command) {
-    const context = {
-      isWorkerContext: true,
-      workerId: this.workerId,
-      timestamp: Date.now()
-    };
-    return await this.facade.executeCommand(command, context);
-  }
-  static assertWorkerContext(context) {
-    if (!context || !context.isWorkerContext) {
-      throw new Error(
-        "[WorkerExecutionBoundary] Violation: DIRECT_COMPONENT -> BACKEND_FACADE is forbidden. Only BullMQ Workers may execute backend commands."
-      );
-    }
-  }
-};
-
-export {
-  ExecutableBackendFacade,
-  WorkerExecutionBoundary
-};

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

@@ -1,138 +0,0 @@
-// src/connectivity/JobScheduler.ts
-var JobScheduler = class {
-  jobs = /* @__PURE__ */ new Map();
-  handlers = /* @__PURE__ */ new Map();
-  sequenceCounters = /* @__PURE__ */ new Map();
-  activeCount = 0;
-  maxConcurrency;
-  paused = false;
-  constructor(maxConcurrency = 5) {
-    this.maxConcurrency = maxConcurrency;
-  }
-  registerHandler(type, handler) {
-    this.handlers.set(type, handler);
-    return this;
-  }
-  submit(input) {
-    const id = input.id || `job-${Date.now()}-${Math.random().toString(36).slice(2, 7)}`;
-    const streamKey = input.sequenceKey || "default";
-    const seq = (this.sequenceCounters.get(streamKey) ?? 0) + 1;
-    this.sequenceCounters.set(streamKey, seq);
-    const job = {
-      id,
-      type: input.type,
-      payload: input.payload,
-      priority: input.priority || "NORMAL",
-      sequence: seq,
-      sequenceKey: streamKey,
-      dependencies: input.dependencies || [],
-      sessionId: input.sessionId,
-      correlationId: input.correlationId,
-      state: "PENDING",
-      progress: 0,
-      createdAt: Date.now(),
-      updatedAt: Date.now()
-    };
-    this.jobs.set(id, job);
-    this.checkAndQueue(job);
-    this.drainQueue();
-    return job;
-  }
-  checkAndQueue(job) {
-    if (job.state !== "PENDING") return false;
-    const depsResolved = (job.dependencies || []).every((depId) => {
-      const dep = this.jobs.get(depId);
-      return dep && dep.state === "COMPLETED";
-    });
-    if (depsResolved) {
-      job.state = "QUEUED";
-      job.updatedAt = Date.now();
-      return true;
-    }
-    return false;
-  }
-  priorityWeight(priority) {
-    switch (priority) {
-      case "CRITICAL":
-        return 4;
-      case "HIGH":
-        return 3;
-      case "NORMAL":
-        return 2;
-      case "LOW":
-        return 1;
-      default:
-        return 2;
-    }
-  }
-  async drainQueue() {
-    if (this.paused || this.activeCount >= this.maxConcurrency) return;
-    const queuedJobs = Array.from(this.jobs.values()).filter((j) => j.state === "QUEUED").sort((a, b) => this.priorityWeight(b.priority) - this.priorityWeight(a.priority) || (a.sequence || 0) - (b.sequence || 0));
-    for (const job of queuedJobs) {
-      if (this.activeCount >= this.maxConcurrency) break;
-      this.executeJob(job);
-    }
-  }
-  async executeJob(job) {
-    const handler = this.handlers.get(job.type);
-    if (!handler) {
-      job.state = "FAILED";
-      job.error = `[JobScheduler] No registered handler for job type "${job.type}".`;
-      job.updatedAt = Date.now();
-      return;
-    }
-    this.activeCount++;
-    job.state = "RUNNING";
-    job.updatedAt = Date.now();
-    const progressCallback = (progress) => {
-      job.progress = Math.min(100, Math.max(0, progress));
-      job.updatedAt = Date.now();
-    };
-    try {
-      job.result = await handler(job, progressCallback);
-      job.state = "COMPLETED";
-      job.progress = 100;
-    } catch (err) {
-      job.state = "FAILED";
-      job.error = err?.message || String(err);
-    } finally {
-      job.updatedAt = Date.now();
-      this.activeCount--;
-      for (const pendingJob of this.jobs.values()) {
-        if (pendingJob.dependencies?.includes(job.id)) {
-          this.checkAndQueue(pendingJob);
-        }
-      }
-      this.drainQueue();
-    }
-  }
-  cancel(jobId) {
-    const job = this.jobs.get(jobId);
-    if (!job || job.state === "COMPLETED" || job.state === "FAILED") return false;
-    job.state = "CANCELLED";
-    job.updatedAt = Date.now();
-    return true;
-  }
-  pause() {
-    this.paused = true;
-  }
-  resume() {
-    this.paused = false;
-    this.drainQueue();
-  }
-  status(jobId) {
-    return this.jobs.get(jobId);
-  }
-  getAllJobs() {
-    return Array.from(this.jobs.values());
-  }
-  clear() {
-    this.jobs.clear();
-    this.sequenceCounters.clear();
-    this.activeCount = 0;
-  }
-};
-
-export {
-  JobScheduler
-};

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