@ultrst-armada/kloks 1.2.1 → 1.4.0

package/packages/backend/dist/index.js

@@ -1,12 +1,33 @@
+import {
+  CompositeBackend,
+  EndpointGenerator,
+  LOCAL_STORAGE_GRAPHS_PREFIX,
+  NodeGraphPersistenceService,
+  createBackend,
+  createCompositeService,
+  createLocalService,
+  createRemoteService,
+  exportGraphAsJsonFile,
+  nodeGraphPersistence,
+  parseGraphJsonFile,
+  validateGraphDocument
+} from "./chunk-BM4QMVPA.js";
 import {
   CANONICAL_SRKL_URL,
   SrklClient,
+  SrklCredentialRegistry,
+  SrklVaultAccessClient,
   createSrklClient,
+  decryptVaultBufferInBrowser,
   getPrimarySrklDeploymentUrl,
   getSrklAccounts,
+  globalCredentialRegistry,
+  hexToBytes,
   srklListBackblazeBuckets,
+  srklService,
+  syncSrklAccounts,
   useSrklServices
-} from "./chunk-MN54ZIKZ.js";
+} from "./chunk-KX3OTBQ3.js";
 import "./chunk-LS3HWJBX.js";
 import {
   authorizeB2,
@@ -16,16 +37,48 @@ import {
   b2UploadFile
 } from "./chunk-4QEMALXF.js";
 import {
-  BaseApiRoute,
-  createSSEResponse,
-  withAuth,
-  withCors
-} from "./chunk-TWCEVES2.js";
-import {
+  RemoteWorkspaceService,
   SyncEngine,
+  WorkingWorkspaceService,
   WorkspaceCloneSyncEngine,
-  WorkspaceFS
-} from "./chunk-KTLD7Z4L.js";
+  WorkspaceFS,
+  b2DeleteFileVersion,
+  b2DeleteFolder,
+  b2ListBuckets as b2ListBuckets2,
+  cleanDbUrl,
+  createWorkspace,
+  deleteWorkspace,
+  deleteWorkspaceFile,
+  deleteWorkspaceFolder,
+  findUserWorkspace,
+  findWorkspaceRecord,
+  getB2BucketId,
+  getDefaultWorkingWorkspaceDir,
+  getUnifiedDbUrl,
+  getWorkingWorkspaceConfig,
+  getWorkingWorkspaceDir,
+  getWorkspaceFolderKey,
+  getWorkspaceFolderPrefix,
+  getWorkspaceStorageDetails,
+  getWorkspaces,
+  isB2Workspace,
+  listWorkspaceFiles,
+  loadWorkspaceData,
+  queryUnifiedDb,
+  readWorkspaceFile,
+  remoteWorkspaceService,
+  renameAppInWorkspaceData,
+  resolveWorkspaceConnection,
+  saveWorkspaceData,
+  setWorkingWorkspaceConfig,
+  syncWorkspace,
+  syncWorkspaceCreateToBucket,
+  syncWorkspaceDataToBucket,
+  syncWorkspaceDeleteToBucket,
+  updateWorkspace,
+  workingWorkspaceService,
+  writeWorkspaceFile
+} from "./chunk-DZ4ZGIZM.js";
 import {
   AuthServiceDefinition,
   AuthServiceFacade,
@@ -41,7 +94,8 @@ import {
   StorageServiceFacade,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade
-} from "./chunk-OYQKQAEF.js";
+} from "./chunk-CU7RZBMF.js";
+import "./chunk-IPP4VURQ.js";
 import {
   BackblazeB2Adapter,
   BaseStorageAdapter,
@@ -61,6 +115,17 @@ import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
 } from "./chunk-FZKBTF34.js";
+import {
+  BaseApiRoute,
+  createSSEResponse,
+  withAuth,
+  withCors
+} from "./chunk-TWCEVES2.js";
+import {
+  BackendProvider,
+  useBackend,
+  useBackendClient
+} from "./chunk-G3ZOSXUR.js";
 import {
   AdminGuard,
   BaseAccountProvider,
@@ -74,10 +139,13 @@ import {
   SessionManager
 } from "./chunk-25Y7AVTP.js";
 import {
-  BackendProvider,
-  useBackend,
-  useBackendClient
-} from "./chunk-G3ZOSXUR.js";
+  AuditLogger,
+  ControlPlaneManager,
+  DatabaseClusterManager,
+  detectDatabaseEngine,
+  getSystemDatabaseUrls,
+  resolveSystemDatabaseClusterNodes
+} from "./chunk-RCCQ7IRM.js";
 import {
   BackendRegistry,
   ConcurrencyConflictError,
@@ -100,14 +168,6 @@ import {
   WebSocketTransport,
   createBackendClient
 } from "./chunk-NIP22V2G.js";
-import {
-  AuditLogger,
-  ControlPlaneManager,
-  DatabaseClusterManager,
-  detectDatabaseEngine,
-  getSystemDatabaseUrls,
-  resolveSystemDatabaseClusterNodes
-} from "./chunk-RCCQ7IRM.js";
 import {
   JobDependencyGraph,
   ResultFlowBridge,
@@ -124,15 +184,6 @@ import {
 import {
   IdempotencyManager
 } from "./chunk-3EPY34R6.js";
-import {
-  CompositeBackend,
-  EndpointGenerator,
-  createBackend,
-  createCompositeService,
-  createLocalService,
-  createRemoteService
-} from "./chunk-P4HL4C6V.js";
-import "./chunk-IPP4VURQ.js";
 
 // src/data/BaseDataProvider.ts
 import { SkipoBase } from "@ultrst-armada/kloks/functions";
@@ -205,40 +256,6 @@ function validateServiceDefinition(def) {
 // src/core/authCore.ts
 import crypto2 from "crypto";
 import bcrypt from "bcryptjs";
-
-// src/core/unifiedDb.ts
-import { neon } from "@neondatabase/serverless";
-function cleanDbUrl(url) {
-  if (!url || typeof url !== "string") return "";
-  return url.trim().replace(/^["']|["']$/g, "");
-}
-function getUnifiedDbUrl(env) {
-  const fromEnv = cleanDbUrl(env?.SYSTEM_DATABASE_URL_1) || cleanDbUrl(env?.DATABASE_URL) || cleanDbUrl(env?.SYSTEM_DATABASE_URL_2);
-  if (fromEnv) return fromEnv;
-  if (typeof process !== "undefined" && process.env) {
-    return cleanDbUrl(process.env.SYSTEM_DATABASE_URL_1) || cleanDbUrl(process.env.DATABASE_URL) || cleanDbUrl(process.env.SYSTEM_DATABASE_URL_2) || cleanDbUrl(process.env.SYSTEM_DATABASE_URL_3) || "";
-  }
-  return "";
-}
-async function queryUnifiedDb(sqlText, params = [], env) {
-  const dbUrl = getUnifiedDbUrl(env);
-  if (!dbUrl) {
-    throw new Error("[UnifiedDB] No database URL configured in environment.");
-  }
-  const sql = neon(dbUrl);
-  try {
-    const rows = await (sql.query ? sql.query(sqlText, params) : sql(sqlText, params));
-    return {
-      rows: Array.isArray(rows) ? rows : [],
-      rowCount: Array.isArray(rows) ? rows.length : 0
-    };
-  } catch (err) {
-    console.error("[UnifiedDB] Query execution error:", err.message);
-    throw err;
-  }
-}
-
-// src/core/authCore.ts
 async function loginUser(email, password, isAdmin = false, env) {
   const normEmail = (email || "").trim().toLowerCase();
   const rawPassword = (password || "").trim();
@@ -314,473 +331,11 @@ async function getUsers(env) {
   }
 }
 
-// src/core/b2DirectCore.ts
-var authCache = /* @__PURE__ */ new Map();
-var bucketIdCache = /* @__PURE__ */ new Map();
-async function authorizeB22(keyId, applicationKey) {
-  const cacheKey = `${keyId.trim()}:${applicationKey.trim()}`;
-  const cached = authCache.get(cacheKey);
-  if (cached && Date.now() < cached.expiresAt) return cached.auth;
-  const authHeader = typeof Buffer !== "undefined" ? Buffer.from(`${keyId.trim()}:${applicationKey.trim()}`).toString("base64") : btoa(`${keyId.trim()}:${applicationKey.trim()}`);
-  let res = await fetch("https://api.backblazeb2.com/b2api/v2/b2_authorize_account", {
-    headers: { Authorization: `Basic ${authHeader}` },
-    signal: AbortSignal.timeout(1e4)
-  });
-  if (!res.ok) {
-    res = await fetch("https://api.backblazeb2.com/b2api/v4/b2_authorize_account", {
-      headers: { Authorization: `Basic ${authHeader}` },
-      signal: AbortSignal.timeout(1e4)
-    });
-  }
-  if (!res.ok) {
-    const errText = await res.text();
-    throw new Error(`Backblaze B2 authorization failed (${res.status}): ${errText}`);
-  }
-  const data = await res.json();
-  const auth = {
-    accountId: data.accountId,
-    authorizationToken: data.authorizationToken,
-    apiUrl: (data.apiInfo?.storageApi?.apiUrl || data.apiUrl || "https://api.backblazeb2.com").replace(/\/+$/, ""),
-    downloadUrl: (data.apiInfo?.storageApi?.downloadUrl || data.downloadUrl || data.apiUrl || "https://f003.backblazeb2.com").replace(/\/+$/, ""),
-    s3ApiUrl: data.apiInfo?.storageApi?.s3ApiUrl || data.s3ApiUrl,
-    allowed: data.apiInfo?.storageApi?.allowed || data.allowed
-  };
-  authCache.set(cacheKey, { auth, expiresAt: Date.now() + 20 * 60 * 1e3 });
-  return auth;
-}
-async function b2ListBuckets2(keyId, applicationKey, bucketId, bucketName) {
-  const auth = await authorizeB22(keyId, applicationKey);
-  const rBucketId = bucketId || auth.allowed?.bucketId || auth.allowed?.buckets?.[0]?.bucketId;
-  const rBucketName = bucketName || auth.allowed?.bucketName || auth.allowed?.buckets?.[0]?.bucketName;
-  if (!auth.allowed?.bucketId && !auth.allowed?.bucketName) {
-    try {
-      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
-        method: "POST",
-        headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-        body: JSON.stringify({ accountId: auth.accountId }),
-        signal: AbortSignal.timeout(8e3)
-      });
-      if (res.ok) {
-        const data = await res.json();
-        if (Array.isArray(data.buckets) && data.buckets.length > 0) return data.buckets;
-      }
-    } catch (err) {
-      console.warn("[B2DirectCore] list_buckets query failed:", err.message);
-    }
-  }
-  if (rBucketId || rBucketName) {
-    const body = { accountId: auth.accountId };
-    if (rBucketId) body.bucketId = rBucketId;
-    else if (rBucketName) body.bucketName = rBucketName;
-    try {
-      const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_buckets`, {
-        method: "POST",
-        headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-        body: JSON.stringify(body),
-        signal: AbortSignal.timeout(8e3)
-      });
-      if (res.ok) {
-        const data = await res.json();
-        if (Array.isArray(data.buckets) && data.buckets.length > 0) return data.buckets;
-      }
-    } catch {
-    }
-    return [{
-      accountId: auth.accountId,
-      bucketId: rBucketId || "restricted",
-      bucketName: rBucketName || (bucketName || "default-bucket"),
-      bucketType: "allPrivate"
-    }];
-  }
-  return [];
-}
-async function getB2BucketId(keyId, applicationKey, bucketName) {
-  const cacheKey = `${keyId.trim()}:${bucketName.trim()}`;
-  if (bucketIdCache.has(cacheKey)) return bucketIdCache.get(cacheKey);
-  const buckets = await b2ListBuckets2(keyId, applicationKey, void 0, bucketName);
-  const match = buckets.find((b) => b.bucketName === bucketName);
-  if (!match) throw new Error(`B2 bucket "${bucketName}" not found in account`);
-  bucketIdCache.set(cacheKey, match.bucketId);
-  return match.bucketId;
-}
-async function b2UploadFile2(keyId, applicationKey, bucketName, fileName, buffer, contentType = "b2/x-auto") {
-  const auth = await authorizeB22(keyId, applicationKey);
-  const bucketId = await getB2BucketId(keyId, applicationKey, bucketName);
-  const urlRes = await fetch(`${auth.apiUrl}/b2api/v2/b2_get_upload_url`, {
-    method: "POST",
-    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-    body: JSON.stringify({ bucketId })
-  });
-  if (!urlRes.ok) throw new Error(`B2 get upload url failed (${urlRes.status})`);
-  const { uploadUrl, authorizationToken } = await urlRes.json();
-  const encodedFileName = encodeURIComponent(fileName).replace(/%2F/g, "/");
-  const uploadRes = await fetch(uploadUrl, {
-    method: "POST",
-    headers: {
-      Authorization: authorizationToken,
-      "X-Bz-File-Name": encodedFileName,
-      "Content-Type": contentType,
-      "Content-Length": String(buffer.byteLength),
-      "X-Bz-Content-Sha1": "do_not_verify"
-    },
-    body: buffer
-  });
-  if (!uploadRes.ok) throw new Error(`B2 upload failed for ${fileName} (${uploadRes.status}): ${await uploadRes.text()}`);
-  return uploadRes.json();
-}
-async function b2DownloadFile2(keyId, applicationKey, bucketName, fileName) {
-  const auth = await authorizeB22(keyId, applicationKey);
-  const encodedName = encodeURIComponent(fileName).replace(/%2F/g, "/");
-  const res = await fetch(`${auth.downloadUrl}/file/${bucketName}/${encodedName}`, { headers: { Authorization: auth.authorizationToken } });
-  if (res.status === 404) return null;
-  if (!res.ok) throw new Error(`B2 download failed for ${fileName} (${res.status})`);
-  return new Uint8Array(await res.arrayBuffer());
-}
-async function b2ListFileNames2(keyId, applicationKey, bucketName, prefix = "") {
-  const auth = await authorizeB22(keyId, applicationKey);
-  const bucketId = await getB2BucketId(keyId, applicationKey, bucketName);
-  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_list_file_names`, {
-    method: "POST",
-    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-    body: JSON.stringify({ bucketId, prefix, maxFileCount: 1e3 })
-  });
-  if (!res.ok) throw new Error(`B2 list files failed (${res.status})`);
-  const data = await res.json();
-  return data.files || [];
-}
-async function b2DeleteFileVersion(keyId, applicationKey, fileName, fileId) {
-  const auth = await authorizeB22(keyId, applicationKey);
-  const res = await fetch(`${auth.apiUrl}/b2api/v2/b2_delete_file_version`, {
-    method: "POST",
-    headers: { Authorization: auth.authorizationToken, "Content-Type": "application/json" },
-    body: JSON.stringify({ fileName, fileId })
-  });
-  if (!res.ok) throw new Error(`B2 delete file version failed (${res.status})`);
-  return res.json();
-}
-async function b2DeleteFolder(keyId, applicationKey, bucketName, folderPrefix) {
-  const cleanPrefix = folderPrefix.replace(/\/+$/, "") + "/";
-  const files = await b2ListFileNames2(keyId, applicationKey, bucketName, cleanPrefix);
-  let deletedCount = 0;
-  for (const file of files) {
-    await b2DeleteFileVersion(keyId, applicationKey, file.fileName, file.fileId);
-    deletedCount++;
-  }
-  return { success: true, deletedCount };
-}
-
-// src/core/workspaceSyncEngine.ts
-import fs from "fs";
-import path from "path";
-
-// src/core/workspaceCanonical.ts
-function formatCanonicalWorkspaceFolderName2(appName, userName, workspaceName) {
-  const safeApp = (appName || "qwnsr").replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  const safeUser = (userName || "user").replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  const safeWs = (workspaceName || "workspace").replace(/[^a-zA-Z0-9]/g, "_").toLowerCase();
-  return `ultrst_${safeApp}_${safeUser}_${safeWs}`;
-}
-
-// src/core/workspaceSyncEngine.ts
-var ACCOUNTS_FILE = path.resolve(".skipo/accounts.json");
-var CONFIG_FILE = path.resolve(".skipo/workspace_config.json");
-function getDefaultWorkingWorkspaceDir() {
-  if (process.env.VERCEL || process.env.AWS_LAMBDA_FUNCTION_NAME) {
-    return path.join("/tmp", "workspace");
-  }
-  return path.join(process.cwd(), "workspace");
-}
-function getWorkingWorkspaceConfig() {
-  try {
-    if (fs.existsSync(CONFIG_FILE)) {
-      const raw = fs.readFileSync(CONFIG_FILE, "utf-8");
-      const parsed = JSON.parse(raw);
-      if (parsed.workingDirectory) {
-        return {
-          workingDirectory: parsed.workingDirectory,
-          autoSyncIntervalMinutes: parsed.autoSyncIntervalMinutes || 5
-        };
-      }
-    }
-  } catch {
-  }
-  return {
-    workingDirectory: getDefaultWorkingWorkspaceDir(),
-    autoSyncIntervalMinutes: 5
-  };
-}
-function setWorkingWorkspaceConfig(cfg) {
-  const current = getWorkingWorkspaceConfig();
-  const updated = {
-    workingDirectory: (cfg.workingDirectory || current.workingDirectory).trim(),
-    autoSyncIntervalMinutes: cfg.autoSyncIntervalMinutes || current.autoSyncIntervalMinutes
-  };
-  try {
-    fs.mkdirSync(path.dirname(CONFIG_FILE), { recursive: true });
-    fs.writeFileSync(CONFIG_FILE, JSON.stringify(updated, null, 2), "utf-8");
-  } catch (err) {
-    console.warn("[WorkspaceSync] Failed to persist working config:", err);
-  }
-  return updated;
-}
-function getWorkingWorkspaceDir() {
-  const dir = getWorkingWorkspaceConfig().workingDirectory;
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-  return dir;
-}
-async function findWorkspaceRecord(workspaceId) {
-  try {
-    if (fs.existsSync(ACCOUNTS_FILE)) {
-      const raw = fs.readFileSync(ACCOUNTS_FILE, "utf-8");
-      const accounts = JSON.parse(raw);
-      for (const u of Object.values(accounts)) {
-        if (Array.isArray(u.workspaces)) {
-          const ws = u.workspaces.find((w) => w.id === workspaceId);
-          if (ws) {
-            const conns = Array.isArray(u.storage_connections) ? u.storage_connections : [];
-            const conn = conns.find((c) => c.id === ws.storageConnectionId) || conns[0] || null;
-            return { user: u, workspace: ws, connection: conn };
-          }
-        }
-      }
-    }
-  } catch {
-  }
-  try {
-    const res = await queryUnifiedDb(`SELECT id, email, username, app_profiles FROM "ultrst-users"`);
-    for (const u of res.rows) {
-      const profiles = typeof u.app_profiles === "string" ? JSON.parse(u.app_profiles) : u.app_profiles || {};
-      const qwnsr = profiles.qwnsr || {};
-      const workspaces = Array.isArray(qwnsr.workspaces) ? qwnsr.workspaces : [];
-      const ws = workspaces.find((w) => w.id === workspaceId);
-      if (ws) {
-        const conns = qwnsr.storage_connections || profiles.srkl?.storage_connections || [];
-        const conn = conns.find((c) => c.id === ws.storageConnectionId) || conns[0] || null;
-        return { user: u, workspace: ws, connection: conn };
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-function getWorkspaceFolderKey(workspace, user) {
-  if (workspace.localFolderKey) return workspace.localFolderKey;
-  if (workspace.localFolderName && workspace.localFolderName.startsWith("ultrst_")) return workspace.localFolderName;
-  const userName = user?.username || user?.name || (user?.email ? user.email.split("@")[0] : "user");
-  return formatCanonicalWorkspaceFolderName2("qwnsr", userName, workspace.name);
-}
-async function collectLocalFiles(dir, baseDir = dir) {
-  if (!fs.existsSync(dir)) return [];
-  const entries = await fs.promises.readdir(dir, { withFileTypes: true });
-  const results = [];
-  for (const entry of entries) {
-    if (entry.name.startsWith(".") && entry.name !== ".bzEmpty") continue;
-    const full = path.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      const nested = await collectLocalFiles(full, baseDir);
-      results.push(...nested);
-    } else if (entry.isFile()) {
-      const st = await fs.promises.stat(full);
-      const rel = path.relative(baseDir, full).replace(/\\/g, "/");
-      results.push({ relPath: rel, fullPath: full, mtimeMs: st.mtimeMs, sizeBytes: st.size });
-    }
-  }
-  return results;
-}
-async function syncWorkspace(workspaceId) {
-  const match = await findWorkspaceRecord(workspaceId);
-  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-  if (!match) {
-    return {
-      success: false,
-      workspaceId,
-      folderKey: workspaceId,
-      workingDir: getWorkingWorkspaceDir(),
-      persistenceType: "local_fs",
-      targetLocation: "Unknown",
-      syncedFiles: [],
-      uploadedCount: 0,
-      downloadedCount: 0,
-      syncedAt: nowIso,
-      error: `Workspace '${workspaceId}' not found.`
-    };
-  }
-  const { workspace, user, connection } = match;
-  const folderKey = getWorkspaceFolderKey(workspace, user);
-  const workingDir = getWorkingWorkspaceDir();
-  const isB2 = workspace.storageProvider === "backblaze_b2" || workspace.storageConfig?.type === "b2";
-  const syncedFiles = [];
-  let uploadedCount = 0;
-  let downloadedCount = 0;
-  if (isB2) {
-    const creds = workspace.storageConfig || connection?.credentials || connection || {};
-    const keyId = creds.keyId || creds.b2KeyId;
-    const appKey = creds.applicationKey || creds.b2ApplicationKey || creds.appKey;
-    const bucketName = creds.bucketName || creds.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-    if (!keyId || !appKey) {
-      return {
-        success: false,
-        workspaceId,
-        folderKey,
-        workingDir,
-        persistenceType: "backblaze_b2",
-        targetLocation: bucketName,
-        syncedFiles: [],
-        uploadedCount: 0,
-        downloadedCount: 0,
-        syncedAt: nowIso,
-        error: "Missing Backblaze B2 credentials for sync."
-      };
-    }
-    try {
-      const b2Prefix = `${folderKey}/`;
-      const remoteFiles = await b2ListFileNames2(keyId, appKey, bucketName, b2Prefix);
-      const remoteMap = /* @__PURE__ */ new Map();
-      for (const rf of remoteFiles) {
-        const cleanName = rf.fileName.slice(b2Prefix.length);
-        if (cleanName) remoteMap.set(cleanName, { fileId: rf.fileId, size: rf.contentLength, timestamp: rf.uploadTimestamp });
-      }
-      const localFiles = await collectLocalFiles(workingDir);
-      const localMap = /* @__PURE__ */ new Map();
-      for (const lf of localFiles) {
-        localMap.set(lf.relPath, lf);
-      }
-      for (const [relPath, rInfo] of remoteMap.entries()) {
-        const lFile = localMap.get(relPath);
-        const shouldDownload = !lFile || rInfo.timestamp > lFile.mtimeMs + 2e3;
-        if (shouldDownload) {
-          const buf = await b2DownloadFile2(keyId, appKey, bucketName, `${b2Prefix}${relPath}`);
-          if (buf) {
-            const destPath = path.join(workingDir, relPath);
-            await fs.promises.mkdir(path.dirname(destPath), { recursive: true });
-            await fs.promises.writeFile(destPath, buf);
-            try {
-              const fileTime = new Date(rInfo.timestamp);
-              await fs.promises.utimes(destPath, fileTime, fileTime);
-            } catch {
-            }
-            syncedFiles.push({ fileName: relPath, action: "DOWNLOADED", sizeBytes: buf.byteLength });
-            downloadedCount++;
-          }
-        }
-      }
-      for (const [relPath, lFile] of localMap.entries()) {
-        const rInfo = remoteMap.get(relPath);
-        const shouldUpload = !rInfo || lFile.mtimeMs > rInfo.timestamp + 2e3;
-        if (shouldUpload) {
-          const content = await fs.promises.readFile(lFile.fullPath);
-          await b2UploadFile2(keyId, appKey, bucketName, `${b2Prefix}${relPath}`, new Uint8Array(content));
-          syncedFiles.push({ fileName: relPath, action: "UPLOADED", sizeBytes: lFile.sizeBytes });
-          uploadedCount++;
-        } else if (!syncedFiles.some((f) => f.fileName === relPath)) {
-          syncedFiles.push({ fileName: relPath, action: "UP_TO_DATE", sizeBytes: lFile.sizeBytes });
-        }
-      }
-      return {
-        success: true,
-        workspaceId,
-        folderKey,
-        workingDir,
-        persistenceType: "backblaze_b2",
-        targetLocation: `B2://${bucketName}/${folderKey}/`,
-        syncedFiles,
-        uploadedCount,
-        downloadedCount,
-        syncedAt: nowIso
-      };
-    } catch (err) {
-      return {
-        success: false,
-        workspaceId,
-        folderKey,
-        workingDir,
-        persistenceType: "backblaze_b2",
-        targetLocation: bucketName,
-        syncedFiles,
-        uploadedCount,
-        downloadedCount,
-        syncedAt: nowIso,
-        error: err.message || "Backblaze sync failed."
-      };
-    }
-  }
-  const vaultDir = path.resolve(process.cwd(), folderKey);
-  await fs.promises.mkdir(vaultDir, { recursive: true });
-  try {
-    const vaultFiles = await collectLocalFiles(vaultDir);
-    const vaultMap = new Map(vaultFiles.map((f) => [f.relPath, f]));
-    const workingFiles = await collectLocalFiles(workingDir);
-    const workingMap = new Map(workingFiles.map((f) => [f.relPath, f]));
-    for (const [relPath, vFile] of vaultMap.entries()) {
-      const wFile = workingMap.get(relPath);
-      const shouldDownload = !wFile || vFile.mtimeMs > wFile.mtimeMs + 1e3;
-      if (shouldDownload) {
-        const dest = path.join(workingDir, relPath);
-        await fs.promises.mkdir(path.dirname(dest), { recursive: true });
-        await fs.promises.copyFile(vFile.fullPath, dest);
-        try {
-          const vTime = new Date(vFile.mtimeMs);
-          await fs.promises.utimes(dest, vTime, vTime);
-        } catch {
-        }
-        syncedFiles.push({ fileName: relPath, action: "DOWNLOADED", sizeBytes: vFile.sizeBytes });
-        downloadedCount++;
-      }
-    }
-    for (const [relPath, wFile] of workingMap.entries()) {
-      const vFile = vaultMap.get(relPath);
-      const shouldUpload = !vFile || wFile.mtimeMs > vFile.mtimeMs + 1e3;
-      if (shouldUpload) {
-        const dest = path.join(vaultDir, relPath);
-        await fs.promises.mkdir(path.dirname(dest), { recursive: true });
-        await fs.promises.copyFile(wFile.fullPath, dest);
-        try {
-          const wTime = new Date(wFile.mtimeMs);
-          await fs.promises.utimes(dest, wTime, wTime);
-        } catch {
-        }
-        syncedFiles.push({ fileName: relPath, action: "UPLOADED", sizeBytes: wFile.sizeBytes });
-        uploadedCount++;
-      } else if (!syncedFiles.some((f) => f.fileName === relPath)) {
-        syncedFiles.push({ fileName: relPath, action: "UP_TO_DATE", sizeBytes: wFile.sizeBytes });
-      }
-    }
-    return {
-      success: true,
-      workspaceId,
-      folderKey,
-      workingDir,
-      persistenceType: "local_fs",
-      targetLocation: vaultDir,
-      syncedFiles,
-      uploadedCount,
-      downloadedCount,
-      syncedAt: nowIso
-    };
-  } catch (err) {
-    return {
-      success: false,
-      workspaceId,
-      folderKey,
-      workingDir,
-      persistenceType: "local_fs",
-      targetLocation: vaultDir,
-      syncedFiles,
-      uploadedCount,
-      downloadedCount,
-      syncedAt: nowIso,
-      error: err.message
-    };
-  }
-}
-
 // src/core/SrklStorageService.ts
 import { S3Client, ListBucketsCommand, HeadBucketCommand } from "@aws-sdk/client-s3";
-import { promises as fs2 } from "fs";
-import path2 from "path";
-var ACCOUNTS_FILE2 = path2.resolve(".skipo/accounts.json");
+import { promises as fs } from "fs";
+import path from "path";
+var ACCOUNTS_FILE = path.resolve(".skipo/accounts.json");
 var SrklStorageService = class {
   srklBaseUrl;
   constructor(srklBaseUrl) {
@@ -893,10 +448,10 @@ var SrklStorageService = class {
   }
   async persistWorkspaceConfig(wsId, config) {
     try {
-      await fs2.mkdir(path2.dirname(ACCOUNTS_FILE2), { recursive: true });
+      await fs.mkdir(path.dirname(ACCOUNTS_FILE), { recursive: true });
       let accounts = {};
       try {
-        accounts = JSON.parse(await fs2.readFile(ACCOUNTS_FILE2, "utf-8"));
+        accounts = JSON.parse(await fs.readFile(ACCOUNTS_FILE, "utf-8"));
       } catch {
         accounts = {};
       }
@@ -907,7 +462,7 @@ var SrklStorageService = class {
             ws.storageConfig = config;
             ws.storageProvider = "backblaze_b2";
             ws.updatedAt = Date.now();
-            await fs2.writeFile(ACCOUNTS_FILE2, JSON.stringify(accounts, null, 2), "utf-8");
+            await fs.writeFile(ACCOUNTS_FILE, JSON.stringify(accounts, null, 2), "utf-8");
             return;
           }
         }
@@ -932,7 +487,7 @@ var SrklStorageService = class {
       });
     }
     try {
-      const raw = await fs2.readFile(ACCOUNTS_FILE2, "utf-8");
+      const raw = await fs.readFile(ACCOUNTS_FILE, "utf-8");
       const accounts = JSON.parse(raw);
       for (const user of Object.values(accounts)) {
         const conns = Array.isArray(user?.storage_connections) ? user.storage_connections : [];
@@ -1061,10 +616,10 @@ async function getSrklAccounts2(userId, service, env) {
     }
   }
   try {
-    const fs10 = await import("fs/promises");
-    const path10 = await import("path");
-    const accPath = path10.resolve(".skipo/accounts.json");
-    const raw = await fs10.readFile(accPath, "utf-8");
+    const fs9 = await import("fs/promises");
+    const path9 = await import("path");
+    const accPath = path9.resolve(".skipo/accounts.json");
+    const raw = await fs9.readFile(accPath, "utf-8");
     const localUsers = JSON.parse(raw);
     for (const u of Object.values(localUsers)) {
       const conns = Array.isArray(u.storage_connections) ? u.storage_connections : [];
@@ -1171,155 +726,6 @@ async function getSrklStatus(env) {
   }
 }
 
-// src/core/workspaceFileCore.ts
-async function getFs() {
-  if (typeof process !== "undefined" && process.versions?.node) {
-    try {
-      const mod = await import("fs");
-      return mod.promises || mod.default?.promises || mod;
-    } catch {
-    }
-  }
-  return null;
-}
-async function getPath() {
-  if (typeof process !== "undefined" && process.versions?.node) {
-    try {
-      const mod = await import("path");
-      return mod.default || mod;
-    } catch {
-    }
-  }
-  return null;
-}
-function getWorkspaceFolderPrefix(workspace) {
-  return workspace.localFolderKey || workspace.localFolderName || (workspace.workspacePath ? workspace.workspacePath.replace(/^\.\//, "") : workspace.id);
-}
-function isB2Workspace(workspace, connection) {
-  return connection?.provider === "backblaze_b2" || connection?.provider === "BACKBLAZE_B2" || workspace?.storageProvider === "backblaze_b2";
-}
-async function writeWorkspaceFile(workspace, connection, relativePath, content, contentType = "application/json") {
-  const cleanRel = relativePath.replace(/^\/+/, "");
-  const prefix = getWorkspaceFolderPrefix(workspace);
-  const buffer = typeof content === "string" ? new TextEncoder().encode(content) : content;
-  if (isB2Workspace(workspace, connection)) {
-    const keyId = connection.b2KeyId || connection.keyId;
-    const appKey = connection.b2ApplicationKey || connection.appKey;
-    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-    const fullKey = `${prefix}/${cleanRel}`;
-    await b2UploadFile2(keyId, appKey, bucketName, fullKey, buffer, contentType);
-    return;
-  }
-  const fs10 = await getFs();
-  const path10 = await getPath();
-  if (!fs10 || !path10) throw new Error("Local filesystem operations not supported in this runtime.");
-  const localDir = path10.resolve(process.cwd(), prefix, path10.dirname(cleanRel));
-  await fs10.mkdir(localDir, { recursive: true });
-  await fs10.writeFile(path10.resolve(process.cwd(), prefix, cleanRel), buffer);
-}
-async function readWorkspaceFile(workspace, connection, relativePath) {
-  const cleanRel = relativePath.replace(/^\/+/, "");
-  const prefix = getWorkspaceFolderPrefix(workspace);
-  if (isB2Workspace(workspace, connection)) {
-    const keyId = connection.b2KeyId || connection.keyId;
-    const appKey = connection.b2ApplicationKey || connection.appKey;
-    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-    const fullKey = `${prefix}/${cleanRel}`;
-    return await b2DownloadFile2(keyId, appKey, bucketName, fullKey);
-  }
-  const fs10 = await getFs();
-  const path10 = await getPath();
-  if (!fs10 || !path10) return null;
-  const fullPath = path10.resolve(process.cwd(), prefix, cleanRel);
-  try {
-    const buf = await fs10.readFile(fullPath);
-    return new Uint8Array(buf);
-  } catch {
-    return null;
-  }
-}
-async function deleteWorkspaceFile(workspace, connection, relativePath) {
-  const cleanRel = relativePath.replace(/^\/+/, "");
-  const prefix = getWorkspaceFolderPrefix(workspace);
-  if (isB2Workspace(workspace, connection)) {
-    const keyId = connection.b2KeyId || connection.keyId;
-    const appKey = connection.b2ApplicationKey || connection.appKey;
-    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-    const fullKey = `${prefix}/${cleanRel}`;
-    const files = await b2ListFileNames2(keyId, appKey, bucketName, fullKey);
-    const match = files.find((f) => f.fileName === fullKey);
-    if (match) {
-      await b2DeleteFileVersion(keyId, appKey, match.fileName, match.fileId);
-      return true;
-    }
-    return false;
-  }
-  const fs10 = await getFs();
-  const path10 = await getPath();
-  if (!fs10 || !path10) return false;
-  const fullPath = path10.resolve(process.cwd(), prefix, cleanRel);
-  try {
-    await fs10.unlink(fullPath);
-    return true;
-  } catch {
-    return false;
-  }
-}
-async function listWorkspaceFiles(workspace, connection, subPrefix = "") {
-  const folderPrefix = getWorkspaceFolderPrefix(workspace);
-  const targetPrefix = subPrefix ? `${folderPrefix}/${subPrefix.replace(/^\/+/, "")}` : `${folderPrefix}/`;
-  if (isB2Workspace(workspace, connection)) {
-    const keyId = connection.b2KeyId || connection.keyId;
-    const appKey = connection.b2ApplicationKey || connection.appKey;
-    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-    const rawFiles = await b2ListFileNames2(keyId, appKey, bucketName, targetPrefix);
-    return rawFiles.map((f) => ({
-      fileName: f.fileName.slice(folderPrefix.length + 1),
-      sizeBytes: f.contentLength,
-      uploadTimestamp: f.uploadTimestamp
-    }));
-  }
-  const fs10 = await getFs();
-  const path10 = await getPath();
-  if (!fs10 || !path10) return [];
-  const baseDir = path10.resolve(process.cwd(), folderPrefix, subPrefix);
-  try {
-    const entries = await fs10.readdir(baseDir, { withFileTypes: true, recursive: true });
-    const result = [];
-    for (const entry of entries) {
-      if (entry.isFile()) {
-        const full = path10.join(entry.parentPath || baseDir, entry.name);
-        const st = await fs10.stat(full);
-        result.push({
-          fileName: path10.relative(path10.resolve(process.cwd(), folderPrefix), full),
-          sizeBytes: st.size
-        });
-      }
-    }
-    return result;
-  } catch {
-    return [];
-  }
-}
-async function deleteWorkspaceFolder(workspace, connection) {
-  const prefix = getWorkspaceFolderPrefix(workspace);
-  if (isB2Workspace(workspace, connection)) {
-    const keyId = connection.b2KeyId || connection.keyId;
-    const appKey = connection.b2ApplicationKey || connection.appKey;
-    const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-    await b2DeleteFolder(keyId, appKey, bucketName, prefix);
-    return;
-  }
-  const fs10 = await getFs();
-  const path10 = await getPath();
-  if (!fs10 || !path10) return;
-  const localDir = path10.resolve(process.cwd(), prefix);
-  try {
-    await fs10.rm(localDir, { recursive: true, force: true });
-  } catch {
-  }
-}
-
 // src/core/credentialVaultCore.ts
 var MANIFEST_PATH = "credentials/manifest.json";
 var SECRET_PREFIX = "credentials/secrets";
@@ -2684,385 +2090,6 @@ async function matchGatewayIngressAsync(urlPath, search, env) {
   return null;
 }
 
-// src/core/workspaceBucketSyncCore.ts
-function resolveWorkspaceConnection(profiles, workspace) {
-  const depm = profiles.depm || {};
-  const conns = depm.storage_connections?.length ? depm.storage_connections : profiles.srkl?.storage_connections || profiles.docustack?.storage_connections || [];
-  return conns.find((c) => c.id === workspace.storageConnectionId) || conns.find((c) => c.role === "primary") || conns[0] || null;
-}
-async function syncWorkspaceCreateToBucket(workspace, connection, env) {
-  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") return;
-  try {
-    const wsMeta = {
-      id: workspace.id,
-      name: workspace.name,
-      createdAt: workspace.createdAt,
-      updatedAt: workspace.updatedAt,
-      storageProvider: "backblaze_b2",
-      bucket: connection.b2BucketName || "ultrst-apps"
-    };
-    await writeWorkspaceFile(workspace, connection, ".bzEmpty", new Uint8Array(0), "application/x-empty");
-    await writeWorkspaceFile(workspace, connection, "workspace.json", JSON.stringify(wsMeta, null, 2), "application/json");
-    await writeWorkspaceFile(
-      workspace,
-      connection,
-      "ecosystem.json",
-      JSON.stringify({ apps: [], nodes: [], edges: [], ecosystems: [] }, null, 2),
-      "application/json"
-    );
-  } catch (err) {
-    console.warn("[WorkspaceBucketSync] Create sync error:", err.message);
-  }
-}
-async function syncWorkspaceDeleteToBucket(workspace, connection, env) {
-  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") return;
-  try {
-    await deleteWorkspaceFolder(workspace, connection);
-  } catch (err) {
-    console.warn("[WorkspaceBucketSync] Delete sync error:", err.message);
-  }
-}
-async function syncWorkspaceDataToBucket(workspace, connection, data, env) {
-  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") return;
-  try {
-    await writeWorkspaceFile(workspace, connection, "ecosystem.json", JSON.stringify(data, null, 2), "application/json");
-  } catch (err) {
-    console.warn("[WorkspaceBucketSync] Data sync error:", err.message);
-  }
-}
-
-// src/core/workspaceDataCore.ts
-async function resolveUserRow(userId, env) {
-  if (userId) {
-    const res = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1 OR email = $1 LIMIT 1`, [userId], env);
-    if (res.rows.length > 0) return res.rows[0];
-  }
-  return null;
-}
-async function loadWorkspaceData(userId, workspaceId, env) {
-  if (!workspaceId) return { success: false, error: "workspaceId required", workspace: null };
-  const user = await resolveUserRow(userId, env);
-  if (!user) return { success: false, error: "User not found", workspace: null };
-  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
-  const depm = profiles.depm || {};
-  const workspaceDataMap = depm.workspace_data || {};
-  let data = workspaceDataMap[workspaceId];
-  const isEmptyData = !data || (!data.nodes || data.nodes.length === 0) && (!data.apps || data.apps.length === 0);
-  if (isEmptyData) {
-    const ws = (depm.workspaces || []).find((w) => w.id === workspaceId);
-    if (ws) {
-      const conn = resolveWorkspaceConnection(profiles, ws);
-      if (conn) {
-        try {
-          const fileBuf = await readWorkspaceFile(ws, conn, "ecosystem.json");
-          if (fileBuf && fileBuf.length > 0) {
-            const parsed = JSON.parse(new TextDecoder().decode(fileBuf));
-            if (parsed.nodes && parsed.nodes.length > 0 || parsed.apps && parsed.apps.length > 0) {
-              if (!profiles.depm) profiles.depm = {};
-              if (!profiles.depm.workspace_data) profiles.depm.workspace_data = {};
-              profiles.depm.workspace_data[workspaceId] = parsed;
-              data = parsed;
-              await queryUnifiedDb(
-                `UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`,
-                [JSON.stringify(profiles), user.id],
-                env
-              );
-              return { success: true, workspace: data, workspaceId };
-            }
-          }
-        } catch (err) {
-          console.warn("[WorkspaceDataCore] Storage recovery check:", err.message);
-        }
-      }
-    }
-  }
-  if (!data) {
-    const ws = (depm.workspaces || []).find((w) => w.id === workspaceId);
-    const ecoName = ws?.ecosystemName || `${ws?.name || "Workspace"} Ecosystem`;
-    const fallback = {
-      apps: [],
-      accounts: [],
-      deployments: [],
-      nodes: [],
-      edges: [],
-      ecosystems: [
-        {
-          id: `eco_${workspaceId}`,
-          name: ecoName,
-          icon: "Globe",
-          health: "HEALTHY",
-          status: "SYSTEM ONLINE",
-          connectedAppsCount: 0,
-          meshLinkCount: 0,
-          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-        }
-      ],
-      ecosystemName: ecoName,
-      ecosystemNodes: [
-        {
-          id: `node_eco_root_${workspaceId}`,
-          type: "ECOSYSTEM",
-          name: ecoName,
-          x: 0,
-          y: 0,
-          appId: "__ecosystem__",
-          icon: "Globe",
-          ecosystemData: { connectedAppsCount: 0, health: "HEALTHY", status: "SYSTEM ONLINE" }
-        }
-      ],
-      ecosystemEdges: []
-    };
-    return { success: true, workspace: fallback, workspaceId };
-  }
-  return { success: true, workspace: data, workspaceId };
-}
-async function saveWorkspaceData(userId, workspaceId, data, env) {
-  if (!workspaceId) return { success: false, error: "workspaceId required" };
-  const user = await resolveUserRow(userId, env);
-  if (!user) return { success: false, error: "User not found" };
-  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
-  if (!profiles.depm) profiles.depm = {};
-  if (!profiles.depm.workspace_data) profiles.depm.workspace_data = {};
-  const existing = profiles.depm.workspace_data[workspaceId];
-  const incomingEmpty = (!data.nodes || data.nodes.length === 0) && (!data.apps || data.apps.length === 0);
-  const existingHasData = existing && (existing.nodes && existing.nodes.length > 0 || existing.apps && existing.apps.length > 0);
-  if (incomingEmpty && existingHasData && !data._forceEmptySave) {
-    console.warn(`[WorkspaceDataCore] Blocked empty overwrite for workspace ${workspaceId}.`);
-    return { success: true, workspaceId, workspace: existing, protected: true };
-  }
-  profiles.depm.workspace_data[workspaceId] = data;
-  if (Array.isArray(profiles.depm.workspaces)) {
-    const ws2 = profiles.depm.workspaces.find((w) => w.id === workspaceId);
-    if (ws2) {
-      ws2.appsCount = Array.isArray(data.apps) ? data.apps.length : 0;
-      ws2.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-  }
-  await queryUnifiedDb(
-    `UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`,
-    [JSON.stringify(profiles), user.id],
-    env
-  );
-  const ws = Array.isArray(profiles.depm?.workspaces) ? profiles.depm.workspaces.find((w) => w.id === workspaceId) : null;
-  if (ws) {
-    const conn = resolveWorkspaceConnection(profiles, ws);
-    await syncWorkspaceDataToBucket(ws, conn, data, env);
-  }
-  return { success: true, workspaceId, workspace: data };
-}
-async function renameAppInWorkspaceData(userId, workspaceId, appId, newName, env) {
-  if (!workspaceId || !appId || !newName) {
-    return { success: false, error: "workspaceId, appId and newName required" };
-  }
-  const loadRes = await loadWorkspaceData(userId, workspaceId, env);
-  if (!loadRes.success || !loadRes.workspace) return loadRes;
-  const wsData = loadRes.workspace;
-  const trimmed = newName.trim();
-  const folderName = trimmed.replace(/[/\\?%*:|"<>]/g, "_");
-  if (Array.isArray(wsData.apps)) {
-    const targetApp = wsData.apps.find((a) => a.id === appId);
-    if (targetApp) {
-      targetApp.name = trimmed;
-      targetApp.folderName = folderName;
-      targetApp.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
-    }
-  }
-  if (Array.isArray(wsData.nodes)) {
-    wsData.nodes = wsData.nodes.map((n) => {
-      if (n.appId === appId && (n.type === "APP" || n.type === "APP_NODE" || n.type === "APP_GRAPH_NODE")) {
-        return { ...n, name: trimmed, appData: n.appData ? { ...n.appData, name: trimmed, folderName } : void 0 };
-      }
-      return n;
-    });
-  }
-  return await saveWorkspaceData(userId, workspaceId, wsData, env);
-}
-
-// src/core/workspaceStorageDetailsCore.ts
-async function getWorkspaceStorageDetails(workspaceId, env) {
-  if (!workspaceId) return { success: false, error: "workspaceId is required" };
-  const { workspace, connection } = await findUserWorkspace(workspaceId, env);
-  const folderPrefix = workspace?.localFolderKey || workspace?.localFolderName || (workspace?.workspacePath ? workspace.workspacePath.replace(/^\.\//, "") : workspaceId);
-  if (!connection || connection.provider !== "backblaze_b2" && connection.provider !== "BACKBLAZE_B2") {
-    return {
-      success: true,
-      workspaceId,
-      storageProvider: workspace?.storageProvider || "local_fs",
-      connection: connection || null,
-      folderPrefix,
-      localStats: { exists: false, appsCount: 0, ecosystemsCount: 0 },
-      bucket: null,
-      files: []
-    };
-  }
-  const keyId = connection.b2KeyId || connection.keyId;
-  const applicationKey = connection.b2ApplicationKey || connection.appKey;
-  const bucketName = connection.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-  try {
-    const buckets = await b2ListBuckets2(keyId, applicationKey, void 0, bucketName);
-    const bucketObj = buckets.find((b) => b.bucketName === bucketName);
-    if (!bucketObj) {
-      return {
-        success: true,
-        workspaceId,
-        storageProvider: "backblaze_b2",
-        connection: { id: connection.id, label: connection.label, provider: connection.provider },
-        folderPrefix,
-        bucket: { name: bucketName, status: "BUCKET_NOT_FOUND" },
-        files: []
-      };
-    }
-    const rawFiles = await b2ListFileNames2(keyId, applicationKey, bucketName, `${folderPrefix}/`);
-    return {
-      success: true,
-      workspaceId,
-      storageProvider: "backblaze_b2",
-      connection: { id: connection.id, label: connection.label, provider: connection.provider },
-      folderPrefix,
-      bucket: {
-        id: bucketObj.bucketId,
-        name: bucketObj.bucketName,
-        type: bucketObj.bucketType,
-        endpoint: connection.b2Endpoint || "s3.eu-central-003.backblazeb2.com",
-        region: connection.b2Region || "eu-central-003",
-        status: "CONNECTED"
-      },
-      fileCount: rawFiles.length,
-      files: rawFiles.map((f) => ({
-        fileName: f.fileName,
-        sizeBytes: f.contentLength,
-        uploadTimestamp: f.uploadTimestamp
-      }))
-    };
-  } catch (err) {
-    return {
-      success: false,
-      workspaceId,
-      storageProvider: "backblaze_b2",
-      error: err.message,
-      folderPrefix
-    };
-  }
-}
-
-// src/core/workspaceCore.ts
-async function findUserWorkspace(workspaceId, env) {
-  const res = await queryUnifiedDb(`SELECT id, email, username, app_profiles FROM "ultrst-users"`, [], env);
-  for (const user of res.rows) {
-    const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
-    const depm = profiles.depm || {};
-    const workspaces = Array.isArray(depm.workspaces) ? depm.workspaces : [];
-    const ws = workspaces.find((w) => w.id === workspaceId);
-    if (ws) {
-      const conns = depm.storage_connections || profiles.srkl?.storage_connections || profiles.docustack?.storage_connections || [];
-      const conn = conns.find((c) => c.id === ws.storageConnectionId) || conns.find((c) => c.role === "primary") || conns[0] || null;
-      return { user, workspace: ws, connection: conn };
-    }
-  }
-  return { user: null, workspace: null, connection: null };
-}
-async function getWorkspaces(userId, env) {
-  if (!userId) {
-    return { success: true, workspaces: [], activeWorkspaceId: null, storage_connections: [] };
-  }
-  const res = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1 OR email = $1 LIMIT 1`, [userId], env);
-  const userRow = res.rows[0];
-  if (!userRow) {
-    return { success: true, workspaces: [], activeWorkspaceId: null, storage_connections: [] };
-  }
-  const profiles = typeof userRow.app_profiles === "string" ? JSON.parse(userRow.app_profiles) : userRow.app_profiles || {};
-  const depm = profiles.depm || {};
-  const workspaces = Array.isArray(depm.workspaces) ? depm.workspaces : [];
-  const activeWorkspaceId = depm.activeWorkspaceId || null;
-  const conns = depm.storage_connections?.length ? depm.storage_connections : profiles.srkl?.storage_connections || [];
-  return { success: true, workspaces, activeWorkspaceId, storage_connections: conns };
-}
-async function createWorkspace(userId, wsData, env) {
-  const uRes = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1`, [userId], env);
-  const user = uRes.rows[0];
-  if (!user) throw new Error("User account not found.");
-  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
-  if (!profiles.depm) profiles.depm = {};
-  const workspaces = Array.isArray(profiles.depm.workspaces) ? profiles.depm.workspaces : [];
-  const wsName = (wsData.name || "New Workspace").trim();
-  const wsId = wsData.id || `ws-depm-${Date.now()}`;
-  const userName = user.username || user.name || "user";
-  const folderKey = `ultrst_depm_${userName.toLowerCase().replace(/[^a-z0-9]/g, "_")}_${wsName.toLowerCase().replace(/[^a-z0-9]/g, "_")}`;
-  const newWs = {
-    ...wsData,
-    id: wsId,
-    name: wsName,
-    localFolderName: folderKey,
-    localFolderKey: folderKey,
-    workspacePath: `./${folderKey}`,
-    storageProvider: wsData.storageProvider || "backblaze_b2",
-    b2BucketName: wsData.b2BucketName || "ultrst-apps",
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    updatedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  workspaces.push(newWs);
-  profiles.depm.workspaces = workspaces;
-  profiles.depm.activeWorkspaceId = wsId;
-  await queryUnifiedDb(`UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`, [JSON.stringify(profiles), user.id], env);
-  const conn = resolveWorkspaceConnection(profiles, newWs);
-  await syncWorkspaceCreateToBucket(newWs, conn, env);
-  return { success: true, workspace: newWs, workspaces };
-}
-async function updateWorkspace(userId, params, env) {
-  const uRes = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1`, [userId], env);
-  const user = uRes.rows[0];
-  if (!user) throw new Error("User not found.");
-  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
-  if (!profiles.depm) profiles.depm = {};
-  const workspaces = Array.isArray(profiles.depm.workspaces) ? profiles.depm.workspaces : [];
-  const { action, workspaceId, updates } = params;
-  const targetId = workspaceId || updates?.id;
-  const match = workspaces.find((w) => w.id === targetId);
-  if (!match) throw new Error("Workspace not found.");
-  if (action === "switch") {
-    profiles.depm.activeWorkspaceId = targetId;
-  } else {
-    const safeUpdates = { ...updates || params };
-    delete safeUpdates.storageProvider;
-    delete safeUpdates.storageConnectionId;
-    delete safeUpdates.b2BucketName;
-    delete safeUpdates.b2Endpoint;
-    delete safeUpdates.b2Region;
-    delete safeUpdates.localFolderName;
-    delete safeUpdates.localFolderKey;
-    delete safeUpdates.workspacePath;
-    delete safeUpdates.primaryStorage;
-    delete safeUpdates.id;
-    delete safeUpdates.action;
-    delete safeUpdates.workspaceId;
-    Object.assign(match, safeUpdates, { updatedAt: (/* @__PURE__ */ new Date()).toISOString() });
-  }
-  await queryUnifiedDb(`UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`, [JSON.stringify(profiles), user.id], env);
-  return { success: true, workspace: match, workspaces };
-}
-async function deleteWorkspace(userId, wsId, env) {
-  const uRes = await queryUnifiedDb(`SELECT * FROM "ultrst-users" WHERE id = $1`, [userId], env);
-  const user = uRes.rows[0];
-  if (!user) throw new Error("User not found.");
-  const profiles = typeof user.app_profiles === "string" ? JSON.parse(user.app_profiles) : user.app_profiles || {};
-  if (!profiles.depm?.workspaces) return { success: true, workspaces: [] };
-  const targetWs = profiles.depm.workspaces.find((w) => w.id === wsId);
-  const conn = targetWs ? resolveWorkspaceConnection(profiles, targetWs) : null;
-  profiles.depm.workspaces = profiles.depm.workspaces.filter((w) => w.id !== wsId);
-  if (profiles.depm.activeWorkspaceId === wsId) {
-    profiles.depm.activeWorkspaceId = profiles.depm.workspaces[0]?.id || null;
-  }
-  if (profiles.depm.workspace_data?.[wsId]) {
-    delete profiles.depm.workspace_data[wsId];
-  }
-  await queryUnifiedDb(`UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`, [JSON.stringify(profiles), user.id], env);
-  if (targetWs && conn) {
-    await syncWorkspaceDeleteToBucket(targetWs, conn, env);
-  }
-  return { success: true, workspaces: profiles.depm.workspaces };
-}
-
 // src/core/cloudflareIntegrationCore.ts
 var cfFetcher = new CloudflareResourceFetcher();
 function buildHeaders(token, authKey, authEmail) {
@@ -3529,8 +2556,8 @@ function createWavBuffer(sampleRate, numChannels, samples) {
 }
 
 // src/server/sampleGenerator.ts
-import fs3 from "fs";
-import path3 from "path";
+import fs2 from "fs";
+import path2 from "path";
 var GLOBAL_SAMPLE_DEFS = [
   {
     filename: "808_sub_boom.wav",
@@ -3627,13 +2654,13 @@ var GLOBAL_SAMPLE_DEFS = [
   }
 ];
 async function ensureGlobalSamples(globalSamplesDir) {
-  if (!fs3.existsSync(globalSamplesDir)) {
-    fs3.mkdirSync(globalSamplesDir, { recursive: true });
+  if (!fs2.existsSync(globalSamplesDir)) {
+    fs2.mkdirSync(globalSamplesDir, { recursive: true });
   }
   const sampleRate = 44100;
   for (const def of GLOBAL_SAMPLE_DEFS) {
-    const filePath = path3.join(globalSamplesDir, def.filename);
-    if (!fs3.existsSync(filePath)) {
+    const filePath = path2.join(globalSamplesDir, def.filename);
+    if (!fs2.existsSync(filePath)) {
       const numSamples = Math.floor(sampleRate * def.durationSec);
       const chL = new Float32Array(numSamples);
       const chR = new Float32Array(numSamples);
@@ -3645,16 +2672,16 @@ async function ensureGlobalSamples(globalSamplesDir) {
         chR[i] = r;
       }
       const wavBuf = createWavBuffer(sampleRate, 2, [chL, chR]);
-      await fs3.promises.writeFile(filePath, wavBuf);
+      await fs2.promises.writeFile(filePath, wavBuf);
     }
   }
 }
 
 // src/server/services/assetPoolService.ts
-import fs4 from "fs";
-import path4 from "path";
-var WORKSPACE_ASSETS_ROOT = path4.join(process.cwd(), "assets");
-var PROJECTS_ROOT = path4.join(process.cwd(), "projects");
+import fs3 from "fs";
+import path3 from "path";
+var WORKSPACE_ASSETS_ROOT = path3.join(process.cwd(), "assets");
+var PROJECTS_ROOT = path3.join(process.cwd(), "projects");
 var SUPPORTED_AUDIO_EXTS = [
   ".wav",
   ".mp3",
@@ -3672,27 +2699,27 @@ var SUPPORTED_AUDIO_EXTS = [
 var SUPPORTED_MIDI_EXTS = [".mid", ".midi", ".json"];
 async function ensureAssetPoolDirectories(rootDir) {
   const dirs = [
-    path4.join(rootDir, "audio", "stereo", "default"),
-    path4.join(rootDir, "audio", "stereo", "userdefined"),
-    path4.join(rootDir, "audio", "mono", "default"),
-    path4.join(rootDir, "audio", "mono", "userdefined"),
-    path4.join(rootDir, "midi", "default"),
-    path4.join(rootDir, "midi", "userdefined")
+    path3.join(rootDir, "audio", "stereo", "default"),
+    path3.join(rootDir, "audio", "stereo", "userdefined"),
+    path3.join(rootDir, "audio", "mono", "default"),
+    path3.join(rootDir, "audio", "mono", "userdefined"),
+    path3.join(rootDir, "midi", "default"),
+    path3.join(rootDir, "midi", "userdefined")
   ];
   for (const dir of dirs) {
-    if (!fs4.existsSync(dir)) {
-      await fs4.promises.mkdir(dir, { recursive: true });
+    if (!fs3.existsSync(dir)) {
+      await fs3.promises.mkdir(dir, { recursive: true });
     }
   }
 }
 async function seedDefaultAssets() {
   await ensureAssetPoolDirectories(WORKSPACE_ASSETS_ROOT);
-  const stereoDefaultDir = path4.join(WORKSPACE_ASSETS_ROOT, "audio", "stereo", "default");
-  const monoDefaultDir = path4.join(WORKSPACE_ASSETS_ROOT, "audio", "mono", "default");
-  const midiDefaultDir = path4.join(WORKSPACE_ASSETS_ROOT, "midi", "default");
+  const stereoDefaultDir = path3.join(WORKSPACE_ASSETS_ROOT, "audio", "stereo", "default");
+  const monoDefaultDir = path3.join(WORKSPACE_ASSETS_ROOT, "audio", "mono", "default");
+  const midiDefaultDir = path3.join(WORKSPACE_ASSETS_ROOT, "midi", "default");
   const sampleRate = 44100;
-  const subBoomPath = path4.join(stereoDefaultDir, "808_sub_boom.wav");
-  if (!fs4.existsSync(subBoomPath)) {
+  const subBoomPath = path3.join(stereoDefaultDir, "808_sub_boom.wav");
+  if (!fs3.existsSync(subBoomPath)) {
     const numSamples = Math.floor(sampleRate * 1.8);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -3703,10 +2730,10 @@ async function seedDefaultAssets() {
       chL[i] = s;
       chR[i] = s;
     }
-    await fs4.promises.writeFile(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    await fs3.promises.writeFile(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const leadPath = path4.join(stereoDefaultDir, "celestial_lead.wav");
-  if (!fs4.existsSync(leadPath)) {
+  const leadPath = path3.join(stereoDefaultDir, "celestial_lead.wav");
+  if (!fs3.existsSync(leadPath)) {
     const numSamples = Math.floor(sampleRate * 2.5);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -3720,10 +2747,10 @@ async function seedDefaultAssets() {
       chL[i] = s1 * env;
       chR[i] = (s1 + s2 * 0.5) * env;
     }
-    await fs4.promises.writeFile(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    await fs3.promises.writeFile(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const padPath = path4.join(stereoDefaultDir, "ethereal_pad.wav");
-  if (!fs4.existsSync(padPath)) {
+  const padPath = path3.join(stereoDefaultDir, "ethereal_pad.wav");
+  if (!fs3.existsSync(padPath)) {
     const numSamples = Math.floor(sampleRate * 3);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -3742,10 +2769,10 @@ async function seedDefaultAssets() {
       chL[i] = left * env;
       chR[i] = right * env;
     }
-    await fs4.promises.writeFile(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    await fs3.promises.writeFile(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const snarePath = path4.join(monoDefaultDir, "snare_snappy.wav");
-  if (!fs4.existsSync(snarePath)) {
+  const snarePath = path3.join(monoDefaultDir, "snare_snappy.wav");
+  if (!fs3.existsSync(snarePath)) {
     const numSamples = Math.floor(sampleRate * 0.8);
     const chM = new Float32Array(numSamples);
     for (let i = 0; i < numSamples; i++) {
@@ -3755,10 +2782,10 @@ async function seedDefaultAssets() {
       const noise = (Math.random() * 2 - 1) * Math.exp(-p * 4.5) * 0.6;
       chM[i] = tone + noise;
     }
-    await fs4.promises.writeFile(snarePath, createWavBuffer(sampleRate, 1, [chM]));
+    await fs3.promises.writeFile(snarePath, createWavBuffer(sampleRate, 1, [chM]));
   }
-  const hihatPath = path4.join(monoDefaultDir, "hihat_closed.wav");
-  if (!fs4.existsSync(hihatPath)) {
+  const hihatPath = path3.join(monoDefaultDir, "hihat_closed.wav");
+  if (!fs3.existsSync(hihatPath)) {
     const numSamples = Math.floor(sampleRate * 0.25);
     const chM = new Float32Array(numSamples);
     for (let i = 0; i < numSamples; i++) {
@@ -3766,10 +2793,10 @@ async function seedDefaultAssets() {
       const noise = (Math.random() * 2 - 1) * Math.exp(-p * 20);
       chM[i] = noise * 0.5;
     }
-    await fs4.promises.writeFile(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
+    await fs3.promises.writeFile(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
   }
-  const midiChordPath = path4.join(midiDefaultDir, "lydian_celestial_pad.json");
-  if (!fs4.existsSync(midiChordPath)) {
+  const midiChordPath = path3.join(midiDefaultDir, "lydian_celestial_pad.json");
+  if (!fs3.existsSync(midiChordPath)) {
     const starterMidiPattern = {
       id: "pat-default-lydian",
       name: "Lydian Celestial Pad",
@@ -3782,31 +2809,31 @@ async function seedDefaultAssets() {
         { note: 71, name: "B4", velocity: 0.75, time: 0, duration: 3.8 }
       ]
     };
-    await fs4.promises.writeFile(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
+    await fs3.promises.writeFile(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
   }
   await ensureProjectAssets("default-kingdom");
 }
 async function ensureProjectAssets(projectId) {
-  const safeId = path4.basename(projectId);
-  const projectAssetsDir = path4.join(PROJECTS_ROOT, safeId, "assets");
+  const safeId = path3.basename(projectId);
+  const projectAssetsDir = path3.join(PROJECTS_ROOT, safeId, "assets");
   await ensureAssetPoolDirectories(projectAssetsDir);
   return projectAssetsDir;
 }
 function getAssetPoolLocationPath(scope, projectId, dataType, channelType, subfolder = "userdefined") {
-  const root = scope === "project" && projectId ? path4.join(PROJECTS_ROOT, path4.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
-  const safeSub = path4.basename(subfolder).replace(/[^a-zA-Z0-9._-]/g, "_");
+  const root = scope === "project" && projectId ? path3.join(PROJECTS_ROOT, path3.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
+  const safeSub = path3.basename(subfolder).replace(/[^a-zA-Z0-9._-]/g, "_");
   if (dataType === "audio") {
     const safeChannel = channelType === "mono" ? "mono" : "stereo";
-    return path4.join(root, "audio", safeChannel, safeSub);
+    return path3.join(root, "audio", safeChannel, safeSub);
   } else {
-    return path4.join(root, "midi", safeSub);
+    return path3.join(root, "midi", safeSub);
   }
 }
 function getAssetPoolPublicUrl(scope, projectId, dataType, channelType, subfolder, filename) {
-  const safeFilename = path4.basename(filename);
-  const safeSub = path4.basename(subfolder);
+  const safeFilename = path3.basename(filename);
+  const safeSub = path3.basename(subfolder);
   if (scope === "project" && projectId) {
-    const safeProj = path4.basename(projectId);
+    const safeProj = path3.basename(projectId);
     if (dataType === "audio") {
       const channel = channelType === "mono" ? "mono" : "stereo";
       return `/projects/${safeProj}/assets/audio/${channel}/${safeSub}/${safeFilename}`;
@@ -3828,31 +2855,31 @@ async function scanAssetPool(scope, projectId) {
   } else {
     await ensureAssetPoolDirectories(WORKSPACE_ASSETS_ROOT);
   }
-  const rootDir = scope === "project" && projectId ? path4.join(PROJECTS_ROOT, path4.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
+  const rootDir = scope === "project" && projectId ? path3.join(PROJECTS_ROOT, path3.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
   const folders = [];
   const items = [];
   async function scanCategoryFolder(dataType, channelType) {
-    const catDir = dataType === "audio" ? path4.join(rootDir, "audio", channelType === "mono" ? "mono" : "stereo") : path4.join(rootDir, "midi");
-    if (!fs4.existsSync(catDir)) {
-      await fs4.promises.mkdir(catDir, { recursive: true });
+    const catDir = dataType === "audio" ? path3.join(rootDir, "audio", channelType === "mono" ? "mono" : "stereo") : path3.join(rootDir, "midi");
+    if (!fs3.existsSync(catDir)) {
+      await fs3.promises.mkdir(catDir, { recursive: true });
     }
-    const subentries = await fs4.promises.readdir(catDir, { withFileTypes: true });
+    const subentries = await fs3.promises.readdir(catDir, { withFileTypes: true });
     for (const entry of subentries) {
       if (!entry.isDirectory()) continue;
       const subfolderName = entry.name;
-      const subfolderDir = path4.join(catDir, subfolderName);
-      const files = await fs4.promises.readdir(subfolderDir);
+      const subfolderDir = path3.join(catDir, subfolderName);
+      const files = await fs3.promises.readdir(subfolderDir);
       let validFileCount = 0;
       for (const file of files) {
         if (file.startsWith(".")) continue;
-        const ext = path4.extname(file).toLowerCase();
+        const ext = path3.extname(file).toLowerCase();
         const isAudio = SUPPORTED_AUDIO_EXTS.includes(ext);
         const isMidi = SUPPORTED_MIDI_EXTS.includes(ext);
         if (dataType === "audio" && !isAudio || dataType === "midi" && !isMidi) continue;
         validFileCount++;
-        const filePath = path4.join(subfolderDir, file);
-        const stat = await fs4.promises.stat(filePath);
-        const cleanName = path4.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+        const filePath = path3.join(subfolderDir, file);
+        const stat = await fs3.promises.stat(filePath);
+        const cleanName = path3.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
         const relPath = dataType === "audio" ? `audio/${channelType === "mono" ? "mono" : "stereo"}/${subfolderName}/${file}` : `midi/${subfolderName}/${file}`;
         const url = getAssetPoolPublicUrl(
           scope,
@@ -3893,7 +2920,7 @@ async function scanAssetPool(scope, projectId) {
   return { folders, items };
 }
 async function createAssetSubfolder(params) {
-  const safeName = path4.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
+  const safeName = path3.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
   if (!safeName) throw new Error("Invalid subfolder name");
   const dirPath = getAssetPoolLocationPath(
     params.scope,
@@ -3902,8 +2929,8 @@ async function createAssetSubfolder(params) {
     params.channelType,
     safeName
   );
-  if (!fs4.existsSync(dirPath)) {
-    await fs4.promises.mkdir(dirPath, { recursive: true });
+  if (!fs3.existsSync(dirPath)) {
+    await fs3.promises.mkdir(dirPath, { recursive: true });
   }
   return {
     name: safeName,
@@ -3922,16 +2949,16 @@ async function saveAssetToPool(params) {
     params.channelType,
     subfolder
   );
-  if (!fs4.existsSync(targetDir)) {
-    await fs4.promises.mkdir(targetDir, { recursive: true });
+  if (!fs3.existsSync(targetDir)) {
+    await fs3.promises.mkdir(targetDir, { recursive: true });
   }
-  const safeFilename = path4.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
-  const ext = path4.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
-  const filePath = path4.join(targetDir, safeFilename);
+  const safeFilename = path3.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
+  const ext = path3.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
+  const filePath = path3.join(targetDir, safeFilename);
   const buffer = Buffer.from(params.base64Content, "base64");
-  await fs4.promises.writeFile(filePath, buffer);
-  const stat = await fs4.promises.stat(filePath);
-  const cleanName = path4.basename(safeFilename, ext).replace(/[-_]/g, " ");
+  await fs3.promises.writeFile(filePath, buffer);
+  const stat = await fs3.promises.stat(filePath);
+  const cleanName = path3.basename(safeFilename, ext).replace(/[-_]/g, " ");
   const relPath = params.dataType === "audio" ? `audio/${params.channelType === "mono" ? "mono" : "stereo"}/${subfolder}/${safeFilename}` : `midi/${subfolder}/${safeFilename}`;
   const url = getAssetPoolPublicUrl(
     params.scope,
@@ -3965,19 +2992,19 @@ async function deleteAssetFromPool(params) {
     params.channelType,
     params.subfolder
   );
-  const filePath = path4.join(targetDir, path4.basename(params.filename));
-  if (fs4.existsSync(filePath)) {
-    await fs4.promises.unlink(filePath);
+  const filePath = path3.join(targetDir, path3.basename(params.filename));
+  if (fs3.existsSync(filePath)) {
+    await fs3.promises.unlink(filePath);
     return true;
   }
   return false;
 }
 
 // src/server/services/graphAssetService.ts
-import fs5 from "fs";
-import path5 from "path";
-var WORKSPACE_ROOT = path5.join(process.cwd(), "workspaces", "default");
-var GRAPHS_ROOT = path5.join(WORKSPACE_ROOT, "graphs");
+import fs4 from "fs";
+import path4 from "path";
+var WORKSPACE_ROOT = path4.join(process.cwd(), "workspaces", "default");
+var GRAPHS_ROOT = path4.join(WORKSPACE_ROOT, "graphs");
 var SUPPORTED_AUDIO_EXTS2 = [
   ".wav",
   ".mp3",
@@ -3995,26 +3022,26 @@ var SUPPORTED_AUDIO_EXTS2 = [
 var SUPPORTED_MIDI_EXTS2 = [".mid", ".midi", ".json"];
 function ensureGraphAssetDirectories(graphDir) {
   const dirs = [
-    path5.join(graphDir, "assets", "audio", "stereo", "default"),
-    path5.join(graphDir, "assets", "audio", "stereo", "userdefined"),
-    path5.join(graphDir, "assets", "audio", "mono", "default"),
-    path5.join(graphDir, "assets", "audio", "mono", "userdefined"),
-    path5.join(graphDir, "assets", "midi", "default"),
-    path5.join(graphDir, "assets", "midi", "userdefined")
+    path4.join(graphDir, "assets", "audio", "stereo", "default"),
+    path4.join(graphDir, "assets", "audio", "stereo", "userdefined"),
+    path4.join(graphDir, "assets", "audio", "mono", "default"),
+    path4.join(graphDir, "assets", "audio", "mono", "userdefined"),
+    path4.join(graphDir, "assets", "midi", "default"),
+    path4.join(graphDir, "assets", "midi", "userdefined")
   ];
   for (const dir of dirs) {
-    if (!fs5.existsSync(dir)) {
-      fs5.mkdirSync(dir, { recursive: true });
+    if (!fs4.existsSync(dir)) {
+      fs4.mkdirSync(dir, { recursive: true });
     }
   }
 }
 function seedStarterGraphAssets(graphDir) {
-  const stereoDefaultDir = path5.join(graphDir, "assets", "audio", "stereo", "default");
-  const monoDefaultDir = path5.join(graphDir, "assets", "audio", "mono", "default");
-  const midiDefaultDir = path5.join(graphDir, "assets", "midi", "default");
+  const stereoDefaultDir = path4.join(graphDir, "assets", "audio", "stereo", "default");
+  const monoDefaultDir = path4.join(graphDir, "assets", "audio", "mono", "default");
+  const midiDefaultDir = path4.join(graphDir, "assets", "midi", "default");
   const sampleRate = 44100;
-  const subBoomPath = path5.join(stereoDefaultDir, "808_sub_boom.wav");
-  if (!fs5.existsSync(subBoomPath)) {
+  const subBoomPath = path4.join(stereoDefaultDir, "808_sub_boom.wav");
+  if (!fs4.existsSync(subBoomPath)) {
     const numSamples = Math.floor(sampleRate * 1.8);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -4025,10 +3052,10 @@ function seedStarterGraphAssets(graphDir) {
       chL[i] = s;
       chR[i] = s;
     }
-    fs5.writeFileSync(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    fs4.writeFileSync(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const leadPath = path5.join(stereoDefaultDir, "celestial_lead.wav");
-  if (!fs5.existsSync(leadPath)) {
+  const leadPath = path4.join(stereoDefaultDir, "celestial_lead.wav");
+  if (!fs4.existsSync(leadPath)) {
     const numSamples = Math.floor(sampleRate * 2.5);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -4042,10 +3069,10 @@ function seedStarterGraphAssets(graphDir) {
       chL[i] = s1 * env;
       chR[i] = (s1 + s2 * 0.5) * env;
     }
-    fs5.writeFileSync(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    fs4.writeFileSync(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const padPath = path5.join(stereoDefaultDir, "ethereal_pad.wav");
-  if (!fs5.existsSync(padPath)) {
+  const padPath = path4.join(stereoDefaultDir, "ethereal_pad.wav");
+  if (!fs4.existsSync(padPath)) {
     const numSamples = Math.floor(sampleRate * 3);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -4064,10 +3091,10 @@ function seedStarterGraphAssets(graphDir) {
       chL[i] = left * env;
       chR[i] = right * env;
     }
-    fs5.writeFileSync(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    fs4.writeFileSync(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const snarePath = path5.join(monoDefaultDir, "snare_snappy.wav");
-  if (!fs5.existsSync(snarePath)) {
+  const snarePath = path4.join(monoDefaultDir, "snare_snappy.wav");
+  if (!fs4.existsSync(snarePath)) {
     const numSamples = Math.floor(sampleRate * 0.8);
     const chM = new Float32Array(numSamples);
     for (let i = 0; i < numSamples; i++) {
@@ -4077,10 +3104,10 @@ function seedStarterGraphAssets(graphDir) {
       const noise = (Math.random() * 2 - 1) * Math.exp(-p * 4.5) * 0.6;
       chM[i] = tone + noise;
     }
-    fs5.writeFileSync(snarePath, createWavBuffer(sampleRate, 1, [chM]));
+    fs4.writeFileSync(snarePath, createWavBuffer(sampleRate, 1, [chM]));
   }
-  const hihatPath = path5.join(monoDefaultDir, "hihat_closed.wav");
-  if (!fs5.existsSync(hihatPath)) {
+  const hihatPath = path4.join(monoDefaultDir, "hihat_closed.wav");
+  if (!fs4.existsSync(hihatPath)) {
     const numSamples = Math.floor(sampleRate * 0.25);
     const chM = new Float32Array(numSamples);
     for (let i = 0; i < numSamples; i++) {
@@ -4088,10 +3115,10 @@ function seedStarterGraphAssets(graphDir) {
       const noise = (Math.random() * 2 - 1) * Math.exp(-p * 20);
       chM[i] = noise * 0.5;
     }
-    fs5.writeFileSync(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
+    fs4.writeFileSync(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
   }
-  const midiChordPath = path5.join(midiDefaultDir, "lydian_celestial_pad.json");
-  if (!fs5.existsSync(midiChordPath)) {
+  const midiChordPath = path4.join(midiDefaultDir, "lydian_celestial_pad.json");
+  if (!fs4.existsSync(midiChordPath)) {
     const starterMidiPattern = {
       id: "pat-default-lydian",
       name: "Lydian Celestial Pad",
@@ -4104,43 +3131,43 @@ function seedStarterGraphAssets(graphDir) {
         { note: 71, name: "B4", velocity: 0.75, time: 0, duration: 3.8 }
       ]
     };
-    fs5.writeFileSync(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
+    fs4.writeFileSync(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
   }
 }
 async function scanGraphAssets(graphId, includeImported = true) {
-  const safeGraphId = path5.basename(graphId);
-  const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
-  if (!fs5.existsSync(graphDir)) {
-    await fs5.promises.mkdir(graphDir, { recursive: true });
+  const safeGraphId = path4.basename(graphId);
+  const graphDir = path4.join(GRAPHS_ROOT, safeGraphId);
+  if (!fs4.existsSync(graphDir)) {
+    await fs4.promises.mkdir(graphDir, { recursive: true });
   }
   ensureGraphAssetDirectories(graphDir);
   const folders = [];
   const items = [];
   const importedItems = [];
   async function scanSingleGraph(gId, isImported, ownerName) {
-    const currentGraphDir = path5.join(GRAPHS_ROOT, path5.basename(gId));
-    const assetsDir = path5.join(currentGraphDir, "assets");
-    if (!fs5.existsSync(assetsDir)) return;
+    const currentGraphDir = path4.join(GRAPHS_ROOT, path4.basename(gId));
+    const assetsDir = path4.join(currentGraphDir, "assets");
+    if (!fs4.existsSync(assetsDir)) return;
     async function scanCategoryFolder(dataType, channelType) {
-      const catDir = dataType === "audio" ? path5.join(assetsDir, "audio", channelType === "mono" ? "mono" : "stereo") : path5.join(assetsDir, "midi");
-      if (!fs5.existsSync(catDir)) return;
-      const subentries = await fs5.promises.readdir(catDir, { withFileTypes: true });
+      const catDir = dataType === "audio" ? path4.join(assetsDir, "audio", channelType === "mono" ? "mono" : "stereo") : path4.join(assetsDir, "midi");
+      if (!fs4.existsSync(catDir)) return;
+      const subentries = await fs4.promises.readdir(catDir, { withFileTypes: true });
       for (const entry of subentries) {
         if (!entry.isDirectory()) continue;
         const subfolderName = entry.name;
-        const subfolderDir = path5.join(catDir, subfolderName);
-        const files = await fs5.promises.readdir(subfolderDir);
+        const subfolderDir = path4.join(catDir, subfolderName);
+        const files = await fs4.promises.readdir(subfolderDir);
         let validFileCount = 0;
         for (const file of files) {
           if (file.startsWith(".")) continue;
-          const ext = path5.extname(file).toLowerCase();
+          const ext = path4.extname(file).toLowerCase();
           const isAudio = SUPPORTED_AUDIO_EXTS2.includes(ext);
           const isMidi = SUPPORTED_MIDI_EXTS2.includes(ext);
           if (dataType === "audio" && !isAudio || dataType === "midi" && !isMidi) continue;
           validFileCount++;
-          const filePath = path5.join(subfolderDir, file);
-          const stat = await fs5.promises.stat(filePath);
-          const cleanName = path5.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+          const filePath = path4.join(subfolderDir, file);
+          const stat = await fs4.promises.stat(filePath);
+          const cleanName = path4.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
           const relPath = dataType === "audio" ? `audio/${channelType === "mono" ? "mono" : "stereo"}/${subfolderName}/${file}` : `midi/${subfolderName}/${file}`;
           const url = dataType === "audio" ? `/graphs/${gId}/assets/audio/${channelType === "mono" ? "mono" : "stereo"}/${subfolderName}/${file}` : `/graphs/${gId}/assets/midi/${subfolderName}/${file}`;
           const item = {
@@ -4183,18 +3210,18 @@ async function scanGraphAssets(graphId, includeImported = true) {
   }
   await scanSingleGraph(safeGraphId, false);
   if (includeImported) {
-    const qmsFile = path5.join(graphDir, "graph.qms");
-    if (fs5.existsSync(qmsFile)) {
+    const qmsFile = path4.join(graphDir, "graph.qms");
+    if (fs4.existsSync(qmsFile)) {
       try {
-        const raw = await fs5.promises.readFile(qmsFile, "utf-8");
+        const raw = await fs4.promises.readFile(qmsFile, "utf-8");
         const pkg = JSON.parse(raw);
         const importedIds = pkg?.metadata?.importedGraphIds || [];
         for (const impId of importedIds) {
-          const impQms = path5.join(GRAPHS_ROOT, impId, "graph.qms");
+          const impQms = path4.join(GRAPHS_ROOT, impId, "graph.qms");
           let impName = impId;
-          if (fs5.existsSync(impQms)) {
+          if (fs4.existsSync(impQms)) {
             try {
-              const impRaw = await fs5.promises.readFile(impQms, "utf-8");
+              const impRaw = await fs4.promises.readFile(impQms, "utf-8");
               const impPkg = JSON.parse(impRaw);
               impName = impPkg?.metadata?.name || impId;
             } catch {
@@ -4210,14 +3237,14 @@ async function scanGraphAssets(graphId, includeImported = true) {
   return { folders, items, importedItems };
 }
 async function createGraphAssetFolder(params) {
-  const safeGraphId = path5.basename(params.graphId);
-  const safeFolderName = path5.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
+  const safeGraphId = path4.basename(params.graphId);
+  const safeFolderName = path4.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
   if (!safeFolderName) throw new Error("Invalid subfolder name");
-  const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
+  const graphDir = path4.join(GRAPHS_ROOT, safeGraphId);
   ensureGraphAssetDirectories(graphDir);
-  const targetDir = params.dataType === "audio" ? path5.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", safeFolderName) : path5.join(graphDir, "assets", "midi", safeFolderName);
-  if (!fs5.existsSync(targetDir)) {
-    await fs5.promises.mkdir(targetDir, { recursive: true });
+  const targetDir = params.dataType === "audio" ? path4.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", safeFolderName) : path4.join(graphDir, "assets", "midi", safeFolderName);
+  if (!fs4.existsSync(targetDir)) {
+    await fs4.promises.mkdir(targetDir, { recursive: true });
   }
   return {
     name: safeFolderName,
@@ -4229,21 +3256,21 @@ async function createGraphAssetFolder(params) {
   };
 }
 async function saveAssetToGraph(params) {
-  const safeGraphId = path5.basename(params.graphId);
+  const safeGraphId = path4.basename(params.graphId);
   const subfolder = params.subfolder || "userdefined";
-  const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
+  const graphDir = path4.join(GRAPHS_ROOT, safeGraphId);
   ensureGraphAssetDirectories(graphDir);
-  const targetDir = params.dataType === "audio" ? path5.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", subfolder) : path5.join(graphDir, "assets", "midi", subfolder);
-  if (!fs5.existsSync(targetDir)) {
-    await fs5.promises.mkdir(targetDir, { recursive: true });
+  const targetDir = params.dataType === "audio" ? path4.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", subfolder) : path4.join(graphDir, "assets", "midi", subfolder);
+  if (!fs4.existsSync(targetDir)) {
+    await fs4.promises.mkdir(targetDir, { recursive: true });
   }
-  const safeFilename = path5.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
-  const ext = path5.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
-  const filePath = path5.join(targetDir, safeFilename);
+  const safeFilename = path4.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
+  const ext = path4.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
+  const filePath = path4.join(targetDir, safeFilename);
   const buffer = Buffer.from(params.base64Content, "base64");
-  await fs5.promises.writeFile(filePath, buffer);
-  const stat = await fs5.promises.stat(filePath);
-  const cleanName = path5.basename(safeFilename, ext).replace(/[-_]/g, " ");
+  await fs4.promises.writeFile(filePath, buffer);
+  const stat = await fs4.promises.stat(filePath);
+  const cleanName = path4.basename(safeFilename, ext).replace(/[-_]/g, " ");
   const relPath = params.dataType === "audio" ? `audio/${params.channelType === "mono" ? "mono" : "stereo"}/${subfolder}/${safeFilename}` : `midi/${subfolder}/${safeFilename}`;
   const url = params.dataType === "audio" ? `/graphs/${safeGraphId}/assets/audio/${params.channelType === "mono" ? "mono" : "stereo"}/${subfolder}/${safeFilename}` : `/graphs/${safeGraphId}/assets/midi/${subfolder}/${safeFilename}`;
   return {
@@ -4262,32 +3289,32 @@ async function saveAssetToGraph(params) {
   };
 }
 async function deleteAssetFromGraph(params) {
-  const safeGraphId = path5.basename(params.graphId);
-  const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
-  const targetDir = params.dataType === "audio" ? path5.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", params.subfolder) : path5.join(graphDir, "assets", "midi", params.subfolder);
-  const filePath = path5.join(targetDir, path5.basename(params.filename));
-  if (fs5.existsSync(filePath)) {
-    await fs5.promises.unlink(filePath);
+  const safeGraphId = path4.basename(params.graphId);
+  const graphDir = path4.join(GRAPHS_ROOT, safeGraphId);
+  const targetDir = params.dataType === "audio" ? path4.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", params.subfolder) : path4.join(graphDir, "assets", "midi", params.subfolder);
+  const filePath = path4.join(targetDir, path4.basename(params.filename));
+  if (fs4.existsSync(filePath)) {
+    await fs4.promises.unlink(filePath);
     return true;
   }
   return false;
 }
 
 // src/server/services/graphPackageService.ts
-import fs6 from "fs";
-import path6 from "path";
+import fs5 from "fs";
+import path5 from "path";
 import { validateGraphImport } from "@ultrst-armada/kloks/state-graph";
-var WORKSPACE_ROOT2 = path6.join(process.cwd(), "workspaces", "default");
-var GRAPHS_ROOT2 = path6.join(WORKSPACE_ROOT2, "graphs");
-var LEGACY_PROJECTS_ROOT = path6.join(process.cwd(), "projects");
+var WORKSPACE_ROOT2 = path5.join(process.cwd(), "workspaces", "default");
+var GRAPHS_ROOT2 = path5.join(WORKSPACE_ROOT2, "graphs");
+var LEGACY_PROJECTS_ROOT = path5.join(process.cwd(), "projects");
 function ensureWorkspaceStructure() {
-  if (!fs6.existsSync(GRAPHS_ROOT2)) {
-    fs6.mkdirSync(GRAPHS_ROOT2, { recursive: true });
+  if (!fs5.existsSync(GRAPHS_ROOT2)) {
+    fs5.mkdirSync(GRAPHS_ROOT2, { recursive: true });
   }
   seedStarterGraphsIfEmpty();
 }
 function seedStarterGraphsIfEmpty() {
-  const existing = fs6.existsSync(GRAPHS_ROOT2) ? fs6.readdirSync(GRAPHS_ROOT2) : [];
+  const existing = fs5.existsSync(GRAPHS_ROOT2) ? fs5.readdirSync(GRAPHS_ROOT2) : [];
   if (existing.length > 0) return;
   const introId = "intro-motif-starter";
   createInitialGraphPackageSync(
@@ -4556,9 +3583,9 @@ function seedStarterGraphsIfEmpty() {
   );
 }
 function createInitialGraphPackageSync(id, name, description, type, bpm, masterVolume, currentBiome, nodes, connections, importedGraphIds = []) {
-  const graphDir = path6.join(GRAPHS_ROOT2, id);
-  if (!fs6.existsSync(graphDir)) {
-    fs6.mkdirSync(graphDir, { recursive: true });
+  const graphDir = path5.join(GRAPHS_ROOT2, id);
+  if (!fs5.existsSync(graphDir)) {
+    fs5.mkdirSync(graphDir, { recursive: true });
   }
   ensureGraphAssetDirectories(graphDir);
   seedStarterGraphAssets(graphDir);
@@ -4591,29 +3618,29 @@ function createInitialGraphPackageSync(id, name, description, type, bpm, masterV
       connections
     }
   };
-  fs6.writeFileSync(path6.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
+  fs5.writeFileSync(path5.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
 }
 async function listAllGraphPackages() {
   ensureWorkspaceStructure();
-  const dirs = await fs6.promises.readdir(GRAPHS_ROOT2);
+  const dirs = await fs5.promises.readdir(GRAPHS_ROOT2);
   const packages = [];
   for (const dir of dirs) {
-    const graphDir = path6.join(GRAPHS_ROOT2, dir);
-    const stat = await fs6.promises.stat(graphDir);
+    const graphDir = path5.join(GRAPHS_ROOT2, dir);
+    const stat = await fs5.promises.stat(graphDir);
     if (!stat.isDirectory()) continue;
-    const qmsFile = path6.join(graphDir, "graph.qms");
-    const legacyProjectFile = path6.join(graphDir, "project.json");
+    const qmsFile = path5.join(graphDir, "graph.qms");
+    const legacyProjectFile = path5.join(graphDir, "project.json");
     let packageData = null;
-    if (fs6.existsSync(qmsFile)) {
+    if (fs5.existsSync(qmsFile)) {
       try {
-        const raw = await fs6.promises.readFile(qmsFile, "utf-8");
+        const raw = await fs5.promises.readFile(qmsFile, "utf-8");
         packageData = JSON.parse(raw);
       } catch (err) {
         console.warn(`Corrupted graph.qms in ${dir}:`, err);
       }
-    } else if (fs6.existsSync(legacyProjectFile)) {
+    } else if (fs5.existsSync(legacyProjectFile)) {
       try {
-        const raw = await fs6.promises.readFile(legacyProjectFile, "utf-8");
+        const raw = await fs5.promises.readFile(legacyProjectFile, "utf-8");
         const legacy = JSON.parse(raw);
         packageData = {
           format: "qms_graph_package",
@@ -4643,7 +3670,7 @@ async function listAllGraphPackages() {
             mapIoConfig: legacy.mapIoConfig
           }
         };
-        await fs6.promises.writeFile(qmsFile, JSON.stringify(packageData, null, 2), "utf-8");
+        await fs5.promises.writeFile(qmsFile, JSON.stringify(packageData, null, 2), "utf-8");
       } catch (err) {
         console.warn(`Failed to auto-migrate legacy project ${dir}:`, err);
       }
@@ -4665,13 +3692,13 @@ async function listAllGraphPackages() {
 }
 async function getGraphPackageById(id) {
   ensureWorkspaceStructure();
-  const safeId = path6.basename(id);
-  const graphDir = path6.join(GRAPHS_ROOT2, safeId);
-  const qmsFile = path6.join(graphDir, "graph.qms");
-  if (!fs6.existsSync(qmsFile)) {
-    const legacyProject = path6.join(LEGACY_PROJECTS_ROOT, safeId, "project.json");
-    if (fs6.existsSync(legacyProject)) {
-      const raw2 = await fs6.promises.readFile(legacyProject, "utf-8");
+  const safeId = path5.basename(id);
+  const graphDir = path5.join(GRAPHS_ROOT2, safeId);
+  const qmsFile = path5.join(graphDir, "graph.qms");
+  if (!fs5.existsSync(qmsFile)) {
+    const legacyProject = path5.join(LEGACY_PROJECTS_ROOT, safeId, "project.json");
+    if (fs5.existsSync(legacyProject)) {
+      const raw2 = await fs5.promises.readFile(legacyProject, "utf-8");
       const legacy = JSON.parse(raw2);
       return {
         format: "qms_graph_package",
@@ -4704,7 +3731,7 @@ async function getGraphPackageById(id) {
     }
     return null;
   }
-  const raw = await fs6.promises.readFile(qmsFile, "utf-8");
+  const raw = await fs5.promises.readFile(qmsFile, "utf-8");
   return JSON.parse(raw);
 }
 async function createGraphPackage(params) {
@@ -4712,8 +3739,8 @@ async function createGraphPackage(params) {
   const name = params.name.trim();
   const safeSlug = name.toLowerCase().replace(/[^a-z0-9_-]/g, "-").replace(/-+/g, "-");
   const id = `${safeSlug}-${Date.now().toString(36)}`;
-  const graphDir = path6.join(GRAPHS_ROOT2, id);
-  await fs6.promises.mkdir(graphDir, { recursive: true });
+  const graphDir = path5.join(GRAPHS_ROOT2, id);
+  await fs5.promises.mkdir(graphDir, { recursive: true });
   await ensureGraphAssetDirectories(graphDir);
   seedStarterGraphAssets(graphDir);
   const now = Date.now();
@@ -4748,8 +3775,8 @@ async function createGraphPackage(params) {
       connections: params.connections || []
     }
   };
-  await fs6.promises.writeFile(
-    path6.join(graphDir, "graph.qms"),
+  await fs5.promises.writeFile(
+    path5.join(graphDir, "graph.qms"),
     JSON.stringify(graphPackage, null, 2),
     "utf-8"
   );
@@ -4757,10 +3784,10 @@ async function createGraphPackage(params) {
 }
 async function saveGraphPackage(id, payload) {
   ensureWorkspaceStructure();
-  const safeId = path6.basename(id);
-  const graphDir = path6.join(GRAPHS_ROOT2, safeId);
-  if (!fs6.existsSync(graphDir)) {
-    await fs6.promises.mkdir(graphDir, { recursive: true });
+  const safeId = path5.basename(id);
+  const graphDir = path5.join(GRAPHS_ROOT2, safeId);
+  if (!fs5.existsSync(graphDir)) {
+    await fs5.promises.mkdir(graphDir, { recursive: true });
     await ensureGraphAssetDirectories(graphDir);
   }
   const existing = await getGraphPackageById(safeId);
@@ -4795,18 +3822,18 @@ async function saveGraphPackage(id, payload) {
       mapIoConfig: payload.mapIoConfig || existing?.graph?.mapIoConfig
     }
   };
-  await fs6.promises.writeFile(
-    path6.join(graphDir, "graph.qms"),
+  await fs5.promises.writeFile(
+    path5.join(graphDir, "graph.qms"),
     JSON.stringify(graphPackage, null, 2),
     "utf-8"
   );
   return graphPackage;
 }
 async function deleteGraphPackage(id) {
-  const safeId = path6.basename(id);
-  const graphDir = path6.join(GRAPHS_ROOT2, safeId);
-  if (!fs6.existsSync(graphDir)) return false;
-  await fs6.promises.rm(graphDir, { recursive: true, force: true });
+  const safeId = path5.basename(id);
+  const graphDir = path5.join(GRAPHS_ROOT2, safeId);
+  if (!fs5.existsSync(graphDir)) return false;
+  await fs5.promises.rm(graphDir, { recursive: true, force: true });
   return true;
 }
 async function importGraphDependency(targetGraphId, candidateImportId) {
@@ -4848,26 +3875,26 @@ async function removeGraphDependency(targetGraphId, importIdToRemove) {
 }
 
 // src/server/services/projectService.ts
-import fs7 from "fs";
-import path7 from "path";
-var PROJECTS_ROOT2 = path7.join(process.cwd(), "projects");
+import fs6 from "fs";
+import path6 from "path";
+var PROJECTS_ROOT2 = path6.join(process.cwd(), "projects");
 var customStarterProjectTemplate = null;
 function configureStarterProjectTemplate(template) {
   customStarterProjectTemplate = template;
 }
 function ensureProjectsRoot(starterTemplate) {
-  if (!fs7.existsSync(PROJECTS_ROOT2)) {
-    fs7.mkdirSync(PROJECTS_ROOT2, { recursive: true });
+  if (!fs6.existsSync(PROJECTS_ROOT2)) {
+    fs6.mkdirSync(PROJECTS_ROOT2, { recursive: true });
   }
   const template = starterTemplate || customStarterProjectTemplate;
   if (template && template.id) {
-    const defaultProjDir = path7.join(PROJECTS_ROOT2, String(template.id));
-    if (!fs7.existsSync(defaultProjDir)) {
-      fs7.mkdirSync(defaultProjDir, { recursive: true });
-      fs7.mkdirSync(path7.join(defaultProjDir, "samples"), { recursive: true });
-      fs7.mkdirSync(path7.join(defaultProjDir, "assets"), { recursive: true });
-      fs7.writeFileSync(
-        path7.join(defaultProjDir, "project.json"),
+    const defaultProjDir = path6.join(PROJECTS_ROOT2, String(template.id));
+    if (!fs6.existsSync(defaultProjDir)) {
+      fs6.mkdirSync(defaultProjDir, { recursive: true });
+      fs6.mkdirSync(path6.join(defaultProjDir, "samples"), { recursive: true });
+      fs6.mkdirSync(path6.join(defaultProjDir, "assets"), { recursive: true });
+      fs6.writeFileSync(
+        path6.join(defaultProjDir, "project.json"),
         JSON.stringify({ ...template, createdAt: Date.now(), updatedAt: Date.now() }, null, 2),
         "utf-8"
       );
@@ -4876,22 +3903,22 @@ function ensureProjectsRoot(starterTemplate) {
 }
 async function listAllProjects() {
   ensureProjectsRoot();
-  const dirs = await fs7.promises.readdir(PROJECTS_ROOT2);
+  const dirs = await fs6.promises.readdir(PROJECTS_ROOT2);
   const projects = [];
   for (const dir of dirs) {
-    const projDir = path7.join(PROJECTS_ROOT2, dir);
-    const stat = await fs7.promises.stat(projDir);
+    const projDir = path6.join(PROJECTS_ROOT2, dir);
+    const stat = await fs6.promises.stat(projDir);
     if (!stat.isDirectory()) continue;
-    const projectFile = path7.join(projDir, "project.json");
-    const samplesDir = path7.join(projDir, "samples");
+    const projectFile = path6.join(projDir, "project.json");
+    const samplesDir = path6.join(projDir, "samples");
     let sampleCount = 0;
-    if (fs7.existsSync(samplesDir)) {
-      const samples = await fs7.promises.readdir(samplesDir);
+    if (fs6.existsSync(samplesDir)) {
+      const samples = await fs6.promises.readdir(samplesDir);
       sampleCount = samples.filter((f) => !f.startsWith(".")).length;
     }
-    if (fs7.existsSync(projectFile)) {
+    if (fs6.existsSync(projectFile)) {
       try {
-        const raw = await fs7.promises.readFile(projectFile, "utf-8");
+        const raw = await fs6.promises.readFile(projectFile, "utf-8");
         const data = JSON.parse(raw);
         projects.push({
           id: data.id || dir,
@@ -4911,24 +3938,24 @@ async function listAllProjects() {
   return projects.sort((a, b) => b.updatedAt - a.updatedAt);
 }
 async function getProjectById(id) {
-  const safeId = path7.basename(id);
-  const projectFile = path7.join(PROJECTS_ROOT2, safeId, "project.json");
-  if (!fs7.existsSync(projectFile)) return null;
-  const raw = await fs7.promises.readFile(projectFile, "utf-8");
+  const safeId = path6.basename(id);
+  const projectFile = path6.join(PROJECTS_ROOT2, safeId, "project.json");
+  if (!fs6.existsSync(projectFile)) return null;
+  const raw = await fs6.promises.readFile(projectFile, "utf-8");
   return JSON.parse(raw);
 }
 async function saveProject(id, payload) {
-  const safeId = path7.basename(id);
-  const projDir = path7.join(PROJECTS_ROOT2, safeId);
-  const projectFile = path7.join(projDir, "project.json");
-  if (!fs7.existsSync(projDir)) {
-    await fs7.promises.mkdir(projDir, { recursive: true });
-    await fs7.promises.mkdir(path7.join(projDir, "samples"), { recursive: true });
-    await fs7.promises.mkdir(path7.join(projDir, "assets"), { recursive: true });
+  const safeId = path6.basename(id);
+  const projDir = path6.join(PROJECTS_ROOT2, safeId);
+  const projectFile = path6.join(projDir, "project.json");
+  if (!fs6.existsSync(projDir)) {
+    await fs6.promises.mkdir(projDir, { recursive: true });
+    await fs6.promises.mkdir(path6.join(projDir, "samples"), { recursive: true });
+    await fs6.promises.mkdir(path6.join(projDir, "assets"), { recursive: true });
   }
   let existingData = {};
-  if (fs7.existsSync(projectFile)) {
-    const raw = await fs7.promises.readFile(projectFile, "utf-8");
+  if (fs6.existsSync(projectFile)) {
+    const raw = await fs6.promises.readFile(projectFile, "utf-8");
     existingData = JSON.parse(raw);
   }
   const updatedData = {
@@ -4937,22 +3964,22 @@ async function saveProject(id, payload) {
     id: safeId,
     updatedAt: Date.now()
   };
-  await fs7.promises.writeFile(projectFile, JSON.stringify(updatedData, null, 2), "utf-8");
+  await fs6.promises.writeFile(projectFile, JSON.stringify(updatedData, null, 2), "utf-8");
   return updatedData;
 }
 async function deleteProject(id) {
-  const safeId = path7.basename(id);
-  const projDir = path7.join(PROJECTS_ROOT2, safeId);
-  if (!fs7.existsSync(projDir)) return false;
-  await fs7.promises.rm(projDir, { recursive: true, force: true });
+  const safeId = path6.basename(id);
+  const projDir = path6.join(PROJECTS_ROOT2, safeId);
+  if (!fs6.existsSync(projDir)) return false;
+  await fs6.promises.rm(projDir, { recursive: true, force: true });
   return true;
 }
 
 // src/server/services/sampleService.ts
-import fs8 from "fs";
-import path8 from "path";
-var SAMPLES_GLOBAL_ROOT = path8.join(process.cwd(), "samples", "global");
-var PROJECTS_ROOT3 = path8.join(process.cwd(), "projects");
+import fs7 from "fs";
+import path7 from "path";
+var SAMPLES_GLOBAL_ROOT = path7.join(process.cwd(), "samples", "global");
+var PROJECTS_ROOT3 = path7.join(process.cwd(), "projects");
 var SUPPORTED_AUDIO_EXTS3 = [".wav", ".mp3", ".ogg", ".flac", ".m4a", ".webm", ".weba", ".aac", ".aiff", ".aif", ".opus", ".mp4"];
 function initGlobalSamplesDirectory() {
   ensureGlobalSamples(SAMPLES_GLOBAL_ROOT).catch((err) => {
@@ -4960,17 +3987,17 @@ function initGlobalSamplesDirectory() {
   });
 }
 async function listGlobalSamples() {
-  if (!fs8.existsSync(SAMPLES_GLOBAL_ROOT)) {
-    await fs8.promises.mkdir(SAMPLES_GLOBAL_ROOT, { recursive: true });
+  if (!fs7.existsSync(SAMPLES_GLOBAL_ROOT)) {
+    await fs7.promises.mkdir(SAMPLES_GLOBAL_ROOT, { recursive: true });
   }
-  const files = await fs8.promises.readdir(SAMPLES_GLOBAL_ROOT);
+  const files = await fs7.promises.readdir(SAMPLES_GLOBAL_ROOT);
   const samples = [];
   for (const file of files) {
-    const ext = path8.extname(file).toLowerCase();
+    const ext = path7.extname(file).toLowerCase();
     if (!SUPPORTED_AUDIO_EXTS3.includes(ext)) continue;
-    const filePath = path8.join(SAMPLES_GLOBAL_ROOT, file);
-    const stat = await fs8.promises.stat(filePath);
-    const baseName = path8.basename(file, ext);
+    const filePath = path7.join(SAMPLES_GLOBAL_ROOT, file);
+    const stat = await fs7.promises.stat(filePath);
+    const baseName = path7.basename(file, ext);
     const cleanName = baseName.replace(/[-_]/g, " ");
     let category = "synth";
     if (/808|kick|snare|hihat|drum|perc/i.test(baseName)) category = "drums";
@@ -4990,15 +4017,15 @@ async function listGlobalSamples() {
   return samples;
 }
 async function saveGlobalSample(filename, base64Content, category) {
-  const safeFilename = path8.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_");
-  const ext = path8.extname(safeFilename).toLowerCase() || ".wav";
-  const filePath = path8.join(SAMPLES_GLOBAL_ROOT, safeFilename);
+  const safeFilename = path7.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_");
+  const ext = path7.extname(safeFilename).toLowerCase() || ".wav";
+  const filePath = path7.join(SAMPLES_GLOBAL_ROOT, safeFilename);
   const buffer = Buffer.from(base64Content, "base64");
-  await fs8.promises.writeFile(filePath, buffer);
-  const stat = await fs8.promises.stat(filePath);
+  await fs7.promises.writeFile(filePath, buffer);
+  const stat = await fs7.promises.stat(filePath);
   return {
     filename: safeFilename,
-    name: path8.basename(safeFilename, ext).replace(/[-_]/g, " "),
+    name: path7.basename(safeFilename, ext).replace(/[-_]/g, " "),
     category: category || "custom",
     format: ext.replace(".", "").toUpperCase(),
     url: `/samples/global/${safeFilename}`,
@@ -5008,28 +4035,28 @@ async function saveGlobalSample(filename, base64Content, category) {
   };
 }
 async function deleteGlobalSample(filename) {
-  const safeFilename = path8.basename(filename);
-  const filePath = path8.join(SAMPLES_GLOBAL_ROOT, safeFilename);
-  if (fs8.existsSync(filePath)) {
-    await fs8.promises.unlink(filePath);
+  const safeFilename = path7.basename(filename);
+  const filePath = path7.join(SAMPLES_GLOBAL_ROOT, safeFilename);
+  if (fs7.existsSync(filePath)) {
+    await fs7.promises.unlink(filePath);
     return true;
   }
   return false;
 }
 async function listProjectSamples(projectId) {
-  const safeId = path8.basename(projectId);
-  const samplesDir = path8.join(PROJECTS_ROOT3, safeId, "samples");
-  if (!fs8.existsSync(samplesDir)) {
-    await fs8.promises.mkdir(samplesDir, { recursive: true });
+  const safeId = path7.basename(projectId);
+  const samplesDir = path7.join(PROJECTS_ROOT3, safeId, "samples");
+  if (!fs7.existsSync(samplesDir)) {
+    await fs7.promises.mkdir(samplesDir, { recursive: true });
   }
-  const files = await fs8.promises.readdir(samplesDir);
+  const files = await fs7.promises.readdir(samplesDir);
   const samples = [];
   for (const file of files) {
-    const ext = path8.extname(file).toLowerCase();
+    const ext = path7.extname(file).toLowerCase();
     if (!SUPPORTED_AUDIO_EXTS3.includes(ext)) continue;
-    const filePath = path8.join(samplesDir, file);
-    const stat = await fs8.promises.stat(filePath);
-    const baseName = path8.basename(file, ext);
+    const filePath = path7.join(samplesDir, file);
+    const stat = await fs7.promises.stat(filePath);
+    const baseName = path7.basename(file, ext);
     samples.push({
       filename: file,
       name: baseName.replace(/[-_]/g, " "),
@@ -5045,21 +4072,21 @@ async function listProjectSamples(projectId) {
   return samples;
 }
 async function saveProjectSample(projectId, filename, base64Content, isRecording) {
-  const safeId = path8.basename(projectId);
-  const samplesDir = path8.join(PROJECTS_ROOT3, safeId, "samples");
-  if (!fs8.existsSync(samplesDir)) {
-    await fs8.promises.mkdir(samplesDir, { recursive: true });
+  const safeId = path7.basename(projectId);
+  const samplesDir = path7.join(PROJECTS_ROOT3, safeId, "samples");
+  if (!fs7.existsSync(samplesDir)) {
+    await fs7.promises.mkdir(samplesDir, { recursive: true });
   }
   const defaultName = isRecording ? `recording_take_${Date.now()}.wav` : `clip_${Date.now()}.wav`;
-  const targetFilename = filename ? path8.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_") : defaultName;
-  const ext = path8.extname(targetFilename).toLowerCase() || ".wav";
-  const filePath = path8.join(samplesDir, targetFilename);
+  const targetFilename = filename ? path7.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_") : defaultName;
+  const ext = path7.extname(targetFilename).toLowerCase() || ".wav";
+  const filePath = path7.join(samplesDir, targetFilename);
   const buffer = Buffer.from(base64Content, "base64");
-  await fs8.promises.writeFile(filePath, buffer);
-  const stat = await fs8.promises.stat(filePath);
+  await fs7.promises.writeFile(filePath, buffer);
+  const stat = await fs7.promises.stat(filePath);
   return {
     filename: targetFilename,
-    name: path8.basename(targetFilename, ext).replace(/[-_]/g, " "),
+    name: path7.basename(targetFilename, ext).replace(/[-_]/g, " "),
     category: isRecording ? "recording" : "import",
     format: ext.replace(".", "").toUpperCase(),
     url: `/projects/${safeId}/samples/${targetFilename}`,
@@ -5070,26 +4097,26 @@ async function saveProjectSample(projectId, filename, base64Content, isRecording
   };
 }
 async function deleteProjectSample(projectId, filename) {
-  const safeId = path8.basename(projectId);
-  const safeFilename = path8.basename(filename);
-  const filePath = path8.join(PROJECTS_ROOT3, safeId, "samples", safeFilename);
-  if (fs8.existsSync(filePath)) {
-    await fs8.promises.unlink(filePath);
+  const safeId = path7.basename(projectId);
+  const safeFilename = path7.basename(filename);
+  const filePath = path7.join(PROJECTS_ROOT3, safeId, "samples", safeFilename);
+  if (fs7.existsSync(filePath)) {
+    await fs7.promises.unlink(filePath);
     return true;
   }
   return false;
 }
 
 // src/server/services/workspaceGraphService.ts
-import fs9 from "fs";
-import path9 from "path";
-var AUTH_FILE_PATH = path9.resolve(".skipo/accounts.json");
+import fs8 from "fs";
+import path8 from "path";
+var AUTH_FILE_PATH = path8.resolve(".skipo/accounts.json");
 async function resolveWorkspaceDir(workspaceIdOrSlug) {
   const workingDir = getWorkingWorkspaceDir();
   let targetWs = null;
   try {
-    if (fs9.existsSync(AUTH_FILE_PATH)) {
-      const raw = await fs9.promises.readFile(AUTH_FILE_PATH, "utf-8");
+    if (fs8.existsSync(AUTH_FILE_PATH)) {
+      const raw = await fs8.promises.readFile(AUTH_FILE_PATH, "utf-8");
       const accounts = JSON.parse(raw);
       for (const user of Object.values(accounts)) {
         if (Array.isArray(user.workspaces)) {
@@ -5109,35 +4136,35 @@ async function resolveWorkspaceDir(workspaceIdOrSlug) {
   if (targetWs) {
     const rawFolderName = targetWs.localFolderName || targetWs.name.replace(/[/\\?%*:|"<>]/g, "_");
     const folderName = rawFolderName.trim();
-    await fs9.promises.mkdir(workingDir, { recursive: true });
+    await fs8.promises.mkdir(workingDir, { recursive: true });
     return { wsDir: workingDir, wsName: targetWs.name, wsFolder: folderName, wsId: targetWs.id };
   }
-  await fs9.promises.mkdir(workingDir, { recursive: true });
+  await fs8.promises.mkdir(workingDir, { recursive: true });
   return { wsDir: workingDir, wsName: "Active Workspace", wsFolder: "workspace", wsId: workspaceIdOrSlug || "default" };
 }
 async function listWorkspaceGraphs(workspaceIdOrSlug) {
   const { wsDir, wsFolder } = await resolveWorkspaceDir(workspaceIdOrSlug);
   const graphs = [];
   const inspectDirForGraph = async (dirPath, folderName) => {
-    const projectJson = path9.join(dirPath, "project.json");
-    const graphQms = path9.join(dirPath, "graph.qms");
+    const projectJson = path8.join(dirPath, "project.json");
+    const graphQms = path8.join(dirPath, "graph.qms");
     let data = null;
-    if (fs9.existsSync(projectJson)) {
+    if (fs8.existsSync(projectJson)) {
       try {
-        const raw = await fs9.promises.readFile(projectJson, "utf-8");
+        const raw = await fs8.promises.readFile(projectJson, "utf-8");
         data = JSON.parse(raw);
       } catch {
       }
-    } else if (fs9.existsSync(graphQms)) {
+    } else if (fs8.existsSync(graphQms)) {
       try {
-        const raw = await fs9.promises.readFile(graphQms, "utf-8");
+        const raw = await fs8.promises.readFile(graphQms, "utf-8");
         const pkg = JSON.parse(raw);
         data = { ...pkg.metadata || {}, ...pkg.graph || {} };
       } catch {
       }
     }
     if (!data) return null;
-    const stat = await fs9.promises.stat(dirPath);
+    const stat = await fs8.promises.stat(dirPath);
     const nodeCount = Array.isArray(data.nodes) ? data.nodes.length : 0;
     const connectionCount = Array.isArray(data.connections) ? data.connections.length : 0;
     return {
@@ -5145,7 +4172,7 @@ async function listWorkspaceGraphs(workspaceIdOrSlug) {
       name: data.name || folderName,
       description: data.description || "",
       folderName,
-      folderPath: path9.relative(process.cwd(), dirPath).replace(/\\/g, "/"),
+      folderPath: path8.relative(process.cwd(), dirPath).replace(/\\/g, "/"),
       createdAt: data.createdAt || stat.birthtimeMs,
       updatedAt: data.updatedAt || stat.mtimeMs,
       bpm: data.bpm || 120,
@@ -5158,18 +4185,18 @@ async function listWorkspaceGraphs(workspaceIdOrSlug) {
       connectionCount
     };
   };
-  const entries = await fs9.promises.readdir(wsDir);
+  const entries = await fs8.promises.readdir(wsDir);
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "samples" || entry === "assets") continue;
-    const fullPath = path9.join(wsDir, entry);
-    const stat = await fs9.promises.stat(fullPath);
+    const fullPath = path8.join(wsDir, entry);
+    const stat = await fs8.promises.stat(fullPath);
     if (!stat.isDirectory()) continue;
     if (entry === "graphs") {
-      const subEntries = await fs9.promises.readdir(fullPath);
+      const subEntries = await fs8.promises.readdir(fullPath);
       for (const sub of subEntries) {
         if (sub.startsWith(".")) continue;
-        const subPath = path9.join(fullPath, sub);
-        const subStat = await fs9.promises.stat(subPath);
+        const subPath = path8.join(fullPath, sub);
+        const subStat = await fs8.promises.stat(subPath);
         if (subStat.isDirectory()) {
           const g2 = await inspectDirForGraph(subPath, sub);
           if (g2) graphs.push(g2);
@@ -5186,10 +4213,10 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
   const { wsDir, wsFolder, wsId } = await resolveWorkspaceDir(workspaceIdOrSlug);
   const rawName = params.name.trim();
   const folderName = rawName.replace(/[/\\?%*:|"<>]/g, "_");
-  const graphDir = path9.join(wsDir, folderName);
-  await fs9.promises.mkdir(graphDir, { recursive: true });
-  await fs9.promises.mkdir(path9.join(graphDir, "samples"), { recursive: true });
-  await fs9.promises.mkdir(path9.join(graphDir, "assets"), { recursive: true });
+  const graphDir = path8.join(wsDir, folderName);
+  await fs8.promises.mkdir(graphDir, { recursive: true });
+  await fs8.promises.mkdir(path8.join(graphDir, "samples"), { recursive: true });
+  await fs8.promises.mkdir(path8.join(graphDir, "assets"), { recursive: true });
   const now = Date.now();
   const nodes = params.templateData?.nodes || [];
   const connections = params.templateData?.connections || [];
@@ -5200,7 +4227,7 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
     id: folderName,
     name: rawName,
     description: params.description || `Workspace graph in ${wsFolder}`,
-    folderPath: path9.relative(process.cwd(), graphDir).replace(/\\/g, "/"),
+    folderPath: path8.relative(process.cwd(), graphDir).replace(/\\/g, "/"),
     createdAt: now,
     updatedAt: now,
     bpm,
@@ -5209,7 +4236,7 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
     nodes,
     connections
   };
-  await fs9.promises.writeFile(path9.join(graphDir, "project.json"), JSON.stringify(projectData, null, 2), "utf-8");
+  await fs8.promises.writeFile(path8.join(graphDir, "project.json"), JSON.stringify(projectData, null, 2), "utf-8");
   const graphPackage = {
     format: "qms_graph_package",
     version: "2.0.0",
@@ -5227,27 +4254,27 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
     },
     graph: { bpm, masterVolume, currentBiome, nodes, connections }
   };
-  await fs9.promises.writeFile(path9.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
+  await fs8.promises.writeFile(path8.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
   return projectData;
 }
 async function getWorkspaceGraph(workspaceIdOrSlug, graphIdOrName) {
   const { wsDir } = await resolveWorkspaceDir(workspaceIdOrSlug);
   const safeTarget = graphIdOrName.replace(/[/\\?%*:|"<>]/g, "_");
   const candidates = [
-    path9.join(wsDir, safeTarget),
-    path9.join(wsDir, graphIdOrName),
-    path9.join(wsDir, "graphs", safeTarget)
+    path8.join(wsDir, safeTarget),
+    path8.join(wsDir, graphIdOrName),
+    path8.join(wsDir, "graphs", safeTarget)
   ];
   for (const cand of candidates) {
-    if (fs9.existsSync(cand)) {
-      const pJson = path9.join(cand, "project.json");
-      if (fs9.existsSync(pJson)) {
-        const raw = await fs9.promises.readFile(pJson, "utf-8");
+    if (fs8.existsSync(cand)) {
+      const pJson = path8.join(cand, "project.json");
+      if (fs8.existsSync(pJson)) {
+        const raw = await fs8.promises.readFile(pJson, "utf-8");
         return JSON.parse(raw);
       }
-      const gQms = path9.join(cand, "graph.qms");
-      if (fs9.existsSync(gQms)) {
-        const raw = await fs9.promises.readFile(gQms, "utf-8");
+      const gQms = path8.join(cand, "graph.qms");
+      if (fs8.existsSync(gQms)) {
+        const raw = await fs8.promises.readFile(gQms, "utf-8");
         const pkg = JSON.parse(raw);
         return { ...pkg.metadata || {}, ...pkg.graph || {} };
       }
@@ -5258,39 +4285,39 @@ async function getWorkspaceGraph(workspaceIdOrSlug, graphIdOrName) {
 async function saveWorkspaceGraph(workspaceIdOrSlug, graphIdOrName, payload) {
   const { wsDir } = await resolveWorkspaceDir(workspaceIdOrSlug);
   const safeTarget = graphIdOrName.replace(/[/\\?%*:|"<>]/g, "_");
-  let targetDir = path9.join(wsDir, safeTarget);
-  if (!fs9.existsSync(targetDir) && fs9.existsSync(path9.join(wsDir, "graphs", safeTarget))) {
-    targetDir = path9.join(wsDir, "graphs", safeTarget);
+  let targetDir = path8.join(wsDir, safeTarget);
+  if (!fs8.existsSync(targetDir) && fs8.existsSync(path8.join(wsDir, "graphs", safeTarget))) {
+    targetDir = path8.join(wsDir, "graphs", safeTarget);
   }
-  await fs9.promises.mkdir(targetDir, { recursive: true });
-  const pJson = path9.join(targetDir, "project.json");
+  await fs8.promises.mkdir(targetDir, { recursive: true });
+  const pJson = path8.join(targetDir, "project.json");
   let existing = {};
-  if (fs9.existsSync(pJson)) {
+  if (fs8.existsSync(pJson)) {
     try {
-      existing = JSON.parse(await fs9.promises.readFile(pJson, "utf-8"));
+      existing = JSON.parse(await fs8.promises.readFile(pJson, "utf-8"));
     } catch {
     }
   }
   const updated = {
     ...existing,
     ...payload,
-    id: existing.id || path9.basename(targetDir),
+    id: existing.id || path8.basename(targetDir),
     updatedAt: Date.now()
   };
-  await fs9.promises.writeFile(pJson, JSON.stringify(updated, null, 2), "utf-8");
+  await fs8.promises.writeFile(pJson, JSON.stringify(updated, null, 2), "utf-8");
   return updated;
 }
 async function deleteWorkspaceGraph(workspaceIdOrSlug, graphIdOrName) {
   const { wsDir } = await resolveWorkspaceDir(workspaceIdOrSlug);
   const safeTarget = graphIdOrName.replace(/[/\\?%*:|"<>]/g, "_");
   const candidates = [
-    path9.join(wsDir, safeTarget),
-    path9.join(wsDir, graphIdOrName),
-    path9.join(wsDir, "graphs", safeTarget)
+    path8.join(wsDir, safeTarget),
+    path8.join(wsDir, graphIdOrName),
+    path8.join(wsDir, "graphs", safeTarget)
   ];
   for (const cand of candidates) {
-    if (fs9.existsSync(cand)) {
-      await fs9.promises.rm(cand, { recursive: true, force: true });
+    if (fs8.existsSync(cand)) {
+      await fs8.promises.rm(cand, { recursive: true, force: true });
       return true;
     }
   }
@@ -5340,14 +4367,17 @@ export {
   JobDependencyGraph,
   JobScheduler,
   LEGACY_PROJECTS_ROOT,
+  LOCAL_STORAGE_GRAPHS_PREFIX,
   LoadBalancer,
   LocalAccountProvider,
   LocalFSAdapter,
   LockManager,
+  NodeGraphPersistenceService,
   PROJECTS_ROOT,
   PasswordHasher,
   RateLimiter,
   RemoteExecutor,
+  RemoteWorkspaceService,
   ResourceFetcherRegistry,
   ResultFlowBridge,
   S3Adapter,
@@ -5358,7 +4388,9 @@ export {
   ServiceDispatcher,
   SessionManager,
   SrklClient,
+  SrklCredentialRegistry,
   SrklStorageService,
+  SrklVaultAccessClient,
   StorageAdapterFactory,
   StorageServiceDefinition,
   StorageServiceFacade,
@@ -5369,6 +4401,7 @@ export {
   WORKSPACE_ROOT,
   WebSocketTransport,
   WorkerExecutionBoundary,
+  WorkingWorkspaceService,
   WorkspaceCloneSyncEngine,
   WorkspaceFS,
   WorkspaceServiceDefinition,
@@ -5383,6 +4416,8 @@ export {
   buildProjectObservability,
   buildProjectsList,
   cleanDbUrl,
+  computeDeploymentFinalWeight,
+  computeUsageWeightScore,
   configureStarterProjectTemplate,
   createAssetSubfolder,
   createBackend,
@@ -5402,6 +4437,7 @@ export {
   createWorkspace,
   createWorkspaceGraph,
   decryptSecretFromBlob,
+  decryptVaultBufferInBrowser,
   deleteAssetFromGraph,
   deleteAssetFromPool,
   deleteCredential,
@@ -5424,6 +4460,7 @@ export {
   ensureS3DirectoryMarker,
   ensureWorkspaceStructure,
   exportEncryptedCredentials,
+  exportGraphAsJsonFile,
   fetchCloudflareData,
   fetchVercelData,
   findUserWorkspace,
@@ -5434,6 +4471,8 @@ export {
   getAssetPoolLocationPath,
   getAssetPoolPublicUrl,
   getB2BucketId,
+  getConnectedDeploymentNode,
+  getConnectedWeightModifiers,
   getCredential,
   getDefaultWorkingWorkspaceDir,
   getExecutions,
@@ -5450,6 +4489,7 @@ export {
   getSystemDatabaseUrls,
   getUnifiedDbUrl,
   getUsers,
+  getWeightModifierScore,
   getWorkingWorkspaceConfig,
   getWorkingWorkspaceDir,
   getWorkspaceFolderKey,
@@ -5457,6 +4497,8 @@ export {
   getWorkspaceGraph,
   getWorkspaceStorageDetails,
   getWorkspaces,
+  globalCredentialRegistry,
+  hexToBytes,
   importEncryptedCredentials,
   importGraphDependency,
   initGlobalSamplesDirectory,
@@ -5476,12 +4518,15 @@ export {
   loginUser,
   matchGatewayIngress,
   matchGatewayIngressAsync,
+  nodeGraphPersistence,
   normalizeBackblazeCredentials,
+  parseGraphJsonFile,
   permanentDeleteS3Folder,
   permanentDeleteS3Object,
   queryUnifiedDb,
   readWorkspaceFile,
   recordExecution,
+  remoteWorkspaceService,
   removeGraphDependency,
   renameAppInWorkspaceData,
   renameS3Folder,
@@ -5510,6 +4555,8 @@ export {
   setWorkingWorkspaceConfig,
   srklListBackblazeBuckets2 as srklCoreListBackblazeBuckets,
   srklListBackblazeBuckets,
+  srklService,
+  syncSrklAccounts,
   syncWorkspace,
   syncWorkspaceCreateToBucket,
   syncWorkspaceDataToBucket,
@@ -5520,8 +4567,10 @@ export {
   useBackend,
   useBackendClient,
   useSrklServices,
+  validateGraphDocument,
   validateServiceDefinition,
   withAuth,
   withCors,
+  workingWorkspaceService,
   writeWorkspaceFile
 };