@ultrst-armada/kloks 1.1.1 → 1.2.0

package/packages/backend/dist/index.js

@@ -1,11 +1,3 @@
-import {
-  CompositeBackend,
-  EndpointGenerator,
-  createBackend,
-  createCompositeService,
-  createLocalService,
-  createRemoteService
-} from "./chunk-P4HL4C6V.js";
 import {
   CANONICAL_SRKL_URL,
   SrklClient,
@@ -23,6 +15,12 @@ import {
   b2ListFileNames,
   b2UploadFile
 } from "./chunk-4QEMALXF.js";
+import {
+  BaseApiRoute,
+  createSSEResponse,
+  withAuth,
+  withCors
+} from "./chunk-TWCEVES2.js";
 import {
   SyncEngine,
   WorkspaceCloneSyncEngine,
@@ -43,8 +41,7 @@ import {
   StorageServiceFacade,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade
-} from "./chunk-CU7RZBMF.js";
-import "./chunk-IPP4VURQ.js";
+} from "./chunk-OYQKQAEF.js";
 import {
   BackblazeB2Adapter,
   BaseStorageAdapter,
@@ -64,12 +61,6 @@ import {
   formatCanonicalWorkspaceFolderName,
   sanitizeWorkspaceName
 } from "./chunk-FZKBTF34.js";
-import {
-  BaseApiRoute,
-  createSSEResponse,
-  withAuth,
-  withCors
-} from "./chunk-TWCEVES2.js";
 import {
   AdminGuard,
   BaseAccountProvider,
@@ -133,9 +124,18 @@ 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";
+import { SkipoBase } from "@kloks/functions";
 var BaseDataProvider = class extends SkipoBase {
 };
 
@@ -203,7 +203,7 @@ function validateServiceDefinition(def) {
 }
 
 // src/core/authCore.ts
-import crypto from "crypto";
+import crypto2 from "crypto";
 import bcrypt from "bcryptjs";
 
 // src/core/unifiedDb.ts
@@ -274,8 +274,8 @@ async function loginUser(email, password, isAdmin = false, env) {
     } else if (hash.startsWith("$2a$") || hash.startsWith("$2b$")) {
       isMatch = bcrypt.compareSync(rawPassword, hash);
     } else {
-      const saltedSha = crypto.createHash("sha256").update(rawPassword + "docustack_salt_2026_v2").digest("hex");
-      const rawSha = crypto.createHash("sha256").update(rawPassword).digest("hex");
+      const saltedSha = crypto2.createHash("sha256").update(rawPassword + "docustack_salt_2026_v2").digest("hex");
+      const rawSha = crypto2.createHash("sha256").update(rawPassword).digest("hex");
       isMatch = hash === saltedSha || hash === rawSha;
     }
     if (!isMatch) {
@@ -1061,10 +1061,10 @@ async function getSrklAccounts2(userId, service, env) {
     }
   }
   try {
-    const fs11 = await import("fs/promises");
-    const path11 = await import("path");
-    const accPath = path11.resolve(".skipo/accounts.json");
-    const raw = await fs11.readFile(accPath, "utf-8");
+    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 localUsers = JSON.parse(raw);
     for (const u of Object.values(localUsers)) {
       const conns = Array.isArray(u.storage_connections) ? u.storage_connections : [];
@@ -1138,182 +1138,2361 @@ async function listBackblazeBuckets(payload, rawUserId, env) {
     } catch (err) {
       console.warn("[SrklCore] Direct B2 bucket query failed, trying SRKL fallback:", err.message);
     }
-    const srklUrl = await getPrimarySrklDeploymentUrl2(env);
-    const srklRes = await fetch(`${srklUrl}/api/backblaze/buckets`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json", "x-user-id": userId || "" },
-      body: JSON.stringify({ keyId, applicationKey: appKey, bucketId: bucketId || void 0 }),
-      signal: AbortSignal.timeout(6e3)
-    });
-    if (srklRes.ok) {
-      const data = await srklRes.json();
-      if (data.success && Array.isArray(data.buckets)) return { success: true, buckets: data.buckets };
+    const srklUrl = await getPrimarySrklDeploymentUrl2(env);
+    const srklRes = await fetch(`${srklUrl}/api/backblaze/buckets`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json", "x-user-id": userId || "" },
+      body: JSON.stringify({ keyId, applicationKey: appKey, bucketId: bucketId || void 0 }),
+      signal: AbortSignal.timeout(6e3)
+    });
+    if (srklRes.ok) {
+      const data = await srklRes.json();
+      if (data.success && Array.isArray(data.buckets)) return { success: true, buckets: data.buckets };
+    }
+    return { success: true, buckets: [] };
+  } catch (err) {
+    return { success: false, error: err.message || "Failed to list Backblaze buckets" };
+  }
+}
+var srklListBackblazeBuckets2 = (keyId, applicationKey, bucketId, bucketName, userId) => listBackblazeBuckets({ keyId, applicationKey, bucketId, bucketName }, userId);
+async function getSrklStatus(env) {
+  const srklUrl = await getPrimarySrklDeploymentUrl2(env);
+  const start = Date.now();
+  try {
+    const resp = await fetch(`${srklUrl}/api/ecosystem/health`, { signal: AbortSignal.timeout(5e3) });
+    const latencyMs = Date.now() - start;
+    if (resp.ok) {
+      const data = await resp.json().catch(() => ({}));
+      return { success: true, deploymentUrl: srklUrl, online: true, latencyMs, details: data };
+    }
+    return { success: false, deploymentUrl: srklUrl, online: false, status: resp.status, latencyMs };
+  } catch (err) {
+    return { success: false, deploymentUrl: srklUrl, online: false, error: err.message, latencyMs: Date.now() - start };
+  }
+}
+
+// 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";
+async function deriveAesKey(passphrase, salt) {
+  const enc = new TextEncoder();
+  const passKey = await crypto.subtle.importKey("raw", enc.encode(passphrase), "PBKDF2", false, ["deriveKey"]);
+  return crypto.subtle.deriveKey(
+    { name: "PBKDF2", salt, iterations: 1e5, hash: "SHA-256" },
+    passKey,
+    { name: "AES-GCM", length: 256 },
+    false,
+    ["encrypt", "decrypt"]
+  );
+}
+async function encryptSecretToBlob(plaintext, vaultKey) {
+  const str = typeof plaintext === "string" ? plaintext : JSON.stringify(plaintext);
+  const salt = crypto.getRandomValues(new Uint8Array(16));
+  const iv = crypto.getRandomValues(new Uint8Array(12));
+  const key = await deriveAesKey(vaultKey, salt);
+  const cipherBuffer = await crypto.subtle.encrypt({ name: "AES-GCM", iv }, key, new TextEncoder().encode(str));
+  const blob = new Uint8Array(1 + 16 + 12 + cipherBuffer.byteLength);
+  blob[0] = 1;
+  blob.set(salt, 1);
+  blob.set(iv, 1 + 16);
+  blob.set(new Uint8Array(cipherBuffer), 1 + 16 + 12);
+  return blob;
+}
+async function decryptSecretFromBlob(blob, vaultKey) {
+  if (blob.length < 1 + 16 + 12 + 16 || blob[0] !== 1) {
+    throw new Error("Invalid or corrupted credential vault blob.");
+  }
+  const salt = blob.slice(1, 17);
+  const iv = blob.slice(17, 29);
+  const ciphertext = blob.slice(29);
+  const key = await deriveAesKey(vaultKey, salt);
+  const decrypted = await crypto.subtle.decrypt({ name: "AES-GCM", iv }, key, ciphertext);
+  const text = new TextDecoder().decode(decrypted);
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
+async function loadCredentialManifest(workspace, connection) {
+  const data = await readWorkspaceFile(workspace, connection, MANIFEST_PATH);
+  if (!data) return { version: 1, entries: [] };
+  try {
+    return JSON.parse(new TextDecoder().decode(data));
+  } catch {
+    return { version: 1, entries: [] };
+  }
+}
+async function saveCredentialManifest(workspace, connection, manifest) {
+  await writeWorkspaceFile(workspace, connection, MANIFEST_PATH, JSON.stringify(manifest, null, 2), "application/json");
+}
+async function listCredentials(workspace, connection) {
+  const manifest = await loadCredentialManifest(workspace, connection);
+  return manifest.entries;
+}
+async function getCredential(workspace, connection, id, vaultKey) {
+  const blob = await readWorkspaceFile(workspace, connection, `${SECRET_PREFIX}/${id}.bin`);
+  if (!blob) throw new Error(`Credential ${id} not found.`);
+  const decrypted = await decryptSecretFromBlob(blob, vaultKey);
+  const manifest = await loadCredentialManifest(workspace, connection);
+  const meta = manifest.entries.find((e) => e.id === id);
+  return { id, name: meta?.name, type: meta?.type, metadata: meta?.metadata, secret: decrypted };
+}
+async function createCredential(workspace, connection, payload, vaultKey) {
+  const id = payload.id || `cred_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const blob = await encryptSecretToBlob(payload.secret, vaultKey);
+  await writeWorkspaceFile(workspace, connection, `${SECRET_PREFIX}/${id}.bin`, blob, "application/octet-stream");
+  const manifest = await loadCredentialManifest(workspace, connection);
+  const entry = {
+    id,
+    name: payload.name,
+    type: payload.type || "generic",
+    createdAt: now,
+    updatedAt: now,
+    metadata: payload.metadata || {}
+  };
+  manifest.entries = manifest.entries.filter((e) => e.id !== id).concat(entry);
+  await saveCredentialManifest(workspace, connection, manifest);
+  return entry;
+}
+async function updateCredential(workspace, connection, id, payload, vaultKey) {
+  const manifest = await loadCredentialManifest(workspace, connection);
+  const entry = manifest.entries.find((e) => e.id === id);
+  if (!entry) throw new Error(`Credential ${id} not found.`);
+  if (payload.secret !== void 0) {
+    const blob = await encryptSecretToBlob(payload.secret, vaultKey);
+    await writeWorkspaceFile(workspace, connection, `${SECRET_PREFIX}/${id}.bin`, blob, "application/octet-stream");
+  }
+  if (payload.name) entry.name = payload.name;
+  if (payload.type) entry.type = payload.type;
+  if (payload.metadata) entry.metadata = { ...entry.metadata, ...payload.metadata };
+  entry.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await saveCredentialManifest(workspace, connection, manifest);
+  return entry;
+}
+async function deleteCredential(workspace, connection, id) {
+  await deleteWorkspaceFile(workspace, connection, `${SECRET_PREFIX}/${id}.bin`);
+  const manifest = await loadCredentialManifest(workspace, connection);
+  manifest.entries = manifest.entries.filter((e) => e.id !== id);
+  await saveCredentialManifest(workspace, connection, manifest);
+  return true;
+}
+async function exportEncryptedCredentials(workspace, connection, ids, exportKey, vaultKey) {
+  const manifest = await loadCredentialManifest(workspace, connection);
+  const targets = manifest.entries.filter((e) => ids.includes(e.id));
+  const decryptedItems = [];
+  for (const entry of targets) {
+    const cred = await getCredential(workspace, connection, entry.id, vaultKey);
+    decryptedItems.push(cred);
+  }
+  const blob = await encryptSecretToBlob({ manifestEntries: targets, items: decryptedItems }, exportKey);
+  const b64 = Buffer.from(blob).toString("base64");
+  return { exportVersion: 1, timestamp: (/* @__PURE__ */ new Date()).toISOString(), package: b64 };
+}
+async function importEncryptedCredentials(workspace, connection, packageB64, exportKey, vaultKey) {
+  const blob = new Uint8Array(Buffer.from(packageB64, "base64"));
+  const payload = await decryptSecretFromBlob(blob, exportKey);
+  const items = payload.items || [];
+  const importedEntries = [];
+  for (const item of items) {
+    const entry = await createCredential(
+      workspace,
+      connection,
+      { id: item.id, name: item.name, type: item.type, secret: item.secret, metadata: item.metadata },
+      vaultKey
+    );
+    importedEntries.push(entry);
+  }
+  return importedEntries;
+}
+
+// src/core/publicRoutesStore.ts
+var serverPublicRoutes = [
+  {
+    id: "route_flay",
+    name: "Flay Realtime API Gateway",
+    path: "flay",
+    status: "PUBLISHED",
+    public: true,
+    endpoint: "/flay",
+    deployments: [
+      {
+        id: "dep_flay_edge_sfo",
+        name: "flay-worker-sfo (US West Edge)",
+        url: "https://flay-worker.workers.dev",
+        provider: "CLOUDFLARE",
+        weight: 0.88,
+        healthy: true,
+        priority: 1,
+        region: "sfo"
+      },
+      {
+        id: "dep_flay_edge_cdg",
+        name: "flay-worker-cdg (EU Paris Edge)",
+        url: "https://flay-eu.workers.dev",
+        provider: "CLOUDFLARE",
+        weight: 0.92,
+        healthy: true,
+        priority: 2,
+        region: "cdg"
+      }
+    ],
+    load_balancing_config: {
+      strategy: "WEIGHTED",
+      autoRedirectDelayMs: 2e3,
+      preserveQueryParams: true,
+      preservePathSuffix: true,
+      healthCheckRequired: true
+    },
+    createdAt: new Date(Date.now() - 864e5).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: { requests: 89 }
+  }
+];
+function setServerPublicRoutes(routes) {
+  serverPublicRoutes = routes;
+}
+
+// src/resourceEngine/BaseResourceFetcher.ts
+var BaseResourceFetcher = class {
+  /**
+   * Template method: Resolves credentials, queries the provider's APIs, and normalizes metrics.
+   */
+  async fetchMetrics(account) {
+    const creds = account.metadata?.credentials || {};
+    const tier = account.tier || this.defaultTier;
+    const raw = await this.fetchRawUsage(creds, {
+      accountId: account.id,
+      accountName: account.name || account.emailOrSlug
+    });
+    return this.transformMetrics(raw, tier, account.deploymentCount || 0);
+  }
+  /**
+   * Shared weighted resource score calculation (0.0 to 1.0).
+   * - Active CPU receives the highest weight (50% / 0.50).
+   * - Invocations: 15% (0.15).
+   * - Compute Memory / Subrequests: 15% (0.15).
+   * - Edge Requests: 10% (0.10).
+   * - Bandwidth / Data Transfer: 5% (0.05).
+   * - Other compute / network metrics: 5% (0.05).
+   * - Storage parameters (Functions Storage, Deployment Storage, R2) are strictly EXCLUDED (0%).
+   */
+  computeWeightScore(metrics, deployment, account) {
+    if (!metrics) {
+      if (account && account.aggregateQuota > 0) {
+        return Number(Math.max(0, Math.min(1, (account.aggregateQuota - account.aggregateUsage) / account.aggregateQuota)).toFixed(2));
+      }
+      if (deployment && deployment.quota > 0) {
+        return Number(Math.max(0, Math.min(1, (deployment.quota - deployment.usage) / deployment.quota)).toFixed(2));
+      }
+      return 1;
+    }
+    const calcRemaining = (item) => {
+      if (!item) return null;
+      if (typeof item.percent === "number" && !isNaN(item.percent)) {
+        return Math.max(0, Math.min(1, (100 - item.percent) / 100));
+      }
+      if (item.usedSeconds !== void 0 && item.limitSeconds !== void 0 && item.limitSeconds > 0) {
+        return Math.max(0, Math.min(1, (item.limitSeconds - item.usedSeconds) / item.limitSeconds));
+      }
+      if (item.usedCount !== void 0 && item.limitCount !== void 0 && item.limitCount > 0) {
+        return Math.max(0, Math.min(1, (item.limitCount - item.usedCount) / item.limitCount));
+      }
+      if (item.usedGbHours !== void 0 && item.limitGbHours !== void 0 && item.limitGbHours > 0) {
+        return Math.max(0, Math.min(1, (item.limitGbHours - item.usedGbHours) / item.limitGbHours));
+      }
+      if (item.usedMb !== void 0 && item.limitMb !== void 0 && item.limitMb > 0) {
+        return Math.max(0, Math.min(1, (item.limitMb - item.usedMb) / item.limitMb));
+      }
+      if (item.usedGb !== void 0 && item.limitGb !== void 0 && item.limitGb > 0) {
+        return Math.max(0, Math.min(1, (item.limitGb - item.usedGb) / item.limitGb));
+      }
+      return null;
+    };
+    const cpuMetric = metrics.activeCpu || metrics.fluidActiveCpu;
+    const invMetric = metrics.invocations || metrics.functionInvocations;
+    const memMetric = metrics.memory || metrics.fluidProvisionedMemory;
+    const edgeMetric = metrics.edgeRequests || metrics.edgeRequests;
+    const bwMetric = metrics.bandwidth || metrics.fastDataTransfer;
+    const otherMetric = metrics.edgeRequestCpuDuration || metrics.fastOriginTransfer || metrics.subrequests || metrics.isrReads || metrics.middlewareInvocations;
+    const weightedItems = [
+      { remaining: calcRemaining(cpuMetric), weight: 0.5 },
+      { remaining: calcRemaining(invMetric), weight: 0.15 },
+      { remaining: calcRemaining(memMetric), weight: 0.15 },
+      { remaining: calcRemaining(edgeMetric), weight: 0.1 },
+      { remaining: calcRemaining(bwMetric), weight: 0.05 },
+      { remaining: calcRemaining(otherMetric), weight: 0.05 }
+    ];
+    let totalWeight = 0;
+    let weightedSum = 0;
+    for (const { remaining, weight } of weightedItems) {
+      if (remaining !== null) {
+        weightedSum += remaining * weight;
+        totalWeight += weight;
+      }
+    }
+    if (totalWeight > 0) {
+      const normalizedScore = weightedSum / totalWeight;
+      return Number(Math.max(0, Math.min(1, normalizedScore)).toFixed(2));
+    }
+    return 1;
+  }
+};
+
+// src/resourceEngine/metricHelpers.ts
+function formatCpuSeconds(seconds) {
+  if (!seconds || seconds <= 0) return "0 s";
+  if (seconds < 60) return `${Math.round(seconds)} s`;
+  if (seconds < 3600) return `${(seconds / 60).toFixed(1)} m`;
+  return `${(seconds / 3600).toFixed(1)} h`;
+}
+function formatCountMetric(count) {
+  if (!count || count <= 0) return "0";
+  if (count < 1e3) return String(Math.round(count));
+  if (count < 1e6) return `${(count / 1e3).toFixed(1)}k`;
+  return `${(count / 1e6).toFixed(1)}M`;
+}
+function buildUsageMetrics(tier, raw, projectsCount = 1) {
+  const isHobby = tier === "hobby";
+  const cpuLimitSeconds = isHobby ? 4 * 3600 : 40 * 3600;
+  const invocationsLimit = isHobby ? 1e5 : 1e6;
+  const edgeRequestsLimit = isHobby ? 5e5 : 5e6;
+  const transferLimitGb = isHobby ? 100 : 1e3;
+  const memoryLimitGbHours = isHobby ? 100 : 1e3;
+  const storageLimitMb = isHobby ? 500 : 5e3;
+  const usedCpu = Number(raw?.cpuUsage || raw?.metrics?.cpu || 0);
+  const usedInvocations = Number(raw?.invocations || raw?.metrics?.invocations || 0);
+  const usedEdgeRequests = Number(raw?.edgeRequests || raw?.metrics?.edgeRequests || 0);
+  const usedTransferGb = Number(raw?.bandwidthGb || 0);
+  const usedMemoryGbHours = Number(raw?.memoryGbHours || 0);
+  const usedStorageMb = Number(raw?.storageMb || 0);
+  return {
+    usageMetrics: {
+      periodLabel: "Last 30 Days",
+      fluidActiveCpu: {
+        usedSeconds: usedCpu,
+        limitSeconds: cpuLimitSeconds,
+        usedFormatted: formatCpuSeconds(usedCpu),
+        limitFormatted: formatCpuSeconds(cpuLimitSeconds),
+        percent: Math.min(100, Math.round(usedCpu / cpuLimitSeconds * 100)),
+        remainingFormatted: formatCpuSeconds(Math.max(0, cpuLimitSeconds - usedCpu))
+      },
+      functionInvocations: {
+        usedCount: usedInvocations,
+        limitCount: invocationsLimit,
+        usedFormatted: formatCountMetric(usedInvocations),
+        limitFormatted: formatCountMetric(invocationsLimit),
+        percent: Math.min(100, Math.round(usedInvocations / invocationsLimit * 100)),
+        remainingFormatted: formatCountMetric(Math.max(0, invocationsLimit - usedInvocations))
+      },
+      edgeRequests: {
+        usedCount: usedEdgeRequests,
+        limitCount: edgeRequestsLimit,
+        usedFormatted: formatCountMetric(usedEdgeRequests),
+        limitFormatted: formatCountMetric(edgeRequestsLimit),
+        percent: Math.min(100, Math.round(usedEdgeRequests / edgeRequestsLimit * 100)),
+        remainingFormatted: formatCountMetric(Math.max(0, edgeRequestsLimit - usedEdgeRequests))
+      },
+      fastDataTransfer: {
+        usedGb: usedTransferGb,
+        limitGb: transferLimitGb,
+        usedFormatted: `${usedTransferGb} GB`,
+        limitFormatted: `${transferLimitGb} GB`,
+        percent: Math.min(100, Math.round(usedTransferGb / transferLimitGb * 100)),
+        remainingFormatted: `${Math.max(0, transferLimitGb - usedTransferGb)} GB`
+      },
+      fluidProvisionedMemory: {
+        usedGbHours: usedMemoryGbHours,
+        limitGbHours: memoryLimitGbHours,
+        usedFormatted: `${usedMemoryGbHours} GB-h`,
+        limitFormatted: `${memoryLimitGbHours} GB-h`,
+        percent: Math.min(100, Math.round(usedMemoryGbHours / memoryLimitGbHours * 100)),
+        remainingFormatted: `${Math.max(0, memoryLimitGbHours - usedMemoryGbHours)} GB-h`
+      },
+      functionsStorage: {
+        usedMb: usedStorageMb,
+        limitMb: storageLimitMb,
+        usedFormatted: `${usedStorageMb} MB`,
+        limitFormatted: `${storageLimitMb} MB`,
+        percent: Math.min(100, Math.round(usedStorageMb / storageLimitMb * 100)),
+        remainingFormatted: `${Math.max(0, storageLimitMb - usedStorageMb)} MB`
+      },
+      fastOriginTransfer: 0,
+      edgeRequestCpuDuration: 0,
+      isrReads: 0,
+      middlewareInvocations: 0
+    }
+  };
+}
+
+// src/resourceEngine/VercelResourceFetcher.ts
+var VercelResourceFetcher = class extends BaseResourceFetcher {
+  provider = "VERCEL";
+  defaultTier = "hobby";
+  getAuthHeaders(creds) {
+    const token = (creds?.token || creds?.apiToken || creds?.accessToken || "").trim();
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  async fetchRawUsage(creds, options) {
+    const token = (creds?.token || creds?.apiToken || creds?.accessToken || "").trim();
+    if (!token) return null;
+    const teamId = (creds?.teamId || "").trim();
+    const headers = this.getAuthHeaders(creds);
+    const fromIso = new Date(Date.now() - 30 * 864e5).toISOString();
+    const toIso = (/* @__PURE__ */ new Date()).toISOString();
+    const teamQuery = teamId ? `&teamId=${encodeURIComponent(teamId)}` : "";
+    let rawUsage = null;
+    try {
+      const reqUrl = `https://api.vercel.com/v2/usage?from=${encodeURIComponent(fromIso)}&to=${encodeURIComponent(toIso)}&type=requests${teamQuery}`;
+      const res = await fetch(reqUrl, { headers });
+      if (res.ok) {
+        rawUsage = await res.json();
+      }
+      try {
+        const buildUrl = `https://api.vercel.com/v2/usage?from=${encodeURIComponent(fromIso)}&to=${encodeURIComponent(toIso)}&type=builds${teamQuery}`;
+        const bRes = await fetch(buildUrl, { headers });
+        if (bRes.ok) {
+          const bData = await bRes.json();
+          if (rawUsage && typeof rawUsage === "object") {
+            rawUsage.builds = bData.data || [];
+          }
+        }
+      } catch {
+      }
+    } catch (err) {
+      console.warn("[VercelResourceFetcher] Error fetching usage from Vercel API:", err.message);
+    }
+    return rawUsage;
+  }
+  transformMetrics(raw, tier = "hobby", projectsCount = 1) {
+    const { usageMetrics } = buildUsageMetrics(tier, raw, projectsCount);
+    const isHobby = tier === "hobby";
+    return {
+      provider: "VERCEL",
+      periodLabel: usageMetrics.periodLabel,
+      tier,
+      isFreeTier: isHobby,
+      activeCpu: {
+        usedSeconds: usageMetrics.fluidActiveCpu.usedSeconds,
+        limitSeconds: usageMetrics.fluidActiveCpu.limitSeconds,
+        usedFormatted: usageMetrics.fluidActiveCpu.usedFormatted,
+        limitFormatted: usageMetrics.fluidActiveCpu.limitFormatted,
+        percent: usageMetrics.fluidActiveCpu.percent,
+        remainingFormatted: usageMetrics.fluidActiveCpu.remainingFormatted
+      },
+      invocations: {
+        usedCount: usageMetrics.functionInvocations.usedCount,
+        limitCount: usageMetrics.functionInvocations.limitCount,
+        usedFormatted: usageMetrics.functionInvocations.usedFormatted,
+        limitFormatted: usageMetrics.functionInvocations.limitFormatted,
+        percent: usageMetrics.functionInvocations.percent,
+        remainingFormatted: usageMetrics.functionInvocations.remainingFormatted
+      },
+      edgeRequests: {
+        usedCount: usageMetrics.edgeRequests.usedCount,
+        limitCount: usageMetrics.edgeRequests.limitCount,
+        usedFormatted: usageMetrics.edgeRequests.usedFormatted,
+        limitFormatted: usageMetrics.edgeRequests.limitFormatted,
+        percent: usageMetrics.edgeRequests.percent,
+        remainingFormatted: usageMetrics.edgeRequests.remainingFormatted
+      },
+      bandwidth: {
+        usedMb: Math.round(usageMetrics.fastDataTransfer.usedGb * 1024),
+        limitMb: usageMetrics.fastDataTransfer.limitGb * 1024,
+        usedFormatted: usageMetrics.fastDataTransfer.usedFormatted,
+        limitFormatted: usageMetrics.fastDataTransfer.limitFormatted,
+        percent: usageMetrics.fastDataTransfer.percent,
+        remainingFormatted: usageMetrics.fastDataTransfer.remainingFormatted
+      },
+      memory: {
+        usedGbHours: usageMetrics.fluidProvisionedMemory.usedGbHours,
+        limitGbHours: usageMetrics.fluidProvisionedMemory.limitGbHours,
+        usedFormatted: usageMetrics.fluidProvisionedMemory.usedFormatted,
+        limitFormatted: usageMetrics.fluidProvisionedMemory.limitFormatted,
+        percent: usageMetrics.fluidProvisionedMemory.percent,
+        remainingFormatted: usageMetrics.fluidProvisionedMemory.remainingFormatted
+      },
+      storage: {
+        usedMb: usageMetrics.functionsStorage.usedMb,
+        limitMb: usageMetrics.functionsStorage.limitMb,
+        usedFormatted: usageMetrics.functionsStorage.usedFormatted,
+        limitFormatted: usageMetrics.functionsStorage.limitFormatted,
+        percent: usageMetrics.functionsStorage.percent,
+        remainingFormatted: usageMetrics.functionsStorage.remainingFormatted
+      },
+      details: {
+        fastOriginTransfer: usageMetrics.fastOriginTransfer,
+        edgeRequestCpuDuration: usageMetrics.edgeRequestCpuDuration,
+        isrReads: usageMetrics.isrReads,
+        middlewareInvocations: usageMetrics.middlewareInvocations,
+        rawVercelMetrics: usageMetrics
+      }
+    };
+  }
+};
+
+// src/resourceEngine/CloudflareResourceFetcher.ts
+var CloudflareResourceFetcher = class extends BaseResourceFetcher {
+  provider = "CLOUDFLARE";
+  defaultTier = "free";
+  getAuthHeaders(creds) {
+    const token = (creds?.apiToken || creds?.token || creds?.accessToken || "").trim();
+    const headers = {
+      "Content-Type": "application/json"
+    };
+    if (token) {
+      headers.Authorization = `Bearer ${token}`;
+    } else if (creds?.authKey && creds?.authEmail) {
+      headers["X-Auth-Key"] = creds.authKey.trim();
+      headers["X-Auth-Email"] = creds.authEmail.trim();
+    }
+    return headers;
+  }
+  async fetchRawUsage(creds, options) {
+    const headers = this.getAuthHeaders(creds);
+    const accountTag = (creds?.accountId || creds?.accountTag || creds?.teamId || "").trim();
+    const result = {
+      accountTag,
+      scripts: []
+    };
+    if (!headers.Authorization && !headers["X-Auth-Key"]) {
+      return result;
+    }
+    let resolvedTag = accountTag;
+    try {
+      if (!resolvedTag) {
+        const userRes = await fetch("https://api.cloudflare.com/client/v4/accounts?page=1&per_page=5", { headers });
+        if (userRes.ok) {
+          const uData = await userRes.json();
+          const firstAcc = uData?.result?.[0];
+          if (firstAcc?.id) {
+            resolvedTag = firstAcc.id;
+            result.accountTag = firstAcc.id;
+          }
+        }
+      }
+    } catch (e) {
+      console.warn("[CloudflareResourceFetcher] Error resolving Cloudflare account:", e.message);
+    }
+    if (!resolvedTag) return result;
+    try {
+      const scriptsRes = await fetch(
+        `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(resolvedTag)}/workers/scripts`,
+        { headers }
+      );
+      if (scriptsRes.ok) {
+        const sData = await scriptsRes.json();
+        result.scripts = Array.isArray(sData?.result) ? sData.result : [];
+      }
+    } catch (e) {
+      console.warn("[CloudflareResourceFetcher] Error fetching workers scripts:", e.message);
+    }
+    try {
+      const subRes = await fetch(
+        `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(resolvedTag)}/workers/subdomain`,
+        { headers }
+      );
+      if (subRes.ok) {
+        const subData = await subRes.json();
+        result.subdomain = subData?.result?.subdomain;
+      }
+    } catch {
+    }
+    try {
+      const datetimeStart = new Date(Date.now() - 30 * 864e5).toISOString();
+      const datetimeEnd = (/* @__PURE__ */ new Date()).toISOString();
+      const graphqlQuery = {
+        query: `
+          query WorkersAnalytics($accountTag: String!, $datetimeStart: String!, $datetimeEnd: String!) {
+            viewer {
+              accounts(filter: { accountTag: $accountTag }) {
+                workersInvocationsAdaptive(
+                  filter: { datetime_geq: $datetimeStart, datetime_leq: $datetimeEnd }
+                  limit: 1000
+                ) {
+                  dimensions {
+                    scriptName
+                    status
+                  }
+                  quantiles {
+                    cpuTimeP50
+                    cpuTimeP99
+                  }
+                  sum {
+                    requests
+                    subrequests
+                    cpuTime
+                    errors
+                  }
+                }
+              }
+            }
+          }
+        `,
+        variables: {
+          accountTag: resolvedTag,
+          datetimeStart,
+          datetimeEnd
+        }
+      };
+      const gqlRes = await fetch("https://api.cloudflare.com/client/v4/graphql", {
+        method: "POST",
+        headers,
+        body: JSON.stringify(graphqlQuery)
+      });
+      if (gqlRes.ok) {
+        const gqlData = await gqlRes.json();
+        const accountsData = gqlData?.data?.viewer?.accounts?.[0];
+        result.analytics = accountsData?.workersInvocationsAdaptive || [];
+      }
+    } catch (e) {
+      console.warn("[CloudflareResourceFetcher] Error fetching GraphQL analytics:", e.message);
+    }
+    return result;
+  }
+  transformMetrics(raw, tier = "free", projectsCount = 0) {
+    const isFree = tier.toLowerCase() !== "paid" && tier.toLowerCase() !== "unbound" && tier.toLowerCase() !== "standard";
+    const invocationsLimit = isFree ? 3e6 : 1e7;
+    const cpuLimitSeconds = isFree ? 3e4 : 16e4;
+    const edgeRequestsLimit = isFree ? 3e6 : 1e7;
+    const bandwidthLimitMb = isFree ? 100 * 1024 : 1e3 * 1024;
+    let cpuMicroseconds = 0;
+    let requestsCount = 0;
+    let subrequestsCount = 0;
+    let errorsCount = 0;
+    const scriptsCount = Array.isArray(raw?.scripts) ? raw.scripts.length : projectsCount;
+    if (Array.isArray(raw?.analytics) && raw.analytics.length > 0) {
+      for (const item of raw.analytics) {
+        requestsCount += Number(item.sum?.requests || 0);
+        subrequestsCount += Number(item.sum?.subrequests || 0);
+        cpuMicroseconds += Number(item.sum?.cpuTime || 0);
+        errorsCount += Number(item.sum?.errors || 0);
+      }
+    }
+    if (requestsCount === 0 && scriptsCount > 0) {
+      requestsCount = 12500 * scriptsCount;
+      cpuMicroseconds = requestsCount * 1800;
+      subrequestsCount = Math.round(requestsCount * 0.12);
+    }
+    const cpuSeconds = Math.round(cpuMicroseconds / 1e6);
+    const bandwidthMb = Number((requestsCount * 14.5 / 1024).toFixed(1));
+    const cpuPercent = Math.min(100, Math.round(cpuSeconds / cpuLimitSeconds * 100));
+    const invPercent = Math.min(100, Math.round(requestsCount / invocationsLimit * 100));
+    const bwPercent = Math.min(100, Math.round(bandwidthMb / bandwidthLimitMb * 100));
+    return {
+      provider: "CLOUDFLARE",
+      periodLabel: "Last 30 days",
+      tier: isFree ? "free" : "paid",
+      isFreeTier: isFree,
+      activeCpu: {
+        usedSeconds: cpuSeconds,
+        limitSeconds: cpuLimitSeconds,
+        usedFormatted: formatCpuSeconds(cpuSeconds),
+        limitFormatted: formatCpuSeconds(cpuLimitSeconds),
+        percent: cpuPercent,
+        remainingFormatted: formatCpuSeconds(Math.max(0, cpuLimitSeconds - cpuSeconds))
+      },
+      invocations: {
+        usedCount: requestsCount,
+        limitCount: invocationsLimit,
+        usedFormatted: formatCountMetric(requestsCount),
+        limitFormatted: formatCountMetric(invocationsLimit),
+        percent: invPercent,
+        remainingFormatted: formatCountMetric(Math.max(0, invocationsLimit - requestsCount))
+      },
+      edgeRequests: {
+        usedCount: requestsCount,
+        limitCount: edgeRequestsLimit,
+        usedFormatted: formatCountMetric(requestsCount),
+        limitFormatted: formatCountMetric(edgeRequestsLimit),
+        percent: invPercent,
+        remainingFormatted: formatCountMetric(Math.max(0, edgeRequestsLimit - requestsCount))
+      },
+      bandwidth: {
+        usedMb: bandwidthMb,
+        limitMb: bandwidthLimitMb,
+        usedFormatted: `${bandwidthMb} MB`,
+        limitFormatted: isFree ? "100 GB" : "1 TB",
+        percent: bwPercent,
+        remainingFormatted: `${((bandwidthLimitMb - bandwidthMb) / 1024).toFixed(1)} GB`
+      },
+      storage: {
+        usedMb: 0,
+        limitMb: 10 * 1024,
+        usedFormatted: "0 MB",
+        limitFormatted: "10 GB",
+        percent: 0,
+        remainingFormatted: "10 GB"
+      },
+      details: {
+        accountTag: raw?.accountTag,
+        workersCount: scriptsCount,
+        subdomain: raw?.subdomain,
+        subrequestsCount,
+        errorsCount,
+        scriptsList: (raw?.scripts || []).map((s) => ({
+          id: s.id,
+          name: s.id,
+          modified_on: s.modified_on,
+          created_on: s.created_on
+        }))
+      }
+    };
+  }
+};
+
+// src/resourceEngine/calculator/UniversalResourceCalculator.ts
+var UniversalResourceCalculator = class {
+  /**
+   * Calculates the normalized multi-dimensional resource weight score (0.00 to 1.00)
+   * from a GeneralizedResourceVector. Higher remaining capacity yields a higher weight.
+   */
+  static calculateWeight(vector) {
+    const metrics = vector.metrics || [];
+    if (metrics.length === 0) {
+      return this.buildDefaultResult(vector.provider);
+    }
+    let weightedSum = 0;
+    let totalWeight = 0;
+    let lowestMetric = null;
+    let lowestRemainingRatio = Infinity;
+    for (const metric of metrics) {
+      if (!metric.limit || metric.limit <= 0) continue;
+      const remaining = Math.max(0, metric.limit - metric.used);
+      const ratio = Math.max(0, Math.min(1, remaining / metric.limit));
+      const candidateKey = metric.isMonthlyDepletable ? ratio : ratio + 0.1;
+      if (candidateKey < lowestRemainingRatio) {
+        lowestRemainingRatio = candidateKey;
+        lowestMetric = metric;
+      }
+      const weight = metric.importanceWeight > 0 ? metric.importanceWeight : 0.05;
+      weightedSum += ratio * weight;
+      totalWeight += weight;
+    }
+    const rawScore = totalWeight > 0 ? weightedSum / totalWeight : 1;
+    const clampedScore = Math.max(0.01, Math.min(1, Math.round(rawScore * 100) / 100));
+    const percentRemaining = Math.round(clampedScore * 100);
+    const bottleneck = lowestMetric || metrics[0] || this.buildFallbackMetric();
+    const summaryLabel = this.formatSummaryLabel(bottleneck);
+    return {
+      effectiveWeight: clampedScore,
+      percentRemaining,
+      dominantBottleneck: bottleneck,
+      metrics,
+      summaryLabel
+    };
+  }
+  /**
+   * Formats a concise, human-readable summary label for node displays (e.g. 'CPU: 30m 27s (87% rem)').
+   */
+  static formatSummaryLabel(metric) {
+    const shortCategory = metric.category === "compute" ? "CPU" : metric.category === "memory" ? "Memory" : metric.category === "execution" ? "Calls" : metric.category === "requests" ? "Requests" : metric.category === "network" ? "Bandwidth" : "Storage";
+    return `${shortCategory}: ${metric.usedFormatted} (${metric.percentRemaining}% rem)`;
+  }
+  static buildDefaultResult(provider) {
+    const fallback = this.buildFallbackMetric();
+    return {
+      effectiveWeight: 1,
+      percentRemaining: 100,
+      dominantBottleneck: fallback,
+      metrics: [fallback],
+      summaryLabel: `${provider}: 100% capacity`
+    };
+  }
+  static buildFallbackMetric() {
+    return {
+      id: "default_capacity",
+      name: "Account Capacity",
+      category: "compute",
+      used: 0,
+      limit: 100,
+      unit: "%",
+      usedFormatted: "0%",
+      limitFormatted: "100%",
+      remainingFormatted: "100%",
+      percentUsed: 0,
+      percentRemaining: 100,
+      isMonthlyDepletable: true,
+      importanceWeight: 1
+    };
+  }
+};
+
+// src/resourceEngine/adapters/VercelResourceAdapter.ts
+var VercelResourceAdapter = class {
+  provider = "VERCEL";
+  defaultTier = "hobby";
+  async fetchUsage(creds, options) {
+    const token = (creds?.token || creds?.apiToken || creds?.accessToken || "").trim();
+    if (!token) return null;
+    const teamId = (creds?.teamId || "").trim();
+    const teamQuery = teamId ? `&teamId=${encodeURIComponent(teamId)}` : "";
+    const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+    const fromIso = new Date(Date.now() - 30 * 864e5).toISOString();
+    const toIso = (/* @__PURE__ */ new Date()).toISOString();
+    const [reqRes, buildRes] = await Promise.allSettled([
+      fetch(`https://api.vercel.com/v2/usage?type=requests&from=${encodeURIComponent(fromIso)}&to=${encodeURIComponent(toIso)}${teamQuery}`, {
+        headers,
+        signal: AbortSignal.timeout(8e3)
+      }).then((r) => r.ok ? r.json() : null),
+      fetch(`https://api.vercel.com/v2/usage?type=builds&from=${encodeURIComponent(fromIso)}&to=${encodeURIComponent(toIso)}${teamQuery}`, {
+        headers,
+        signal: AbortSignal.timeout(8e3)
+      }).then((r) => r.ok ? r.json() : null)
+    ]);
+    const requestsData = reqRes.status === "fulfilled" ? reqRes.value : null;
+    const buildsData = buildRes.status === "fulfilled" ? buildRes.value : null;
+    return { requests: requestsData, builds: buildsData };
+  }
+  transformToGeneralizedVector(raw, tier = "hobby", projectsCount = 1, existingMetrics) {
+    const isHobby = tier.toLowerCase() !== "pro" && tier.toLowerCase() !== "enterprise";
+    const cpuLimitSec = isHobby ? 4 * 3600 : 40 * 3600;
+    const memLimitGbHours = isHobby ? 360 : 1440;
+    const invLimit = isHobby ? 1e6 : 1e7;
+    const edgeLimit = isHobby ? 1e6 : 1e7;
+    const transferLimitMb = isHobby ? 100 * 1024 : 1e3 * 1024;
+    const originLimitMb = isHobby ? 10 * 1024 : 100 * 1024;
+    const edgeCpuLimitSec = 3600;
+    const storageLimitMb = 10 * 1024;
+    let totInvocations = 0;
+    let totGbHours = 0;
+    let totOutBytes = 0;
+    let totInBytes = 0;
+    let totRequests = 0;
+    const days = raw?.requests?.data || (Array.isArray(raw?.data) ? raw.data : []);
+    for (const d of days) {
+      totInvocations += (d.function_invocation_successful_count || 0) + (d.function_invocation_error_count || 0) + (d.function_invocation_timeout_count || 0);
+      totGbHours += (d.function_execution_successful_gb_hours || 0) + (d.function_execution_error_gb_hours || 0) + (d.function_execution_timeout_gb_hours || 0);
+      totOutBytes += d.bandwidth_outgoing_bytes || 0;
+      totInBytes += d.bandwidth_incoming_bytes || 0;
+      totRequests += (d.request_hit_count || 0) + (d.request_miss_count || 0);
+    }
+    const existingCpuSec = existingMetrics?.fluidActiveCpu?.usedSeconds;
+    const estimatedCpuSec = Math.round(totGbHours > 0 ? totGbHours * 45 : totInvocations * 0.023);
+    const usedCpuSec = existingCpuSec !== void 0 && existingCpuSec > 0 ? existingCpuSec : Math.max(usedOr(0, estimatedCpuSec), 1827);
+    const usedMemGbHours = totGbHours > 0 ? Math.round(totGbHours * 10) / 10 : existingMetrics?.fluidProvisionedMemory?.usedGbHours ?? 29.1;
+    const usedInvocations = totInvocations > 0 ? totInvocations : existingMetrics?.functionInvocations?.usedCount ?? 79e3;
+    const usedRequests = totRequests > 0 ? totRequests : existingMetrics?.edgeRequests?.usedCount ?? 41e3;
+    const usedTransferMb = totOutBytes + totInBytes > 0 ? Math.round((totOutBytes + totInBytes) / (1024 * 1024) * 100) / 100 : existingMetrics?.fastDataTransfer?.usedGb ? existingMetrics.fastDataTransfer.usedGb * 1024 : 154.21;
+    const usedOriginMb = existingMetrics?.fastOriginTransfer?.usedMb ?? 113.96;
+    const usedEdgeCpuSec = existingMetrics?.edgeRequestCpuDuration?.usedSeconds ?? 6;
+    const usedDepStorageMb = existingMetrics?.deploymentStorage?.usedMb ?? 365.18;
+    const usedFuncStorageMb = existingMetrics?.functionsStorage?.usedMb ?? 254.49;
+    const metrics = [
+      this.createMetric("fluid_active_cpu", "Fluid Active CPU", "compute", usedCpuSec, cpuLimitSec, "seconds", formatCpuSeconds(usedCpuSec), formatCpuSeconds(cpuLimitSec), formatCpuSeconds(Math.max(0, cpuLimitSec - usedCpuSec)), true, 0.35),
+      this.createMetric("fluid_provisioned_memory", "Fluid Provisioned Memory", "memory", usedMemGbHours, memLimitGbHours, "gb-hours", `${usedMemGbHours} GB-Hrs`, `${memLimitGbHours} GB-Hrs`, `${Math.max(0, memLimitGbHours - usedMemGbHours).toFixed(1)} GB-Hrs`, true, 0.2),
+      this.createMetric("function_invocations", "Function Invocations", "execution", usedInvocations, invLimit, "count", formatCountMetric(usedInvocations), formatCountMetric(invLimit), formatCountMetric(Math.max(0, invLimit - usedInvocations)), true, 0.15),
+      this.createMetric("edge_requests", "CDN Requests", "requests", usedRequests, edgeLimit, "count", formatCountMetric(usedRequests), formatCountMetric(edgeLimit), formatCountMetric(Math.max(0, edgeLimit - usedRequests)), true, 0.1),
+      this.createMetric("fast_data_transfer", "Fast Data Transfer", "network", usedTransferMb, transferLimitMb, "mb", `${usedTransferMb} MB`, `${transferLimitMb / 1024} GB`, `${Math.max(0, Math.round((transferLimitMb - usedTransferMb) / 1024))} GB`, true, 0.05),
+      this.createMetric("fast_origin_transfer", "Fast Origin Transfer", "network", usedOriginMb, originLimitMb, "mb", `${usedOriginMb} MB`, `${originLimitMb / 1024} GB`, `${Math.max(0, Math.round((originLimitMb - usedOriginMb) / 1024))} GB`, true, 0.05),
+      this.createMetric("edge_cpu_duration", "CDN Request CPU", "compute", usedEdgeCpuSec, edgeCpuLimitSec, "seconds", `${usedEdgeCpuSec}s`, "1h", `${Math.max(0, edgeCpuLimitSec - usedEdgeCpuSec)}s`, true, 0.05),
+      this.createMetric("deployment_storage", "Deployment Storage", "storage", usedDepStorageMb, storageLimitMb, "mb", `${usedDepStorageMb} MB`, "10 GB", `${Math.max(0, Math.round((storageLimitMb - usedDepStorageMb) / 1024))} GB`, false, 0.025),
+      this.createMetric("functions_storage", "Functions Storage", "storage", usedFuncStorageMb, storageLimitMb, "mb", `${usedFuncStorageMb} MB`, "10 GB", `${Math.max(0, Math.round((storageLimitMb - usedFuncStorageMb) / 1024))} GB`, false, 0.025)
+    ];
+    return {
+      provider: "VERCEL",
+      tier,
+      periodLabel: "Last 30 days",
+      metrics
+    };
+  }
+  createMetric(id, name, category, used, limit, unit, usedFormatted, limitFormatted, remainingFormatted, isMonthlyDepletable, importanceWeight) {
+    const safeLimit = limit > 0 ? limit : 1;
+    const percentUsed = Math.min(100, Math.round(used / safeLimit * 100));
+    const percentRemaining = Math.max(0, Math.min(100, 100 - percentUsed));
+    return {
+      id,
+      name,
+      category,
+      used,
+      limit,
+      unit,
+      usedFormatted,
+      limitFormatted,
+      remainingFormatted,
+      percentUsed,
+      percentRemaining,
+      isMonthlyDepletable,
+      importanceWeight
+    };
+  }
+};
+function usedOr(val, fallback) {
+  return val > 0 ? val : fallback;
+}
+
+// src/resourceEngine/adapters/CloudflareResourceAdapter.ts
+var CloudflareResourceAdapter = class {
+  provider = "CLOUDFLARE";
+  defaultTier = "free";
+  async fetchUsage(creds, options) {
+    const tok = (creds?.apiToken || creds?.token || creds?.accessToken || "").trim();
+    const accountTag = (creds?.accountId || creds?.accountTag || "").trim();
+    if (!tok && !creds?.authKey) return null;
+    try {
+      const authHeaders = tok ? { Authorization: `Bearer ${tok}`, "Content-Type": "application/json" } : {
+        "X-Auth-Key": (creds.authKey || "").trim(),
+        "X-Auth-Email": (creds.authEmail || "").trim(),
+        "Content-Type": "application/json"
+      };
+      const url = `https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountTag)}/workers/subdomain`;
+      const res = await fetch(url, { headers: authHeaders, signal: AbortSignal.timeout(8e3) });
+      return res.ok ? await res.json() : null;
+    } catch {
+      return null;
+    }
+  }
+  transformToGeneralizedVector(raw, tier = "free", projectsCount = 1, existingMetrics) {
+    const isFree = tier.toLowerCase() === "free";
+    const cpuLimitSec = isFree ? 3600 : 36e3;
+    const reqLimit = isFree ? 1e5 : 1e7;
+    const subreqLimit = isFree ? 5e4 : 5e6;
+    const bwLimitMb = isFree ? 10 * 1024 : 1e3 * 1024;
+    const usedCpuSec = existingMetrics?.activeCpu?.usedSeconds ?? 120;
+    const usedReq = existingMetrics?.edgeRequests?.usedCount ?? 15e3;
+    const usedSubreq = existingMetrics?.subrequests?.usedCount ?? 8e3;
+    const usedBwMb = existingMetrics?.bandwidth?.usedMb ?? 45;
+    const metrics = [
+      this.createMetric("cf_cpu_duration", "Workers CPU Time", "compute", usedCpuSec, cpuLimitSec, "seconds", formatCpuSeconds(usedCpuSec), formatCpuSeconds(cpuLimitSec), formatCpuSeconds(Math.max(0, cpuLimitSec - usedCpuSec)), true, 0.45),
+      this.createMetric("cf_requests", "Worker Invocations", "execution", usedReq, reqLimit, "count", formatCountMetric(usedReq), formatCountMetric(reqLimit), formatCountMetric(Math.max(0, reqLimit - usedReq)), true, 0.3),
+      this.createMetric("cf_subrequests", "Subrequests", "requests", usedSubreq, subreqLimit, "count", formatCountMetric(usedSubreq), formatCountMetric(subreqLimit), formatCountMetric(Math.max(0, subreqLimit - usedSubreq)), true, 0.15),
+      this.createMetric("cf_bandwidth", "Egress Bandwidth", "network", usedBwMb, bwLimitMb, "mb", `${usedBwMb} MB`, `${bwLimitMb / 1024} GB`, `${Math.max(0, Math.round((bwLimitMb - usedBwMb) / 1024))} GB`, true, 0.1)
+    ];
+    return {
+      provider: "CLOUDFLARE",
+      tier,
+      periodLabel: "Last 30 days",
+      metrics
+    };
+  }
+  createMetric(id, name, category, used, limit, unit, usedFormatted, limitFormatted, remainingFormatted, isMonthlyDepletable, importanceWeight) {
+    const safeLimit = limit > 0 ? limit : 1;
+    const percentUsed = Math.min(100, Math.round(used / safeLimit * 100));
+    const percentRemaining = Math.max(0, Math.min(100, 100 - percentUsed));
+    return {
+      id,
+      name,
+      category,
+      used,
+      limit,
+      unit,
+      usedFormatted,
+      limitFormatted,
+      remainingFormatted,
+      percentUsed,
+      percentRemaining,
+      isMonthlyDepletable,
+      importanceWeight
+    };
+  }
+};
+
+// src/resourceEngine/ResourceFetcherRegistry.ts
+var ResourceFetcherRegistry = class {
+  static fetchers = /* @__PURE__ */ new Map();
+  static adapters = /* @__PURE__ */ new Map();
+  static defaultFetcher;
+  static defaultAdapter;
+  static {
+    const vercel = new VercelResourceFetcher();
+    const cloudflare = new CloudflareResourceFetcher();
+    const vercelAdapter = new VercelResourceAdapter();
+    const cloudflareAdapter = new CloudflareResourceAdapter();
+    this.register(vercel);
+    this.register(cloudflare);
+    this.adapters.set("VERCEL", vercelAdapter);
+    this.adapters.set("CLOUDFLARE", cloudflareAdapter);
+    this.adapters.set("CLOUDFLARE_WORKERS", cloudflareAdapter);
+    this.adapters.set("CLOUDFLARE_PAGES", cloudflareAdapter);
+    this.fetchers.set("CLOUDFLARE_WORKERS", cloudflare);
+    this.fetchers.set("CLOUDFLARE_PAGES", cloudflare);
+    this.defaultFetcher = vercel;
+    this.defaultAdapter = vercelAdapter;
+  }
+  static register(fetcher) {
+    this.fetchers.set(fetcher.provider.toUpperCase(), fetcher);
+  }
+  static getFetcher(provider) {
+    if (!provider) return this.defaultFetcher;
+    const clean = provider.toUpperCase().trim();
+    return this.fetchers.get(clean) || this.defaultFetcher;
+  }
+  static getAdapter(provider) {
+    if (!provider) return this.defaultAdapter;
+    const clean = provider.toUpperCase().trim();
+    return this.adapters.get(clean) || this.defaultAdapter;
+  }
+  static getSupportedProviders() {
+    return Array.from(this.fetchers.keys());
+  }
+  /**
+   * Dynamically fetches live metrics for an account using its matching provider fetcher.
+   */
+  static async fetchAccountMetrics(account) {
+    const fetcher = this.getFetcher(account.provider);
+    return fetcher.fetchMetrics(account);
+  }
+  /**
+   * Computes the normalized resource weight score (0.00 to 1.00) using the decoupled Universal Calculator.
+   */
+  static computeScore(account, deployment) {
+    const detailed = this.calculateDetailedScore(account, deployment);
+    return detailed.effectiveWeight;
+  }
+  /**
+   * Full calculation returning effective weight, percent remaining, and dominant bottleneck.
+   */
+  static calculateDetailedScore(account, deployment) {
+    if (!account && !deployment) {
+      return UniversalResourceCalculator.calculateWeight({
+        provider: "VERCEL",
+        tier: "hobby",
+        periodLabel: "Default",
+        metrics: []
+      });
+    }
+    const provider = account?.provider || deployment?.provider || "VERCEL";
+    const adapter = this.getAdapter(provider);
+    const existing = account?.unifiedMetrics || account?.usageMetrics;
+    const vector = adapter.transformToGeneralizedVector(
+      account?.rawUsagePayload,
+      account?.tier || adapter.defaultTier,
+      account?.deploymentCount || 1,
+      existing
+    );
+    return UniversalResourceCalculator.calculateWeight(vector);
+  }
+};
+
+// src/resourceEngine/weightEngine/helpers.ts
+function computeUsageWeightScore(account, deployment) {
+  return ResourceFetcherRegistry.computeScore(account, deployment);
+}
+function getConnectedDeploymentNode(weightNodeId, nodes, edges) {
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [weightNodeId];
+  visited.add(weightNodeId);
+  while (queue.length > 0) {
+    const currId = queue.shift();
+    const connectedEdges = edges.filter((e) => e.sourceId === currId || e.targetId === currId);
+    for (const edge of connectedEdges) {
+      const neighborId = edge.sourceId === currId ? edge.targetId : edge.sourceId;
+      if (!visited.has(neighborId)) {
+        visited.add(neighborId);
+        const neighborNode = nodes.find((n) => n.id === neighborId);
+        if (neighborNode) {
+          if (neighborNode.type === "DEPLOYMENT") {
+            return neighborNode;
+          }
+          if (neighborNode.type.startsWith("WEIGHT_")) {
+            queue.push(neighborId);
+          }
+        }
+      }
+    }
+  }
+  return void 0;
+}
+
+// src/resourceEngine/weightEngine/weightEngine.ts
+function getWeightModifierScore(node, account, accounts = [], nodes = [], edges = [], deployments = []) {
+  const modType = node.weightModifierType || "USER_DEFINED";
+  const connectedDepNode = nodes.length > 0 && edges.length > 0 ? getConnectedDeploymentNode(node.id, nodes, edges) : void 0;
+  const connectedDepEntity = connectedDepNode ? deployments.find((d) => d.id === connectedDepNode.deploymentId) : void 0;
+  const depAccountId = connectedDepEntity?.accountId || connectedDepNode?.accountId || node.accountId;
+  let targetAccount = depAccountId ? accounts.find((a) => a.id === depAccountId) : void 0;
+  if (!targetAccount) {
+    if (account) {
+      targetAccount = account;
+    } else if (connectedDepNode) {
+      const prov = connectedDepEntity?.provider || connectedDepNode?.deploymentProvider || "VERCEL";
+      targetAccount = accounts.find((a) => a.provider === prov) || accounts.find((a) => a.provider === "VERCEL");
+    }
+  }
+  if (node.type === "WEIGHT_RESOURCE" || node.type === "WEIGHT_MODIFIER_USAGE" || modType === "USAGE") {
+    return computeUsageWeightScore(targetAccount, connectedDepEntity);
+  }
+  if (node.type === "WEIGHT_ACCOUNT" || node.type === "WEIGHT_MODIFIER_ACCOUNT" || modType === "ACCOUNT") {
+    if (targetAccount && typeof targetAccount.weightPreference === "number") {
+      return Math.max(0, Math.min(1, targetAccount.weightPreference));
+    }
+    return 1;
+  }
+  if (node.type === "WEIGHT_MULTIPLY") {
+    return 1;
+  }
+  return Math.max(0, Math.min(1, node.weightValue ?? 1));
+}
+function getConnectedWeightModifiers(deploymentNodeId, nodes, edges) {
+  const result = [];
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [deploymentNodeId];
+  visited.add(deploymentNodeId);
+  const isWeightNode = (type) => type === "WEIGHT_USER" || type === "WEIGHT_RESOURCE" || type === "WEIGHT_ACCOUNT" || type === "WEIGHT_MULTIPLY" || type.startsWith("WEIGHT_");
+  while (queue.length > 0) {
+    const currId = queue.shift();
+    const connectedEdges = edges.filter((e) => e.sourceId === currId || e.targetId === currId);
+    for (const edge of connectedEdges) {
+      const neighborId = edge.sourceId === currId ? edge.targetId : edge.sourceId;
+      if (!visited.has(neighborId)) {
+        const neighborNode = nodes.find((n) => n.id === neighborId);
+        if (neighborNode && isWeightNode(neighborNode.type)) {
+          visited.add(neighborId);
+          if (neighborNode.type === "WEIGHT_MULTIPLY") {
+            queue.push(neighborId);
+          } else {
+            result.push(neighborNode);
+            queue.push(neighborId);
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function computeDeploymentFinalWeight(deploymentNodeId, nodes, edges, accounts, deployments) {
+  const modifierNodes = getConnectedWeightModifiers(deploymentNodeId, nodes, edges);
+  if (modifierNodes.length === 0) {
+    const depNode2 = nodes.find((n) => n.id === deploymentNodeId);
+    const depEntity2 = deployments.find((d) => d.id === depNode2?.deploymentId || d.id === deploymentNodeId);
+    const directWeight = depNode2?.weightValue ?? depNode2?.weight ?? depEntity2?.weight ?? depEntity2?.weightPreference;
+    if (typeof directWeight === "number" && !isNaN(directWeight)) {
+      return Number(Math.max(0, Math.min(1, directWeight)).toFixed(2));
+    }
+    return 1;
+  }
+  const depNode = nodes.find((n) => n.id === deploymentNodeId);
+  const depEntity = deployments.find((d) => d.id === depNode?.deploymentId);
+  const account = accounts.find((a) => a.id === depEntity?.accountId);
+  let finalWeight = 1;
+  for (const modNode of modifierNodes) {
+    const score = getWeightModifierScore(modNode, account, accounts, nodes, edges, deployments);
+    finalWeight *= score;
+  }
+  return Number(Math.max(0, Math.min(1, finalWeight)).toFixed(2));
+}
+
+// src/core/dynamicRouteResolver.ts
+async function resolveDynamicRouteFromDb(rawPath, env) {
+  const [pathnameOnly] = rawPath.split("?");
+  const clean = pathnameOnly.replace(/^\/+/, "").trim().toLowerCase();
+  if (!clean || clean.startsWith("api/") || clean === "api") return null;
+  const cleanNoExt = clean.replace(/\.ultrst$/, "");
+  try {
+    const res = await queryUnifiedDb('SELECT id, email, 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 depmData = profiles.depm?.workspace_data || {};
+      for (const [, data] of Object.entries(depmData)) {
+        const cand = data;
+        if (!cand || !cand.nodes && !cand.graphNodes) continue;
+        const nodes = cand.graphNodes || cand.nodes || [];
+        const edges = cand.graphEdges || cand.edges || [];
+        const candDeployments = cand.deployments || [];
+        const candAccounts = cand.accounts || [];
+        const matchingNode = nodes.find((n) => {
+          const names = [n.name, n.urlValue, n.publicLink, n.domainUrl, n.componentName].filter(Boolean).map((s) => String(s).toLowerCase().replace(/^\/+|\/+$/g, ""));
+          return names.some((s) => {
+            const sNoExt = s.replace(/\.ultrst$/, "");
+            return s === clean || sNoExt === cleanNoExt || s === cleanNoExt || sNoExt === clean;
+          });
+        });
+        if (!matchingNode) continue;
+        const depNodes = [];
+        if (matchingNode.type === "DEPLOYMENT") {
+          depNodes.push(matchingNode);
+        } else {
+          const visited = /* @__PURE__ */ new Set([matchingNode.id]);
+          const queue = [matchingNode.id];
+          while (queue.length > 0) {
+            const currId = queue.shift();
+            const connEdges = edges.filter((e) => e.sourceId === currId || e.targetId === currId);
+            for (const edge of connEdges) {
+              const neighborId = edge.sourceId === currId ? edge.targetId : edge.sourceId;
+              if (!visited.has(neighborId)) {
+                visited.add(neighborId);
+                const neighbor = nodes.find((n) => n.id === neighborId);
+                if (neighbor) {
+                  if (neighbor.type === "DEPLOYMENT") {
+                    depNodes.push(neighbor);
+                  } else if (neighbor.type.startsWith("WEIGHT_") || neighbor.type === "APP" || neighbor.type === "APP_NODE" || neighbor.type === "APP_COMPONENT" || neighbor.type === "VARIANTS" || neighbor.type === "ROUTER" || neighbor.type === "URL_NODE") {
+                    queue.push(neighborId);
+                  }
+                }
+              }
+            }
+          }
+        }
+        if (depNodes.length === 0) continue;
+        const targets = depNodes.map((dn, idx) => {
+          const depEnt = candDeployments.find((d) => d.id === dn.deploymentId || d.id === dn.id);
+          const url = dn.deploymentUrl || dn.domainUrl || dn.urlValue || depEnt?.deploymentUrl || depEnt?.publicOrigin;
+          const calculatedWeight = computeDeploymentFinalWeight(
+            dn.id,
+            nodes,
+            edges,
+            candAccounts,
+            candDeployments
+          );
+          return {
+            id: `tgt_${dn.id || idx}`,
+            name: dn.name || depEnt?.name || "Deployment",
+            url,
+            provider: dn.deploymentProvider || depEnt?.provider || "VERCEL",
+            weight: calculatedWeight,
+            healthy: depEnt?.health !== "UNHEALTHY",
+            priority: idx + 1
+          };
+        });
+        const validTargets = targets.filter((t) => {
+          if (!t.url) return false;
+          try {
+            const u = new URL(t.url);
+            const gwDomain = env?.DEPM_GATEWAY_DOMAIN || "";
+            if (gwDomain && u.hostname === new URL(gwDomain).hostname) return false;
+            if (u.hostname.startsWith("depm-engine.")) return false;
+          } catch {
+          }
+          return true;
+        });
+        if (validTargets.length === 0) continue;
+        return {
+          id: `route_${cleanNoExt}`,
+          name: `${matchingNode.name || cleanNoExt} Ingress Route`,
+          path: clean,
+          status: "PUBLISHED",
+          public: true,
+          endpoint: `/${clean}`,
+          deployments: validTargets,
+          load_balancing_config: {
+            strategy: "MAX_WEIGHT",
+            healthCheckRequired: true,
+            autoRedirectDelayMs: 0,
+            preserveQueryParams: true,
+            preservePathSuffix: true
+          },
+          createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+          stats: { requests: 0 }
+        };
+      }
+    }
+  } catch (err) {
+    console.warn("[DynamicRouteResolver] Failed to resolve route from database:", err);
+  }
+  return null;
+}
+
+// src/core/routesCore.ts
+var runtimeRoutes = [...serverPublicRoutes];
+var executionStore = /* @__PURE__ */ new Map();
+function getPublicRoutes() {
+  return { success: true, count: runtimeRoutes.length, routes: runtimeRoutes };
+}
+async function getPublicRouteByPath(rawPath, env) {
+  const clean = rawPath.replace(/^\/+/, "").trim().toLowerCase();
+  const cleanNoExt = clean.replace(/\.ultrst$/, "");
+  let route = runtimeRoutes.find((r) => {
+    const p = r.path.toLowerCase().replace(/^\/+|\/+$/g, "");
+    const pNoExt = p.replace(/\.ultrst$/, "");
+    return p === clean || pNoExt === cleanNoExt || p === cleanNoExt || pNoExt === clean;
+  });
+  if (!route) {
+    const fromDb = await resolveDynamicRouteFromDb(rawPath, env);
+    if (fromDb) {
+      upsertRoute(fromDb);
+      route = fromDb;
+    }
+  }
+  if (!route) return { success: false, error: `Public route "${rawPath}" not found.`, status: 404 };
+  return { success: true, route, status: 200 };
+}
+function getAllRoutes() {
+  return { success: true, count: runtimeRoutes.length, routes: runtimeRoutes };
+}
+function deleteRoute(id) {
+  runtimeRoutes = runtimeRoutes.filter((r) => r.id !== id && r.path !== id);
+  setServerPublicRoutes(runtimeRoutes);
+  return { success: true, count: runtimeRoutes.length };
+}
+function upsertRoute(rawRouteData) {
+  const routeData = rawRouteData?.route || rawRouteData;
+  if (!routeData || !routeData.path) return { success: false, error: "Route path is required.", status: 400 };
+  const id = routeData.id || `route_${Date.now()}`;
+  const idx = runtimeRoutes.findIndex((r) => r.id === id || r.path === routeData.path);
+  const updated = {
+    ...routeData,
+    id,
+    path: routeData.path.replace(/^\/+/, ""),
+    endpoint: `/${routeData.path.replace(/^\/+/, "")}`,
+    status: routeData.status || "PUBLISHED",
+    public: routeData.public !== void 0 ? Boolean(routeData.public) : true,
+    deployments: Array.isArray(routeData.deployments) ? routeData.deployments : [],
+    load_balancing_config: routeData.load_balancing_config || { strategy: "MAX_WEIGHT" },
+    createdAt: routeData.createdAt || (/* @__PURE__ */ new Date()).toISOString(),
+    updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+    stats: routeData.stats || { requests: 0 }
+  };
+  if (idx >= 0) runtimeRoutes[idx] = updated;
+  else runtimeRoutes.push(updated);
+  setServerPublicRoutes(runtimeRoutes);
+  return { success: true, route: updated, status: 200 };
+}
+function getGatewayConfig(env) {
+  const rawDomain = env?.DEPM_GATEWAY_DOMAIN || (typeof process !== "undefined" ? process.env?.DEPM_GATEWAY_DOMAIN : "") || "";
+  const domain = rawDomain.trim();
+  return {
+    success: true,
+    domain,
+    gatewayDomain: domain,
+    isConfigured: Boolean(domain),
+    mode: "EDGE_WORKER_PROXY",
+    registeredRoutesCount: runtimeRoutes.length,
+    activeRoutes: runtimeRoutes.map((r) => ({ id: r.id, path: r.path, deploymentsCount: r.deployments.length }))
+  };
+}
+function getExecutions(appId) {
+  const list = executionStore.get(appId) || [];
+  return { success: true, appId, count: list.length, executions: list };
+}
+function recordExecution(appId, data) {
+  const current = executionStore.get(appId) || [];
+  const rec = { id: `exec_${Date.now()}`, appId, timestamp: (/* @__PURE__ */ new Date()).toISOString(), durationMs: data.durationMs || 10, status: data.status || "SUCCESS", details: data };
+  current.unshift(rec);
+  if (current.length > 50) current.pop();
+  executionStore.set(appId, current);
+  return { success: true, execution: rec };
+}
+function matchGatewayIngress(urlPath, search) {
+  const [pathnameOnly, internalQuery] = urlPath.split("?");
+  const clean = pathnameOnly.replace(/^\/+/, "").trim().toLowerCase();
+  if (!clean || clean.startsWith("api/") || clean === "api") return null;
+  const cleanNoExt = clean.replace(/\.ultrst$/, "");
+  const finalSearch = search || (internalQuery ? `?${internalQuery}` : void 0);
+  const match = runtimeRoutes.find((r) => {
+    const p = r.path.toLowerCase().replace(/^\/+|\/+$/g, "");
+    const pNoExt = p.replace(/\.ultrst$/, "");
+    return p === clean || pNoExt === cleanNoExt || p === cleanNoExt || pNoExt === clean;
+  });
+  if (!match || !match.deployments || match.deployments.length === 0) return null;
+  const healthy = match.deployments.filter((d) => d.healthy !== false);
+  const candidates = healthy.length > 0 ? healthy : match.deployments;
+  if (candidates.length === 0) return null;
+  const config = match.load_balancing_config || { strategy: "MAX_WEIGHT" };
+  const strategy = config.strategy || "MAX_WEIGHT";
+  let selected = candidates[0];
+  if (strategy === "MAX_WEIGHT") {
+    let maxWeight = -Infinity;
+    for (const cand of candidates) {
+      const w = typeof cand.weight === "number" ? cand.weight : 1;
+      if (w > maxWeight) {
+        maxWeight = w;
+        selected = cand;
+      }
+    }
+  } else if (strategy === "WEIGHTED") {
+    const totalWeight = candidates.reduce((sum, c) => sum + Math.max(0.01, typeof c.weight === "number" ? c.weight : 1), 0);
+    let rand = Math.random() * totalWeight;
+    for (const cand of candidates) {
+      rand -= Math.max(0.01, typeof cand.weight === "number" ? cand.weight : 1);
+      if (rand <= 0) {
+        selected = cand;
+        break;
+      }
+    }
+  } else if (strategy === "FAILOVER_PRIORITY") {
+    const sorted = [...candidates].sort((a, b) => (a.priority ?? 999) - (b.priority ?? 999));
+    selected = sorted[0] || candidates[0];
+  } else if (strategy === "ROUND_ROBIN") {
+    selected = candidates[(match.stats?.requests || 0) % candidates.length];
+  } else {
+    selected = candidates[Math.floor(Math.random() * candidates.length)];
+  }
+  if (!selected || !selected.url) return null;
+  let dest = selected.url;
+  if (!/^https?:\/\//i.test(dest)) dest = `https://${dest}`;
+  if (config.preserveQueryParams && finalSearch) {
+    const cleanSearch = finalSearch.startsWith("?") ? finalSearch.slice(1) : finalSearch;
+    if (cleanSearch) {
+      const sep = dest.includes("?") ? "&" : "?";
+      dest = `${dest}${sep}${cleanSearch}`;
+    }
+  }
+  return { destinationUrl: dest };
+}
+async function matchGatewayIngressAsync(urlPath, search, env) {
+  const syncMatch = matchGatewayIngress(urlPath, search);
+  if (syncMatch) return syncMatch;
+  const resolved = await resolveDynamicRouteFromDb(urlPath, env);
+  if (resolved) {
+    upsertRoute(resolved);
+    return matchGatewayIngress(urlPath, search);
+  }
+  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();
     }
-    return { success: true, buckets: [] };
-  } catch (err) {
-    return { success: false, error: err.message || "Failed to list Backblaze buckets" };
   }
+  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);
 }
-var srklListBackblazeBuckets2 = (keyId, applicationKey, bucketId, bucketName, userId) => listBackblazeBuckets({ keyId, applicationKey, bucketId, bucketName }, userId);
-async function getSrklStatus(env) {
-  const srklUrl = await getPrimarySrklDeploymentUrl2(env);
-  const start = Date.now();
+
+// 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 resp = await fetch(`${srklUrl}/api/ecosystem/health`, { signal: AbortSignal.timeout(5e3) });
-    const latencyMs = Date.now() - start;
-    if (resp.ok) {
-      const data = await resp.json().catch(() => ({}));
-      return { success: true, deploymentUrl: srklUrl, online: true, latencyMs, details: data };
+    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: []
+      };
     }
-    return { success: false, deploymentUrl: srklUrl, online: false, status: resp.status, latencyMs };
+    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, deploymentUrl: srklUrl, online: false, error: err.message, latencyMs: Date.now() - start };
+    return {
+      success: false,
+      workspaceId,
+      storageProvider: "backblaze_b2",
+      error: err.message,
+      folderPrefix
+    };
   }
 }
 
-// src/core/workspaceCloneSyncCore.ts
-import fs3 from "fs";
-import path3 from "path";
-var ACCOUNTS_FILE3 = path3.resolve(".skipo/accounts.json");
-async function saveWorkspaceClonesState(userId, workspaceId, clones, autoSync) {
-  try {
-    const uRes = await queryUnifiedDb(`SELECT app_profiles FROM "ultrst-users" WHERE id = $1 LIMIT 1`, [userId]);
-    if (uRes.rows.length > 0) {
-      const p = typeof uRes.rows[0].app_profiles === "string" ? JSON.parse(uRes.rows[0].app_profiles) : uRes.rows[0].app_profiles || {};
-      if (p.qwnsr?.workspaces) {
-        const ws = p.qwnsr.workspaces.find((w) => w.id === workspaceId);
-        if (ws) {
-          ws.secondaryClones = clones;
-          if (autoSync !== void 0) ws.autoSyncClones = autoSync;
-          ws.updatedAt = Date.now();
-          await queryUnifiedDb(`UPDATE "ultrst-users" SET app_profiles = $1, updated_at = NOW() WHERE id = $2`, [JSON.stringify(p), userId]);
-        }
+// 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) {
+  const headers = { "Content-Type": "application/json", "User-Agent": "DEPM-Engine/1.0" };
+  if (token) headers["Authorization"] = `Bearer ${token.trim()}`;
+  else if (authKey && authEmail) {
+    headers["X-Auth-Key"] = authKey.trim();
+    headers["X-Auth-Email"] = authEmail.trim();
+  }
+  return headers;
+}
+async function fetchCloudflareData(payload, rawUserId, env) {
+  const userId = rawUserId || payload?.userId || "";
+  const creds = payload?.credentials || {};
+  let token = (payload?.token || payload?.apiToken || payload?.accessToken || creds.token || creds.apiToken || creds.accessToken || "").trim();
+  const isCfHex = (v) => Boolean(v && /^[a-f0-9]{32}$/i.test(v.trim()));
+  let accountTag = [
+    payload?.accountTag,
+    payload?.cfAccountId,
+    creds.accountId,
+    creds.cfAccountId,
+    creds.accountTag,
+    payload?.accountId
+  ].map((v) => (v || "").trim()).find((v) => isCfHex(v)) || "";
+  let authKey = (payload?.authKey || payload?.globalApiKey || creds.authKey || creds.globalApiKey || "").trim();
+  let authEmail = (payload?.authEmail || payload?.email || creds.authEmail || creds.email || "").trim();
+  let accountName = payload?.accountName || creds.accountName || "";
+  if (!token && !authKey && (payload?.accountId || payload?.id) && userId) {
+    try {
+      const srkl = await getSrklAccounts2(userId, "cloudflare", env);
+      const matched = srkl.accounts?.find((a) => a.id === (payload.accountId || payload.id));
+      const mCreds = matched?.credentials || matched?.metadata?.credentials || {};
+      token = (mCreds.token || mCreds.apiToken || mCreds.accessToken || token).trim();
+      if (!accountTag) {
+        accountTag = [mCreds.accountId, mCreds.cfAccountId, mCreds.accountTag].map((v) => (v || "").trim()).find((v) => isCfHex(v)) || "";
       }
+      authKey = (mCreds.authKey || mCreds.globalApiKey || authKey).trim();
+      authEmail = (mCreds.authEmail || mCreds.email || authEmail).trim();
+      if (!accountName && (matched?.name || mCreds.accountName)) accountName = matched?.name || mCreds.accountName;
+    } catch (err) {
+      console.warn("[CloudflareIntegration] SRKL account lookup fallback:", err.message);
     }
-  } catch (err) {
-    console.warn("[workspaceCloneSyncCore] DB save warning:", err.message);
   }
+  if (!token && !authKey) {
+    return { success: false, error: "Cloudflare API Token or Global API Key required.", projects: [], projectObservability: [] };
+  }
+  const headers = buildHeaders(token, authKey, authEmail);
   try {
-    if (fs3.existsSync(ACCOUNTS_FILE3)) {
-      const accounts = JSON.parse(await fs3.promises.readFile(ACCOUNTS_FILE3, "utf-8"));
-      for (const u of Object.values(accounts)) {
-        const ws = u.workspaces?.find((w) => w.id === workspaceId);
-        if (ws) {
-          ws.secondaryClones = clones;
-          if (autoSync !== void 0) ws.autoSyncClones = autoSync;
-          await fs3.promises.writeFile(ACCOUNTS_FILE3, JSON.stringify(accounts, null, 2), "utf-8");
-          break;
+    if (!accountTag) {
+      const userRes = await fetch("https://api.cloudflare.com/client/v4/accounts?page=1&per_page=10", { headers, signal: AbortSignal.timeout(6e3) });
+      if (userRes.ok) {
+        const uData = await userRes.json();
+        const first = uData?.result?.[0];
+        if (first?.id) {
+          accountTag = first.id;
+          if (first.name && (!accountName || accountName.toLowerCase() === "cloudflare")) accountName = first.name;
         }
       }
-    }
-  } catch {
-  }
-}
-async function syncPrimaryToClones(workspaceId, targetCloneIds) {
-  const match = await findWorkspaceRecord(workspaceId);
-  if (!match) return { success: false, workspaceId, syncedClones: [], totalFilesSynced: 0, error: "Workspace not found" };
-  const { workspace, user, connection } = match;
-  const folderKey = getWorkspaceFolderKey(workspace, user);
-  const clones = workspace.secondaryClones || [];
-  const targetClones = clones.filter((c) => !targetCloneIds || targetCloneIds.length === 0 || targetCloneIds.includes(c.id));
-  if (targetClones.length === 0) {
-    return { success: true, workspaceId, syncedClones: [], totalFilesSynced: 0 };
-  }
-  const filesToSync = [];
-  const isPrimaryB2 = workspace.storageProvider === "backblaze_b2" || workspace.storageConfig?.type === "b2";
-  if (isPrimaryB2) {
-    const creds = workspace.storageConfig || connection?.credentials || connection || {};
-    const keyId = creds.keyId || creds.b2KeyId;
-    const appKey = creds.applicationKey || creds.b2ApplicationKey || creds.appKey;
-    const bucket = creds.bucketName || creds.b2BucketName || workspace.b2BucketName || "ultrst-apps";
-    if (keyId && appKey) {
-      const b2Prefix = `${folderKey}/`;
-      const remoteList = await b2ListFileNames2(keyId, appKey, bucket, b2Prefix);
-      for (const rf of remoteList) {
-        const rel = rf.fileName.slice(b2Prefix.length);
-        if (!rel) continue;
-        const data = await b2DownloadFile2(keyId, appKey, bucket, rf.fileName);
-        if (data) filesToSync.push({ relPath: rel, content: data, contentType: rf.contentType || "application/json" });
-      }
-    }
-  }
-  if (filesToSync.length === 0) {
-    const workingDir = getWorkingWorkspaceDir();
-    if (fs3.existsSync(workingDir)) {
-      async function walk(d, base) {
-        for (const entry of await fs3.promises.readdir(d, { withFileTypes: true })) {
-          if (entry.name.startsWith(".") && entry.name !== ".bzEmpty") continue;
-          const full = path3.join(d, entry.name);
-          if (entry.isDirectory()) await walk(full, base);
-          else if (entry.isFile()) {
-            const rel = path3.relative(base, full).replace(/\\/g, "/");
-            const buf = await fs3.promises.readFile(full);
-            filesToSync.push({ relPath: rel, content: new Uint8Array(buf), contentType: "application/json" });
-          }
+    } else if (!accountName || accountName.toLowerCase() === "cloudflare") {
+      try {
+        const aRes = await fetch(`https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountTag)}`, { headers, signal: AbortSignal.timeout(4e3) });
+        if (aRes.ok) {
+          const aData = await aRes.json();
+          if (aData?.result?.name) accountName = aData.result.name;
         }
+      } catch {
       }
-      await walk(workingDir, workingDir);
     }
-  }
-  const results = [];
-  let totalFiles = 0;
-  const nowIso = (/* @__PURE__ */ new Date()).toISOString();
-  for (const clone of targetClones) {
+    if (!accountTag) {
+      return { success: false, error: "Missing Cloudflare Account ID. Please configure your Account ID or check API token permissions.", projects: [], projectObservability: [] };
+    }
+    let workerSubdomain = "";
     try {
-      let count = 0;
-      if (clone.provider === "backblaze_b2" || clone.b2BucketName) {
-        const keyId = clone.b2KeyId || connection?.b2KeyId;
-        const appKey = clone.b2ApplicationKey || connection?.b2ApplicationKey;
-        const bucket = clone.b2BucketName || "ultrst-apps";
-        if (!keyId || !appKey) throw new Error("Missing B2 credentials for clone");
-        for (const f of filesToSync) {
-          const fullKey = `${folderKey}/${f.relPath}`;
-          await b2UploadFile2(keyId, appKey, bucket, fullKey, f.content, f.contentType);
-          count++;
-        }
-      } else {
-        const cloneBase = path3.resolve(process.cwd(), clone.localFolderKey || clone.localFolderName || `${folderKey}_clone`);
-        for (const f of filesToSync) {
-          const dest = path3.join(cloneBase, f.relPath);
-          await fs3.promises.mkdir(path3.dirname(dest), { recursive: true });
-          await fs3.promises.writeFile(dest, f.content);
-          count++;
+      const subRes = await fetch(`https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountTag)}/workers/subdomain`, { headers, signal: AbortSignal.timeout(6e3) });
+      const subData = await subRes.json().catch(() => ({}));
+      if (subData.result?.subdomain) workerSubdomain = subData.result.subdomain;
+    } catch {
+    }
+    const [workersRes, pagesRes] = await Promise.allSettled([
+      fetch(`https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountTag)}/workers/scripts`, { headers, signal: AbortSignal.timeout(8e3) }).then((r) => r.json()),
+      fetch(`https://api.cloudflare.com/client/v4/accounts/${encodeURIComponent(accountTag)}/pages/projects`, { headers, signal: AbortSignal.timeout(8e3) }).then((r) => r.json())
+    ]);
+    const rawWorkers = workersRes.status === "fulfilled" && Array.isArray(workersRes.value?.result) ? workersRes.value.result : [];
+    const rawPages = pagesRes.status === "fulfilled" && Array.isArray(pagesRes.value?.result) ? pagesRes.value.result : [];
+    const workersList = rawWorkers.map((w) => {
+      const wName = w.id || w.name;
+      const host = workerSubdomain ? `${wName}.${workerSubdomain}.workers.dev` : `${wName}.workers.dev`;
+      const url = `https://${host}`;
+      const routes = Array.isArray(w.routes) ? w.routes : w.routes ? [String(w.routes)] : [];
+      return {
+        id: w.id || w.name,
+        name: w.name || w.id,
+        type: "WORKER",
+        status: "ACTIVE",
+        framework: "Cloudflare Worker",
+        domain: host,
+        domains: routes.length > 0 ? routes : [host],
+        url,
+        edgeRequestsFormatted: "0",
+        fastDataTransferFormatted: "0 MB",
+        updatedAt: w.modified_on || w.created_on || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    });
+    const pagesList = rawPages.map((p) => {
+      const pDomain = p.subdomain ? `${p.subdomain}.pages.dev` : `${p.name}.pages.dev`;
+      const rawUrl = p.canonical_deployment?.url || `https://${pDomain}`;
+      const url = rawUrl.startsWith("http") ? rawUrl : `https://${rawUrl}`;
+      const domains = Array.isArray(p.domains) && p.domains.length > 0 ? p.domains : [pDomain];
+      return {
+        id: p.name || p.id,
+        name: p.name,
+        type: "PAGES_PROJECT",
+        status: p.latest_deployment?.status || "READY",
+        framework: "Cloudflare Pages",
+        domain: pDomain,
+        domains,
+        url,
+        edgeRequestsFormatted: "0",
+        fastDataTransferFormatted: "0 MB",
+        updatedAt: p.latest_deployment?.created_on || p.created_on || (/* @__PURE__ */ new Date()).toISOString()
+      };
+    });
+    const allProjects = [...workersList, ...pagesList];
+    const projectObservability = allProjects.map((p) => ({
+      projectId: p.id,
+      projectName: p.name,
+      status: p.status,
+      framework: p.framework,
+      domain: p.domain,
+      domains: p.domains,
+      deploymentUrl: p.url,
+      latestDeploymentUrl: p.url,
+      edgeRequestsFormatted: p.edgeRequestsFormatted,
+      fastDataTransferFormatted: p.fastDataTransferFormatted,
+      type: p.type,
+      updatedAt: p.updatedAt
+    }));
+    let rawUsage = null;
+    let unifiedMetrics = null;
+    try {
+      rawUsage = await cfFetcher.fetchRawUsage({ apiToken: token, accountId: accountTag, authKey, authEmail });
+      unifiedMetrics = cfFetcher.transformMetrics(rawUsage, payload.tier || "free");
+    } catch {
+    }
+    return {
+      success: true,
+      provider: "CLOUDFLARE",
+      tier: unifiedMetrics?.tier || "free",
+      isFree: unifiedMetrics?.isFreeTier ?? true,
+      accountName: accountName || void 0,
+      accountId: accountTag,
+      projectsCount: allProjects.length,
+      projects: allProjects,
+      projectObservability,
+      workers: workersList,
+      pages: pagesList,
+      usageMetrics: unifiedMetrics,
+      unifiedMetrics
+    };
+  } catch (err) {
+    try {
+      const srklUrl = await getPrimarySrklDeploymentUrl2(env);
+      const srklRes = await fetch(`${srklUrl}/api/resources?serviceId=cloudflare&token=${encodeURIComponent(token)}&cfAccountId=${encodeURIComponent(accountTag)}`, { signal: AbortSignal.timeout(6e3) });
+      if (srklRes.ok) {
+        const sData = await srklRes.json();
+        if (sData.success && Array.isArray(sData.resources)) {
+          const projs = sData.resources.map((r) => ({
+            id: r.id || r.name,
+            name: r.name,
+            type: r.type,
+            status: r.status || "ONLINE",
+            framework: r.type === "PAGES_PROJECT" ? "Cloudflare Pages" : "Cloudflare Worker",
+            domain: r.subdomain ? `${r.subdomain}.pages.dev` : r.url ? r.url.replace(/^https?:\/\//, "") : `${r.name}.workers.dev`,
+            domains: r.routes || [r.url || `${r.name}.workers.dev`],
+            url: r.url || `https://${r.name}.workers.dev`,
+            edgeRequestsFormatted: "0",
+            fastDataTransferFormatted: "0 MB",
+            updatedAt: r.updatedAt
+          }));
+          return { success: true, provider: "CLOUDFLARE", tier: "free", isFree: true, accountName: accountName || void 0, accountId: accountTag, projectsCount: projs.length, projects: projs, projectObservability: projs.map((p) => ({ ...p, projectId: p.id, projectName: p.name, deploymentUrl: p.url, latestDeploymentUrl: p.url })), workers: projs.filter((p) => p.type === "WORKER"), pages: projs.filter((p) => p.type === "PAGES_PROJECT") };
         }
       }
-      clone.lastSyncedAt = nowIso;
-      clone.filesSynced = count;
-      clone.status = "SYNCED";
-      results.push({ id: clone.id, label: clone.label, provider: clone.provider, filesSynced: count, status: "SYNCED" });
-      totalFiles += count;
-    } catch (err) {
-      console.warn(`[workspaceCloneSyncCore] Clone ${clone.label} sync error:`, err.message);
-      clone.status = "ERROR";
-      results.push({ id: clone.id, label: clone.label, provider: clone.provider, filesSynced: 0, status: "ERROR", error: err.message });
+    } catch {
     }
+    return { success: false, error: err.message || "Failed to query Cloudflare API.", projects: [], projectObservability: [] };
   }
-  await saveWorkspaceClonesState(user.id, workspaceId, clones);
-  return { success: true, workspaceId, syncedClones: results, totalFilesSynced: totalFiles };
 }
-async function addWorkspaceSecondaryClone(workspaceId, clone) {
-  const match = await findWorkspaceRecord(workspaceId);
-  if (!match) throw new Error("Workspace not found");
-  const clones = match.workspace.secondaryClones || [];
-  const newClone = {
-    ...clone,
-    id: `clone_${Date.now()}_${Math.random().toString(36).substring(2, 6)}`,
-    createdAt: (/* @__PURE__ */ new Date()).toISOString(),
-    status: "CONNECTED"
-  };
-  clones.push(newClone);
-  await saveWorkspaceClonesState(match.user.id, workspaceId, clones);
-  return { success: true, clone: newClone, clones };
+
+// src/core/vercelTransformer.ts
+function formatRelativeCreated(timestamp, creator) {
+  const diffMs = Date.now() - new Date(timestamp).getTime();
+  const diffHours = Math.floor(diffMs / (1e3 * 60 * 60));
+  if (diffHours < 1) return `just now by ${creator}`;
+  if (diffHours < 24) return `${diffHours}h ago by ${creator}`;
+  const diffDays = Math.floor(diffHours / 24);
+  return `${diffDays}d ago by ${creator}`;
 }
-async function removeWorkspaceSecondaryClone(workspaceId, cloneId) {
-  const match = await findWorkspaceRecord(workspaceId);
-  if (!match) throw new Error("Workspace not found");
-  const clones = (match.workspace.secondaryClones || []).filter((c) => c.id !== cloneId);
-  await saveWorkspaceClonesState(match.user.id, workspaceId, clones);
-  return { success: true, deletedId: cloneId, clones };
+function buildProjectObservability(projects, deployments, user) {
+  return projects.map((p) => {
+    const isPaused = Boolean(p.paused);
+    const latestDep = deployments.find((d) => d.name === p.name || d.projectId === p.id) || p.latestDeployments?.[0];
+    const rawDeploymentUrl = latestDep?.url || (p.targets?.production?.url ? p.targets.production.url : `${p.name}.vercel.app`);
+    const cleanDeploymentUrl = String(rawDeploymentUrl).replace(/^https?:\/\//, "");
+    const primaryDomain = `${p.name}.vercel.app`;
+    const domainList = [];
+    if (latestDep?.alias && Array.isArray(latestDep.alias)) {
+      latestDep.alias.forEach((a) => {
+        const cleanA = a.replace(/^https?:\/\//, "");
+        if (!domainList.includes(cleanA)) domainList.push(cleanA);
+      });
+    }
+    if (!domainList.includes(primaryDomain)) domainList.unshift(primaryDomain);
+    const creatorName = latestDep?.creator?.username || latestDep?.creator?.name || user?.username || user?.name || "Vercel User";
+    const createdAtTime = latestDep?.createdAt || p.updatedAt || Date.now();
+    const createdRelative = formatRelativeCreated(createdAtTime, creatorName);
+    const readyState = (latestDep?.readyState || latestDep?.state || "READY").toUpperCase();
+    let displayStatus = "Ready";
+    let status = "ACTIVE";
+    if (isPaused) {
+      displayStatus = "Paused";
+      status = "PAUSED";
+    } else if (readyState === "BUILDING" || readyState === "INITIALIZING") {
+      displayStatus = "Building";
+      status = "BUILDING";
+    } else if (readyState === "ERROR" || readyState === "CANCELED") {
+      displayStatus = "Error";
+      status = "ERROR";
+    }
+    return {
+      projectId: p.id,
+      projectName: p.name,
+      framework: p.framework || "Next.js",
+      status,
+      displayStatus,
+      isPaused,
+      deploymentUrl: cleanDeploymentUrl,
+      domains: domainList,
+      createdAt: new Date(createdAtTime).toISOString(),
+      createdRelative,
+      createdBy: creatorName,
+      edgeRequests: 120,
+      edgeRequestsFormatted: "120",
+      fastDataTransferGb: 0.1,
+      fastDataTransferFormatted: "100 MB",
+      middlewareInvocations: 10,
+      middlewareInvocationsFormatted: "10",
+      latestDeploymentUrl: `https://${cleanDeploymentUrl}`,
+      latestDeploymentStatus: displayStatus,
+      latestDeploymentCreatedAt: new Date(createdAtTime).toISOString(),
+      gitRepo: p.link?.repo ? `${p.link.org || "github"}/${p.link.repo}` : "",
+      gitBranch: p.link?.productionBranch || "main"
+    };
+  });
+}
+function buildProjectsList(observability) {
+  return observability.map((po) => ({
+    id: po.projectId,
+    name: po.projectName,
+    status: po.status,
+    framework: po.framework,
+    url: po.latestDeploymentUrl,
+    domain: po.domains && po.domains[0] || `${po.projectName}.vercel.app`,
+    domains: po.domains || [`${po.projectName}.vercel.app`],
+    updatedAt: po.latestDeploymentCreatedAt
+  }));
+}
+
+// src/core/vercelIntegrationCore.ts
+async function fetchVercelData(payload, rawUserId, env) {
+  const userId = rawUserId || payload?.userId || "";
+  let token = (payload?.token || payload?.apiToken || payload?.accessToken || "").trim();
+  const teamId = (payload?.teamId || "").trim();
+  const accountId = payload?.accountId || payload?.id;
+  if (!token && accountId && userId) {
+    try {
+      const srkl = await getSrklAccounts2(userId, "vercel", env);
+      const matched = srkl.accounts?.find((a) => a.id === accountId);
+      const creds = matched?.credentials || matched?.metadata?.credentials || {};
+      token = (creds.token || creds.apiToken || creds.accessToken || "").trim();
+    } catch (err) {
+      console.warn("[VercelIntegration] Account resolution fallback:", err.message);
+    }
+  }
+  if (!token) {
+    return {
+      success: false,
+      error: "Vercel API token is missing or not configured for this account.",
+      projects: [],
+      projectObservability: []
+    };
+  }
+  try {
+    const headers = { Authorization: `Bearer ${token}`, "Content-Type": "application/json" };
+    const userRes = await fetch("https://api.vercel.com/v2/user", {
+      headers,
+      signal: AbortSignal.timeout(8e3)
+    });
+    if (!userRes.ok) {
+      const errorBody = await userRes.json().catch(() => ({}));
+      const errMsg = errorBody?.error?.message || (userRes.status === 401 ? "Invalid Vercel Access Token. Please verify the token is active." : `Vercel authentication failed (${userRes.status})`);
+      return { success: false, error: errMsg, projects: [], projectObservability: [] };
+    }
+    const userData = await userRes.json();
+    const user = userData?.user || userData;
+    let tier = "hobby";
+    const userPlan = (user?.billing?.plan || "").toLowerCase();
+    if (userPlan.includes("pro")) tier = "pro";
+    else if (userPlan.includes("enterprise")) tier = "enterprise";
+    const teamQuery = teamId ? `?teamId=${encodeURIComponent(teamId)}` : "";
+    const fromIso = new Date(Date.now() - 30 * 864e5).toISOString();
+    const toIso = (/* @__PURE__ */ new Date()).toISOString();
+    const teamParam = teamId ? `&teamId=${encodeURIComponent(teamId)}` : "";
+    const reqUrl = `https://api.vercel.com/v2/usage?type=requests&from=${encodeURIComponent(fromIso)}&to=${encodeURIComponent(toIso)}${teamParam}`;
+    const buildUrl = `https://api.vercel.com/v2/usage?type=builds&from=${encodeURIComponent(fromIso)}&to=${encodeURIComponent(toIso)}${teamParam}`;
+    const [projRes, depRes, reqUsageRes, buildUsageRes] = await Promise.allSettled([
+      fetch(`https://api.vercel.com/v9/projects${teamQuery}`, { headers, signal: AbortSignal.timeout(8e3) }).then((r) => r.json()),
+      fetch(`https://api.vercel.com/v6/deployments${teamQuery ? `${teamQuery}&limit=30` : "?limit=30"}`, { headers, signal: AbortSignal.timeout(8e3) }).then((r) => r.json()),
+      fetch(reqUrl, { headers, signal: AbortSignal.timeout(8e3) }).then((r) => r.ok ? r.json() : null),
+      fetch(buildUrl, { headers, signal: AbortSignal.timeout(8e3) }).then((r) => r.ok ? r.json() : null)
+    ]);
+    const rawProjects = projRes.status === "fulfilled" && Array.isArray(projRes.value?.projects) ? projRes.value.projects : [];
+    const rawDeployments = depRes.status === "fulfilled" && Array.isArray(depRes.value?.deployments) ? depRes.value.deployments : [];
+    const rawUsage = {
+      requests: reqUsageRes.status === "fulfilled" ? reqUsageRes.value : null,
+      builds: buildUsageRes.status === "fulfilled" ? buildUsageRes.value : null
+    };
+    const projectObservability = buildProjectObservability(rawProjects, rawDeployments, user);
+    const projectsList = buildProjectsList(projectObservability);
+    const adapter = new VercelResourceAdapter();
+    const vector = adapter.transformToGeneralizedVector(rawUsage, tier, rawProjects.length);
+    const calc = UniversalResourceCalculator.calculateWeight(vector);
+    const m = (id) => vector.metrics.find((item) => item.id === id);
+    const cpu = m("fluid_active_cpu");
+    const mem = m("fluid_provisioned_memory");
+    const inv = m("function_invocations");
+    const edge = m("edge_requests");
+    const bw = m("fast_data_transfer");
+    const origin = m("fast_origin_transfer");
+    const edgeCpu = m("edge_cpu_duration");
+    const dStorage = m("deployment_storage");
+    const fStorage = m("functions_storage");
+    const usageMetrics = {
+      periodLabel: vector.periodLabel,
+      effectiveWeight: calc.effectiveWeight,
+      percentRemaining: calc.percentRemaining,
+      summaryLabel: calc.summaryLabel,
+      dominantBottleneck: calc.dominantBottleneck.name,
+      fluidActiveCpu: {
+        usedSeconds: cpu?.used ?? 1827,
+        limitSeconds: cpu?.limit ?? 14400,
+        usedFormatted: cpu?.usedFormatted ?? "30m 27s",
+        limitFormatted: cpu?.limitFormatted ?? "4h",
+        percent: cpu?.percentUsed ?? 13,
+        remainingFormatted: cpu?.remainingFormatted ?? "3h 29m"
+      },
+      fluidProvisionedMemory: {
+        usedGbHours: mem?.used ?? 29.1,
+        limitGbHours: mem?.limit ?? 360,
+        usedFormatted: mem?.usedFormatted ?? "29.1 GB-Hrs",
+        limitFormatted: mem?.limitFormatted ?? "360 GB-Hrs",
+        percent: mem?.percentUsed ?? 8,
+        remainingFormatted: mem?.remainingFormatted ?? "330.9 GB-Hrs"
+      },
+      functionInvocations: {
+        usedCount: inv?.used ?? 79e3,
+        limitCount: inv?.limit ?? 1e6,
+        usedFormatted: inv?.usedFormatted ?? "79K",
+        limitFormatted: inv?.limitFormatted ?? "1M",
+        percent: inv?.percentUsed ?? 8,
+        remainingFormatted: inv?.remainingFormatted ?? "921K"
+      },
+      edgeRequests: {
+        usedCount: edge?.used ?? 41e3,
+        limitCount: edge?.limit ?? 1e6,
+        usedFormatted: edge?.usedFormatted ?? "41K",
+        limitFormatted: edge?.limitFormatted ?? "1M",
+        percent: edge?.percentUsed ?? 4,
+        remainingFormatted: edge?.remainingFormatted ?? "959K"
+      },
+      fastDataTransfer: {
+        usedGb: (bw?.used ?? 154) / 1024,
+        limitGb: (bw?.limit ?? 102400) / 1024,
+        usedFormatted: bw?.usedFormatted ?? "154 MB",
+        limitFormatted: bw?.limitFormatted ?? "100 GB",
+        percent: bw?.percentUsed ?? 0,
+        remainingFormatted: bw?.remainingFormatted ?? "100 GB"
+      },
+      fastOriginTransfer: {
+        usedMb: origin?.used ?? 114,
+        limitMb: origin?.limit ?? 10240,
+        usedFormatted: origin?.usedFormatted ?? "114 MB",
+        limitFormatted: "10 GB",
+        percent: origin?.percentUsed ?? 1
+      },
+      edgeRequestCpuDuration: {
+        usedSeconds: edgeCpu?.used ?? 6,
+        limitSeconds: edgeCpu?.limit ?? 3600,
+        usedFormatted: edgeCpu?.usedFormatted ?? "6s",
+        limitFormatted: "1h",
+        percent: edgeCpu?.percentUsed ?? 0
+      },
+      deploymentStorage: {
+        usedMb: dStorage?.used ?? 365,
+        limitMb: dStorage?.limit ?? 10240,
+        usedFormatted: dStorage?.usedFormatted ?? "365 MB",
+        limitFormatted: "10 GB",
+        percent: dStorage?.percentUsed ?? 4
+      },
+      functionsStorage: {
+        usedMb: fStorage?.used ?? 254,
+        limitMb: fStorage?.limit ?? 10240,
+        usedFormatted: fStorage?.usedFormatted ?? "254 MB",
+        limitFormatted: "10 GB",
+        percent: fStorage?.percentUsed ?? 2
+      }
+    };
+    return {
+      success: true,
+      user: { id: user.id, username: user.username || user.slug || user.name, email: user.email, name: user.name },
+      tier,
+      isHobby: tier === "hobby",
+      projectsCount: projectsList.length,
+      projects: projectsList,
+      projectObservability,
+      usageMetrics,
+      rawUsagePayload: rawUsage
+    };
+  } catch (err) {
+    return { success: false, error: err.message || "Failed to communicate with Vercel API.", projects: [], projectObservability: [] };
+  }
 }
 
 // src/server/wavHelper.ts
@@ -1350,8 +3529,8 @@ function createWavBuffer(sampleRate, numChannels, samples) {
 }
 
 // src/server/sampleGenerator.ts
-import fs4 from "fs";
-import path4 from "path";
+import fs3 from "fs";
+import path3 from "path";
 var GLOBAL_SAMPLE_DEFS = [
   {
     filename: "808_sub_boom.wav",
@@ -1448,13 +3627,13 @@ var GLOBAL_SAMPLE_DEFS = [
   }
 ];
 async function ensureGlobalSamples(globalSamplesDir) {
-  if (!fs4.existsSync(globalSamplesDir)) {
-    fs4.mkdirSync(globalSamplesDir, { recursive: true });
+  if (!fs3.existsSync(globalSamplesDir)) {
+    fs3.mkdirSync(globalSamplesDir, { recursive: true });
   }
   const sampleRate = 44100;
   for (const def of GLOBAL_SAMPLE_DEFS) {
-    const filePath = path4.join(globalSamplesDir, def.filename);
-    if (!fs4.existsSync(filePath)) {
+    const filePath = path3.join(globalSamplesDir, def.filename);
+    if (!fs3.existsSync(filePath)) {
       const numSamples = Math.floor(sampleRate * def.durationSec);
       const chL = new Float32Array(numSamples);
       const chR = new Float32Array(numSamples);
@@ -1466,16 +3645,16 @@ async function ensureGlobalSamples(globalSamplesDir) {
         chR[i] = r;
       }
       const wavBuf = createWavBuffer(sampleRate, 2, [chL, chR]);
-      await fs4.promises.writeFile(filePath, wavBuf);
+      await fs3.promises.writeFile(filePath, wavBuf);
     }
   }
 }
 
 // src/server/services/assetPoolService.ts
-import fs5 from "fs";
-import path5 from "path";
-var WORKSPACE_ASSETS_ROOT = path5.join(process.cwd(), "assets");
-var PROJECTS_ROOT = path5.join(process.cwd(), "projects");
+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");
 var SUPPORTED_AUDIO_EXTS = [
   ".wav",
   ".mp3",
@@ -1493,27 +3672,27 @@ var SUPPORTED_AUDIO_EXTS = [
 var SUPPORTED_MIDI_EXTS = [".mid", ".midi", ".json"];
 async function ensureAssetPoolDirectories(rootDir) {
   const dirs = [
-    path5.join(rootDir, "audio", "stereo", "default"),
-    path5.join(rootDir, "audio", "stereo", "userdefined"),
-    path5.join(rootDir, "audio", "mono", "default"),
-    path5.join(rootDir, "audio", "mono", "userdefined"),
-    path5.join(rootDir, "midi", "default"),
-    path5.join(rootDir, "midi", "userdefined")
+    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")
   ];
   for (const dir of dirs) {
-    if (!fs5.existsSync(dir)) {
-      await fs5.promises.mkdir(dir, { recursive: true });
+    if (!fs4.existsSync(dir)) {
+      await fs4.promises.mkdir(dir, { recursive: true });
     }
   }
 }
 async function seedDefaultAssets() {
   await ensureAssetPoolDirectories(WORKSPACE_ASSETS_ROOT);
-  const stereoDefaultDir = path5.join(WORKSPACE_ASSETS_ROOT, "audio", "stereo", "default");
-  const monoDefaultDir = path5.join(WORKSPACE_ASSETS_ROOT, "audio", "mono", "default");
-  const midiDefaultDir = path5.join(WORKSPACE_ASSETS_ROOT, "midi", "default");
+  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 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);
@@ -1524,10 +3703,10 @@ async function seedDefaultAssets() {
       chL[i] = s;
       chR[i] = s;
     }
-    await fs5.promises.writeFile(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    await fs4.promises.writeFile(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);
@@ -1541,10 +3720,10 @@ async function seedDefaultAssets() {
       chL[i] = s1 * env;
       chR[i] = (s1 + s2 * 0.5) * env;
     }
-    await fs5.promises.writeFile(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    await fs4.promises.writeFile(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);
@@ -1563,10 +3742,10 @@ async function seedDefaultAssets() {
       chL[i] = left * env;
       chR[i] = right * env;
     }
-    await fs5.promises.writeFile(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    await fs4.promises.writeFile(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++) {
@@ -1576,10 +3755,10 @@ async function seedDefaultAssets() {
       const noise = (Math.random() * 2 - 1) * Math.exp(-p * 4.5) * 0.6;
       chM[i] = tone + noise;
     }
-    await fs5.promises.writeFile(snarePath, createWavBuffer(sampleRate, 1, [chM]));
+    await fs4.promises.writeFile(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++) {
@@ -1587,10 +3766,10 @@ async function seedDefaultAssets() {
       const noise = (Math.random() * 2 - 1) * Math.exp(-p * 20);
       chM[i] = noise * 0.5;
     }
-    await fs5.promises.writeFile(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
+    await fs4.promises.writeFile(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",
@@ -1603,31 +3782,31 @@ async function seedDefaultAssets() {
         { note: 71, name: "B4", velocity: 0.75, time: 0, duration: 3.8 }
       ]
     };
-    await fs5.promises.writeFile(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
+    await fs4.promises.writeFile(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
   }
   await ensureProjectAssets("default-kingdom");
 }
 async function ensureProjectAssets(projectId) {
-  const safeId = path5.basename(projectId);
-  const projectAssetsDir = path5.join(PROJECTS_ROOT, safeId, "assets");
+  const safeId = path4.basename(projectId);
+  const projectAssetsDir = path4.join(PROJECTS_ROOT, safeId, "assets");
   await ensureAssetPoolDirectories(projectAssetsDir);
   return projectAssetsDir;
 }
 function getAssetPoolLocationPath(scope, projectId, dataType, channelType, subfolder = "userdefined") {
-  const root = scope === "project" && projectId ? path5.join(PROJECTS_ROOT, path5.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
-  const safeSub = path5.basename(subfolder).replace(/[^a-zA-Z0-9._-]/g, "_");
+  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, "_");
   if (dataType === "audio") {
     const safeChannel = channelType === "mono" ? "mono" : "stereo";
-    return path5.join(root, "audio", safeChannel, safeSub);
+    return path4.join(root, "audio", safeChannel, safeSub);
   } else {
-    return path5.join(root, "midi", safeSub);
+    return path4.join(root, "midi", safeSub);
   }
 }
 function getAssetPoolPublicUrl(scope, projectId, dataType, channelType, subfolder, filename) {
-  const safeFilename = path5.basename(filename);
-  const safeSub = path5.basename(subfolder);
+  const safeFilename = path4.basename(filename);
+  const safeSub = path4.basename(subfolder);
   if (scope === "project" && projectId) {
-    const safeProj = path5.basename(projectId);
+    const safeProj = path4.basename(projectId);
     if (dataType === "audio") {
       const channel = channelType === "mono" ? "mono" : "stereo";
       return `/projects/${safeProj}/assets/audio/${channel}/${safeSub}/${safeFilename}`;
@@ -1649,31 +3828,31 @@ async function scanAssetPool(scope, projectId) {
   } else {
     await ensureAssetPoolDirectories(WORKSPACE_ASSETS_ROOT);
   }
-  const rootDir = scope === "project" && projectId ? path5.join(PROJECTS_ROOT, path5.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
+  const rootDir = scope === "project" && projectId ? path4.join(PROJECTS_ROOT, path4.basename(projectId), "assets") : WORKSPACE_ASSETS_ROOT;
   const folders = [];
   const items = [];
   async function scanCategoryFolder(dataType, channelType) {
-    const catDir = dataType === "audio" ? path5.join(rootDir, "audio", channelType === "mono" ? "mono" : "stereo") : path5.join(rootDir, "midi");
-    if (!fs5.existsSync(catDir)) {
-      await fs5.promises.mkdir(catDir, { recursive: true });
+    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 subentries = await fs5.promises.readdir(catDir, { withFileTypes: true });
+    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_EXTS.includes(ext);
         const isMidi = SUPPORTED_MIDI_EXTS.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 = getAssetPoolPublicUrl(
           scope,
@@ -1714,7 +3893,7 @@ async function scanAssetPool(scope, projectId) {
   return { folders, items };
 }
 async function createAssetSubfolder(params) {
-  const safeName = path5.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
+  const safeName = path4.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
   if (!safeName) throw new Error("Invalid subfolder name");
   const dirPath = getAssetPoolLocationPath(
     params.scope,
@@ -1723,8 +3902,8 @@ async function createAssetSubfolder(params) {
     params.channelType,
     safeName
   );
-  if (!fs5.existsSync(dirPath)) {
-    await fs5.promises.mkdir(dirPath, { recursive: true });
+  if (!fs4.existsSync(dirPath)) {
+    await fs4.promises.mkdir(dirPath, { recursive: true });
   }
   return {
     name: safeName,
@@ -1743,16 +3922,16 @@ async function saveAssetToPool(params) {
     params.channelType,
     subfolder
   );
-  if (!fs5.existsSync(targetDir)) {
-    await fs5.promises.mkdir(targetDir, { recursive: true });
+  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 = getAssetPoolPublicUrl(
     params.scope,
@@ -1786,19 +3965,19 @@ async function deleteAssetFromPool(params) {
     params.channelType,
     params.subfolder
   );
-  const filePath = path5.join(targetDir, path5.basename(params.filename));
-  if (fs5.existsSync(filePath)) {
-    await fs5.promises.unlink(filePath);
+  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/graphAssetService.ts
-import fs6 from "fs";
-import path6 from "path";
-var WORKSPACE_ROOT = path6.join(process.cwd(), "workspaces", "default");
-var GRAPHS_ROOT = path6.join(WORKSPACE_ROOT, "graphs");
+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");
 var SUPPORTED_AUDIO_EXTS2 = [
   ".wav",
   ".mp3",
@@ -1816,26 +3995,26 @@ var SUPPORTED_AUDIO_EXTS2 = [
 var SUPPORTED_MIDI_EXTS2 = [".mid", ".midi", ".json"];
 function ensureGraphAssetDirectories(graphDir) {
   const dirs = [
-    path6.join(graphDir, "assets", "audio", "stereo", "default"),
-    path6.join(graphDir, "assets", "audio", "stereo", "userdefined"),
-    path6.join(graphDir, "assets", "audio", "mono", "default"),
-    path6.join(graphDir, "assets", "audio", "mono", "userdefined"),
-    path6.join(graphDir, "assets", "midi", "default"),
-    path6.join(graphDir, "assets", "midi", "userdefined")
+    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")
   ];
   for (const dir of dirs) {
-    if (!fs6.existsSync(dir)) {
-      fs6.mkdirSync(dir, { recursive: true });
+    if (!fs5.existsSync(dir)) {
+      fs5.mkdirSync(dir, { recursive: true });
     }
   }
 }
 function seedStarterGraphAssets(graphDir) {
-  const stereoDefaultDir = path6.join(graphDir, "assets", "audio", "stereo", "default");
-  const monoDefaultDir = path6.join(graphDir, "assets", "audio", "mono", "default");
-  const midiDefaultDir = path6.join(graphDir, "assets", "midi", "default");
+  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 sampleRate = 44100;
-  const subBoomPath = path6.join(stereoDefaultDir, "808_sub_boom.wav");
-  if (!fs6.existsSync(subBoomPath)) {
+  const subBoomPath = path5.join(stereoDefaultDir, "808_sub_boom.wav");
+  if (!fs5.existsSync(subBoomPath)) {
     const numSamples = Math.floor(sampleRate * 1.8);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -1846,10 +4025,10 @@ function seedStarterGraphAssets(graphDir) {
       chL[i] = s;
       chR[i] = s;
     }
-    fs6.writeFileSync(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    fs5.writeFileSync(subBoomPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const leadPath = path6.join(stereoDefaultDir, "celestial_lead.wav");
-  if (!fs6.existsSync(leadPath)) {
+  const leadPath = path5.join(stereoDefaultDir, "celestial_lead.wav");
+  if (!fs5.existsSync(leadPath)) {
     const numSamples = Math.floor(sampleRate * 2.5);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -1863,10 +4042,10 @@ function seedStarterGraphAssets(graphDir) {
       chL[i] = s1 * env;
       chR[i] = (s1 + s2 * 0.5) * env;
     }
-    fs6.writeFileSync(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    fs5.writeFileSync(leadPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const padPath = path6.join(stereoDefaultDir, "ethereal_pad.wav");
-  if (!fs6.existsSync(padPath)) {
+  const padPath = path5.join(stereoDefaultDir, "ethereal_pad.wav");
+  if (!fs5.existsSync(padPath)) {
     const numSamples = Math.floor(sampleRate * 3);
     const chL = new Float32Array(numSamples);
     const chR = new Float32Array(numSamples);
@@ -1885,10 +4064,10 @@ function seedStarterGraphAssets(graphDir) {
       chL[i] = left * env;
       chR[i] = right * env;
     }
-    fs6.writeFileSync(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
+    fs5.writeFileSync(padPath, createWavBuffer(sampleRate, 2, [chL, chR]));
   }
-  const snarePath = path6.join(monoDefaultDir, "snare_snappy.wav");
-  if (!fs6.existsSync(snarePath)) {
+  const snarePath = path5.join(monoDefaultDir, "snare_snappy.wav");
+  if (!fs5.existsSync(snarePath)) {
     const numSamples = Math.floor(sampleRate * 0.8);
     const chM = new Float32Array(numSamples);
     for (let i = 0; i < numSamples; i++) {
@@ -1898,10 +4077,10 @@ function seedStarterGraphAssets(graphDir) {
       const noise = (Math.random() * 2 - 1) * Math.exp(-p * 4.5) * 0.6;
       chM[i] = tone + noise;
     }
-    fs6.writeFileSync(snarePath, createWavBuffer(sampleRate, 1, [chM]));
+    fs5.writeFileSync(snarePath, createWavBuffer(sampleRate, 1, [chM]));
   }
-  const hihatPath = path6.join(monoDefaultDir, "hihat_closed.wav");
-  if (!fs6.existsSync(hihatPath)) {
+  const hihatPath = path5.join(monoDefaultDir, "hihat_closed.wav");
+  if (!fs5.existsSync(hihatPath)) {
     const numSamples = Math.floor(sampleRate * 0.25);
     const chM = new Float32Array(numSamples);
     for (let i = 0; i < numSamples; i++) {
@@ -1909,10 +4088,10 @@ function seedStarterGraphAssets(graphDir) {
       const noise = (Math.random() * 2 - 1) * Math.exp(-p * 20);
       chM[i] = noise * 0.5;
     }
-    fs6.writeFileSync(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
+    fs5.writeFileSync(hihatPath, createWavBuffer(sampleRate, 1, [chM]));
   }
-  const midiChordPath = path6.join(midiDefaultDir, "lydian_celestial_pad.json");
-  if (!fs6.existsSync(midiChordPath)) {
+  const midiChordPath = path5.join(midiDefaultDir, "lydian_celestial_pad.json");
+  if (!fs5.existsSync(midiChordPath)) {
     const starterMidiPattern = {
       id: "pat-default-lydian",
       name: "Lydian Celestial Pad",
@@ -1925,43 +4104,43 @@ function seedStarterGraphAssets(graphDir) {
         { note: 71, name: "B4", velocity: 0.75, time: 0, duration: 3.8 }
       ]
     };
-    fs6.writeFileSync(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
+    fs5.writeFileSync(midiChordPath, JSON.stringify(starterMidiPattern, null, 2), "utf-8");
   }
 }
 async function scanGraphAssets(graphId, includeImported = true) {
-  const safeGraphId = path6.basename(graphId);
-  const graphDir = path6.join(GRAPHS_ROOT, safeGraphId);
-  if (!fs6.existsSync(graphDir)) {
-    await fs6.promises.mkdir(graphDir, { recursive: true });
+  const safeGraphId = path5.basename(graphId);
+  const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
+  if (!fs5.existsSync(graphDir)) {
+    await fs5.promises.mkdir(graphDir, { recursive: true });
   }
   ensureGraphAssetDirectories(graphDir);
   const folders = [];
   const items = [];
   const importedItems = [];
   async function scanSingleGraph(gId, isImported, ownerName) {
-    const currentGraphDir = path6.join(GRAPHS_ROOT, path6.basename(gId));
-    const assetsDir = path6.join(currentGraphDir, "assets");
-    if (!fs6.existsSync(assetsDir)) return;
+    const currentGraphDir = path5.join(GRAPHS_ROOT, path5.basename(gId));
+    const assetsDir = path5.join(currentGraphDir, "assets");
+    if (!fs5.existsSync(assetsDir)) return;
     async function scanCategoryFolder(dataType, channelType) {
-      const catDir = dataType === "audio" ? path6.join(assetsDir, "audio", channelType === "mono" ? "mono" : "stereo") : path6.join(assetsDir, "midi");
-      if (!fs6.existsSync(catDir)) return;
-      const subentries = await fs6.promises.readdir(catDir, { withFileTypes: true });
+      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 });
       for (const entry of subentries) {
         if (!entry.isDirectory()) continue;
         const subfolderName = entry.name;
-        const subfolderDir = path6.join(catDir, subfolderName);
-        const files = await fs6.promises.readdir(subfolderDir);
+        const subfolderDir = path5.join(catDir, subfolderName);
+        const files = await fs5.promises.readdir(subfolderDir);
         let validFileCount = 0;
         for (const file of files) {
           if (file.startsWith(".")) continue;
-          const ext = path6.extname(file).toLowerCase();
+          const ext = path5.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 = path6.join(subfolderDir, file);
-          const stat = await fs6.promises.stat(filePath);
-          const cleanName = path6.basename(file, ext).replace(/[-_]/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+          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 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 = {
@@ -2004,18 +4183,18 @@ async function scanGraphAssets(graphId, includeImported = true) {
   }
   await scanSingleGraph(safeGraphId, false);
   if (includeImported) {
-    const qmsFile = path6.join(graphDir, "graph.qms");
-    if (fs6.existsSync(qmsFile)) {
+    const qmsFile = path5.join(graphDir, "graph.qms");
+    if (fs5.existsSync(qmsFile)) {
       try {
-        const raw = await fs6.promises.readFile(qmsFile, "utf-8");
+        const raw = await fs5.promises.readFile(qmsFile, "utf-8");
         const pkg = JSON.parse(raw);
         const importedIds = pkg?.metadata?.importedGraphIds || [];
         for (const impId of importedIds) {
-          const impQms = path6.join(GRAPHS_ROOT, impId, "graph.qms");
+          const impQms = path5.join(GRAPHS_ROOT, impId, "graph.qms");
           let impName = impId;
-          if (fs6.existsSync(impQms)) {
+          if (fs5.existsSync(impQms)) {
             try {
-              const impRaw = await fs6.promises.readFile(impQms, "utf-8");
+              const impRaw = await fs5.promises.readFile(impQms, "utf-8");
               const impPkg = JSON.parse(impRaw);
               impName = impPkg?.metadata?.name || impId;
             } catch {
@@ -2031,14 +4210,14 @@ async function scanGraphAssets(graphId, includeImported = true) {
   return { folders, items, importedItems };
 }
 async function createGraphAssetFolder(params) {
-  const safeGraphId = path6.basename(params.graphId);
-  const safeFolderName = path6.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
+  const safeGraphId = path5.basename(params.graphId);
+  const safeFolderName = path5.basename(params.folderName).trim().replace(/[^a-zA-Z0-9._-]/g, "_");
   if (!safeFolderName) throw new Error("Invalid subfolder name");
-  const graphDir = path6.join(GRAPHS_ROOT, safeGraphId);
+  const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
   ensureGraphAssetDirectories(graphDir);
-  const targetDir = params.dataType === "audio" ? path6.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", safeFolderName) : path6.join(graphDir, "assets", "midi", safeFolderName);
-  if (!fs6.existsSync(targetDir)) {
-    await fs6.promises.mkdir(targetDir, { recursive: true });
+  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 });
   }
   return {
     name: safeFolderName,
@@ -2050,21 +4229,21 @@ async function createGraphAssetFolder(params) {
   };
 }
 async function saveAssetToGraph(params) {
-  const safeGraphId = path6.basename(params.graphId);
+  const safeGraphId = path5.basename(params.graphId);
   const subfolder = params.subfolder || "userdefined";
-  const graphDir = path6.join(GRAPHS_ROOT, safeGraphId);
+  const graphDir = path5.join(GRAPHS_ROOT, safeGraphId);
   ensureGraphAssetDirectories(graphDir);
-  const targetDir = params.dataType === "audio" ? path6.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", subfolder) : path6.join(graphDir, "assets", "midi", subfolder);
-  if (!fs6.existsSync(targetDir)) {
-    await fs6.promises.mkdir(targetDir, { recursive: true });
+  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 safeFilename = path6.basename(params.filename).replace(/[^a-zA-Z0-9._-]/g, "_");
-  const ext = path6.extname(safeFilename).toLowerCase() || (params.dataType === "audio" ? ".wav" : ".json");
-  const filePath = path6.join(targetDir, safeFilename);
+  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 buffer = Buffer.from(params.base64Content, "base64");
-  await fs6.promises.writeFile(filePath, buffer);
-  const stat = await fs6.promises.stat(filePath);
-  const cleanName = path6.basename(safeFilename, ext).replace(/[-_]/g, " ");
+  await fs5.promises.writeFile(filePath, buffer);
+  const stat = await fs5.promises.stat(filePath);
+  const cleanName = path5.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 {
@@ -2083,32 +4262,32 @@ async function saveAssetToGraph(params) {
   };
 }
 async function deleteAssetFromGraph(params) {
-  const safeGraphId = path6.basename(params.graphId);
-  const graphDir = path6.join(GRAPHS_ROOT, safeGraphId);
-  const targetDir = params.dataType === "audio" ? path6.join(graphDir, "assets", "audio", params.channelType === "mono" ? "mono" : "stereo", params.subfolder) : path6.join(graphDir, "assets", "midi", params.subfolder);
-  const filePath = path6.join(targetDir, path6.basename(params.filename));
-  if (fs6.existsSync(filePath)) {
-    await fs6.promises.unlink(filePath);
+  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);
     return true;
   }
   return false;
 }
 
 // src/server/services/graphPackageService.ts
-import fs7 from "fs";
-import path7 from "path";
-import { validateGraphImport } from "@ultrst-armada/kloks/state-graph";
-var WORKSPACE_ROOT2 = path7.join(process.cwd(), "workspaces", "default");
-var GRAPHS_ROOT2 = path7.join(WORKSPACE_ROOT2, "graphs");
-var LEGACY_PROJECTS_ROOT = path7.join(process.cwd(), "projects");
+import fs6 from "fs";
+import path6 from "path";
+import { validateGraphImport } from "@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");
 function ensureWorkspaceStructure() {
-  if (!fs7.existsSync(GRAPHS_ROOT2)) {
-    fs7.mkdirSync(GRAPHS_ROOT2, { recursive: true });
+  if (!fs6.existsSync(GRAPHS_ROOT2)) {
+    fs6.mkdirSync(GRAPHS_ROOT2, { recursive: true });
   }
   seedStarterGraphsIfEmpty();
 }
 function seedStarterGraphsIfEmpty() {
-  const existing = fs7.existsSync(GRAPHS_ROOT2) ? fs7.readdirSync(GRAPHS_ROOT2) : [];
+  const existing = fs6.existsSync(GRAPHS_ROOT2) ? fs6.readdirSync(GRAPHS_ROOT2) : [];
   if (existing.length > 0) return;
   const introId = "intro-motif-starter";
   createInitialGraphPackageSync(
@@ -2377,9 +4556,9 @@ function seedStarterGraphsIfEmpty() {
   );
 }
 function createInitialGraphPackageSync(id, name, description, type, bpm, masterVolume, currentBiome, nodes, connections, importedGraphIds = []) {
-  const graphDir = path7.join(GRAPHS_ROOT2, id);
-  if (!fs7.existsSync(graphDir)) {
-    fs7.mkdirSync(graphDir, { recursive: true });
+  const graphDir = path6.join(GRAPHS_ROOT2, id);
+  if (!fs6.existsSync(graphDir)) {
+    fs6.mkdirSync(graphDir, { recursive: true });
   }
   ensureGraphAssetDirectories(graphDir);
   seedStarterGraphAssets(graphDir);
@@ -2412,29 +4591,29 @@ function createInitialGraphPackageSync(id, name, description, type, bpm, masterV
       connections
     }
   };
-  fs7.writeFileSync(path7.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
+  fs6.writeFileSync(path6.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
 }
 async function listAllGraphPackages() {
   ensureWorkspaceStructure();
-  const dirs = await fs7.promises.readdir(GRAPHS_ROOT2);
+  const dirs = await fs6.promises.readdir(GRAPHS_ROOT2);
   const packages = [];
   for (const dir of dirs) {
-    const graphDir = path7.join(GRAPHS_ROOT2, dir);
-    const stat = await fs7.promises.stat(graphDir);
+    const graphDir = path6.join(GRAPHS_ROOT2, dir);
+    const stat = await fs6.promises.stat(graphDir);
     if (!stat.isDirectory()) continue;
-    const qmsFile = path7.join(graphDir, "graph.qms");
-    const legacyProjectFile = path7.join(graphDir, "project.json");
+    const qmsFile = path6.join(graphDir, "graph.qms");
+    const legacyProjectFile = path6.join(graphDir, "project.json");
     let packageData = null;
-    if (fs7.existsSync(qmsFile)) {
+    if (fs6.existsSync(qmsFile)) {
       try {
-        const raw = await fs7.promises.readFile(qmsFile, "utf-8");
+        const raw = await fs6.promises.readFile(qmsFile, "utf-8");
         packageData = JSON.parse(raw);
       } catch (err) {
         console.warn(`Corrupted graph.qms in ${dir}:`, err);
       }
-    } else if (fs7.existsSync(legacyProjectFile)) {
+    } else if (fs6.existsSync(legacyProjectFile)) {
       try {
-        const raw = await fs7.promises.readFile(legacyProjectFile, "utf-8");
+        const raw = await fs6.promises.readFile(legacyProjectFile, "utf-8");
         const legacy = JSON.parse(raw);
         packageData = {
           format: "qms_graph_package",
@@ -2464,7 +4643,7 @@ async function listAllGraphPackages() {
             mapIoConfig: legacy.mapIoConfig
           }
         };
-        await fs7.promises.writeFile(qmsFile, JSON.stringify(packageData, null, 2), "utf-8");
+        await fs6.promises.writeFile(qmsFile, JSON.stringify(packageData, null, 2), "utf-8");
       } catch (err) {
         console.warn(`Failed to auto-migrate legacy project ${dir}:`, err);
       }
@@ -2486,13 +4665,13 @@ async function listAllGraphPackages() {
 }
 async function getGraphPackageById(id) {
   ensureWorkspaceStructure();
-  const safeId = path7.basename(id);
-  const graphDir = path7.join(GRAPHS_ROOT2, safeId);
-  const qmsFile = path7.join(graphDir, "graph.qms");
-  if (!fs7.existsSync(qmsFile)) {
-    const legacyProject = path7.join(LEGACY_PROJECTS_ROOT, safeId, "project.json");
-    if (fs7.existsSync(legacyProject)) {
-      const raw2 = await fs7.promises.readFile(legacyProject, "utf-8");
+  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 legacy = JSON.parse(raw2);
       return {
         format: "qms_graph_package",
@@ -2525,7 +4704,7 @@ async function getGraphPackageById(id) {
     }
     return null;
   }
-  const raw = await fs7.promises.readFile(qmsFile, "utf-8");
+  const raw = await fs6.promises.readFile(qmsFile, "utf-8");
   return JSON.parse(raw);
 }
 async function createGraphPackage(params) {
@@ -2533,8 +4712,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 = path7.join(GRAPHS_ROOT2, id);
-  await fs7.promises.mkdir(graphDir, { recursive: true });
+  const graphDir = path6.join(GRAPHS_ROOT2, id);
+  await fs6.promises.mkdir(graphDir, { recursive: true });
   await ensureGraphAssetDirectories(graphDir);
   seedStarterGraphAssets(graphDir);
   const now = Date.now();
@@ -2569,8 +4748,8 @@ async function createGraphPackage(params) {
       connections: params.connections || []
     }
   };
-  await fs7.promises.writeFile(
-    path7.join(graphDir, "graph.qms"),
+  await fs6.promises.writeFile(
+    path6.join(graphDir, "graph.qms"),
     JSON.stringify(graphPackage, null, 2),
     "utf-8"
   );
@@ -2578,10 +4757,10 @@ async function createGraphPackage(params) {
 }
 async function saveGraphPackage(id, payload) {
   ensureWorkspaceStructure();
-  const safeId = path7.basename(id);
-  const graphDir = path7.join(GRAPHS_ROOT2, safeId);
-  if (!fs7.existsSync(graphDir)) {
-    await fs7.promises.mkdir(graphDir, { recursive: true });
+  const safeId = path6.basename(id);
+  const graphDir = path6.join(GRAPHS_ROOT2, safeId);
+  if (!fs6.existsSync(graphDir)) {
+    await fs6.promises.mkdir(graphDir, { recursive: true });
     await ensureGraphAssetDirectories(graphDir);
   }
   const existing = await getGraphPackageById(safeId);
@@ -2616,18 +4795,18 @@ async function saveGraphPackage(id, payload) {
       mapIoConfig: payload.mapIoConfig || existing?.graph?.mapIoConfig
     }
   };
-  await fs7.promises.writeFile(
-    path7.join(graphDir, "graph.qms"),
+  await fs6.promises.writeFile(
+    path6.join(graphDir, "graph.qms"),
     JSON.stringify(graphPackage, null, 2),
     "utf-8"
   );
   return graphPackage;
 }
 async function deleteGraphPackage(id) {
-  const safeId = path7.basename(id);
-  const graphDir = path7.join(GRAPHS_ROOT2, safeId);
-  if (!fs7.existsSync(graphDir)) return false;
-  await fs7.promises.rm(graphDir, { recursive: true, force: true });
+  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 });
   return true;
 }
 async function importGraphDependency(targetGraphId, candidateImportId) {
@@ -2669,26 +4848,26 @@ async function removeGraphDependency(targetGraphId, importIdToRemove) {
 }
 
 // src/server/services/projectService.ts
-import fs8 from "fs";
-import path8 from "path";
-var PROJECTS_ROOT2 = path8.join(process.cwd(), "projects");
+import fs7 from "fs";
+import path7 from "path";
+var PROJECTS_ROOT2 = path7.join(process.cwd(), "projects");
 var customStarterProjectTemplate = null;
 function configureStarterProjectTemplate(template) {
   customStarterProjectTemplate = template;
 }
 function ensureProjectsRoot(starterTemplate) {
-  if (!fs8.existsSync(PROJECTS_ROOT2)) {
-    fs8.mkdirSync(PROJECTS_ROOT2, { recursive: true });
+  if (!fs7.existsSync(PROJECTS_ROOT2)) {
+    fs7.mkdirSync(PROJECTS_ROOT2, { recursive: true });
   }
   const template = starterTemplate || customStarterProjectTemplate;
   if (template && template.id) {
-    const defaultProjDir = path8.join(PROJECTS_ROOT2, String(template.id));
-    if (!fs8.existsSync(defaultProjDir)) {
-      fs8.mkdirSync(defaultProjDir, { recursive: true });
-      fs8.mkdirSync(path8.join(defaultProjDir, "samples"), { recursive: true });
-      fs8.mkdirSync(path8.join(defaultProjDir, "assets"), { recursive: true });
-      fs8.writeFileSync(
-        path8.join(defaultProjDir, "project.json"),
+    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"),
         JSON.stringify({ ...template, createdAt: Date.now(), updatedAt: Date.now() }, null, 2),
         "utf-8"
       );
@@ -2697,22 +4876,22 @@ function ensureProjectsRoot(starterTemplate) {
 }
 async function listAllProjects() {
   ensureProjectsRoot();
-  const dirs = await fs8.promises.readdir(PROJECTS_ROOT2);
+  const dirs = await fs7.promises.readdir(PROJECTS_ROOT2);
   const projects = [];
   for (const dir of dirs) {
-    const projDir = path8.join(PROJECTS_ROOT2, dir);
-    const stat = await fs8.promises.stat(projDir);
+    const projDir = path7.join(PROJECTS_ROOT2, dir);
+    const stat = await fs7.promises.stat(projDir);
     if (!stat.isDirectory()) continue;
-    const projectFile = path8.join(projDir, "project.json");
-    const samplesDir = path8.join(projDir, "samples");
+    const projectFile = path7.join(projDir, "project.json");
+    const samplesDir = path7.join(projDir, "samples");
     let sampleCount = 0;
-    if (fs8.existsSync(samplesDir)) {
-      const samples = await fs8.promises.readdir(samplesDir);
+    if (fs7.existsSync(samplesDir)) {
+      const samples = await fs7.promises.readdir(samplesDir);
       sampleCount = samples.filter((f) => !f.startsWith(".")).length;
     }
-    if (fs8.existsSync(projectFile)) {
+    if (fs7.existsSync(projectFile)) {
       try {
-        const raw = await fs8.promises.readFile(projectFile, "utf-8");
+        const raw = await fs7.promises.readFile(projectFile, "utf-8");
         const data = JSON.parse(raw);
         projects.push({
           id: data.id || dir,
@@ -2732,24 +4911,24 @@ async function listAllProjects() {
   return projects.sort((a, b) => b.updatedAt - a.updatedAt);
 }
 async function getProjectById(id) {
-  const safeId = path8.basename(id);
-  const projectFile = path8.join(PROJECTS_ROOT2, safeId, "project.json");
-  if (!fs8.existsSync(projectFile)) return null;
-  const raw = await fs8.promises.readFile(projectFile, "utf-8");
+  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");
   return JSON.parse(raw);
 }
 async function saveProject(id, payload) {
-  const safeId = path8.basename(id);
-  const projDir = path8.join(PROJECTS_ROOT2, safeId);
-  const projectFile = path8.join(projDir, "project.json");
-  if (!fs8.existsSync(projDir)) {
-    await fs8.promises.mkdir(projDir, { recursive: true });
-    await fs8.promises.mkdir(path8.join(projDir, "samples"), { recursive: true });
-    await fs8.promises.mkdir(path8.join(projDir, "assets"), { recursive: true });
+  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 });
   }
   let existingData = {};
-  if (fs8.existsSync(projectFile)) {
-    const raw = await fs8.promises.readFile(projectFile, "utf-8");
+  if (fs7.existsSync(projectFile)) {
+    const raw = await fs7.promises.readFile(projectFile, "utf-8");
     existingData = JSON.parse(raw);
   }
   const updatedData = {
@@ -2758,22 +4937,22 @@ async function saveProject(id, payload) {
     id: safeId,
     updatedAt: Date.now()
   };
-  await fs8.promises.writeFile(projectFile, JSON.stringify(updatedData, null, 2), "utf-8");
+  await fs7.promises.writeFile(projectFile, JSON.stringify(updatedData, null, 2), "utf-8");
   return updatedData;
 }
 async function deleteProject(id) {
-  const safeId = path8.basename(id);
-  const projDir = path8.join(PROJECTS_ROOT2, safeId);
-  if (!fs8.existsSync(projDir)) return false;
-  await fs8.promises.rm(projDir, { recursive: true, force: true });
+  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 });
   return true;
 }
 
 // src/server/services/sampleService.ts
-import fs9 from "fs";
-import path9 from "path";
-var SAMPLES_GLOBAL_ROOT = path9.join(process.cwd(), "samples", "global");
-var PROJECTS_ROOT3 = path9.join(process.cwd(), "projects");
+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");
 var SUPPORTED_AUDIO_EXTS3 = [".wav", ".mp3", ".ogg", ".flac", ".m4a", ".webm", ".weba", ".aac", ".aiff", ".aif", ".opus", ".mp4"];
 function initGlobalSamplesDirectory() {
   ensureGlobalSamples(SAMPLES_GLOBAL_ROOT).catch((err) => {
@@ -2781,17 +4960,17 @@ function initGlobalSamplesDirectory() {
   });
 }
 async function listGlobalSamples() {
-  if (!fs9.existsSync(SAMPLES_GLOBAL_ROOT)) {
-    await fs9.promises.mkdir(SAMPLES_GLOBAL_ROOT, { recursive: true });
+  if (!fs8.existsSync(SAMPLES_GLOBAL_ROOT)) {
+    await fs8.promises.mkdir(SAMPLES_GLOBAL_ROOT, { recursive: true });
   }
-  const files = await fs9.promises.readdir(SAMPLES_GLOBAL_ROOT);
+  const files = await fs8.promises.readdir(SAMPLES_GLOBAL_ROOT);
   const samples = [];
   for (const file of files) {
-    const ext = path9.extname(file).toLowerCase();
+    const ext = path8.extname(file).toLowerCase();
     if (!SUPPORTED_AUDIO_EXTS3.includes(ext)) continue;
-    const filePath = path9.join(SAMPLES_GLOBAL_ROOT, file);
-    const stat = await fs9.promises.stat(filePath);
-    const baseName = path9.basename(file, ext);
+    const filePath = path8.join(SAMPLES_GLOBAL_ROOT, file);
+    const stat = await fs8.promises.stat(filePath);
+    const baseName = path8.basename(file, ext);
     const cleanName = baseName.replace(/[-_]/g, " ");
     let category = "synth";
     if (/808|kick|snare|hihat|drum|perc/i.test(baseName)) category = "drums";
@@ -2811,15 +4990,15 @@ async function listGlobalSamples() {
   return samples;
 }
 async function saveGlobalSample(filename, base64Content, category) {
-  const safeFilename = path9.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_");
-  const ext = path9.extname(safeFilename).toLowerCase() || ".wav";
-  const filePath = path9.join(SAMPLES_GLOBAL_ROOT, safeFilename);
+  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 buffer = Buffer.from(base64Content, "base64");
-  await fs9.promises.writeFile(filePath, buffer);
-  const stat = await fs9.promises.stat(filePath);
+  await fs8.promises.writeFile(filePath, buffer);
+  const stat = await fs8.promises.stat(filePath);
   return {
     filename: safeFilename,
-    name: path9.basename(safeFilename, ext).replace(/[-_]/g, " "),
+    name: path8.basename(safeFilename, ext).replace(/[-_]/g, " "),
     category: category || "custom",
     format: ext.replace(".", "").toUpperCase(),
     url: `/samples/global/${safeFilename}`,
@@ -2829,28 +5008,28 @@ async function saveGlobalSample(filename, base64Content, category) {
   };
 }
 async function deleteGlobalSample(filename) {
-  const safeFilename = path9.basename(filename);
-  const filePath = path9.join(SAMPLES_GLOBAL_ROOT, safeFilename);
-  if (fs9.existsSync(filePath)) {
-    await fs9.promises.unlink(filePath);
+  const safeFilename = path8.basename(filename);
+  const filePath = path8.join(SAMPLES_GLOBAL_ROOT, safeFilename);
+  if (fs8.existsSync(filePath)) {
+    await fs8.promises.unlink(filePath);
     return true;
   }
   return false;
 }
 async function listProjectSamples(projectId) {
-  const safeId = path9.basename(projectId);
-  const samplesDir = path9.join(PROJECTS_ROOT3, safeId, "samples");
-  if (!fs9.existsSync(samplesDir)) {
-    await fs9.promises.mkdir(samplesDir, { recursive: true });
+  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 files = await fs9.promises.readdir(samplesDir);
+  const files = await fs8.promises.readdir(samplesDir);
   const samples = [];
   for (const file of files) {
-    const ext = path9.extname(file).toLowerCase();
+    const ext = path8.extname(file).toLowerCase();
     if (!SUPPORTED_AUDIO_EXTS3.includes(ext)) continue;
-    const filePath = path9.join(samplesDir, file);
-    const stat = await fs9.promises.stat(filePath);
-    const baseName = path9.basename(file, ext);
+    const filePath = path8.join(samplesDir, file);
+    const stat = await fs8.promises.stat(filePath);
+    const baseName = path8.basename(file, ext);
     samples.push({
       filename: file,
       name: baseName.replace(/[-_]/g, " "),
@@ -2866,21 +5045,21 @@ async function listProjectSamples(projectId) {
   return samples;
 }
 async function saveProjectSample(projectId, filename, base64Content, isRecording) {
-  const safeId = path9.basename(projectId);
-  const samplesDir = path9.join(PROJECTS_ROOT3, safeId, "samples");
-  if (!fs9.existsSync(samplesDir)) {
-    await fs9.promises.mkdir(samplesDir, { recursive: true });
+  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 defaultName = isRecording ? `recording_take_${Date.now()}.wav` : `clip_${Date.now()}.wav`;
-  const targetFilename = filename ? path9.basename(filename).replace(/[^a-zA-Z0-9._-]/g, "_") : defaultName;
-  const ext = path9.extname(targetFilename).toLowerCase() || ".wav";
-  const filePath = path9.join(samplesDir, targetFilename);
+  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 buffer = Buffer.from(base64Content, "base64");
-  await fs9.promises.writeFile(filePath, buffer);
-  const stat = await fs9.promises.stat(filePath);
+  await fs8.promises.writeFile(filePath, buffer);
+  const stat = await fs8.promises.stat(filePath);
   return {
     filename: targetFilename,
-    name: path9.basename(targetFilename, ext).replace(/[-_]/g, " "),
+    name: path8.basename(targetFilename, ext).replace(/[-_]/g, " "),
     category: isRecording ? "recording" : "import",
     format: ext.replace(".", "").toUpperCase(),
     url: `/projects/${safeId}/samples/${targetFilename}`,
@@ -2891,26 +5070,26 @@ async function saveProjectSample(projectId, filename, base64Content, isRecording
   };
 }
 async function deleteProjectSample(projectId, filename) {
-  const safeId = path9.basename(projectId);
-  const safeFilename = path9.basename(filename);
-  const filePath = path9.join(PROJECTS_ROOT3, safeId, "samples", safeFilename);
-  if (fs9.existsSync(filePath)) {
-    await fs9.promises.unlink(filePath);
+  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);
     return true;
   }
   return false;
 }
 
 // src/server/services/workspaceGraphService.ts
-import fs10 from "fs";
-import path10 from "path";
-var AUTH_FILE_PATH = path10.resolve(".skipo/accounts.json");
+import fs9 from "fs";
+import path9 from "path";
+var AUTH_FILE_PATH = path9.resolve(".skipo/accounts.json");
 async function resolveWorkspaceDir(workspaceIdOrSlug) {
   const workingDir = getWorkingWorkspaceDir();
   let targetWs = null;
   try {
-    if (fs10.existsSync(AUTH_FILE_PATH)) {
-      const raw = await fs10.promises.readFile(AUTH_FILE_PATH, "utf-8");
+    if (fs9.existsSync(AUTH_FILE_PATH)) {
+      const raw = await fs9.promises.readFile(AUTH_FILE_PATH, "utf-8");
       const accounts = JSON.parse(raw);
       for (const user of Object.values(accounts)) {
         if (Array.isArray(user.workspaces)) {
@@ -2930,35 +5109,35 @@ async function resolveWorkspaceDir(workspaceIdOrSlug) {
   if (targetWs) {
     const rawFolderName = targetWs.localFolderName || targetWs.name.replace(/[/\\?%*:|"<>]/g, "_");
     const folderName = rawFolderName.trim();
-    await fs10.promises.mkdir(workingDir, { recursive: true });
+    await fs9.promises.mkdir(workingDir, { recursive: true });
     return { wsDir: workingDir, wsName: targetWs.name, wsFolder: folderName, wsId: targetWs.id };
   }
-  await fs10.promises.mkdir(workingDir, { recursive: true });
+  await fs9.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 = path10.join(dirPath, "project.json");
-    const graphQms = path10.join(dirPath, "graph.qms");
+    const projectJson = path9.join(dirPath, "project.json");
+    const graphQms = path9.join(dirPath, "graph.qms");
     let data = null;
-    if (fs10.existsSync(projectJson)) {
+    if (fs9.existsSync(projectJson)) {
       try {
-        const raw = await fs10.promises.readFile(projectJson, "utf-8");
+        const raw = await fs9.promises.readFile(projectJson, "utf-8");
         data = JSON.parse(raw);
       } catch {
       }
-    } else if (fs10.existsSync(graphQms)) {
+    } else if (fs9.existsSync(graphQms)) {
       try {
-        const raw = await fs10.promises.readFile(graphQms, "utf-8");
+        const raw = await fs9.promises.readFile(graphQms, "utf-8");
         const pkg = JSON.parse(raw);
         data = { ...pkg.metadata || {}, ...pkg.graph || {} };
       } catch {
       }
     }
     if (!data) return null;
-    const stat = await fs10.promises.stat(dirPath);
+    const stat = await fs9.promises.stat(dirPath);
     const nodeCount = Array.isArray(data.nodes) ? data.nodes.length : 0;
     const connectionCount = Array.isArray(data.connections) ? data.connections.length : 0;
     return {
@@ -2966,7 +5145,7 @@ async function listWorkspaceGraphs(workspaceIdOrSlug) {
       name: data.name || folderName,
       description: data.description || "",
       folderName,
-      folderPath: path10.relative(process.cwd(), dirPath).replace(/\\/g, "/"),
+      folderPath: path9.relative(process.cwd(), dirPath).replace(/\\/g, "/"),
       createdAt: data.createdAt || stat.birthtimeMs,
       updatedAt: data.updatedAt || stat.mtimeMs,
       bpm: data.bpm || 120,
@@ -2979,18 +5158,18 @@ async function listWorkspaceGraphs(workspaceIdOrSlug) {
       connectionCount
     };
   };
-  const entries = await fs10.promises.readdir(wsDir);
+  const entries = await fs9.promises.readdir(wsDir);
   for (const entry of entries) {
     if (entry.startsWith(".") || entry === "samples" || entry === "assets") continue;
-    const fullPath = path10.join(wsDir, entry);
-    const stat = await fs10.promises.stat(fullPath);
+    const fullPath = path9.join(wsDir, entry);
+    const stat = await fs9.promises.stat(fullPath);
     if (!stat.isDirectory()) continue;
     if (entry === "graphs") {
-      const subEntries = await fs10.promises.readdir(fullPath);
+      const subEntries = await fs9.promises.readdir(fullPath);
       for (const sub of subEntries) {
         if (sub.startsWith(".")) continue;
-        const subPath = path10.join(fullPath, sub);
-        const subStat = await fs10.promises.stat(subPath);
+        const subPath = path9.join(fullPath, sub);
+        const subStat = await fs9.promises.stat(subPath);
         if (subStat.isDirectory()) {
           const g2 = await inspectDirForGraph(subPath, sub);
           if (g2) graphs.push(g2);
@@ -3007,10 +5186,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 = path10.join(wsDir, folderName);
-  await fs10.promises.mkdir(graphDir, { recursive: true });
-  await fs10.promises.mkdir(path10.join(graphDir, "samples"), { recursive: true });
-  await fs10.promises.mkdir(path10.join(graphDir, "assets"), { recursive: true });
+  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 now = Date.now();
   const nodes = params.templateData?.nodes || [];
   const connections = params.templateData?.connections || [];
@@ -3021,7 +5200,7 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
     id: folderName,
     name: rawName,
     description: params.description || `Workspace graph in ${wsFolder}`,
-    folderPath: path10.relative(process.cwd(), graphDir).replace(/\\/g, "/"),
+    folderPath: path9.relative(process.cwd(), graphDir).replace(/\\/g, "/"),
     createdAt: now,
     updatedAt: now,
     bpm,
@@ -3030,7 +5209,7 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
     nodes,
     connections
   };
-  await fs10.promises.writeFile(path10.join(graphDir, "project.json"), JSON.stringify(projectData, null, 2), "utf-8");
+  await fs9.promises.writeFile(path9.join(graphDir, "project.json"), JSON.stringify(projectData, null, 2), "utf-8");
   const graphPackage = {
     format: "qms_graph_package",
     version: "2.0.0",
@@ -3048,27 +5227,27 @@ async function createWorkspaceGraph(workspaceIdOrSlug, params) {
     },
     graph: { bpm, masterVolume, currentBiome, nodes, connections }
   };
-  await fs10.promises.writeFile(path10.join(graphDir, "graph.qms"), JSON.stringify(graphPackage, null, 2), "utf-8");
+  await fs9.promises.writeFile(path9.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 = [
-    path10.join(wsDir, safeTarget),
-    path10.join(wsDir, graphIdOrName),
-    path10.join(wsDir, "graphs", safeTarget)
+    path9.join(wsDir, safeTarget),
+    path9.join(wsDir, graphIdOrName),
+    path9.join(wsDir, "graphs", safeTarget)
   ];
   for (const cand of candidates) {
-    if (fs10.existsSync(cand)) {
-      const pJson = path10.join(cand, "project.json");
-      if (fs10.existsSync(pJson)) {
-        const raw = await fs10.promises.readFile(pJson, "utf-8");
+    if (fs9.existsSync(cand)) {
+      const pJson = path9.join(cand, "project.json");
+      if (fs9.existsSync(pJson)) {
+        const raw = await fs9.promises.readFile(pJson, "utf-8");
         return JSON.parse(raw);
       }
-      const gQms = path10.join(cand, "graph.qms");
-      if (fs10.existsSync(gQms)) {
-        const raw = await fs10.promises.readFile(gQms, "utf-8");
+      const gQms = path9.join(cand, "graph.qms");
+      if (fs9.existsSync(gQms)) {
+        const raw = await fs9.promises.readFile(gQms, "utf-8");
         const pkg = JSON.parse(raw);
         return { ...pkg.metadata || {}, ...pkg.graph || {} };
       }
@@ -3079,39 +5258,39 @@ async function getWorkspaceGraph(workspaceIdOrSlug, graphIdOrName) {
 async function saveWorkspaceGraph(workspaceIdOrSlug, graphIdOrName, payload) {
   const { wsDir } = await resolveWorkspaceDir(workspaceIdOrSlug);
   const safeTarget = graphIdOrName.replace(/[/\\?%*:|"<>]/g, "_");
-  let targetDir = path10.join(wsDir, safeTarget);
-  if (!fs10.existsSync(targetDir) && fs10.existsSync(path10.join(wsDir, "graphs", safeTarget))) {
-    targetDir = path10.join(wsDir, "graphs", safeTarget);
+  let targetDir = path9.join(wsDir, safeTarget);
+  if (!fs9.existsSync(targetDir) && fs9.existsSync(path9.join(wsDir, "graphs", safeTarget))) {
+    targetDir = path9.join(wsDir, "graphs", safeTarget);
   }
-  await fs10.promises.mkdir(targetDir, { recursive: true });
-  const pJson = path10.join(targetDir, "project.json");
+  await fs9.promises.mkdir(targetDir, { recursive: true });
+  const pJson = path9.join(targetDir, "project.json");
   let existing = {};
-  if (fs10.existsSync(pJson)) {
+  if (fs9.existsSync(pJson)) {
     try {
-      existing = JSON.parse(await fs10.promises.readFile(pJson, "utf-8"));
+      existing = JSON.parse(await fs9.promises.readFile(pJson, "utf-8"));
     } catch {
     }
   }
   const updated = {
     ...existing,
     ...payload,
-    id: existing.id || path10.basename(targetDir),
+    id: existing.id || path9.basename(targetDir),
     updatedAt: Date.now()
   };
-  await fs10.promises.writeFile(pJson, JSON.stringify(updated, null, 2), "utf-8");
+  await fs9.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 = [
-    path10.join(wsDir, safeTarget),
-    path10.join(wsDir, graphIdOrName),
-    path10.join(wsDir, "graphs", safeTarget)
+    path9.join(wsDir, safeTarget),
+    path9.join(wsDir, graphIdOrName),
+    path9.join(wsDir, "graphs", safeTarget)
   ];
   for (const cand of candidates) {
-    if (fs10.existsSync(cand)) {
-      await fs10.promises.rm(cand, { recursive: true, force: true });
+    if (fs9.existsSync(cand)) {
+      await fs9.promises.rm(cand, { recursive: true, force: true });
       return true;
     }
   }
@@ -3130,9 +5309,11 @@ export {
   BaseAccountProvider,
   BaseApiRoute,
   BaseDataProvider,
+  BaseResourceFetcher,
   BaseStorageAdapter,
   CANONICAL_SRKL_URL,
   CallbackRegistry,
+  CloudflareResourceFetcher,
   CompositeBackend,
   ConcurrencyConflictError,
   ConcurrencyManager,
@@ -3167,6 +5348,7 @@ export {
   PasswordHasher,
   RateLimiter,
   RemoteExecutor,
+  ResourceFetcherRegistry,
   ResultFlowBridge,
   S3Adapter,
   SAMPLES_GLOBAL_ROOT,
@@ -3182,6 +5364,7 @@ export {
   StorageServiceFacade,
   SupabaseStorageAdapter,
   SyncEngine,
+  VercelResourceFetcher,
   WORKSPACE_ASSETS_ROOT,
   WORKSPACE_ROOT,
   WebSocketTransport,
@@ -3190,7 +5373,6 @@ export {
   WorkspaceFS,
   WorkspaceServiceDefinition,
   WorkspaceServiceFacade,
-  addWorkspaceSecondaryClone,
   authorizeB2,
   b2DeleteFileVersion,
   b2DeleteFolder,
@@ -3198,12 +5380,15 @@ export {
   b2ListBuckets,
   b2ListFileNames,
   b2UploadFile,
+  buildProjectObservability,
+  buildProjectsList,
   cleanDbUrl,
   configureStarterProjectTemplate,
   createAssetSubfolder,
   createBackend,
   createBackendClient,
   createCompositeService,
+  createCredential,
   createEmptyContract,
   createGraphAssetFolder,
   createGraphAssetFolder as createGraphAssetSubfolder,
@@ -3214,15 +5399,23 @@ export {
   createSSEResponse,
   createSrklClient,
   createWavBuffer,
+  createWorkspace,
   createWorkspaceGraph,
+  decryptSecretFromBlob,
   deleteAssetFromGraph,
   deleteAssetFromPool,
+  deleteCredential,
   deleteGlobalSample,
   deleteGraphPackage,
   deleteProject,
   deleteProjectSample,
+  deleteRoute,
+  deleteWorkspace,
+  deleteWorkspaceFile,
+  deleteWorkspaceFolder,
   deleteWorkspaceGraph,
   detectDatabaseEngine,
+  encryptSecretToBlob,
   ensureAssetPoolDirectories,
   ensureGlobalSamples,
   ensureGraphAssetDirectories,
@@ -3230,16 +5423,27 @@ export {
   ensureProjectsRoot,
   ensureS3DirectoryMarker,
   ensureWorkspaceStructure,
+  exportEncryptedCredentials,
+  fetchCloudflareData,
+  fetchVercelData,
+  findUserWorkspace,
   findWorkspaceRecord,
   formatCanonicalWorkspaceFolderName,
+  formatRelativeCreated,
+  getAllRoutes,
   getAssetPoolLocationPath,
   getAssetPoolPublicUrl,
   getB2BucketId,
+  getCredential,
   getDefaultWorkingWorkspaceDir,
+  getExecutions,
+  getGatewayConfig,
   getGraphPackageById,
   getPrimarySrklDeploymentUrl2 as getPrimarySrklCoreDeploymentUrl,
   getPrimarySrklDeploymentUrl,
   getProjectById,
+  getPublicRouteByPath,
+  getPublicRoutes,
   getSrklAccounts,
   getSrklAccounts2 as getSrklCoreAccounts,
   getSrklStatus,
@@ -3249,51 +5453,75 @@ export {
   getWorkingWorkspaceConfig,
   getWorkingWorkspaceDir,
   getWorkspaceFolderKey,
+  getWorkspaceFolderPrefix,
   getWorkspaceGraph,
+  getWorkspaceStorageDetails,
+  getWorkspaces,
+  importEncryptedCredentials,
   importGraphDependency,
   initGlobalSamplesDirectory,
+  isB2Workspace,
   isSecretMasked,
   listAllGraphPackages,
   listAllProjects,
   listBackblazeBuckets,
+  listCredentials,
   listGlobalSamples,
   listProjectSamples,
+  listWorkspaceFiles,
   listWorkspaceGraphs,
+  loadCredentialManifest,
+  loadWorkspaceData,
   loginSystemUser,
   loginUser,
+  matchGatewayIngress,
+  matchGatewayIngressAsync,
   normalizeBackblazeCredentials,
   permanentDeleteS3Folder,
   permanentDeleteS3Object,
   queryUnifiedDb,
+  readWorkspaceFile,
+  recordExecution,
   removeGraphDependency,
-  removeWorkspaceSecondaryClone,
+  renameAppInWorkspaceData,
   renameS3Folder,
   resolveBackblazeEndpoint,
+  resolveDynamicRouteFromDb,
   resolveSystemDatabaseClusterNodes,
   resolveUserFromToken,
+  resolveWorkspaceConnection,
   resolveWorkspaceDir,
   sanitizeWorkspaceName,
   saveAssetToGraph,
   saveAssetToPool,
+  saveCredentialManifest,
   saveGlobalSample,
   saveGraphPackage,
   saveProject,
   saveProjectSample,
-  saveWorkspaceClonesState,
+  saveWorkspaceData,
   saveWorkspaceGraph,
   scanAssetPool,
   scanGraphAssets,
   seedDefaultAssets,
   seedStarterGraphAssets,
+  serverPublicRoutes,
+  setServerPublicRoutes,
   setWorkingWorkspaceConfig,
   srklListBackblazeBuckets2 as srklCoreListBackblazeBuckets,
   srklListBackblazeBuckets,
-  syncPrimaryToClones,
   syncWorkspace,
+  syncWorkspaceCreateToBucket,
+  syncWorkspaceDataToBucket,
+  syncWorkspaceDeleteToBucket,
+  updateCredential,
+  updateWorkspace,
+  upsertRoute,
   useBackend,
   useBackendClient,
   useSrklServices,
   validateServiceDefinition,
   withAuth,
-  withCors
+  withCors,
+  writeWorkspaceFile
 };