@ultrst-armada/kloks 1.2.0 → 1.3.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ultrst-armada/kloks",
-  "version": "1.2.0",
+  "version": "1.3.0",
   "private": false,
   "publishConfig": {
     "access": "public",
@@ -103,6 +103,7 @@
   "scripts": {
     "build": "pnpm -r run build",
     "postbuild": "node -e \"import('fs').then(fs => { for (const pkg of fs.readdirSync('packages')) { const d = 'packages/' + pkg + '/dist'; if (!fs.existsSync(d)) continue; for (const f of fs.readdirSync(d, { recursive: true })) { const p = d + '/' + f; if (fs.statSync(p).isFile() && (p.endsWith('.js') || p.endsWith('.d.ts'))) { const c = fs.readFileSync(p, 'utf8'); const n = c.replaceAll('@kloks/', '@ultrst-armada/kloks/').replaceAll('@ultrst/kloks/', '@ultrst-armada/kloks/').replaceAll('\\\"kloks/', '\\\"@ultrst-armada/kloks/').replaceAll('\\'kloks/', '\\'@ultrst-armada/kloks/'); if (c !== n) fs.writeFileSync(p, n); } } } })\"",
+    "prepublishOnly": "npm run postbuild",
     "test": "vitest run",
     "typecheck": "pnpm -r run typecheck",
     "clean": "pnpm -r run clean"

package/packages/audio-midi/dist/chunk-3GRGELA4.js

@@ -33,7 +33,7 @@ var DEFAULT_NAMED_BUSSES = [
 ];
 
 // src/engine/audio/synthEngine/synthEngine.ts
-import { midiToFreq } from "@kloks/state-graph";
+import { midiToFreq } from "@ultrst-armada/kloks/state-graph";
 
 // src/engine/audio/outputRouter.ts
 var MultiChannelOutputRouter = class {
@@ -320,7 +320,7 @@ function createAudioGraphNode(node) {
 }
 
 // src/engine/audio/synthEngine/synthEngine.ts
-import { getActiveEffectsForNode } from "@kloks/state-graph";
+import { getActiveEffectsForNode } from "@ultrst-armada/kloks/state-graph";
 
 // src/engine/audio/dsp/saturationCurves.ts
 function generateSaturationCurve(type, drive = 1.5, samples = 4096) {
@@ -2090,14 +2090,14 @@ function buildOutputChannelList(totalChannels, descriptions = {}) {
 }
 
 // src/engine/audio/audioInputManager/audioInputManager.ts
-import { topLevelIoRegistry } from "@kloks/state-graph";
+import { topLevelIoRegistry } from "@ultrst-armada/kloks/state-graph";
 import {
   loadStoredConfig,
   saveStoredConfig,
   enumerateSystemAudioDevices
-} from "@kloks/state-graph";
-import { acquireAudioInputStream, stopAudioMediaStream } from "@kloks/state-graph";
-import { AudioBusDriver } from "@kloks/state-graph";
+} from "@ultrst-armada/kloks/state-graph";
+import { acquireAudioInputStream, stopAudioMediaStream } from "@ultrst-armada/kloks/state-graph";
+import { AudioBusDriver } from "@ultrst-armada/kloks/state-graph";
 var DEFAULT_NAMED_INPUTS = DEFAULT_NAMED_BUSSES;
 var AudioInputManager = class {
   audioCtx = null;

package/packages/audio-midi/dist/index.d.ts

@@ -1,7 +1,7 @@
 import * as _ultrst_armada_krnl from '@ultrst-armada/krnl';
 import { ServiceDefinition, IService } from '@ultrst-armada/krnl';
-import { INodeVisuals, SpaceNode, NodeConnection, MidiNote, SynthPreset, ContainerNode, PlayerNode, SamplePresetType, AudioTrackData, HardwareChannelInfo, NamedAudioBus, AudioDeviceInfo, ConnectionsConfig, MidiInputDevice, StoredPacket, RecorderNode, CurveTrackData, CurvePoint, EffectNode, CompressorEffectConfig, MultibandCompressorEffectConfig } from '@kloks/state-graph';
-export { AudioConcepts, BufferConcepts, BufferCycleCalculation } from '@kloks/state-graph';
+import { INodeVisuals, SpaceNode, NodeConnection, MidiNote, SynthPreset, ContainerNode, PlayerNode, SamplePresetType, AudioTrackData, HardwareChannelInfo, NamedAudioBus, AudioDeviceInfo, ConnectionsConfig, MidiInputDevice, StoredPacket, RecorderNode, CurveTrackData, CurvePoint, EffectNode, CompressorEffectConfig, MultibandCompressorEffectConfig } from '@ultrst-armada/kloks/state-graph';
+export { AudioConcepts, BufferConcepts, BufferCycleCalculation } from '@ultrst-armada/kloks/state-graph';
 
 /**
  * Pro-Audio Hardware Input/Output Manager (Named Bus Architecture)
@@ -934,7 +934,7 @@ declare const OscServiceFacade: {
 
 /**
  * @file index.ts
- * @description @kloks/audio-midi — KrnlTS-backed Pro-Audio Named Bus & Reactive Web MIDI Services.
+ * @description @ultrst-armada/kloks/audio-midi — KrnlTS-backed Pro-Audio Named Bus & Reactive Web MIDI Services.
  * Converted from Skipo audio-midi engine into first-class KrnlTS services and orchestrators.
  */
 

package/packages/audio-midi/dist/index.js

@@ -607,7 +607,7 @@ var MidiManager = class {
 import {
   AudioConcepts,
   BufferConcepts
-} from "@kloks/state-graph";
+} from "@ultrst-armada/kloks/state-graph";
 
 // src/engine/index.ts
 import {
@@ -615,7 +615,7 @@ import {
   configureControlDispatcher,
   configureNodePerformanceTracker,
   configureSolidifyExecution
-} from "@kloks/state-graph";
+} from "@ultrst-armada/kloks/state-graph";
 
 // src/engine/audio/retrospectiveBufferEngine/retrospectiveBufferEngine.ts
 var RetrospectiveBufferEngine = class {
@@ -896,9 +896,9 @@ var RetrospectiveBufferEngine = class {
 var retrospectiveBufferEngine = new RetrospectiveBufferEngine();
 
 // src/engine/audio/sequencerEngine/sequencerEngine.ts
-import { shouldTriggerFireAtClock } from "@kloks/state-graph";
-import { getEffectsAffectingWire } from "@kloks/state-graph";
-import { getActiveEffectsForNode as getActiveEffectsForNode2 } from "@kloks/state-graph";
+import { shouldTriggerFireAtClock } from "@ultrst-armada/kloks/state-graph";
+import { getEffectsAffectingWire } from "@ultrst-armada/kloks/state-graph";
+import { getActiveEffectsForNode as getActiveEffectsForNode2 } from "@ultrst-armada/kloks/state-graph";
 
 // src/engine/audio/curveEngine.ts
 var CurveEngine = class {
@@ -1010,7 +1010,7 @@ var CurveEngine = class {
 var curveEngine = new CurveEngine();
 
 // src/engine/audio/sequencerStepProcessor.ts
-import { getActiveEffectsForNode } from "@kloks/state-graph";
+import { getActiveEffectsForNode } from "@ultrst-armada/kloks/state-graph";
 function playContainerNoteWithEffects(container, note, nodes, connections, bpm, isPlaying, nodeVisuals) {
   const activeEffects = getActiveEffectsForNode(container, nodes, connections);
   const delayEffect = activeEffects.find((e) => e.effectType === "delay");
@@ -1088,8 +1088,8 @@ function processActiveContainers(activeContainerPlayheads, containerMap, prevBea
 }
 
 // src/engine/audio/sequencerEngine/sequencerEngine.ts
-import { calculateNextQuantizeBeat } from "@kloks/state-graph";
-import { executeCodeNodeScript } from "@kloks/state-graph";
+import { calculateNextQuantizeBeat } from "@ultrst-armada/kloks/state-graph";
+import { executeCodeNodeScript } from "@ultrst-armada/kloks/state-graph";
 var SequencerEngine = class {
   bpm = 120;
   isPlaying = false;
@@ -1669,8 +1669,8 @@ var SequencerEngine = class {
 var sequencerEngine = new SequencerEngine();
 
 // src/engine/midi/midiManager/midiManager.ts
-import { midiToNoteName } from "@kloks/state-graph";
-import { topLevelIoRegistry } from "@kloks/state-graph";
+import { midiToNoteName } from "@ultrst-armada/kloks/state-graph";
+import { topLevelIoRegistry } from "@ultrst-armada/kloks/state-graph";
 var MidiManager2 = class {
   midiAccess = null;
   listeners = /* @__PURE__ */ new Set();

package/packages/backend/dist/BaseAccountProvider-DduKf5HG.d.ts

@@ -1,4 +1,4 @@
-import { SkipoBase } from '@kloks/functions';
+import { SkipoBase } from '@ultrst-armada/kloks/functions';
 
 type UserRole = 'user' | 'admin';
 interface User {

package/packages/backend/dist/BaseStorageAdapter-tosOoSUg.d.ts

@@ -1,4 +1,4 @@
-import { SkipoBase } from '@kloks/functions';
+import { SkipoBase } from '@ultrst-armada/kloks/functions';
 
 type StorageMode = 'local' | 'local_hosted' | 'remote';
 type StorageProviderType = 'local_fs' | 's3' | 'backblaze_b2' | 'b2' | 'cloudflare_r2' | 'r2' | 'supabase' | 'firebase' | 'google_drive';

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

@@ -1,4 +1,4 @@
-import { SkipoBase } from '@kloks/functions';
+import { SkipoBase } from '@ultrst-armada/kloks/functions';
 
 interface ApiResponse<T> {
     data?: T;

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

@@ -1,6 +1,6 @@
 import { B as BaseAccountProvider, U as User, C as CreateUserData, a as AuthSession } from '../BaseAccountProvider-DduKf5HG.js';
 export { A as AuthCredentials, R as RateLimiter, S as SessionManager, b as SignupInput, c as UserRole } from '../BaseAccountProvider-DduKf5HG.js';
-import { SkipoBase } from '@kloks/functions';
+import { SkipoBase } from '@ultrst-armada/kloks/functions';
 
 declare class PasswordHasher {
     static hash(password: string, saltRounds?: number): Promise<string>;

package/packages/backend/dist/chunk-4ZFXEFOE.js

@@ -26,7 +26,7 @@ var PasswordHasher = class {
 };
 
 // src/auth/BaseAccountProvider.ts
-import { SkipoBase } from "@kloks/functions";
+import { SkipoBase } from "@ultrst-armada/kloks/functions";
 var BaseAccountProvider = class extends SkipoBase {
   rateLimiter = new RateLimiter();
   sessionManager = new SessionManager();
@@ -153,7 +153,7 @@ var LocalAccountProvider = class extends BaseAccountProvider {
 };
 
 // src/auth/AdminGuard.ts
-import { SkipoBase as SkipoBase2 } from "@kloks/functions";
+import { SkipoBase as SkipoBase2 } from "@ultrst-armada/kloks/functions";
 var AdminGuard = class _AdminGuard extends SkipoBase2 {
   static async verify(authHeaderOrToken, provider) {
     const session = await _AdminGuard.verifyUser(authHeaderOrToken, provider);

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

@@ -0,0 +1,338 @@
+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);
+}
+
+// src/services/nodeGraphPersistence/types.ts
+var LOCAL_STORAGE_GRAPHS_PREFIX = "depm_graph_doc_";
+
+// src/services/nodeGraphPersistence/helpers.ts
+function validateGraphDocument(data) {
+  const errors = [];
+  if (!data || typeof data !== "object") {
+    return { valid: false, errors: ["Invalid JSON: payload must be a JSON object"] };
+  }
+  if (!data.appId) errors.push("Missing required property: appId");
+  if (!data.appName) errors.push("Missing required property: appName");
+  if (!data.graph || typeof data.graph !== "object") {
+    errors.push("Missing or invalid property: graph");
+  } else {
+    if (!Array.isArray(data.graph.nodes)) errors.push("Missing or invalid property: graph.nodes (must be array)");
+    if (!Array.isArray(data.graph.edges)) errors.push("Missing or invalid property: graph.edges (must be array)");
+  }
+  if (errors.length > 0) {
+    return { valid: false, errors };
+  }
+  return {
+    valid: true,
+    errors: [],
+    document: data
+  };
+}
+function exportGraphAsJsonFile(graphDoc) {
+  if (typeof window === "undefined") return;
+  const jsonString = JSON.stringify(graphDoc, null, 2);
+  const blob = new Blob([jsonString], { type: "application/json" });
+  const url = URL.createObjectURL(blob);
+  const safeName = (graphDoc.appName || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+  const filename = `${safeName}_${graphDoc.appId}.graph.json`;
+  const link = window.document.createElement("a");
+  link.href = url;
+  link.download = filename;
+  window.document.body.appendChild(link);
+  link.click();
+  window.document.body.removeChild(link);
+  URL.revokeObjectURL(url);
+}
+async function parseGraphJsonFile(file) {
+  try {
+    const text = await file.text();
+    const parsed = JSON.parse(text);
+    return validateGraphDocument(parsed);
+  } catch (err) {
+    return {
+      valid: false,
+      errors: [`Failed to parse JSON: ${err.message}`]
+    };
+  }
+}
+
+// src/services/nodeGraphPersistence/nodeGraphPersistence.ts
+var NodeGraphPersistenceService = class {
+  /**
+   * Generates a fully compliant v1.0.0 JSON document representing the app's complete node graph.
+   */
+  createGraphDocument(options) {
+    const { app, nodes, edges, deployments = [], viewport, storageConnection } = options;
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const targetProvider = storageConnection?.provider || "local_fs";
+    const targetBucketOrFolder = storageConnection?.localFolderName || storageConnection?.b2BucketName || storageConnection?.s3BucketName || storageConnection?.r2BucketName || storageConnection?.supabaseBucketName || "Vault";
+    const safeAppName = (app.name || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_");
+    const filePath = `graphs/${safeAppName}_${app.id}.graph.json`;
+    return {
+      $schema: "https://skipo.dev/schemas/depm-node-graph.v1.json",
+      version: "1.0.0",
+      appId: app.id,
+      appName: app.name,
+      appIcon: app.icon || "Layers",
+      description: app.description,
+      publicLink: app.publicLink || `https://${safeAppName}.ecosystem.network`,
+      createdAt: app.createdAt || now,
+      updatedAt: now,
+      exportedAt: now,
+      viewport: viewport || { zoom: 1, pan: { x: 0, y: 0 } },
+      graph: {
+        nodes: nodes.filter((n) => !n.appId || n.appId === app.id),
+        edges: edges.filter((e) => !e.appId || e.appId === app.id)
+      },
+      deployments: deployments.filter(
+        (d) => nodes.some((n) => (!n.appId || n.appId === app.id) && n.deploymentId === d.id)
+      ),
+      storageMetadata: {
+        provider: targetProvider,
+        targetName: targetBucketOrFolder,
+        targetPath: filePath,
+        storageConnectionId: storageConnection?.id,
+        syncedAt: now
+      }
+    };
+  }
+  /**
+   * Validates a parsed JSON object to verify it matches the NodeGraphDocument schema.
+   */
+  validateGraphDocument(data) {
+    return validateGraphDocument(data);
+  }
+  /**
+   * Saves the node graph to the selected user storage option (Local Folder or Cloud Bucket)
+   * and caches it in LocalStorage.
+   */
+  async saveGraphToStorage(options, customDirectoryHandle) {
+    const document = this.createGraphDocument(options);
+    const jsonString = JSON.stringify(document, null, 2);
+    const provider = options.storageConnection?.provider || "local_fs";
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        window.localStorage.setItem(`${LOCAL_STORAGE_GRAPHS_PREFIX}${document.appId}`, jsonString);
+        window.localStorage.setItem(`depm_latest_saved_graph_${document.appId}`, JSON.stringify({
+          updatedAt: document.updatedAt,
+          provider,
+          targetName: document.storageMetadata?.targetName
+        }));
+      }
+    } catch {
+    }
+    if (provider === "local_fs" && typeof window !== "undefined") {
+      try {
+        if (customDirectoryHandle) {
+          const fileName = `${(document.appName || "graph").toLowerCase().replace(/[^a-z0-9_-]/g, "_")}_${document.appId}.graph.json`;
+          const fileHandle = await customDirectoryHandle.getFileHandle(fileName, { create: true });
+          const writable = await fileHandle.createWritable();
+          await writable.write(jsonString);
+          await writable.close();
+          return {
+            success: true,
+            document,
+            message: `Saved node graph directly to local folder "${customDirectoryHandle.name || "Vault"}"`,
+            targetPath: `${customDirectoryHandle.name}/${fileName}`
+          };
+        }
+      } catch (err) {
+        console.warn("Native FS Handle save warning:", err);
+      }
+    }
+    const targetPath = document.storageMetadata?.targetPath || `graphs/${document.appId}.graph.json`;
+    const targetName = document.storageMetadata?.targetName || "Vault";
+    const simulatedLatency = provider === "local_fs" ? 10 : 80;
+    await new Promise((resolve) => setTimeout(resolve, simulatedLatency));
+    return {
+      success: true,
+      document,
+      message: `Node graph saved to ${(provider || "storage").toUpperCase().replace("_", " ")} (${targetName}: ${targetPath})`,
+      targetPath
+    };
+  }
+  /**
+   * Loads a cached or previously saved node graph document for an app.
+   */
+  loadSavedGraph(appId) {
+    try {
+      if (typeof window !== "undefined" && window.localStorage) {
+        const stored = window.localStorage.getItem(`${LOCAL_STORAGE_GRAPHS_PREFIX}${appId}`);
+        if (stored) {
+          const parsed = JSON.parse(stored);
+          const validation = this.validateGraphDocument(parsed);
+          if (validation.valid && validation.document) {
+            return validation.document;
+          }
+        }
+      }
+    } catch {
+    }
+    return null;
+  }
+  /**
+   * Triggers a browser download of the node graph as a portable JSON file.
+   */
+  exportGraphAsJsonFile(graphDoc) {
+    exportGraphAsJsonFile(graphDoc);
+  }
+  /**
+   * Reads and parses a graph JSON file from an input file element.
+   */
+  async parseGraphJsonFile(file) {
+    return parseGraphJsonFile(file);
+  }
+};
+var nodeGraphPersistence = new NodeGraphPersistenceService();
+
+export {
+  createLocalService,
+  createRemoteService,
+  CompositeBackend,
+  EndpointGenerator,
+  createBackend,
+  createCompositeService,
+  LOCAL_STORAGE_GRAPHS_PREFIX,
+  validateGraphDocument,
+  exportGraphAsJsonFile,
+  parseGraphJsonFile,
+  NodeGraphPersistenceService,
+  nodeGraphPersistence
+};

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

@@ -1,5 +1,5 @@
 // src/storage/BaseStorageAdapter.ts
-import { SkipoBase } from "@kloks/functions";
+import { SkipoBase } from "@ultrst-armada/kloks/functions";
 var BaseStorageAdapter = class extends SkipoBase {
   config;
   constructor(config) {

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

@@ -1,5 +1,5 @@
 // src/workspace/WorkspaceFS.ts
-import { SkipoBase } from "@kloks/functions";
+import { SkipoBase } from "@ultrst-armada/kloks/functions";
 var WorkspaceFS = class extends SkipoBase {
   primary;
   syncEngine;
@@ -54,7 +54,7 @@ var WorkspaceFS = class extends SkipoBase {
 };
 
 // src/workspace/SyncEngine.ts
-import { SkipoBase as SkipoBase2 } from "@kloks/functions";
+import { SkipoBase as SkipoBase2 } from "@ultrst-armada/kloks/functions";
 var SyncEngine = class extends SkipoBase2 {
   primary;
   backups;
@@ -87,7 +87,7 @@ var SyncEngine = class extends SkipoBase2 {
 };
 
 // src/workspace/WorkspaceCloneSyncEngine.ts
-import { SkipoBase as SkipoBase3 } from "@kloks/functions";
+import { SkipoBase as SkipoBase3 } from "@ultrst-armada/kloks/functions";
 var WorkspaceCloneSyncEngine = class extends SkipoBase3 {
   constructor() {
     super({ name: "WorkspaceCloneSyncEngine" });