@ultrst-armada/kloks 1.4.3 → 1.4.4

package/packages/state-graph/kloks.manifest.json

@@ -13,8 +13,14 @@
         "export": "StateLifecycleServiceFacade",
         "facade": "StateLifecycleServiceFacade"
       },
-      "modes": ["backend"],
-      "targets": { "backend": ["BackendFacade.services"] }
+      "modes": [
+        "backend"
+      ],
+      "targets": {
+        "backend": [
+          "BackendFacade.services"
+        ]
+      }
     },
     {
       "id": "node-graph",
@@ -26,15 +32,25 @@
         "export": "NodeGraphEngineServiceFacade",
         "facade": "NodeGraphEngineServiceFacade"
       },
-      "ui": {
-        "package": "@floks/canvas-ui",
-        "components": ["InfiniteCanvas"]
-      },
-      "modes": ["backend", "fullstack"],
+      "modes": [
+        "backend",
+        "fullstack"
+      ],
       "targets": {
-        "backend": ["BackendFacade.services"],
-        "frontend": ["App.main-content"]
-      }
+        "backend": [
+          "BackendFacade.services"
+        ],
+        "frontend": [
+          "App.main-content"
+        ]
+      },
+      "defaultFrontend": {
+        "component": "FrnlEditableNodeGraph",
+        "package": "@ultrst-armada/floks/canvas-ui",
+        "export": "FrnlEditableNodeGraph",
+        "relationship": "recommended"
+      },
+      "dependencies": []
     }
   ]
 }

package/packages/state-graph/package.json

@@ -23,11 +23,6 @@
       "types": "./dist/state/index.d.ts",
       "default": "./dist/state/index.js"
     },
-    "./execution": {
-      "import": "./dist/execution/index.js",
-      "types": "./dist/execution/index.d.ts",
-      "default": "./dist/execution/index.js"
-    },
     "./domain": {
       "import": "./dist/domain/index.js",
       "types": "./dist/domain/index.d.ts",
@@ -50,13 +45,12 @@
     }
   },
   "scripts": {
-    "build": "tsup src/index.ts src/state/index.ts src/execution/index.ts src/domain/index.ts src/rules/index.ts src/spatial/index.ts src/store/index.ts --format esm --dts --clean --external zustand --external bullmq --external react --external ws",
+    "build": "tsup src/index.ts src/state/index.ts src/domain/index.ts src/rules/index.ts src/spatial/index.ts src/store/index.ts --format esm --dts --clean --external zustand --external react --external ws",
     "typecheck": "tsc --noEmit",
     "clean": "rm -rf dist"
   },
   "dependencies": {
     "@kloks/functions": "workspace:*",
-    "bullmq": "^6.3.8",
     "zustand": "^5.0.15"
   },
   "peerDependencies": {
@@ -68,6 +62,6 @@
     }
   },
   "devDependencies": {
-    "@ultrst-armada/krnl": "^1.0.2"
+    "@ultrst-armada/krnl": "^1.0.3"
   }
 }

package/packages/backend/dist/IdempotencyManager-B5MjK871.d.ts

@@ -1,16 +0,0 @@
-/**
- * @file IdempotencyManager.ts
- * @description In-flight mutation deduplication, concurrent attachment, and completed result caching.
- */
-declare class IdempotencyManager {
-    private inFlight;
-    private completedCache;
-    private ttlMs;
-    constructor(ttlMs?: number);
-    executeIdempotent<T>(idempotencyKey: string, operation: () => Promise<T>): Promise<T>;
-    has(idempotencyKey: string): boolean;
-    prune(): void;
-    clear(): void;
-}
-
-export { IdempotencyManager as I };

package/packages/backend/dist/chunk-25Y7AVTP.js

@@ -1,55 +0,0 @@
-// src/auth/SessionManager.ts
-var SessionManager = class {
-  ttl;
-  constructor(ttlMs = 864e5) {
-    this.ttl = ttlMs;
-  }
-  generateToken(userId) {
-    return `sess::${userId}::${Date.now()}::${Math.random().toString(36).substring(2, 9)}`;
-  }
-  createSession(userId, role) {
-    return {
-      token: this.generateToken(userId),
-      userId,
-      role,
-      expiresAt: Date.now() + this.ttl
-    };
-  }
-  isValid(session) {
-    return Date.now() < session.expiresAt;
-  }
-};
-
-// src/auth/RateLimiter.ts
-var RateLimiter = class {
-  attempts = /* @__PURE__ */ new Map();
-  windowMs;
-  maxUser;
-  maxAdmin;
-  constructor(windowMs = 9e5, maxUser = 5, maxAdmin = 3) {
-    this.windowMs = windowMs;
-    this.maxUser = maxUser;
-    this.maxAdmin = maxAdmin;
-  }
-  check(identifier, isAdminAttempt = false) {
-    const now = Date.now();
-    let record = this.attempts.get(identifier);
-    if (!record || now - record.windowStart > this.windowMs) {
-      record = { count: 0, windowStart: now };
-      this.attempts.set(identifier, record);
-    }
-    record.count++;
-    const limit = isAdminAttempt ? this.maxAdmin : this.maxUser;
-    if (record.count > limit) {
-      throw new Error("Too many requests. Please try again later.");
-    }
-  }
-  reset(identifier) {
-    this.attempts.delete(identifier);
-  }
-};
-
-export {
-  SessionManager,
-  RateLimiter
-};

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