@ultrst-armada/kloks 1.2.1 → 1.4.0

package/packages/client/dist/index.js

@@ -0,0 +1,62 @@
+// src/browserExecutionClient.ts
+var BrowserExecutionClient = class {
+  gatewayUrl;
+  headers;
+  timeoutMs;
+  constructor(options = {}) {
+    this.gatewayUrl = options.gatewayUrl || "/api/queue";
+    this.headers = options.headers || { "Content-Type": "application/json" };
+    this.timeoutMs = options.timeoutMs || 15e3;
+  }
+  createCommand(type, payload, options = {}) {
+    const correlationId = options.correlationId || `corr_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`;
+    return {
+      id: `cmd_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+      type,
+      payload,
+      metadata: options.metadata,
+      correlationId,
+      idempotencyKey: options.idempotencyKey,
+      createdAt: Date.now()
+    };
+  }
+  async enqueue(command) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      const res = await fetch(`${this.gatewayUrl}/enqueue`, {
+        method: "POST",
+        headers: this.headers,
+        body: JSON.stringify(command),
+        signal: controller.signal
+      });
+      if (!res.ok) {
+        throw new Error(`[BrowserExecutionClient] Enqueue failed: HTTP ${res.status}`);
+      }
+      const data = await res.json();
+      return {
+        jobId: data.jobId || command.id,
+        correlationId: command.correlationId
+      };
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async checkStatus(jobId) {
+    const res = await fetch(`${this.gatewayUrl}/status/${encodeURIComponent(jobId)}`, {
+      method: "GET",
+      headers: this.headers
+    });
+    if (!res.ok) {
+      throw new Error(`[BrowserExecutionClient] Check status failed: HTTP ${res.status}`);
+    }
+    return await res.json();
+  }
+};
+function createBrowserExecutionClient(options) {
+  return new BrowserExecutionClient(options);
+}
+export {
+  BrowserExecutionClient,
+  createBrowserExecutionClient
+};

package/packages/client/package.json

@@ -0,0 +1,41 @@
+{
+  "name": "@kloks/client",
+  "version": "1.0.0",
+  "description": "Kloks Browser-Safe Execution Client & Shared Contracts with Zero Server Closure",
+  "type": "module",
+  "private": false,
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "skipoManifest": "./kloks.manifest.json",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts --clean --external react --external zod",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist"
+  },
+  "dependencies": {
+    "zod": "^3.24.1"
+  },
+  "peerDependencies": {
+    "react": "^18.0.0 || ^19.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@ultrst-armada/krnl": "^1.0.0"
+  }
+}

package/packages/state-graph/dist/index.js

@@ -14,6 +14,20 @@ import {
   useCommand
 } from "./chunk-ZTHBPV24.js";
 import "./chunk-RHRXPY2U.js";
+import {
+  CommandApi,
+  GhostStore,
+  GraphStore
+} from "./chunk-4UVGXFEM.js";
+import {
+  BaseGraph,
+  BaseNode,
+  BaseViewWindow,
+  CustomGraph,
+  CustomNode,
+  CustomViewWindow,
+  DEFAULT_GRAPH_SETTINGS
+} from "./chunk-KG6QYS26.js";
 import {
   AttractionEngine,
   GhostInferenceEngine,
@@ -29,20 +43,6 @@ import {
   WireTypeRegistry,
   initializeDefaultGraphRules
 } from "./chunk-TZOL3RN7.js";
-import {
-  CommandApi,
-  GhostStore,
-  GraphStore
-} from "./chunk-4UVGXFEM.js";
-import {
-  BaseGraph,
-  BaseNode,
-  BaseViewWindow,
-  CustomGraph,
-  CustomNode,
-  CustomViewWindow,
-  DEFAULT_GRAPH_SETTINGS
-} from "./chunk-KG6QYS26.js";
 import {
   AutoSolidify,
   SpatialEngine,

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

@@ -1,124 +0,0 @@
-// src/workspace/WorkspaceFS.ts
-import { SkipoBase } from "@ultrst-armada/kloks/functions";
-var WorkspaceFS = class extends SkipoBase {
-  primary;
-  syncEngine;
-  config;
-  constructor(primary, config, syncEngine) {
-    super();
-    this.primary = primary;
-    this.config = config;
-    this.syncEngine = syncEngine;
-  }
-  setPrimary(newPrimary) {
-    this.primary = newPrimary;
-  }
-  setSyncEngine(engine) {
-    this.syncEngine = engine;
-  }
-  async exists(pathStr) {
-    return this.primary.exists(pathStr);
-  }
-  async stat(pathStr) {
-    return this.primary.stat(pathStr);
-  }
-  async list(pathStr = "") {
-    return this.primary.list(pathStr);
-  }
-  async read(pathStr) {
-    return this.primary.read(pathStr);
-  }
-  async readText(pathStr) {
-    const data = await this.read(pathStr);
-    return Buffer.from(data).toString("utf8");
-  }
-  async write(pathStr, data) {
-    await this.primary.write(pathStr, data);
-    if (this.syncEngine && this.config.sync?.enabled && this.config.sync.mode === "on_write") {
-      this.syncEngine.syncFile(pathStr).catch((err) => {
-        console.warn(`[WorkspaceFS] Async backup sync warning for '${pathStr}':`, err.message);
-      });
-    }
-  }
-  async mkdir(pathStr) {
-    await this.primary.mkdir(pathStr);
-  }
-  async delete(pathStr) {
-    await this.primary.delete(pathStr);
-    if (this.syncEngine && this.config.sync?.enabled && this.config.sync.deletePropagation) {
-      this.syncEngine.deleteFile(pathStr).catch((err) => {
-        console.warn(`[WorkspaceFS] Async delete sync warning for '${pathStr}':`, err.message);
-      });
-    }
-  }
-};
-
-// src/workspace/SyncEngine.ts
-import { SkipoBase as SkipoBase2 } from "@ultrst-armada/kloks/functions";
-var SyncEngine = class extends SkipoBase2 {
-  primary;
-  backups;
-  config;
-  constructor(primary, backups, config) {
-    super({ name: "SyncEngine" });
-    this.primary = primary;
-    this.backups = backups;
-    this.config = config;
-  }
-  async syncFile(pathStr) {
-    const data = await this.primary.read(pathStr);
-    for (const backup of this.backups) {
-      try {
-        await backup.write(pathStr, data);
-      } catch (e) {
-        console.error(`[SyncEngine] Failed to sync ${pathStr} to backup:`, e.message);
-      }
-    }
-  }
-  async deleteFile(pathStr) {
-    for (const backup of this.backups) {
-      try {
-        await backup.delete(pathStr);
-      } catch (e) {
-        console.error(`[SyncEngine] Failed to delete ${pathStr} on backup:`, e.message);
-      }
-    }
-  }
-};
-
-// src/workspace/WorkspaceCloneSyncEngine.ts
-import { SkipoBase as SkipoBase3 } from "@ultrst-armada/kloks/functions";
-var WorkspaceCloneSyncEngine = class extends SkipoBase3 {
-  constructor() {
-    super({ name: "WorkspaceCloneSyncEngine" });
-  }
-  async replicateToClones(files, clones, uploadFn) {
-    const results = [];
-    let totalSynced = 0;
-    const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-    for (const clone of clones) {
-      try {
-        let count = 0;
-        for (const file of files) {
-          await uploadFn(clone, file.relPath, file.content, file.contentType);
-          count++;
-        }
-        clone.lastSyncedAt = nowIso;
-        clone.filesSynced = count;
-        clone.status = "SYNCED";
-        results.push({ cloneId: clone.id, label: clone.label, provider: clone.provider, filesSynced: count, status: "SYNCED" });
-        totalSynced += count;
-      } catch (err) {
-        clone.status = "ERROR";
-        results.push({ cloneId: clone.id, label: clone.label, provider: clone.provider, filesSynced: 0, status: "ERROR", error: err.message });
-      }
-    }
-    return { results, totalSynced };
-  }
-};
-
-export {
-  WorkspaceFS,
-  SyncEngine,
-  WorkspaceCloneSyncEngine
-};

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

@@ -1,149 +0,0 @@
-import {
-  createService,
-  createServiceDefinition,
-  createServiceProxy
-} from "./chunk-IPP4VURQ.js";
-
-// src/services/ServiceBoundary.ts
-function createLocalService(definition) {
-  return createService(createServiceDefinition(definition));
-}
-function createRemoteService(definition, adapter, endpoint) {
-  return createServiceProxy(definition, adapter, endpoint);
-}
-
-// src/services/CompositeBackend.ts
-var CompositeBackend = class {
-  id;
-  name;
-  version;
-  services = /* @__PURE__ */ new Map();
-  capabilitiesList = [];
-  constructor(name, version = "1.0.0") {
-    this.name = name;
-    this.id = `backend-${name}`;
-    this.version = version;
-  }
-  registerService(service) {
-    this.services.set(service.name, service);
-    return this;
-  }
-  getService(name) {
-    return this.services.get(name);
-  }
-  getServices() {
-    return Array.from(this.services.values());
-  }
-  registerCapability(capability) {
-    if (!this.capabilitiesList.includes(capability)) {
-      this.capabilitiesList.push(capability);
-    }
-    return this;
-  }
-  async start() {
-    for (const service of this.services.values()) {
-      await service.start();
-    }
-  }
-  async stop() {
-    for (const service of this.services.values()) {
-      await service.stop();
-    }
-  }
-  async call(op, input, ctx) {
-    const firstDot = op.indexOf(".");
-    if (firstDot === -1) {
-      throw new Error(`[CompositeBackend] Invalid operation '${op}'. Expected 'service.operation'.`);
-    }
-    const serviceName = op.slice(0, firstDot);
-    const operationName = op.slice(firstDot + 1);
-    const service = this.services.get(serviceName);
-    if (!service) {
-      throw new Error(`[CompositeBackend] Service '${serviceName}' not registered in '${this.name}'.`);
-    }
-    return await service.call(operationName, input, ctx);
-  }
-  getState() {
-    const aggregated = {};
-    for (const [name, service] of this.services) {
-      aggregated[name] = service.getState();
-    }
-    return Object.freeze(aggregated);
-  }
-  setState(_mutation) {
-  }
-  on(event, handler) {
-    const [serviceName, eventName] = event.split(".");
-    const service = this.services.get(serviceName);
-    if (!service) return () => {
-    };
-    return service.on(eventName, handler);
-  }
-  emit(event, payload) {
-    const [serviceName, eventName] = event.split(".");
-    const service = this.services.get(serviceName);
-    if (service) {
-      service.emit(eventName, payload);
-    }
-  }
-  getDefinition() {
-    const ops = {};
-    for (const service of this.services.values()) {
-      const def = service.getDefinition();
-      for (const [opKey, opDef] of Object.entries(def.operations)) {
-        ops[`${service.name}.${opKey}`] = opDef;
-      }
-    }
-    return {
-      id: this.id,
-      name: this.name,
-      version: this.version,
-      operations: ops,
-      capabilities: this.capabilitiesList.map((c) => ({
-        id: c,
-        name: c,
-        protocols: ["http", "ws", "udp", "p2p"]
-      })),
-      protocols: ["http", "ws", "udp", "p2p"]
-    };
-  }
-};
-
-// src/services/EndpointGenerator.ts
-var EndpointGenerator = class {
-  static generateEndpoints(backend, basePort = 8e3) {
-    const def = backend.getDefinition();
-    const ops = Object.keys(def.operations);
-    return {
-      httpRoutes: ops.map((op) => `/api/${op.replace(".", "/")}`),
-      wsChannels: ops.map((op) => `channel:${op}`),
-      udpEndpoints: [`udp://127.0.0.1:${basePort}`],
-      p2pBindings: ops.map((op) => `p2p://${backend.name}/${op}`)
-    };
-  }
-  static generateDescriptors(backend, host = "127.0.0.1", port = 8080) {
-    return [
-      { protocol: "http", address: host, port, capabilities: ["requestResponse"] },
-      { protocol: "ws", address: host, port, capabilities: ["requestResponse", "pubSub"] },
-      { protocol: "udp", address: host, port, capabilities: ["datagram"] },
-      { protocol: "p2p", address: `p2p://${backend.name}`, capabilities: ["peerToPeer"] }
-    ];
-  }
-};
-
-// src/services/ServiceGenerators.ts
-function createBackend(name) {
-  return new CompositeBackend(name);
-}
-function createCompositeService(name) {
-  return new CompositeBackend(name);
-}
-
-export {
-  createLocalService,
-  createRemoteService,
-  CompositeBackend,
-  EndpointGenerator,
-  createBackend,
-  createCompositeService
-};

package/packages/backend/dist/{chunk-OYQKQAEF.js → chunk-CU7RZBMF.js}

@@ -1,3 +1,7 @@
+import {
+  createService,
+  createServiceDefinition
+} from "./chunk-IPP4VURQ.js";
 import {
   StorageAdapterFactory
 } from "./chunk-J2J24JVC.js";
@@ -13,10 +17,6 @@ import {
   ExecutableBackendFacade,
   WorkerExecutionBoundary
 } from "./chunk-QGHDJGYS.js";
-import {
-  createService,
-  createServiceDefinition
-} from "./chunk-IPP4VURQ.js";
 
 // src/krnl-services.ts
 var AuthServiceDefinition = createServiceDefinition({