@ultrst-armada/kloks 1.3.0 → 1.4.1

package/packages/backend/dist/krnl-services.js

@@ -13,8 +13,8 @@ import {
   StorageServiceFacade,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade
-} from "./chunk-CU7RZBMF.js";
-import "./chunk-IPP4VURQ.js";
+} from "./chunk-FO6WYLW4.js";
+import "./chunk-7KNGX522.js";
 import "./chunk-J2J24JVC.js";
 import "./chunk-FZKBTF34.js";
 import "./chunk-25Y7AVTP.js";

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

@@ -11,8 +11,8 @@ import {
   nodeGraphPersistence,
   parseGraphJsonFile,
   validateGraphDocument
-} from "../chunk-BM4QMVPA.js";
-import "../chunk-IPP4VURQ.js";
+} from "../chunk-XTWHEZWS.js";
+import "../chunk-7KNGX522.js";
 export {
   CompositeBackend,
   EndpointGenerator,

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

@@ -108,4 +108,122 @@ declare class WorkspaceCloneSyncEngine extends SkipoBase {
     }>;
 }
 
-export { type CloneReplicationResult, type ConflictPolicy, SyncEngine, type SyncState, WorkspaceCloneSyncEngine, type WorkspaceConfig, type WorkspaceDescriptor, WorkspaceFS, type WorkspaceSecondaryClone, type WorkspaceSyncSummary, formatCanonicalWorkspaceFolderName, sanitizeWorkspaceName };
+/**
+ * @file WorkspaceService.ts
+ * @description Canonical WorkspaceService interface contract for Kloks backend.
+ * Governs remote-first (DEPM) and local working-workspace (QWNSR) architectures.
+ * Conforms to Skipo Governance (< 200 lines).
+ */
+
+interface WorkspaceFileEntry {
+    path: string;
+    name: string;
+    sizeBytes?: number;
+    updatedAt?: string | number;
+    isFolder?: boolean;
+}
+interface WorkspaceLookupResult {
+    user?: any;
+    workspace: any;
+    connection?: any;
+}
+interface WorkspaceListResult {
+    success: boolean;
+    workspaces: any[];
+    activeWorkspaceId?: string | null;
+    storage_connections?: any[];
+}
+interface WorkspaceMutationResult {
+    success: boolean;
+    workspace?: any;
+    workspaces?: any[];
+}
+interface WorkspaceService {
+    readonly type: 'remote' | 'working';
+    findWorkspace(workspaceId: string, env?: Record<string, unknown>): Promise<WorkspaceLookupResult>;
+    listWorkspaces(userId?: string, env?: Record<string, unknown>): Promise<WorkspaceListResult>;
+    createWorkspace(userId: string, data: any, env?: Record<string, unknown>): Promise<WorkspaceMutationResult>;
+    updateWorkspace(userId: string, params: any, env?: Record<string, unknown>): Promise<WorkspaceMutationResult>;
+    deleteWorkspace(userId: string, workspaceId: string, env?: Record<string, unknown>): Promise<{
+        success: boolean;
+        workspaces?: any[];
+    }>;
+    readFile(workspaceId: string, filePath: string, env?: Record<string, unknown>): Promise<Uint8Array | string>;
+    writeFile(workspaceId: string, filePath: string, content: Uint8Array | string, env?: Record<string, unknown>): Promise<{
+        success: boolean;
+        path: string;
+        sizeBytes?: number;
+    }>;
+    deleteFile(workspaceId: string, filePath: string, env?: Record<string, unknown>): Promise<{
+        success: boolean;
+    }>;
+    listFiles(workspaceId: string, subfolder?: string, env?: Record<string, unknown>): Promise<WorkspaceFileEntry[]>;
+    sync?(workspaceId: string, options?: any, env?: Record<string, unknown>): Promise<WorkspaceSyncSummary>;
+}
+
+/**
+ * @file RemoteWorkspaceService.ts
+ * @description Remote-first WorkspaceService implementation for Kloks.
+ * Directly mediates with authoritative remote storage (Backblaze B2/S3/DB) without requiring local working files.
+ * Canonical choice for DEPM. Conforms to Skipo Governance (< 200 lines).
+ */
+
+declare class RemoteWorkspaceService implements WorkspaceService {
+    readonly type: "remote";
+    findWorkspace(workspaceId: string, env?: Record<string, unknown>): Promise<WorkspaceLookupResult>;
+    listWorkspaces(userId?: string, env?: Record<string, unknown>): Promise<WorkspaceListResult>;
+    createWorkspace(userId: string, data: any, env?: Record<string, unknown>): Promise<WorkspaceMutationResult>;
+    updateWorkspace(userId: string, params: any, env?: Record<string, unknown>): Promise<WorkspaceMutationResult>;
+    deleteWorkspace(userId: string, workspaceId: string, env?: Record<string, unknown>): Promise<{
+        success: boolean;
+        workspaces?: any[];
+    }>;
+    readFile(workspaceId: string, filePath: string, env?: Record<string, unknown>): Promise<Uint8Array | string>;
+    writeFile(workspaceId: string, filePath: string, content: Uint8Array | string, env?: Record<string, unknown>): Promise<{
+        success: boolean;
+        path: string;
+        sizeBytes?: number;
+    }>;
+    deleteFile(workspaceId: string, filePath: string, env?: Record<string, unknown>): Promise<{
+        success: boolean;
+    }>;
+    listFiles(workspaceId: string, subfolder?: string, env?: Record<string, unknown>): Promise<WorkspaceFileEntry[]>;
+}
+declare const remoteWorkspaceService: RemoteWorkspaceService;
+
+/**
+ * @file WorkingWorkspaceService.ts
+ * @description Local Working-Workspace implementation for Kloks.
+ * Operates on a local working directory for fast low-latency I/O and explicitly
+ * synchronizes with authoritative remote storage (Backblaze B2/S3/DB).
+ * Canonical choice for QWNSR. Conforms to Skipo Governance (< 200 lines).
+ */
+
+declare class WorkingWorkspaceService implements WorkspaceService {
+    private workingDirResolver?;
+    readonly type: "working";
+    constructor(workingDirResolver?: () => string);
+    getWorkingDir(): string;
+    findWorkspace(workspaceId: string, env?: Record<string, unknown>): Promise<WorkspaceLookupResult>;
+    listWorkspaces(userId?: string, env?: Record<string, unknown>): Promise<WorkspaceListResult>;
+    createWorkspace(userId: string, data: any, env?: Record<string, unknown>): Promise<WorkspaceMutationResult>;
+    updateWorkspace(userId: string, params: any, env?: Record<string, unknown>): Promise<WorkspaceMutationResult>;
+    deleteWorkspace(userId: string, workspaceId: string, env?: Record<string, unknown>): Promise<{
+        success: boolean;
+        workspaces?: any[];
+    }>;
+    readFile(_workspaceId: string, filePath: string): Promise<Uint8Array | string>;
+    writeFile(_workspaceId: string, filePath: string, content: Uint8Array | string): Promise<{
+        success: boolean;
+        path: string;
+        sizeBytes?: number;
+    }>;
+    deleteFile(_workspaceId: string, filePath: string): Promise<{
+        success: boolean;
+    }>;
+    listFiles(_workspaceId: string, subfolder?: string): Promise<WorkspaceFileEntry[]>;
+    sync(workspaceId: string, _options?: any, _env?: Record<string, unknown>): Promise<WorkspaceSyncSummary>;
+}
+declare const workingWorkspaceService: WorkingWorkspaceService;
+
+export { type CloneReplicationResult, type ConflictPolicy, RemoteWorkspaceService, SyncEngine, type SyncState, WorkingWorkspaceService, WorkspaceCloneSyncEngine, type WorkspaceConfig, type WorkspaceDescriptor, WorkspaceFS, type WorkspaceFileEntry, type WorkspaceListResult, type WorkspaceLookupResult, type WorkspaceMutationResult, type WorkspaceSecondaryClone, type WorkspaceService, type WorkspaceSyncSummary, formatCanonicalWorkspaceFolderName, remoteWorkspaceService, sanitizeWorkspaceName, workingWorkspaceService };

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

@@ -1,16 +1,24 @@
 import {
+  RemoteWorkspaceService,
   SyncEngine,
+  WorkingWorkspaceService,
   WorkspaceCloneSyncEngine,
-  WorkspaceFS
-} from "../chunk-KTLD7Z4L.js";
+  WorkspaceFS,
+  remoteWorkspaceService,
+  workingWorkspaceService
+} from "../chunk-DZ4ZGIZM.js";
 import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
 } from "../chunk-FZKBTF34.js";
 export {
+  RemoteWorkspaceService,
   SyncEngine,
+  WorkingWorkspaceService,
   WorkspaceCloneSyncEngine,
   WorkspaceFS,
   formatCanonicalWorkspaceFolderName,
-  sanitizeWorkspaceName
+  remoteWorkspaceService,
+  sanitizeWorkspaceName,
+  workingWorkspaceService
 };

package/packages/backend/package.json

@@ -120,6 +120,6 @@
     }
   },
   "devDependencies": {
-    "@ultrst-armada/krnl": "^1.0.0"
+    "@ultrst-armada/krnl": "^1.0.2"
   }
 }

package/packages/client/dist/index.d.ts

@@ -0,0 +1,154 @@
+/**
+ * @file queueContracts.ts
+ * @description Pure browser-safe command, job, queue, and execution contracts.
+ * ZERO Node/server/BullMQ dependency closure.
+ * Conforms to Skipo Governance (< 200 lines).
+ */
+interface CorrelationMetadata {
+    correlationId: string;
+    idempotencyKey?: string;
+    timestamp: number;
+    source?: string;
+    traceId?: string;
+}
+interface BackendCommand<TPayload = unknown> {
+    id: string;
+    type: string;
+    payload: TPayload;
+    metadata?: Record<string, unknown>;
+    correlationId: string;
+    idempotencyKey?: string;
+    createdAt: number;
+}
+type JobStatus = 'QUEUED' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'RETRYING';
+type JobPriority = 'LOW' | 'NORMAL' | 'HIGH' | 'CRITICAL';
+interface RetryPolicy {
+    maxAttempts: number;
+    backoffMs: number;
+}
+interface ExecutionJob<TPayload = unknown> {
+    id: string;
+    correlationId: string;
+    command: BackendCommand<TPayload>;
+    status: JobStatus;
+    priority: JobPriority;
+    retryPolicy?: RetryPolicy;
+    attemptsMade: number;
+    createdAt: number;
+    completedAt?: number;
+}
+interface NormalizedResult<TData = unknown> {
+    correlationId: string;
+    status: 'COMPLETED' | 'FAILED';
+    data?: TData;
+    error?: string;
+    executionTimestamp: number;
+}
+interface QueueTransportOptions {
+    gatewayUrl?: string;
+    headers?: Record<string, string>;
+    timeoutMs?: number;
+}
+interface QueueGatewayContract {
+    enqueue<T = unknown>(command: BackendCommand<T>): Promise<{
+        jobId: string;
+        correlationId: string;
+    }>;
+    checkStatus(jobId: string): Promise<NormalizedResult>;
+}
+interface WorkspaceDescriptor {
+    id: string;
+    name: string;
+    ownerId: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface WorkspaceSyncSummary {
+    success: boolean;
+    workspaceId: string;
+    folderKey: string;
+    workingDir?: string;
+    persistenceType: string;
+    targetLocation: string;
+    syncedFiles: Array<{
+        fileName: string;
+        action: string;
+        sizeBytes?: number;
+    }>;
+    uploadedCount: number;
+    downloadedCount: number;
+    syncedAt: string;
+    error?: string;
+}
+interface WorkspaceLookupResult {
+    user?: any;
+    workspace: any;
+    connection?: any;
+}
+interface WorkspaceListResult {
+    success: boolean;
+    workspaces: any[];
+    activeWorkspaceId?: string | null;
+    storage_connections?: any[];
+}
+interface WorkspaceMutationResult {
+    success: boolean;
+    workspace?: any;
+    workspaces?: any[];
+}
+interface WorkspaceFileEntry {
+    path: string;
+    name: string;
+    sizeBytes?: number;
+    updatedAt?: string | number;
+    isFolder?: boolean;
+}
+interface WorkspaceServiceContract {
+    readonly type: 'remote' | 'working';
+    findWorkspace(workspaceId: string): Promise<WorkspaceLookupResult>;
+    listWorkspaces(userId?: string): Promise<WorkspaceListResult>;
+    createWorkspace(userId: string, data: any): Promise<WorkspaceMutationResult>;
+    updateWorkspace(userId: string, params: any): Promise<WorkspaceMutationResult>;
+    deleteWorkspace(userId: string, workspaceId: string): Promise<{
+        success: boolean;
+        workspaces?: any[];
+    }>;
+    readFile(workspaceId: string, filePath: string): Promise<Uint8Array | string>;
+    writeFile(workspaceId: string, filePath: string, content: Uint8Array | string): Promise<{
+        success: boolean;
+        path: string;
+        sizeBytes?: number;
+    }>;
+    deleteFile(workspaceId: string, filePath: string): Promise<{
+        success: boolean;
+    }>;
+    listFiles(workspaceId: string, subfolder?: string): Promise<WorkspaceFileEntry[]>;
+    sync?(workspaceId: string, options?: any): Promise<WorkspaceSyncSummary>;
+}
+
+/**
+ * @file browserExecutionClient.ts
+ * @description Browser-safe execution client for SKIPO applications.
+ * Dispatches commands across the queue transport boundary to the backend queue gateway.
+ * Conforms to Skipo Governance (< 200 lines).
+ */
+
+declare class BrowserExecutionClient implements QueueGatewayContract {
+    private gatewayUrl;
+    private headers;
+    private timeoutMs;
+    constructor(options?: QueueTransportOptions);
+    createCommand<T = unknown>(type: string, payload: T, options?: {
+        correlationId?: string;
+        idempotencyKey?: string;
+        metadata?: Record<string, unknown>;
+    }): BackendCommand<T>;
+    enqueue<T = unknown>(command: BackendCommand<T>): Promise<{
+        jobId: string;
+        correlationId: string;
+    }>;
+    checkStatus(jobId: string): Promise<NormalizedResult>;
+}
+declare function createBrowserExecutionClient(options?: QueueTransportOptions): BrowserExecutionClient;
+
+export { type BackendCommand, BrowserExecutionClient, type CorrelationMetadata, type ExecutionJob, type JobPriority, type JobStatus, type NormalizedResult, type QueueGatewayContract, type QueueTransportOptions, type RetryPolicy, type WorkspaceDescriptor, type WorkspaceFileEntry, type WorkspaceListResult, type WorkspaceLookupResult, type WorkspaceMutationResult, type WorkspaceServiceContract, type WorkspaceSyncSummary, createBrowserExecutionClient };

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.2"
+  }
+}

package/packages/contracts/package.json

@@ -28,6 +28,6 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
-    "@ultrst-armada/krnl": "^1.0.0"
+    "@ultrst-armada/krnl": "^1.0.2"
   }
 }

package/packages/functions/dist/index.js

@@ -1,5 +1,4 @@
-// ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.0/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js
-import { WebSocketServer, WebSocket } from "ws";
+// ../../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();

package/packages/functions/package.json

@@ -28,6 +28,6 @@
     "zod": "^3.24.1"
   },
   "devDependencies": {
-    "@ultrst-armada/krnl": "^1.0.0"
+    "@ultrst-armada/krnl": "^1.0.2"
   }
 }

package/packages/orchestrations/package.json

@@ -30,6 +30,6 @@
     "@kloks/backend": "workspace:*"
   },
   "devDependencies": {
-    "@ultrst-armada/krnl": "^1.0.0"
+    "@ultrst-armada/krnl": "^1.0.2"
   }
 }

package/packages/services/dist/index.js

@@ -1,6 +1,5 @@
-// ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.0/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js
+// ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.2/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js
 import http from "http";
-import { WebSocketServer, WebSocket } from "ws";
 var ServiceStateStore = class {
   state;
   listeners = /* @__PURE__ */ new Set();

package/packages/services/package.json

@@ -28,6 +28,6 @@
     "@kloks/state-graph": "workspace:*"
   },
   "devDependencies": {
-    "@ultrst-armada/krnl": "^1.0.0"
+    "@ultrst-armada/krnl": "^1.0.2"
   }
 }

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

@@ -13,6 +13,16 @@ import {
   SkipoExecutionEngine,
   useCommand
 } from "./chunk-ZTHBPV24.js";
+import "./chunk-Q5I42UX7.js";
+import {
+  LifecycleCycleError,
+  LifecycleGraph,
+  SKIPO_STATE,
+  SkipoStateEngine,
+  useLifecycleScope,
+  useSkipoBind,
+  useSkipoState
+} from "./chunk-SHIBCPGQ.js";
 import {
   AttractionEngine,
   GhostInferenceEngine,
@@ -29,16 +39,6 @@ import {
   WireTypeRegistry,
   initializeDefaultGraphRules
 } from "./chunk-TZOL3RN7.js";
-import "./chunk-Q5I42UX7.js";
-import {
-  LifecycleCycleError,
-  LifecycleGraph,
-  SKIPO_STATE,
-  SkipoStateEngine,
-  useLifecycleScope,
-  useSkipoBind,
-  useSkipoState
-} from "./chunk-SHIBCPGQ.js";
 import {
   CommandApi,
   GhostStore,
@@ -68,8 +68,7 @@ import {
 } from "./chunk-ISFNY7EZ.js";
 import "./chunk-3RG5ZIWI.js";
 
-// ../../node_modules/.pnpm/@ultrst-armada+krnl@1.0.0/node_modules/@ultrst-armada/krnl/packages/core/dist/index.js
-import { WebSocketServer, WebSocket } from "ws";
+// ../../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();

package/packages/state-graph/package.json

@@ -68,6 +68,6 @@
     }
   },
   "devDependencies": {
-    "@ultrst-armada/krnl": "^1.0.0"
+    "@ultrst-armada/krnl": "^1.0.2"
   }
 }

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