@qaecy/cue-cli 0.0.22 → 0.0.26

package/main.js

@@ -94,17 +94,19 @@ var init_worker_pool = __esm({
 // apps/desktop/cue-cli/src/main.ts
 var import_commander = require("commander");
 var import_fs9 = require("fs");
-var import_path5 = require("path");
+var import_path6 = require("path");
 
 // apps/desktop/cue-cli/src/variables.ts
 var import_path = require("path");
-var TOKEN_ENDPOINT_EMULATOR = "http://localhost:8093/token";
-var TOKEN_ENDPOINT = "https://accessors-api-gateway-ueyeemwf2a-oa.a.run.app/token";
-var SPARQL_ENDPOINT_EMULATOR = "http://localhost:8093/triplestore/query";
+var EMULATOR_API_GATEWAY_PORT = process.env.CUE_EMULATOR_API_GATEWAY_PORT ?? "8093";
+var EMULATOR_API_GATEWAY_BASE = `http://localhost:${EMULATOR_API_GATEWAY_PORT}`;
+var TOKEN_ENDPOINT_EMULATOR = `${EMULATOR_API_GATEWAY_BASE}/token`;
+var EMULATOR_QLEVER_PORT = process.env.CUE_QLEVER_PORT ?? "8102";
+var QLEVER_QUERY_ENDPOINT_EMULATOR = process.env.CUE_QLEVER_ENDPOINT ? `${process.env.CUE_QLEVER_ENDPOINT}/query` : `http://localhost:${EMULATOR_QLEVER_PORT}/query`;
+var QLEVER_UPDATE_ENDPOINT_EMULATOR = process.env.CUE_QLEVER_ENDPOINT ? `${process.env.CUE_QLEVER_ENDPOINT}/update` : `http://localhost:${EMULATOR_QLEVER_PORT}/update`;
+var SPARQL_ENDPOINT_EMULATOR = `${EMULATOR_API_GATEWAY_BASE}/triplestore/query`;
 var SPARQL_ENDPOINT = "https://accessors-api-gateway-ueyeemwf2a-oa.a.run.app/triplestore/query";
 var HASH_WORKER_PATH = (0, import_path.join)(__dirname, "hash-worker.js");
-var SERVICE_ID = "cue-cli";
-var RDF_BASE = "https://cue.qaecy.com/r/";
 var PROJECT_ID = "qaecy-mvp-406413.appspot.com";
 var FIREBASE_CONFIG = (useEmulator = false) => ({
   apiKey: "AIzaSyCLhz5Wa3ZCERQZVurSt9bqupPeREALFLk",
@@ -416,16 +418,36 @@ var CueFirebase = class _CueFirebase {
       throw new Error("Storage persistence is not initialized");
     if (this._app === void 0)
       throw new Error("App is not initialized");
+    const _env = typeof process !== "undefined" ? process.env : {};
+    const authEmulatorEnv = _env["FIREBASE_AUTH_EMULATOR_HOST"];
+    const authEmulatorUrl = authEmulatorEnv ? `http://${authEmulatorEnv}` : "http://localhost:9099";
+    const firestoreEnv = _env["FIRESTORE_EMULATOR_HOST"];
+    const [firestoreHost, firestorePortStr] = firestoreEnv ? firestoreEnv.split(":") : ["localhost", "8080"];
+    const firestorePort = parseInt(firestorePortStr ?? "8080", 10);
+    const storageEnv = _env["STORAGE_EMULATOR_HOST"];
+    let storageHost = "localhost";
+    let storagePort = 9199;
+    if (storageEnv) {
+      try {
+        const u = new URL(storageEnv.startsWith("http") ? storageEnv : `http://${storageEnv}`);
+        storageHost = u.hostname;
+        storagePort = parseInt(u.port || "9199", 10);
+      } catch {
+        const parts = storageEnv.split(":");
+        storageHost = parts[0];
+        storagePort = parseInt(parts[1] ?? "9199", 10);
+      }
+    }
     const functions = (0, import_functions.getFunctions)(this._app, GCP_REGION);
-    (0, import_auth.connectAuthEmulator)(this._auth, "http://localhost:9099");
-    (0, import_firestore.connectFirestoreEmulator)((0, import_firestore.getFirestore)(this._app), "localhost", 8080);
+    (0, import_auth.connectAuthEmulator)(this._auth, authEmulatorUrl);
+    (0, import_firestore.connectFirestoreEmulator)((0, import_firestore.getFirestore)(this._app), firestoreHost, firestorePort);
     (0, import_functions.connectFunctionsEmulator)(functions, "localhost", 5001);
-    (0, import_storage.connectStorageEmulator)(this._storageProcessed, "localhost", 9199);
-    (0, import_storage.connectStorageEmulator)(this._storageRaw, "localhost", 9199);
-    (0, import_storage.connectStorageEmulator)(this._storageChatSessions, "localhost", 9199);
-    (0, import_storage.connectStorageEmulator)(this._storageLogs, "localhost", 9199);
-    (0, import_storage.connectStorageEmulator)(this._storagePublic, "localhost", 9199);
-    (0, import_storage.connectStorageEmulator)(this._storagePersistence, "localhost", 9199);
+    (0, import_storage.connectStorageEmulator)(this._storageProcessed, storageHost, storagePort);
+    (0, import_storage.connectStorageEmulator)(this._storageRaw, storageHost, storagePort);
+    (0, import_storage.connectStorageEmulator)(this._storageChatSessions, storageHost, storagePort);
+    (0, import_storage.connectStorageEmulator)(this._storageLogs, storageHost, storagePort);
+    (0, import_storage.connectStorageEmulator)(this._storagePublic, storageHost, storagePort);
+    (0, import_storage.connectStorageEmulator)(this._storagePersistence, storageHost, storagePort);
     if (!this._muted)
       console.info("Firebase emulators attached");
   }
@@ -441,6 +463,7 @@ var import_storage2 = require("firebase/storage");
 var qaecyPrefixes = {
   qcy: "https://dev.qaecy.com/ont#",
   "qcy-e": "https://dev.qaecy.com/enum#",
+  "qcy-l": "https://dev.qaecy.com/logs#",
   "qcy-f": "https://dev.qaecy.com/functions#",
   obc: "https://w3id.org/obc#",
   // OpenBIM Components
@@ -4024,7 +4047,7 @@ async function deleteUnzipped(dir) {
 
 // apps/desktop/cue-cli/src/helpers/query-handler.ts
 var import_auth2 = require("firebase/auth");
-async function queryHandler(query, spaceId, useEmulator) {
+async function queryHandler(query3, spaceId, useEmulator) {
   const endpoint = useEmulator ? SPARQL_ENDPOINT_EMULATOR : SPARQL_ENDPOINT;
   const token = await (0, import_auth2.getAuth)().currentUser?.getIdToken();
   const res = await fetch(endpoint, {
@@ -4035,7 +4058,7 @@ async function queryHandler(query, spaceId, useEmulator) {
       "Content-Type": "application/sparql-query",
       Accept: "application/sparql-results+json"
     },
-    body: query
+    body: query3
   });
   if (!res.ok) {
     console.error(
@@ -4055,639 +4078,705 @@ function fileSizePretty(size) {
   return (size / Math.pow(1024, i)).toFixed(2) + " " + sizes[i];
 }
 
-// apps/desktop/cue-cli/src/helpers/fetch-custom-token.ts
-async function fetchCustomToken(pid, apiKey, useEmulator) {
-  const url = useEmulator ? TOKEN_ENDPOINT_EMULATOR : TOKEN_ENDPOINT;
-  const data = await fetch(url, {
-    method: "GET",
-    headers: {
-      "x-project-id": pid,
-      "cue-api-key": apiKey
-    }
-  });
-  if (!data.ok) {
-    console.error("Failed to fetch token:", data.statusText);
-    process.exit(1);
-  }
-  const result = await data.json();
-  return result.token;
-}
+// libs/js/cue-sdk/src/lib/cue.ts
+var import_app2 = require("firebase/app");
 
-// apps/desktop/cue-cli/src/helpers/auth.ts
+// libs/js/cue-sdk/src/lib/auth.ts
 var import_auth3 = require("firebase/auth");
-async function authenticate(emulators, key, verbose = false) {
-  if (!key) {
-    key = process.env.CUE_API_KEY;
-    if (!key) {
-      console.error(
-        "API key is required. Provide it via --key option or CUE_API_KEY environment variable."
+var MICROSOFT_PROVIDER_ID = "microsoft.com";
+var CueAuth = class {
+  _auth;
+  _endpoints;
+  constructor(app, useEmulator = false, endpoints) {
+    this._auth = (0, import_auth3.getAuth)(app);
+    this._endpoints = endpoints;
+    if (useEmulator) {
+      (0, import_auth3.connectAuthEmulator)(this._auth, endpoints.authEmulatorUrl, {
+        disableWarnings: true
+      });
+    }
+  }
+  async signIn(provider, credentials) {
+    if (provider === "password") {
+      if (!credentials)
+        throw new Error("credentials are required for password sign-in");
+      const result2 = await (0, import_auth3.signInWithEmailAndPassword)(
+        this._auth,
+        credentials.email,
+        credentials.password
       );
-      process.exit(1);
+      return result2.user;
     }
+    const firebaseProvider = provider === "google" ? new import_auth3.GoogleAuthProvider() : new import_auth3.OAuthProvider(MICROSOFT_PROVIDER_ID);
+    const result = await (0, import_auth3.signInWithPopup)(this._auth, firebaseProvider);
+    return result.user;
   }
-  const fb = CueFirebase.getInstance(
-    FIREBASE_CONFIG(emulators),
-    void 0,
-    !verbose
-  );
-  if (verbose)
-    console.info("Fetching custom token \u23F3");
-  const customToken = await fetchCustomToken("xx", key, emulators);
-  if (verbose)
-    console.info("Fetched token \u2705");
-  if (verbose)
-    console.info("Signing in \u23F3");
-  const userCredentials = await (0, import_auth3.signInWithCustomToken)(fb.auth, customToken);
-  if (verbose)
-    console.info("Signed in \u2705");
-  const idTokenResult = await userCredentials.user.getIdTokenResult();
-  const role = idTokenResult.claims["role"];
-  const isSuperAdmin = role === "superadmin";
-  return { isSuperAdmin, userId: userCredentials.user.uid };
-}
+  /** Sign in with a Cue API key */
+  async signInWithApiKey(cueApiKey, projectId) {
+    const response = await fetch(this._endpoints.tokenUrl, {
+      method: "GET",
+      headers: {
+        "x-project-id": projectId,
+        "cue-api-key": cueApiKey
+      }
+    });
+    if (!response.ok)
+      throw new Error(`Failed to fetch custom token: ${response.statusText}`);
+    const { token } = await response.json();
+    const result = await (0, import_auth3.signInWithCustomToken)(this._auth, token);
+    return result.user;
+  }
+  /** Sign out the current user */
+  async signOut() {
+    await (0, import_auth3.signOut)(this._auth);
+  }
+  /** Currently signed-in user, or null if not authenticated */
+  get currentUser() {
+    return this._auth.currentUser;
+  }
+  /** Subscribe to authentication state changes. Returns an unsubscribe function. */
+  onAuthStateChanged(listener) {
+    return (0, import_auth3.onAuthStateChanged)(this._auth, listener);
+  }
+  /** Get the Firebase ID token for the current user, or null if not authenticated */
+  async getToken(forceRefresh = false) {
+    const user = this._auth.currentUser;
+    if (!user)
+      return null;
+    return user.getIdToken(forceRefresh);
+  }
+  /** Raw Firebase Auth instance, for advanced use cases */
+  get firebaseAuth() {
+    return this._auth;
+  }
+};
 
-// apps/desktop/cue-cli/src/cue-cli-compare.ts
-async function compareHandler(options) {
-  const { space, path, verbose, provider, emulators, zip } = options;
-  try {
-    await authenticate(emulators, options.key, verbose);
-    if (verbose)
-      console.info("Building compare base \u23F3");
-    const qh = async (query) => queryHandler(query, space, emulators);
-    const [localFiles, remoteFiles] = await Promise.all([
-      listLocalFiles(
-        path,
-        provider,
-        verbose,
-        5,
-        IGNORED_LOCAL,
-        HASH_WORKER_PATH,
-        zip
-      ),
-      listRemoteFiles(space, provider, qh, verbose)
-    ]);
-    const unzipPromise = zip ? deleteUnzipped(path) : Promise.resolve();
-    if (zip) {
-      if (verbose)
-        console.info("Started deletion of temp unzipped dirs \u23F3");
+// libs/js/cue-sdk/src/lib/api.ts
+var ENDPOINT_SEARCH = "/assistant/search";
+var ENDPOINT_SPARQL = "/triplestore/query";
+var CueApi = class {
+  constructor(_auth, _gatewayUrl, projects, sync) {
+    this._auth = _auth;
+    this._gatewayUrl = _gatewayUrl;
+    this.projects = projects;
+    this.sync = sync;
+  }
+  async _authHeaders() {
+    return this.getAuthHeaders();
+  }
+  /**
+   * Returns standard authentication headers for the current user.
+   * Useful when calling Cue-backed services directly (e.g. the GIS proxy).
+   */
+  async getAuthHeaders() {
+    const token = await this._auth.getToken();
+    if (!token)
+      throw new Error("Not authenticated. Call cue.auth.signIn() first.");
+    return {
+      Authorization: `Bearer ${token}`,
+      "Content-Type": "application/json"
+    };
+  }
+  /**
+   * Search project documents using natural language.
+   * The user must be authenticated before calling this.
+   */
+  async search(request) {
+    const headers = await this._authHeaders();
+    const response = await fetch(`${this._gatewayUrl}${ENDPOINT_SEARCH}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({
+        term: request.term,
+        projectId: request.projectId,
+        categories: request.categories ?? []
+      })
+    });
+    if (!response.ok) {
+      throw new Error(`Search request failed: ${response.status} ${response.statusText}`);
     }
-    const report = await compareLocalRemote(localFiles, remoteFiles);
-    await unzipPromise;
-    if (zip && verbose)
-      console.info("Cleaned up unzipped files \u2705");
-    if (verbose)
-      console.info("Built compare base \u2705");
-    console.log("");
-    console.log("--- Compare Report ---");
-    console.log("");
-    console.log(`Total files: ${report.totalCount}`);
-    console.log(`Total size: ${fileSizePretty(report.totalSize || 0)}`);
-    console.log("");
-    console.log(
-      `Files synchronized: ${report.syncCount} (${(report.synctPctCount * 100).toFixed(2)}%)`
-    );
-    console.log(
-      `Synchronized size: ${fileSizePretty(report.syncSize || 0)} (${(report.synctPctSize * 100).toFixed(2)}%)`
-    );
-    console.log("");
-    if (report.localNotOnRemote) {
-      console.log(
-        `${report.localNotOnRemote.length} files do not exist on remote`
-      );
-      if (verbose && report.localNotOnRemote.length > 0) {
-        for (const f of report.localNotOnRemote) {
-          console.log(
-            "  - " + f.relativePath + " (" + fileSizePretty(f.size || 0) + ")"
-          );
-        }
-      }
-      console.log("");
+    return response.json();
+  }
+  /**
+   * Execute a SPARQL query against the project's triplestore.
+   * The user must be authenticated before calling this.
+   */
+  async sparql(query3, projectId) {
+    const headers = await this._authHeaders();
+    const response = await fetch(`${this._gatewayUrl}${ENDPOINT_SPARQL}`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify({ query: query3, projectId })
+    });
+    if (!response.ok) {
+      throw new Error(`SPARQL query failed: ${response.status} ${response.statusText}`);
     }
-    if (report.localNotOnRemotePathOnly) {
-      console.log(
-        `${report.localNotOnRemotePathOnly.length} file paths do not exist on remote on providerId "${provider}" (file duplicates)`
-      );
-      if (verbose && report.localNotOnRemotePathOnly.length > 0) {
-        for (const f of report.localNotOnRemotePathOnly) {
-          console.log(
-            "  - " + f.relativePath + " (" + fileSizePretty(f.size || 0) + ")"
-          );
-        }
-      }
-      console.log("");
+    return response.json();
+  }
+};
+
+// libs/js/cue-sdk/src/lib/project.ts
+var import_firestore2 = require("firebase/firestore");
+var COLLECTION_PROJECTS2 = "projects";
+var CueProjects = class {
+  constructor(_auth, app, useEmulator = false, endpoints) {
+    this._auth = _auth;
+    this._db = (0, import_firestore2.getFirestore)(app);
+    if (useEmulator) {
+      const host = endpoints?.firestoreEmulatorHost ?? "localhost";
+      const port = endpoints?.firestoreEmulatorPort ?? 8080;
+      (0, import_firestore2.connectFirestoreEmulator)(this._db, host, port);
     }
-    if (report.remoteNotOnLocal) {
-      console.log(`${report.remoteNotOnLocal.length} files do not exist locally`);
-      console.log(
-        "This might expected if the files belong to another provider or have been deleted locally"
-      );
-      if (verbose && report.remoteNotOnLocal.length > 0) {
-        for (const f of report.remoteNotOnLocal) {
-          console.log(
-            "  - " + f.contentUUID + " (" + fileSizePretty(f.size || 0) + ")"
-          );
-        }
-      }
-      console.log("");
+  }
+  _db;
+  _requireUser() {
+    const user = this._auth.currentUser;
+    if (!user)
+      throw new Error("Not authenticated. Call cue.auth.signIn() first.");
+    return user.uid;
+  }
+  /**
+   * Create a new project. The authenticated user is automatically set as admin, syncer, and member.
+   * Throws if a project with the given ID already exists.
+   */
+  async createProject(options) {
+    const userId = this._requireUser();
+    const projectId = options.id ?? crypto.randomUUID();
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    const projectSettings = { views: [], chatDisabled: false };
+    const ref5 = (0, import_firestore2.doc)((0, import_firestore2.collection)(this._db, COLLECTION_PROJECTS2), projectId);
+    const existing = await (0, import_firestore2.getDoc)(ref5);
+    if (existing.exists()) {
+      throw new Error(`Project with ID "${projectId}" already exists.`);
     }
-    if (report.remoteNotOnLocalPathOnly) {
-      console.log(
-        `${report.remoteNotOnLocalPathOnly.length} file paths on providerId "${provider}" do not exist locally`
-      );
-      console.log(
-        "This might expected if the files belong to another provider or have been deleted locally"
-      );
-      if (verbose && report.remoteNotOnLocalPathOnly.length > 0) {
-        for (const f of report.remoteNotOnLocalPathOnly) {
-          console.log(
-            "  - " + f.contentUUID + " (" + fileSizePretty(f.size || 0) + ")"
-          );
+    const data = {
+      id: projectId,
+      name: options.name,
+      organizationID: options.organizationID,
+      created: now,
+      lastSync: null,
+      isPublic: false,
+      members: [userId],
+      syncers: [userId],
+      admins: [userId],
+      alternativeIDs: [projectId],
+      projectSettings
+    };
+    await (0, import_firestore2.setDoc)(ref5, data);
+    return data;
+  }
+  /**
+   * List all projects where the authenticated user appears in the members, syncers, or admins array.
+   * Runs three parallel Firestore queries and deduplicates by project ID.
+   */
+  async listProjects() {
+    const userId = this._requireUser();
+    const col = (0, import_firestore2.collection)(this._db, COLLECTION_PROJECTS2);
+    const [memberSnap, syncerSnap, adminSnap] = await Promise.all([
+      (0, import_firestore2.getDocs)((0, import_firestore2.query)(col, (0, import_firestore2.where)("members", "array-contains", userId))),
+      (0, import_firestore2.getDocs)((0, import_firestore2.query)(col, (0, import_firestore2.where)("syncers", "array-contains", userId))),
+      (0, import_firestore2.getDocs)((0, import_firestore2.query)(col, (0, import_firestore2.where)("admins", "array-contains", userId)))
+    ]);
+    const seen = /* @__PURE__ */ new Set();
+    const results = [];
+    for (const snap of [memberSnap, syncerSnap, adminSnap]) {
+      for (const d of snap.docs) {
+        const project = d.data();
+        if (!seen.has(project.id)) {
+          seen.add(project.id);
+          results.push(project);
         }
       }
-      console.log("");
     }
-  } catch (err) {
-    console.error("Error:", err);
-    process.exit(1);
+    return results;
   }
-}
-
-// apps/desktop/cue-cli/src/helpers/get-files-containing-substring.ts
-var import_storage3 = require("firebase/storage");
-var import_path3 = require("path");
-var import_promises3 = require("fs/promises");
-async function getFilesContainingSubstring(bucket, subDir = "", subString = "") {
-  const firebase = CueFirebase.getInstance();
-  const storage = bucket === "raw" ? firebase.storageRaw : firebase.storageProcessed;
-  console.log("Fetching files from storage bucket:", bucket, "in subdir:", subDir, "containing substring:", subString);
-  const listResult = await (0, import_storage3.listAll)((0, import_storage3.ref)(storage, subDir));
-  const outputDir = (0, import_path3.join)(process.cwd(), "downloaded_blobs", bucket, subDir);
-  await (0, import_promises3.mkdir)(outputDir, { recursive: true });
-  for (const fileRef of listResult.items) {
-    console.log(fileRef.name);
-    if (subDir && !fileRef.name.includes(subString))
-      continue;
-    const bytes = await (0, import_storage3.getBytes)(fileRef);
-    const outputPath = (0, import_path3.join)(outputDir, fileRef.name);
-    await (0, import_promises3.writeFile)(outputPath, Buffer.from(bytes));
-    console.log(`Downloaded ${fileRef.name} to ${outputPath} \u2705`);
+  /** Fetch a single project by ID. Returns null if not found. */
+  async getProject(projectId) {
+    const ref5 = (0, import_firestore2.doc)((0, import_firestore2.collection)(this._db, COLLECTION_PROJECTS2), projectId);
+    const snap = await (0, import_firestore2.getDoc)(ref5);
+    if (!snap.exists())
+      return null;
+    return snap.data();
   }
-}
+  /**
+   * Atomically increments `unitsConsumed` on the top-level `clientSync/{projectId}`
+   * document, creating it if it doesn't exist. Intended for pre-flight checks.
+   */
+  async incrementUnitsConsumed(projectId, units, userId) {
+    if (units <= 0)
+      return;
+    const ref5 = (0, import_firestore2.doc)(this._db, "clientSync", projectId);
+    await (0, import_firestore2.setDoc)(ref5, {
+      unitsConsumed: (0, import_firestore2.increment)(units),
+      lastUpdated: (0, import_firestore2.serverTimestamp)(),
+      lastUserId: userId
+    }, { merge: true });
+  }
+};
 
-// apps/desktop/cue-cli/src/cue-cli-dump-processed.ts
-async function dumpProcessedHandler(options) {
-  const { space, verbose, emulators, processor } = options;
-  try {
-    const { isSuperAdmin } = await authenticate(emulators, options.key, verbose);
-    if (!isSuperAdmin) {
-      console.error("Sorry - this tool is only for super admin users");
-      process.exit(1);
+// libs/js/cue-sdk/src/lib/profile.ts
+var import_auth4 = require("firebase/auth");
+var import_firestore3 = require("firebase/firestore");
+var import_nanoid = require("nanoid");
+var COLLECTION_API_KEYS2 = "apiKeys";
+var CueProfile = class {
+  constructor(_auth, app, useEmulator, emulatorHost, emulatorPort) {
+    this._auth = _auth;
+    this._db = (0, import_firestore3.getFirestore)(app);
+    if (useEmulator) {
+      (0, import_firestore3.connectFirestoreEmulator)(this._db, emulatorHost, emulatorPort);
     }
-    if (verbose)
-      console.info(`Dumping processed files for processor ${processor} \u23F3`);
-    const files = await getFilesContainingSubstring("processed", `${space}/triples`, processor);
-    console.log(files);
-  } catch (err) {
-    console.error("Error:", err);
-    process.exit(1);
   }
-}
-
-// apps/desktop/cue-cli/src/helpers/graph-dump.ts
-var import_fs2 = require("fs");
-var import_stream = require("stream");
-var import_fs3 = require("fs");
-var import_zlib = require("zlib");
-var import_promises4 = require("stream/promises");
-var import_promises5 = require("fs/promises");
-var import_auth6 = require("firebase/auth");
-
-// libs/js/size-tools/src/lib/js-size-tools.ts
-function humanFileSize(bytes, si = false, dp = 1) {
-  const thresh = si ? 1e3 : 1024;
-  if (Math.abs(bytes) < thresh) {
-    return bytes + " B";
+  _db;
+  _apiKeyDocRef;
+  /** Whether the current user has an active API key. */
+  async hasAPIKey() {
+    const uid = this._auth.currentUser?.uid;
+    if (!uid)
+      return false;
+    return this._checkIfUserHasAPIKey(uid);
   }
-  const units = si ? ["kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"] : ["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
-  let u = -1;
-  const r = 10 ** dp;
-  do {
-    bytes /= thresh;
-    ++u;
-  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
-  return bytes.toFixed(dp) + " " + units[u];
-}
-
-// apps/desktop/cue-cli/src/helpers/graph-dump.ts
-var import_fs4 = require("fs");
-async function dumpRdfGraphToFileJelly(spaceId, useEmulator = false, verbose = false) {
-  return dumpRdfGraphToFile(
-    spaceId,
-    useEmulator,
-    verbose,
-    `${spaceId}.jelly`,
-    "application/x-jelly-rdf"
-  );
-}
-async function dumpRdfGraphToFile(spaceId, useEmulator = false, verbose = false, outFile, mimeType = "application/n-quads") {
-  const endpoint = useEmulator ? SPARQL_ENDPOINT_EMULATOR : SPARQL_ENDPOINT;
-  const dataUrl = endpoint.replace("/query", "/data");
-  if (verbose)
-    console.info(`Streaming RDF graph \u23F3`);
-  const filePath = outFile || `${spaceId}.nq`;
-  if ((0, import_fs4.existsSync)(filePath) || (0, import_fs4.existsSync)(`${filePath}.gz`)) {
-    if (verbose)
-      console.info(`File ${filePath} already exists, skipping download.`);
-    return mimeType === "application/n-quads" ? `${filePath}.gz` : filePath;
+  /** Returns the sign-in methods registered for the current user's email. */
+  async getSignInMethods() {
+    const user = this._auth.currentUser;
+    if (!user?.email)
+      throw new Error("User has no e-mail");
+    return (0, import_auth4.fetchSignInMethodsForEmail)(this._auth.firebaseAuth, user.email);
   }
-  const token = await (0, import_auth6.getAuth)().currentUser?.getIdToken();
-  const res = await fetch(dataUrl, {
-    method: "GET",
-    headers: {
-      "x-project-id": spaceId,
-      authorization: `Bearer ${token}`,
-      Accept: mimeType
-    }
-  });
-  if (!res.ok || !res.body) {
-    throw new Error(`Failed to stream data: ${res.status} ${res.statusText}`);
+  /** Builds a human-readable label from a Firebase UserInfo provider entry. */
+  buildProviderLabel(userInfo) {
+    if (userInfo.displayName && userInfo.email)
+      return `${userInfo.displayName} (${userInfo.email})`;
+    return userInfo.displayName ?? userInfo.email ?? "-";
   }
-  const fileStream = (0, import_fs2.createWriteStream)(filePath, { flags: "w" });
-  const nodeStream = import_stream.Readable.fromWeb(res.body);
-  let chunkCount = 0;
-  let totalSize = 0;
-  let hasDataTimeout = null;
-  let lastChunkTime = Date.now();
-  nodeStream.on("data", (chunk) => {
-    lastChunkTime = Date.now();
-    chunkCount++;
-    totalSize += chunk.length;
-    if (hasDataTimeout) {
-      clearTimeout(hasDataTimeout);
+  /** Returns SSO accounts linked to the current user (excludes password). */
+  getSSOAccounts() {
+    const user = this._auth.currentUser;
+    if (!user)
+      return [];
+    return user.providerData.filter((p) => p.providerId !== "password").map((p) => ({ id: p.providerId, label: this.buildProviderLabel(p) }));
+  }
+  /** Links a Google or Microsoft provider to the current account via popup. Returns the new provider label. */
+  async linkProvider(ssoProvider) {
+    const user = this._requireUser();
+    const provider = ssoProvider === "google.com" ? new import_auth4.GoogleAuthProvider() : new import_auth4.OAuthProvider(ssoProvider);
+    const credential = await (0, import_auth4.linkWithPopup)(user, provider);
+    const userInfo = credential.user.providerData.find(
+      (pd) => pd.providerId === ssoProvider
+    );
+    return userInfo ? this.buildProviderLabel(userInfo) : "-";
+  }
+  /** Unlinks a provider from the current account. */
+  async unlinkProvider(providerId) {
+    await (0, import_auth4.unlink)(this._requireUser(), providerId);
+  }
+  /** Changes the password. Reauthenticates first. */
+  async updatePassword(currentPassword, newPassword) {
+    const user = this._requireUser();
+    if (!user.email)
+      throw new Error("User has no e-mail");
+    await (0, import_auth4.reauthenticateWithCredential)(
+      user,
+      import_auth4.EmailAuthProvider.credential(user.email, currentPassword)
+    );
+    await (0, import_auth4.updatePassword)(user, newPassword);
+  }
+  /** Adds (sets) a password for an account that currently only uses SSO. */
+  async addPassword(password) {
+    const user = this._requireUser();
+    if (!user.email)
+      throw new Error("User has no e-mail");
+    await (0, import_auth4.linkWithCredential)(user, import_auth4.EmailAuthProvider.credential(user.email, password));
+  }
+  /** Requests an e-mail change. Sends a verification e-mail to the new address. */
+  async updateEmail(newEmail, password) {
+    const user = this._requireUser();
+    if (!user.email)
+      throw new Error("User e-mail not available");
+    await (0, import_auth4.reauthenticateWithCredential)(
+      user,
+      import_auth4.EmailAuthProvider.credential(user.email, password)
+    );
+    await (0, import_auth4.verifyBeforeUpdateEmail)(user, newEmail);
+    await (0, import_auth4.sendEmailVerification)(user);
+  }
+  /** Creates a new API key for the current user. */
+  async createAPIKey(expiration) {
+    const uid = this._auth.currentUser?.uid;
+    if (!uid)
+      throw new Error("User not authenticated");
+    const data = { key: `cue-${(0, import_nanoid.nanoid)(150)}`, uid, expiration };
+    const col = (0, import_firestore3.collection)(this._db, COLLECTION_API_KEYS2);
+    this._apiKeyDocRef = await (0, import_firestore3.addDoc)(col, data);
+    return data;
+  }
+  /** Revokes the current user's API key. */
+  async revokeAPIKey() {
+    if (!this._apiKeyDocRef)
+      throw new Error("No API key document reference");
+    await (0, import_firestore3.deleteDoc)(this._apiKeyDocRef);
+    this._apiKeyDocRef = void 0;
+  }
+  /** Fetches the current user's existing API key. */
+  async requestAPIKey() {
+    if (!this._apiKeyDocRef)
+      throw new Error("No API key document reference");
+    const doc2 = (await (0, import_firestore3.getDoc)(this._apiKeyDocRef)).data();
+    return { key: doc2.key, expiration: doc2.expiration };
+  }
+  async _checkIfUserHasAPIKey(uid) {
+    const col = (0, import_firestore3.collection)(this._db, COLLECTION_API_KEYS2);
+    const q = (0, import_firestore3.query)(col, (0, import_firestore3.where)("uid", "==", uid), (0, import_firestore3.limit)(1));
+    const snapshot = await (0, import_firestore3.getDocs)(q);
+    if (!snapshot.empty)
+      this._apiKeyDocRef = snapshot.docs[0].ref;
+    return !snapshot.empty;
+  }
+  _requireUser() {
+    const user = this._auth.currentUser;
+    if (!user)
+      throw new Error("Not authenticated");
+    return user;
+  }
+};
+
+// libs/js/cue-sdk/src/lib/cue.ts
+var FIREBASE_PROJECT_ID = "qaecy-mvp-406413";
+var FIREBASE_SENDER_ID = "734737865998";
+var ENDPOINTS = {
+  production: {
+    gatewayUrl: "https://accessors-api-gateway-ueyeemwf2a-oa.a.run.app",
+    tokenUrl: "https://accessors-api-gateway-ueyeemwf2a-oa.a.run.app/token",
+    authEmulatorUrl: "http://localhost:9099",
+    storageEmulatorHost: "localhost",
+    storageEmulatorPort: 9199,
+    firestoreEmulatorHost: "localhost",
+    firestoreEmulatorPort: 8080
+  },
+  emulator: {
+    gatewayUrl: "http://localhost:8093",
+    tokenUrl: "http://localhost:8093/token",
+    authEmulatorUrl: "http://localhost:9099",
+    storageEmulatorHost: "localhost",
+    storageEmulatorPort: 9199,
+    firestoreEmulatorHost: "localhost",
+    firestoreEmulatorPort: 8080
+  }
+};
+var Cue = class {
+  auth;
+  api;
+  profile;
+  _app;
+  _endpoints;
+  _isEmulator;
+  constructor(config) {
+    const env = config.environment ?? "production";
+    this._endpoints = { ...ENDPOINTS[env], ...config.endpoints };
+    this._isEmulator = env === "emulator";
+    this._app = (0, import_app2.initializeApp)({
+      apiKey: config.apiKey,
+      appId: config.appId,
+      measurementId: config.measurementId,
+      authDomain: `${FIREBASE_PROJECT_ID}.firebaseapp.com`,
+      projectId: FIREBASE_PROJECT_ID,
+      messagingSenderId: FIREBASE_SENDER_ID
+    });
+    this.auth = new CueAuth(this._app, this._isEmulator, this._endpoints);
+    const projects = new CueProjects(this.auth, this._app, this._isEmulator, this._endpoints);
+    this.api = this._buildApi(projects);
+    this.profile = new CueProfile(
+      this.auth,
+      this._app,
+      this._isEmulator,
+      this._endpoints.firestoreEmulatorHost,
+      this._endpoints.firestoreEmulatorPort
+    );
+  }
+  /** Override in subclasses to provide a custom CueApi (e.g. with sync). */
+  _buildApi(projects) {
+    return new CueApi(this.auth, this._endpoints.gatewayUrl, projects);
+  }
+  /** Convenience: get the current user's Firebase ID token */
+  getToken(forceRefresh = false) {
+    return this.auth.getToken(forceRefresh);
+  }
+};
+
+// libs/js/cue-sdk/src/lib/cue-node.ts
+var import_storage4 = require("firebase/storage");
+
+// libs/js/databases/src/lib/graph/fuseki.ts
+var Fuseki = class _Fuseki {
+  queryEndpoint;
+  updateEndpoint;
+  baseHeaders;
+  static RELEVANT_HEADER_KEYS = [
+    "authorization",
+    "Authorization",
+    "x-project-id"
+  ];
+  constructor(graphOptions) {
+    this.queryEndpoint = graphOptions.queryEndpoint;
+    this.updateEndpoint = graphOptions.updateEndpoint;
+    this.baseHeaders = Object.fromEntries(
+      Object.entries(graphOptions.originalHeaders || {}).filter(
+        ([key]) => _Fuseki.RELEVANT_HEADER_KEYS.includes(key)
+      )
+    );
+    if (graphOptions.authHeader !== void 0) {
+      this.baseHeaders["Authorization"] = graphOptions.authHeader;
     }
-    if (verbose && totalSize >= 10 * 1024 * 1024 && totalSize % (10 * 1024 * 1024) < chunk.length)
-      console.info(
-        `Writing chunk #${chunkCount}, size: ${humanFileSize(totalSize)}`
+  }
+  async ping() {
+    const query3 = "ASK { }";
+    const res = await this.query(query3);
+    return res.boolean;
+  }
+  async query(query3, accept = "application/sparql-results+json") {
+    let res;
+    try {
+      res = await fetch(this.queryEndpoint, {
+        headers: {
+          ...this.baseHeaders,
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: accept
+        },
+        method: "POST",
+        body: new URLSearchParams({ query: query3 })
+      });
+    } catch (err) {
+      throw new Error(
+        `Fuseki is not accessible at ${this.queryEndpoint}: ${err instanceof Error ? err.message : String(err)}`
       );
-  });
-  const streamTimeout = 3e5;
-  hasDataTimeout = setTimeout(() => {
-    const timeSinceLastChunk = Date.now() - lastChunkTime;
-    if (timeSinceLastChunk > streamTimeout) {
-      console.error(`Stream appears stalled - no data received for ${timeSinceLastChunk}ms`);
-      nodeStream.destroy(new Error("Stream timeout"));
     }
-  }, streamTimeout);
-  try {
-    await (0, import_promises4.pipeline)(nodeStream, fileStream);
-  } finally {
-    if (hasDataTimeout) {
-      clearTimeout(hasDataTimeout);
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Fuseki query failed (HTTP ${res.status}): ${body}`);
     }
+    return await res.json();
   }
-  if (verbose)
-    console.info(`Total chunks written: ${chunkCount}, total size: ${humanFileSize(totalSize)}`);
-  if (totalSize === 0) {
-    throw new Error("No data received from server - possible authentication or permission issue");
+  async subset(query3, accept = "text/turtle") {
+    const res = await fetch(this.queryEndpoint, {
+      headers: {
+        ...this.baseHeaders,
+        "Content-Type": "application/x-www-form-urlencoded",
+        Authorization: this.baseHeaders["Authorization"] || "",
+        Accept: accept
+      },
+      method: "POST",
+      body: new URLSearchParams({ query: query3 })
+    });
+    if (accept === "application/ld+json") {
+      return await res.json();
+    }
+    return await res.text();
   }
-  if (verbose)
-    console.info(`Streamed RDF graph to ${filePath} \u2705`);
-  if (mimeType === "application/n-quads") {
-    if (verbose)
-      console.info(`
-Gzipping to ${filePath}.gz \u23F3`);
-    await _doGzip(filePath);
-    if (verbose)
-      console.info(`Gzipped to ${filePath}.gz \u2705`);
-    return `${filePath}.gz`;
+  async update(update) {
+    const res = await fetch(this.updateEndpoint, {
+      headers: {
+        ...this.baseHeaders,
+        "Content-Type": "application/x-www-form-urlencoded"
+      },
+      method: "POST",
+      body: new URLSearchParams({ update })
+    });
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`SPARQL update failed (HTTP ${res.status}): ${body}`);
+    }
+    const contentType = res.headers.get("content-type") ?? "";
+    if (contentType.includes("application/json")) {
+      return await res.json();
+    }
+    return {
+      ok: res.ok,
+      status: res.status,
+      message: await res.text()
+    };
   }
-  return filePath;
-}
-async function dumpRdfGraphToFileConstruct(spaceId, useEmulator = false, verbose = false, graphIRI, batchSize = 5e4, concurrency = 8, maxRetries = 5, retryDelayMs = 1e3, delayBetweenBatchesMs = 500) {
-  const endpoint = useEmulator ? SPARQL_ENDPOINT_EMULATOR : SPARQL_ENDPOINT;
-  const filePath = `${spaceId}.nq`;
-  const graph = graphIRI !== void 0 ? `<${graphIRI}>` : "?g";
-  const constructQuery = `
-    CONSTRUCT { GRAPH ${graph} { ?s ?p ?o } }
-    WHERE { GRAPH ${graph} { ?s ?p ?o } }
-  `;
-  let offset = 0;
-  const fileStream = (0, import_fs2.createWriteStream)(filePath, { flags: "w" });
-  let hasMore = true;
-  while (hasMore) {
-    const queries = Array.from(
-      { length: concurrency },
-      (_, i) => `${constructQuery} LIMIT ${batchSize} OFFSET ${offset + i * batchSize}`
-    );
-    offset += batchSize * concurrency;
-    const results = await Promise.all(
-      queries.map(
-        (q, idx) => retryWithBackoff(
-          () => _doQuery(q, spaceId, endpoint),
-          maxRetries,
-          retryDelayMs,
-          verbose ? `Batch ${offset - batchSize * concurrency + idx * batchSize}` : void 0
-        )
+};
+
+// libs/js/databases/src/lib/graph/qlever.ts
+var QLever = class _QLever {
+  queryEndpoint;
+  updateEndpoint;
+  baseHeaders;
+  static RELEVANT_HEADER_KEYS = [
+    "authorization",
+    "Authorization",
+    "x-project-id",
+    "x-user-roles"
+    // add more if needed
+  ];
+  constructor(graphOptions) {
+    this.queryEndpoint = graphOptions.queryEndpoint;
+    this.updateEndpoint = graphOptions.updateEndpoint;
+    this.baseHeaders = Object.fromEntries(
+      Object.entries(graphOptions.originalHeaders || {}).filter(
+        ([key]) => _QLever.RELEVANT_HEADER_KEYS.includes(key)
       )
     );
-    const batches = results.filter(Boolean);
-    if (batches.length === 0) {
-      hasMore = false;
-      break;
-    }
-    for (const batch of batches) {
-      fileStream.write(batch.trim() + "\n");
-    }
-    if (verbose)
-      process.stdout.write(`Current offset: ${offset.toLocaleString()}\r`);
-    if (delayBetweenBatchesMs > 0)
-      await new Promise((res) => setTimeout(res, delayBetweenBatchesMs));
   }
-  fileStream.end();
-  if (verbose)
-    console.info(`
-Gzipping to ${filePath}.gz \u23F3`);
-  await _doGzip(filePath);
-  if (verbose)
-    console.info(`Gzipped to ${filePath}.gz \u2705`);
-  return `${filePath}.gz`;
-}
-async function retryWithBackoff(fn, maxRetries, delayMs, label) {
-  let attempt = 0;
-  let lastErr = null;
-  while (attempt < maxRetries) {
+  async ping() {
+    const query3 = "ASK { }";
+    const res = await this.query(query3);
+    return res.boolean;
+  }
+  async query(query3, accept = "application/sparql-results+json") {
+    let res;
     try {
-      const result = await fn();
-      if (result !== null && result !== void 0)
-        return result;
+      console.log(this.queryEndpoint);
+      res = await fetch(this.queryEndpoint, {
+        headers: {
+          ...this.baseHeaders,
+          "Content-Type": "application/x-www-form-urlencoded",
+          Accept: accept
+        },
+        method: "POST",
+        body: new URLSearchParams({ query: query3 })
+      });
     } catch (err) {
-      lastErr = err;
+      throw new Error(
+        `QLever is not accessible at ${this.queryEndpoint}: ${err instanceof Error ? err.message : String(err)}`
+      );
     }
-    attempt++;
-    if (label)
-      console.warn(`${label}: Retry ${attempt}/${maxRetries}`);
-    await new Promise(
-      (res) => setTimeout(res, delayMs * Math.pow(2, attempt - 1))
-    );
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`QLever query failed (HTTP ${res.status}): ${body}`);
+    }
+    return await res.json();
   }
-  if (label)
-    console.error(`${label}: Failed after ${maxRetries} retries`, lastErr);
-  return null;
-}
-async function _doGzip(filePath) {
-  const gzFilePath = `${filePath}.gz`;
-  await new Promise((resolve2, reject) => {
-    const gzip = (0, import_zlib.createGzip)();
-    const source = (0, import_fs3.createReadStream)(filePath);
-    const dest = (0, import_fs2.createWriteStream)(gzFilePath);
-    (0, import_promises4.pipeline)(source, gzip, dest).then(resolve2).catch(reject);
-  });
-  await (0, import_promises5.unlink)(filePath);
-}
-async function _doQuery(query, spaceId, url) {
-  const token = await (0, import_auth6.getAuth)().currentUser?.getIdToken();
-  try {
-    const res = await fetch(url, {
+  async subset(query3, accept = "text/turtle") {
+    const res = await fetch(this.queryEndpoint, {
+      headers: {
+        ...this.baseHeaders,
+        "Content-Type": "application/x-www-form-urlencoded",
+        Accept: accept
+      },
       method: "POST",
+      body: new URLSearchParams({ query: query3 })
+    });
+    return await res.text();
+  }
+  async update(update) {
+    const res = await fetch(this.updateEndpoint, {
       headers: {
-        "x-project-id": spaceId,
-        authorization: `Bearer ${token}`,
-        "Content-Type": "application/sparql-query",
-        Accept: "application/n-quads"
+        ...this.baseHeaders,
+        "Content-Type": "application/x-www-form-urlencoded"
       },
-      body: query
+      method: "POST",
+      body: new URLSearchParams({ update })
     });
     if (!res.ok) {
-      console.error(`Error: ${res.status} ${res.statusText}`);
-      return null;
+      const body = await res.text();
+      throw new Error(`SPARQL update failed (HTTP ${res.status}): ${body}`);
     }
-    return await res.text();
-  } catch (e) {
-    console.error(e);
-    return null;
+    return await res.json();
   }
-}
+};
 
-// apps/desktop/cue-cli/src/helpers/graph-create.ts
-var import_auth7 = require("firebase/auth");
-async function createGraph(id) {
-  const token = await (0, import_auth7.getAuth)().currentUser?.getIdToken();
-  const dataSetUrl = SPARQL_ENDPOINT_EMULATOR.replace("/query", `/$/datasets`);
-  const res = await fetch(dataSetUrl, {
-    method: "POST",
-    headers: {
-      "x-project-id": id,
-      authorization: `Bearer ${token}`,
-      "content-type": "text/turtle"
-    },
-    body: _getTemplate(id)
-  });
-  if (!res.ok) {
-    throw new Error(`Failed to create graph: ${res.statusText}`);
+// libs/js/databases/src/lib/graph/main.ts
+var CueGraphDatabase = class {
+  constructor(options) {
+    this.options = options;
+    switch (this.options.graphType) {
+      case "qlever":
+        this._db = new QLever(this.options);
+        break;
+      case "fuseki":
+        this._db = new Fuseki(this.options);
+        break;
+      default:
+        throw new Error(`Unsupported graph type: ${this.options.graphType}`);
+    }
   }
-}
-function _getTemplate(partition, base = "fuseki-base-new/fuseki") {
-  return `@prefix :       <http://base/#> .
-    @prefix fuseki: <http://jena.apache.org/fuseki#> .
-    @prefix rdfs:   <http://www.w3.org/2000/01/rdf-schema#> .
-    @prefix rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
-    @prefix tdb2:   <http://jena.apache.org/2016/tdb#> .
-    @prefix skos:   <http://www.w3.org/2004/02/skos/core#> .
-    @prefix text:   <http://jena.apache.org/text#> .
-    @prefix qcy:    <${qaecyPrefixes["qcy"]}> .
-    @prefix qcye:  <${qaecyPrefixes["qcy-e"]}> .
+  _db;
+  ping() {
+    return this._db.ping();
+  }
+  query(queryString, accept) {
+    return this._db.query(queryString, accept);
+  }
+  subset(queryString, accept) {
+    if (this.options.graphType === "qlever") {
+      if (accept && accept !== "text/turtle") {
+        return Promise.reject(
+          new Error(
+            `QLever only supports 'text/turtle' for CONSTRUCT/DESCRIBE queries.`
+          )
+        );
+      }
+      return this._db.subset(
+        queryString,
+        accept
+      );
+    }
+    return this._db.subset(queryString, accept);
+  }
+  update(updateString) {
+    return this._db.update(updateString);
+  }
+};
 
+// libs/js/databases/src/lib/blob/blob.ts
+var import_storage3 = require("firebase/storage");
+var CueBlobStorage = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /**
+   * Upload binary data to the raw storage bucket with retry logic.
+   */
+  async uploadRaw(blobName, data, metadata, maxRetries = 3) {
+    const fileRef = (0, import_storage3.ref)(this.options.storageRaw, blobName);
+    let attempt = 0;
+    let lastError;
+    while (attempt < maxRetries) {
+      try {
+        await new Promise((resolve2, reject) => {
+          const task = (0, import_storage3.uploadBytesResumable)(fileRef, data, {
+            customMetadata: metadata
+          });
+          task.on("state_changed", null, reject, resolve2);
+        });
+        return;
+      } catch (err) {
+        lastError = err;
+        attempt++;
+        if (attempt < maxRetries) {
+          await new Promise((res) => setTimeout(res, 1e3 * attempt));
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Upload data to the processed storage bucket.
+   * Skips upload and returns `false` if the blob already exists.
+   */
+  async uploadProcessed(blobName, data, metadata) {
+    const fileRef = (0, import_storage3.ref)(this.options.storageProcessed, blobName);
+    const existing = await (0, import_storage3.getMetadata)(fileRef).catch(() => null);
+    if (existing)
+      return false;
+    await (0, import_storage3.uploadBytes)(fileRef, data, { customMetadata: metadata });
+    return true;
+  }
+  /**
+   * List all blob names directly under `prefix` in the raw storage bucket.
+   */
+  async listRaw(prefix) {
+    const listRef = (0, import_storage3.ref)(this.options.storageRaw, prefix);
+    const result = await (0, import_storage3.listAll)(listRef);
+    return result.items.map((item) => item.name);
+  }
+};
 
-    :tdb_dataset_readwrite a tdb2:DatasetTDB2;
-        tdb2:location  "${base}/databases/${partition}/tdb";
-        tdb2:unionDefaultGraph true ;
-        tdb2:transactionMode "transactional" ;
-        tdb2:transactionLogType "journal" ;
-        tdb2:blockFileSize "32M" ;
-        tdb2:blockCacheSize "1G" ;
-        tdb2:fileMode "direct" .
-
-    :service_tdb_all  a  fuseki:Service;
-        fuseki:name      "${partition}" ;
-        rdfs:label       "TDB2 ${partition}";
-        fuseki:dataset   :tdb_dataset_readwrite;
-        fuseki:allowedUsers             "admin";
-        fuseki:endpoint  [ fuseki:name       "update";
-                        fuseki:operation  fuseki:update
-                        ];
-        fuseki:endpoint  [ fuseki:name       "query";
-                        fuseki:operation  fuseki:query
-                        ];
-        fuseki:endpoint  [ fuseki:name       "get";
-                        fuseki:operation  fuseki:gsp-r
-                        ];
-        fuseki:endpoint  [ fuseki:name       "shacl";
-                        fuseki:operation  fuseki:shacl
-                        ];
-        fuseki:endpoint  [ fuseki:name       "data";
-                        fuseki:operation  fuseki:gsp-rw
-                        ];
-        fuseki:endpoint  [ fuseki:name       "sparql";
-                        fuseki:operation  fuseki:query
-                        ].`;
-}
-
-// apps/desktop/cue-cli/src/helpers/graph-upload.ts
-var import_auth8 = require("firebase/auth");
-var import_fs5 = require("fs");
-async function uploadToLocalGraph(id, filePath, mimeType = "application/n-quads", zipped = false) {
-  const stream = (0, import_fs5.createReadStream)(filePath);
-  const token = await (0, import_auth8.getAuth)().currentUser?.getIdToken();
-  const dataUrl = SPARQL_ENDPOINT_EMULATOR.replace("/query", "/data");
-  const headers = {
-    "x-project-id": id,
-    authorization: `Bearer ${token}`,
-    "Content-Type": mimeType
-  };
-  if (zipped) {
-    headers["Content-Encoding"] = "gzip";
-  }
-  const res = await fetch(dataUrl, {
-    method: "POST",
-    headers,
-    body: stream,
-    duplex: "half"
-  });
-  const text = await res.text();
-  console.log(text);
-  if (!res.ok) {
-    console.error(`Failed to upload graph: ${res.statusText}`);
-    return;
-  }
-}
-
-// apps/desktop/cue-cli/src/cue-cli-dump.ts
-async function dumpHandler(options) {
-  const { space, verbose, emulators, jelly, query, load } = options;
-  try {
-    const { isSuperAdmin } = await authenticate(emulators, options.key, verbose);
-    if (!isSuperAdmin) {
-      console.error("Sorry - this tool is only for super admin users");
-      process.exit(1);
-    }
-    if (verbose)
-      console.info("Dumping graph \u23F3");
-    let filePath = "";
-    if (jelly) {
-      if (verbose)
-        console.info("Setting: Jelly format");
-      if (verbose)
-        console.time("Downloaded graph \u2705");
-      filePath = await dumpRdfGraphToFileJelly(space, emulators, verbose);
-      if (verbose)
-        console.timeEnd("Downloaded graph \u2705");
-    } else {
-      if (verbose)
-        console.time("Downloaded and zipped graph \u2705");
-      if (query) {
-        if (verbose)
-          console.info("Setting: Construct query");
-        filePath = await dumpRdfGraphToFileConstruct(space, emulators, verbose);
-      } else {
-        if (verbose)
-          console.info("Setting: /data endpoint");
-        filePath = await dumpRdfGraphToFile(space, emulators, verbose);
-      }
-      if (verbose)
-        console.timeEnd("Downloaded and zipped graph \u2705");
-    }
-    console.info(`File written: ${filePath}`);
-    if (load && !emulators) {
-      if (verbose)
-        console.info(`Creating local RDF graph with id: ${space} \u23F3`);
-      await createGraph(space);
-      if (verbose)
-        console.info(`Created local RDF graph \u2705`);
-      if (verbose)
-        console.info(`Uploading file to local RDF graph \u23F3`);
-      await uploadToLocalGraph(
-        space,
-        filePath,
-        jelly ? "application/jelly+json" : "application/n-quads",
-        jelly ? false : true
-      );
-      if (verbose)
-        console.info(`Uploaded file to local RDF graph \u2705`);
-    }
-  } catch (err) {
-    console.error("Error:", err);
-    process.exit(1);
-  }
-}
-
-// apps/desktop/cue-cli/src/helpers/repair-remote-ttl.ts
-var import_storage4 = require("firebase/storage");
-async function repairRemoteTTL(space, subString, regex, substituteString) {
-  const firebase = CueFirebase.getInstance();
-  const storage = firebase.storageProcessed;
-  console.log("Fetching files from storage bucket 'triples' containing substring:", subString);
-  const listResult = await (0, import_storage4.listAll)((0, import_storage4.ref)(storage, `${space}/triples`));
-  for (const fileRef of listResult.items) {
-    if (subString && !fileRef.name.match(subString))
-      continue;
-    const stream = await (0, import_storage4.getStream)(fileRef);
-    const reader = stream.getReader();
-    const chunks = [];
-    let done = false;
-    while (!done) {
-      const { value, done: streamDone } = await reader.read();
-      if (value) {
-        chunks.push(value);
-      }
-      done = streamDone;
-    }
-    let fileContent = Buffer.concat(chunks).toString("utf8");
-    let modified = false;
-    if (substituteString && regex) {
-      const newContent = fileContent.replace(regex, substituteString);
-      if (newContent !== fileContent) {
-        fileContent = newContent;
-        modified = true;
-      }
-    }
-    if (modified) {
-      const buffer = Buffer.from(fileContent, "utf8");
-      let existingMetadata = {};
-      try {
-        existingMetadata = await (0, import_storage4.getMetadata)(fileRef);
-      } catch (err) {
-        console.warn(`Could not fetch metadata for ${fileRef.name}, proceeding with default.`);
-      }
-      const customMetadata = { ...existingMetadata.customMetadata || {}, stored: "False" };
-      const metadata = { customMetadata };
-      await (0, import_storage4.uploadBytesResumable)((0, import_storage4.ref)(storage, `${space}/triples/${fileRef.name}`), buffer, metadata);
-      console.log(`Fixed ${fileRef.name} \u2705`);
-    } else {
-      console.log(`No changes for ${fileRef.name}`);
-    }
-  }
-}
-
-// apps/desktop/cue-cli/src/cue-cli-repair-ttl.ts
-async function repairTtlHandler(options) {
-  const { space, verbose, emulators, processor, from, to } = options;
-  try {
-    const { isSuperAdmin } = await authenticate(emulators, options.key, verbose);
-    if (!isSuperAdmin) {
-      console.error("Sorry - this tool is only for super admin users");
-      process.exit(1);
-    }
-    if (verbose)
-      console.info(`Repairing TTL files for processor ${processor} \u23F3`);
-    await repairRemoteTTL(space, processor, new RegExp(from, "g"), to);
-  } catch (err) {
-    console.error("Error:", err);
-    process.exit(1);
-  }
-}
-
-// apps/desktop/cue-cli/src/helpers/upload-file.ts
-var import_storage5 = require("firebase/storage");
+// libs/js/cue-sdk/src/lib/sync.ts
+var import_promises3 = require("fs/promises");
+var import_path3 = require("path");
+var import_module = require("module");
 
 // libs/js/models/src/lib/file-extensions.ts
 var fileExtensionsInfo = {
@@ -5715,18 +5804,33 @@ function getFileSuffix(filename) {
 var { namedNode: namedNode4, literal: literal3 } = import_n34.DataFactory;
 var a3 = namedNode4("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
 
+// libs/js/rdf-document-writers/src/lib/process-logs.ts
+var import_n35 = require("n3");
+
 // libs/js/rdf-document-writers/src/lib/serialize-rdf.ts
-async function serializeRDF(namespace, writer) {
+async function serializeRDF(namespace, writer, format = "ttl") {
   return new Promise((resolve2, reject) => {
     writer.end((err, res) => {
       if (err)
         reject(err);
-      resolve2(namespace !== "" ? `@base <${namespace}>.
+      const addBase = format === "ttl" && namespace !== "";
+      resolve2(addBase ? `@base <${namespace}>.
 ${res}` : res);
     });
   });
 }
 
+// libs/js/rdf-document-writers/src/lib/process-logs.ts
+var import_uuid6 = require("uuid");
+var { namedNode: namedNode5, literal: literal4 } = import_n35.DataFactory;
+var a4 = namedNode5("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
+var prefixes3 = {
+  qcy: qaecyPrefixes["qcy"],
+  "qcy-e": qaecyPrefixes["qcy-e"],
+  "qcy-l": qaecyPrefixes["qcy-l"],
+  xsd: prefixCC["xsd"]
+};
+
 // libs/js/file-metadata-helpers/src/lib/js-file-metadata-helpers.ts
 function uploadedFileMetadata(originalName, projectId, userId, md5, providerId, clientMetadata, mime, skipLoading = false, skipProcessing = false) {
   const suffix = getFileSuffix(originalName);
@@ -5750,123 +5854,941 @@ function uploadedFileMetadata(originalName, projectId, userId, md5, providerId,
     provider_id: providerId ?? "",
     mime,
     additional_metadata: clientMetadata ?? "",
-    last_seen_as: JSON.stringify({ hostId: providerId ?? "", fileUUID })
+    last_seen_as: JSON.stringify({
+      hostId: providerId ?? "",
+      fileUUID
+    })
+  };
+}
+function turtleFileMetadata(sourceFile, processorId, locationUUID, stored = false) {
+  const ids = extractIdsFromRawPath(sourceFile);
+  const blob_name = locationUUID !== void 0 ? `${ids.projectId}/triples/${ids.documentUUID}_${locationUUID}_${processorId}.ttl` : `${ids.projectId}/triples/${ids.documentUUID}_${processorId}.ttl`;
+  const identifier = locationUUID !== void 0 ? `${ids.documentUUID}_${locationUUID}` : ids.documentUUID;
+  return {
+    blob_name,
+    processor: processorId,
+    space_id: ids.projectId,
+    stored: stored ? "True" : "False",
+    suffix: ".ttl",
+    identifier,
+    source: sourceFile
   };
 }
-function turtleFileMetadata(sourceFile, processorId, locationUUID, stored = false) {
-  const ids = extractIdsFromRawPath(sourceFile);
-  const blob_name = locationUUID !== void 0 ? `${ids.projectId}/triples/${ids.documentUUID}_${locationUUID}_${processorId}.ttl` : `${ids.projectId}/triples/${ids.documentUUID}_${processorId}.ttl`;
-  return {
-    blob_name,
-    processor: processorId,
-    space_id: ids.projectId,
-    stored: stored ? "True" : "False",
-    suffix: ".ttl",
-    identifier: `${ids.documentUUID}_${locationUUID}`,
-    source: sourceFile
+
+// libs/js/cue-sdk/src/lib/sync.ts
+var _scanFn = null;
+var _fileMapFn = null;
+var _wasmInitPromise = null;
+async function _initWasm() {
+  const _require = (0, import_module.createRequire)((0, import_path3.resolve)(process.cwd(), "_anchor.js"));
+  const pkgMain = _require.resolve("dir-scanner-wasm");
+  const wasmBinary = await (0, import_promises3.readFile)((0, import_path3.join)((0, import_path3.dirname)(pkgMain), "dir_scanner_wasm_bg.wasm"));
+  const mod = await import(
+    /* @vite-ignore */
+    pkgMain
+  );
+  await mod.default({ module_or_path: wasmBinary });
+  _scanFn = mod.scan;
+  _fileMapFn = mod.scan_file_map;
+}
+var DEFAULT_GRAPH_TYPE = "fuseki";
+var DEFAULT_SERVICE_ID = "cue-cli";
+var DEFAULT_RDF_BASE = "https://cue.qaecy.com/r/";
+var ENDPOINT_FUSEKI_QUERY = "/triplestore/query";
+var ENDPOINT_QLEVER_QUERY = "/sparql/query";
+var ENDPOINT_FUSEKI_UPDATE = "/triplestore/update";
+var ENDPOINT_QLEVER_UPDATE = "/sparql/update";
+var CueSyncApi = class {
+  constructor(_auth, _projects, _blob, _gatewayUrl, _serviceId = DEFAULT_SERVICE_ID, _rdfBase = DEFAULT_RDF_BASE) {
+    this._auth = _auth;
+    this._projects = _projects;
+    this._blob = _blob;
+    this._gatewayUrl = _gatewayUrl;
+    this._serviceId = _serviceId;
+    this._rdfBase = _rdfBase;
+  }
+  _graphMap = /* @__PURE__ */ new Map();
+  async sync(localFiles, options) {
+    const { spaceId, providerId, userId, verbose } = options;
+    const token = await this._auth.getToken();
+    if (!token)
+      throw new Error("Not authenticated. Call cue.auth.signIn() first.");
+    const graph = await this._getOrCreateGraph(spaceId, token);
+    if (verbose)
+      console.info("Listing remote files \u23F3");
+    const remoteFiles = await this._listRemoteFiles(graph, spaceId, providerId, verbose);
+    const report = await compareLocalRemote(localFiles, remoteFiles);
+    if (verbose) {
+      console.info(`Total local files: ${localFiles.length}`);
+      console.info(`Total remote files: ${remoteFiles.length}`);
+      console.info(
+        `Total files to sync: ${(report.localNotOnRemote?.length ?? 0) + report.localNotOnRemotePathOnly.length}`
+      );
+    }
+    let syncCount = report.syncCount;
+    let syncSize = report.syncSize;
+    let failedUploads = 0;
+    let rdfWritten = false;
+    let unitsConsumed = 0;
+    let fileUnits = {};
+    try {
+      if (!_wasmInitPromise)
+        _wasmInitPromise = _initWasm();
+      await _wasmInitPromise;
+      const entries = await Promise.all(
+        localFiles.map(async (f) => ({
+          originalPath: f.relativePath,
+          data: new Uint8Array(await (0, import_promises3.readFile)(f.fullPath))
+        }))
+      );
+      fileUnits = _fileMapFn(entries);
+    } catch (err) {
+      console.warn("[CueSyncApi] Unit map failed, proceeding without unit tracking:", err);
+    }
+    const toUpload = report.localNotOnRemote ?? [];
+    if (verbose && toUpload.length)
+      console.info("Syncing missing files \u23F3");
+    for (const file of toUpload) {
+      let uploadSucceeded = false;
+      try {
+        const rawMeta = uploadedFileMetadata(
+          file.relativePath,
+          spaceId,
+          userId,
+          file.md5,
+          providerId
+        );
+        if (!rawMeta.blob_name)
+          throw new Error(`blob_name missing for ${file.relativePath}`);
+        const fileBuffer = await (0, import_promises3.readFile)(file.fullPath);
+        await this._blob.uploadRaw(
+          rawMeta.blob_name,
+          new Uint8Array(fileBuffer),
+          rawMeta
+        );
+        const uploaded = await this._uploadRdfMetadata(file, rawMeta, verbose);
+        if (uploaded)
+          rdfWritten = true;
+        syncCount += 1;
+        syncSize += file.size || 0;
+        uploadSucceeded = true;
+        this._logProgress(syncCount, report.totalCount, syncSize, report.totalSize, verbose);
+      } catch (err) {
+        failedUploads += 1;
+        console.error(`[CueSyncApi] Failed to upload file: ${file.fullPath}`);
+        if (verbose)
+          console.error("[CueSyncApi] Upload error details:", err);
+      }
+      if (uploadSucceeded) {
+        const fileUnitsCount = fileUnits[file.relativePath] ?? 0;
+        if (fileUnitsCount > 0) {
+          unitsConsumed += fileUnitsCount;
+          try {
+            await this._projects.incrementUnitsConsumed(spaceId, fileUnitsCount, userId);
+          } catch (err) {
+            console.error(`[CueSyncApi] Failed to write clientSync entry for ${file.relativePath}:`, err);
+          }
+        }
+      }
+    }
+    if (verbose && report.localNotOnRemotePathOnly.length)
+      console.info(`Syncing missing file locations (on provider "${providerId}") \u23F3`);
+    for (const file of report.localNotOnRemotePathOnly) {
+      const rawMeta = uploadedFileMetadata(
+        file.relativePath,
+        spaceId,
+        userId,
+        file.md5,
+        providerId
+      );
+      if (!rawMeta.blob_name)
+        throw new Error(`blob_name missing for ${file.relativePath}`);
+      const uploaded = await this._uploadRdfMetadata(file, rawMeta, verbose);
+      if (uploaded)
+        rdfWritten = true;
+      syncCount += 1;
+      syncSize += file.size || 0;
+      const fileUnitsCount = fileUnits[file.relativePath] ?? 0;
+      if (fileUnitsCount > 0) {
+        unitsConsumed += fileUnitsCount;
+        try {
+          await this._projects.incrementUnitsConsumed(spaceId, fileUnitsCount, userId);
+        } catch (err) {
+          console.error(`[CueSyncApi] Failed to write clientSync entry for ${file.relativePath}:`, err);
+        }
+      }
+      this._logProgress(syncCount, report.totalCount, syncSize, report.totalSize, verbose);
+    }
+    return {
+      syncCount,
+      syncSize,
+      failedUploads,
+      totalCount: report.totalCount,
+      totalSize: report.totalSize,
+      rdfWritten,
+      unitsConsumed
+    };
+  }
+  async _getOrCreateGraph(spaceId, token) {
+    const cached = this._graphMap.get(spaceId);
+    if (cached)
+      return cached;
+    const project = await this._projects.getProject(spaceId);
+    const graphType = project?.projectSettings?.graph?.type ?? DEFAULT_GRAPH_TYPE;
+    const queryEndpoint = graphType === "qlever" ? `${this._gatewayUrl}${ENDPOINT_QLEVER_QUERY}` : `${this._gatewayUrl}${ENDPOINT_FUSEKI_QUERY}`;
+    const updateEndpoint = graphType === "qlever" ? `${this._gatewayUrl}${ENDPOINT_QLEVER_UPDATE}` : `${this._gatewayUrl}${ENDPOINT_FUSEKI_UPDATE}`;
+    const graph = new CueGraphDatabase({
+      graphType,
+      queryEndpoint,
+      updateEndpoint,
+      originalHeaders: {
+        "x-project-id": spaceId,
+        authorization: `Bearer ${token}`
+      }
+    });
+    this._graphMap.set(spaceId, graph);
+    return graph;
+  }
+  async _listRemoteFiles(graph, spaceId, providerId, verbose) {
+    if (verbose)
+      console.info(`Listing files in raw space: ${spaceId}`);
+    const [blobNames, locationMap] = await Promise.all([
+      this._blob.listRaw(spaceId),
+      this._getGraphFiles(graph, providerId)
+    ]);
+    if (verbose)
+      console.info(`Found ${blobNames.length} files in raw store for space: ${spaceId}`);
+    const files = [];
+    for (const name of blobNames) {
+      const contentUUID = name.substring(0, 36);
+      const locations = locationMap[contentUUID] ?? [];
+      if (locations.length === 0) {
+        if (verbose)
+          console.warn(`No location data found for contentUUID: ${contentUUID}`);
+        files.push({ contentUUID });
+      } else {
+        for (const loc of locations) {
+          files.push({
+            contentUUID,
+            locationUUID: loc.locationUUID,
+            created: loc.created,
+            size: loc.size
+          });
+        }
+      }
+    }
+    return files;
+  }
+  async _getGraphFiles(graph, providerId) {
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT ?fc ?loc ?created ?fp ?size
+WHERE {
+  ?fc a qcy:FileContent ;
+      qcy:sizeBytes ?size ;
+      qcy:hasFileLocation ?loc .
+  ?loc qcy:remoteProviderId "${providerId}" ;
+       qcy:dateCreated ?created ;
+       qcy:filePath ?fp .
+}`;
+    const res = await graph.query(q, "application/sparql-results+json");
+    const map = {};
+    if (typeof res === "string")
+      return map;
+    for (const b of res.results.bindings) {
+      const locationUUID = b["loc"].value.split("/").at(-1) ?? "";
+      const contentUUID = b["fc"].value.split("/").at(-1) ?? "";
+      const created = b["created"].value;
+      const size = b["size"].value;
+      if (!map[contentUUID])
+        map[contentUUID] = [];
+      map[contentUUID].push({ locationUUID, created, size });
+    }
+    return map;
+  }
+  async _uploadRdfMetadata(file, rawMeta, verbose) {
+    if (!rawMeta.blob_name)
+      throw new Error(`blob_name missing for ${file.relativePath}`);
+    const ttlMeta = turtleFileMetadata(
+      rawMeta.blob_name,
+      this._serviceId,
+      file.locationUUID
+    );
+    if (!ttlMeta.blob_name)
+      throw new Error(`ttl blob_name missing for ${rawMeta.blob_name}`);
+    const writer = fileLocationRaw(rawMeta, file.size);
+    const namespace = `${this._rdfBase}${ttlMeta.space_id}/`;
+    const triples = await serializeRDF(namespace, writer);
+    const uploaded = await this._blob.uploadProcessed(
+      ttlMeta.blob_name,
+      new Uint8Array(Buffer.from(triples, "utf-8")),
+      ttlMeta
+    );
+    if (!uploaded && verbose) {
+      console.info(
+        `Graph data for ${file.relativePath} already exists \u2014 skipping \u26A0\uFE0F`
+      );
+    }
+    return uploaded;
+  }
+  /**
+   * Scans `localFiles` and returns a per-extension cost breakdown.
+   *
+   * Each {@link ScanOutputRecord} contains `units` — the billable metric for
+   * that extension (e.g. pages for PDFs, rows for spreadsheets) — which can be
+   * shown to the user before or after calling {@link sync}.
+   */
+  async scanCost(localFiles) {
+    if (!_wasmInitPromise)
+      _wasmInitPromise = _initWasm();
+    await _wasmInitPromise;
+    const entries = await Promise.all(
+      localFiles.map(async (f) => ({
+        originalPath: f.relativePath,
+        data: new Uint8Array(await (0, import_promises3.readFile)(f.fullPath))
+      }))
+    );
+    return _scanFn(entries);
+  }
+  _logProgress(syncCount, totalCount, syncSize, totalSize, verbose) {
+    if (!verbose || totalCount === 0)
+      return;
+    if (syncCount % Math.ceil(totalCount / 100) !== 0)
+      return;
+    const pct = Math.floor(syncCount / totalCount * 100);
+    console.info(
+      `Progress: ${pct}% (${syncCount}/${totalCount} files, ${syncSize}/${totalSize} bytes)`
+    );
+  }
+};
+
+// libs/js/cue-sdk/src/lib/cue-node.ts
+var BUCKET_RAW2 = "spaces_raw_eu_west6";
+var BUCKET_PROCESSED2 = "spaces_processed_eu_west6";
+var CueNode = class extends Cue {
+  constructor(config) {
+    super(config);
+  }
+  _buildApi(projects) {
+    const storageRaw = (0, import_storage4.getStorage)(this._app, BUCKET_RAW2);
+    const storageProcessed = (0, import_storage4.getStorage)(this._app, BUCKET_PROCESSED2);
+    if (this._isEmulator) {
+      const storageHost = this._endpoints.storageEmulatorHost;
+      const storagePort = this._endpoints.storageEmulatorPort;
+      (0, import_storage4.connectStorageEmulator)(storageRaw, storageHost, storagePort);
+      (0, import_storage4.connectStorageEmulator)(storageProcessed, storageHost, storagePort);
+    }
+    const blob = new CueBlobStorage({ storageRaw, storageProcessed });
+    const syncApi = new CueSyncApi(this.auth, projects, blob, this._endpoints.gatewayUrl);
+    return new CueApi(this.auth, this._endpoints.gatewayUrl, projects, syncApi);
+  }
+};
+
+// apps/desktop/cue-cli/src/helpers/auth.ts
+async function authenticate(emulators, space, key, verbose = false) {
+  if (!key) {
+    key = process.env.CUE_API_KEY;
+    if (!key) {
+      console.error(
+        "API key is required. Provide it via --key option or CUE_API_KEY environment variable."
+      );
+      process.exit(1);
+    }
+  }
+  const cue = new CueNode({
+    apiKey: FIREBASE_CONFIG().apiKey,
+    appId: FIREBASE_CONFIG().appId,
+    measurementId: FIREBASE_CONFIG().measurementId,
+    environment: emulators ? "emulator" : "production"
+  });
+  if (verbose)
+    console.info("Authenticating \u23F3");
+  const user = await cue.auth.signInWithApiKey(key, space);
+  if (verbose)
+    console.info("Authenticated \u2705");
+  const idTokenResult = await user.getIdTokenResult();
+  const role = idTokenResult.claims["role"];
+  const isSuperAdmin = role === "superadmin";
+  return { isSuperAdmin, userId: user.uid };
+}
+
+// apps/desktop/cue-cli/src/cue-cli-compare.ts
+async function compareHandler(options) {
+  const { space, path, verbose, provider, emulators, zip } = options;
+  try {
+    await authenticate(emulators, space, options.key, verbose);
+    if (verbose)
+      console.info("Building compare base \u23F3");
+    const qh = async (query3) => queryHandler(query3, space, emulators);
+    const [localFiles, remoteFiles] = await Promise.all([
+      listLocalFiles(
+        path,
+        provider,
+        verbose,
+        5,
+        IGNORED_LOCAL,
+        HASH_WORKER_PATH,
+        zip
+      ),
+      listRemoteFiles(space, provider, qh, verbose)
+    ]);
+    const unzipPromise = zip ? deleteUnzipped(path) : Promise.resolve();
+    if (zip) {
+      if (verbose)
+        console.info("Started deletion of temp unzipped dirs \u23F3");
+    }
+    const report = await compareLocalRemote(localFiles, remoteFiles);
+    await unzipPromise;
+    if (zip && verbose)
+      console.info("Cleaned up unzipped files \u2705");
+    if (verbose)
+      console.info("Built compare base \u2705");
+    console.log("");
+    console.log("--- Compare Report ---");
+    console.log("");
+    console.log(`Total files: ${report.totalCount}`);
+    console.log(`Total size: ${fileSizePretty(report.totalSize || 0)}`);
+    console.log("");
+    console.log(
+      `Files synchronized: ${report.syncCount} (${(report.synctPctCount * 100).toFixed(2)}%)`
+    );
+    console.log(
+      `Synchronized size: ${fileSizePretty(report.syncSize || 0)} (${(report.synctPctSize * 100).toFixed(2)}%)`
+    );
+    console.log("");
+    if (report.localNotOnRemote) {
+      console.log(
+        `${report.localNotOnRemote.length} files do not exist on remote`
+      );
+      if (verbose && report.localNotOnRemote.length > 0) {
+        for (const f of report.localNotOnRemote) {
+          console.log(
+            "  - " + f.relativePath + " (" + fileSizePretty(f.size || 0) + ")"
+          );
+        }
+      }
+      console.log("");
+    }
+    if (report.localNotOnRemotePathOnly) {
+      console.log(
+        `${report.localNotOnRemotePathOnly.length} file paths do not exist on remote on providerId "${provider}" (file duplicates)`
+      );
+      if (verbose && report.localNotOnRemotePathOnly.length > 0) {
+        for (const f of report.localNotOnRemotePathOnly) {
+          console.log(
+            "  - " + f.relativePath + " (" + fileSizePretty(f.size || 0) + ")"
+          );
+        }
+      }
+      console.log("");
+    }
+    if (report.remoteNotOnLocal) {
+      console.log(`${report.remoteNotOnLocal.length} files do not exist locally`);
+      console.log(
+        "This might expected if the files belong to another provider or have been deleted locally"
+      );
+      if (verbose && report.remoteNotOnLocal.length > 0) {
+        for (const f of report.remoteNotOnLocal) {
+          console.log(
+            "  - " + f.contentUUID + " (" + fileSizePretty(f.size || 0) + ")"
+          );
+        }
+      }
+      console.log("");
+    }
+    if (report.remoteNotOnLocalPathOnly) {
+      console.log(
+        `${report.remoteNotOnLocalPathOnly.length} file paths on providerId "${provider}" do not exist locally`
+      );
+      console.log(
+        "This might expected if the files belong to another provider or have been deleted locally"
+      );
+      if (verbose && report.remoteNotOnLocalPathOnly.length > 0) {
+        for (const f of report.remoteNotOnLocalPathOnly) {
+          console.log(
+            "  - " + f.contentUUID + " (" + fileSizePretty(f.size || 0) + ")"
+          );
+        }
+      }
+      console.log("");
+    }
+  } catch (err) {
+    console.error("Error:", err);
+    process.exit(1);
+  }
+}
+
+// apps/desktop/cue-cli/src/helpers/get-files-containing-substring.ts
+var import_storage5 = require("firebase/storage");
+var import_path4 = require("path");
+var import_promises4 = require("fs/promises");
+async function getFilesContainingSubstring(bucket, subDir = "", subString = "") {
+  const firebase = CueFirebase.getInstance();
+  const storage = bucket === "raw" ? firebase.storageRaw : firebase.storageProcessed;
+  console.log("Fetching files from storage bucket:", bucket, "in subdir:", subDir, "containing substring:", subString);
+  const listResult = await (0, import_storage5.listAll)((0, import_storage5.ref)(storage, subDir));
+  const outputDir = (0, import_path4.join)(process.cwd(), "downloaded_blobs", bucket, subDir);
+  await (0, import_promises4.mkdir)(outputDir, { recursive: true });
+  for (const fileRef of listResult.items) {
+    console.log(fileRef.name);
+    if (subDir && !fileRef.name.includes(subString))
+      continue;
+    const bytes = await (0, import_storage5.getBytes)(fileRef);
+    const outputPath = (0, import_path4.join)(outputDir, fileRef.name);
+    await (0, import_promises4.writeFile)(outputPath, Buffer.from(bytes));
+    console.log(`Downloaded ${fileRef.name} to ${outputPath} \u2705`);
+  }
+}
+
+// apps/desktop/cue-cli/src/cue-cli-dump-processed.ts
+async function dumpProcessedHandler(options) {
+  const { space, verbose, emulators, processor } = options;
+  try {
+    const { isSuperAdmin } = await authenticate(emulators, space, options.key, verbose);
+    if (!isSuperAdmin) {
+      console.error("Sorry - this tool is only for super admin users");
+      process.exit(1);
+    }
+    if (verbose)
+      console.info(`Dumping processed files for processor ${processor} \u23F3`);
+    const files = await getFilesContainingSubstring("processed", `${space}/triples`, processor);
+    console.log(files);
+  } catch (err) {
+    console.error("Error:", err);
+    process.exit(1);
+  }
+}
+
+// apps/desktop/cue-cli/src/helpers/graph-dump.ts
+var import_fs2 = require("fs");
+var import_stream = require("stream");
+var import_fs3 = require("fs");
+var import_zlib = require("zlib");
+var import_promises5 = require("stream/promises");
+var import_promises6 = require("fs/promises");
+var import_auth9 = require("firebase/auth");
+
+// libs/js/size-tools/src/lib/js-size-tools.ts
+function humanFileSize(bytes, si = false, dp = 1) {
+  const thresh = si ? 1e3 : 1024;
+  if (Math.abs(bytes) < thresh) {
+    return bytes + " B";
+  }
+  const units = si ? ["kB", "MB", "GB", "TB", "PB", "EB", "ZB", "YB"] : ["KiB", "MiB", "GiB", "TiB", "PiB", "EiB", "ZiB", "YiB"];
+  let u = -1;
+  const r = 10 ** dp;
+  do {
+    bytes /= thresh;
+    ++u;
+  } while (Math.round(Math.abs(bytes) * r) / r >= thresh && u < units.length - 1);
+  return bytes.toFixed(dp) + " " + units[u];
+}
+
+// apps/desktop/cue-cli/src/helpers/graph-dump.ts
+var import_fs4 = require("fs");
+async function dumpRdfGraphToFileJelly(spaceId, useEmulator = false, verbose = false) {
+  return dumpRdfGraphToFile(
+    spaceId,
+    useEmulator,
+    verbose,
+    `${spaceId}.jelly`,
+    "application/x-jelly-rdf"
+  );
+}
+async function dumpRdfGraphToFile(spaceId, useEmulator = false, verbose = false, outFile, mimeType = "application/n-quads") {
+  const endpoint = useEmulator ? SPARQL_ENDPOINT_EMULATOR : SPARQL_ENDPOINT;
+  const dataUrl = endpoint.replace("/query", "/data");
+  if (verbose)
+    console.info(`Streaming RDF graph \u23F3`);
+  const filePath = outFile || `${spaceId}.nq`;
+  if ((0, import_fs4.existsSync)(filePath) || (0, import_fs4.existsSync)(`${filePath}.gz`)) {
+    if (verbose)
+      console.info(`File ${filePath} already exists, skipping download.`);
+    return mimeType === "application/n-quads" ? `${filePath}.gz` : filePath;
+  }
+  const token = await (0, import_auth9.getAuth)().currentUser?.getIdToken();
+  const res = await fetch(dataUrl, {
+    method: "GET",
+    headers: {
+      "x-project-id": spaceId,
+      authorization: `Bearer ${token}`,
+      Accept: mimeType
+    }
+  });
+  if (!res.ok || !res.body) {
+    throw new Error(`Failed to stream data: ${res.status} ${res.statusText}`);
+  }
+  const fileStream = (0, import_fs2.createWriteStream)(filePath, { flags: "w" });
+  const nodeStream = import_stream.Readable.fromWeb(res.body);
+  let chunkCount = 0;
+  let totalSize = 0;
+  let hasDataTimeout = null;
+  let lastChunkTime = Date.now();
+  nodeStream.on("data", (chunk) => {
+    lastChunkTime = Date.now();
+    chunkCount++;
+    totalSize += chunk.length;
+    if (hasDataTimeout) {
+      clearTimeout(hasDataTimeout);
+    }
+    if (verbose && totalSize >= 10 * 1024 * 1024 && totalSize % (10 * 1024 * 1024) < chunk.length)
+      console.info(
+        `Writing chunk #${chunkCount}, size: ${humanFileSize(totalSize)}`
+      );
+  });
+  const streamTimeout = 3e5;
+  hasDataTimeout = setTimeout(() => {
+    const timeSinceLastChunk = Date.now() - lastChunkTime;
+    if (timeSinceLastChunk > streamTimeout) {
+      console.error(`Stream appears stalled - no data received for ${timeSinceLastChunk}ms`);
+      nodeStream.destroy(new Error("Stream timeout"));
+    }
+  }, streamTimeout);
+  try {
+    await (0, import_promises5.pipeline)(nodeStream, fileStream);
+  } finally {
+    if (hasDataTimeout) {
+      clearTimeout(hasDataTimeout);
+    }
+  }
+  if (verbose)
+    console.info(`Total chunks written: ${chunkCount}, total size: ${humanFileSize(totalSize)}`);
+  if (totalSize === 0) {
+    throw new Error("No data received from server - possible authentication or permission issue");
+  }
+  if (verbose)
+    console.info(`Streamed RDF graph to ${filePath} \u2705`);
+  if (mimeType === "application/n-quads") {
+    if (verbose)
+      console.info(`
+Gzipping to ${filePath}.gz \u23F3`);
+    await _doGzip(filePath);
+    if (verbose)
+      console.info(`Gzipped to ${filePath}.gz \u2705`);
+    return `${filePath}.gz`;
+  }
+  return filePath;
+}
+async function dumpRdfGraphToFileConstruct(spaceId, useEmulator = false, verbose = false, graphIRI, batchSize = 5e4, concurrency = 8, maxRetries = 5, retryDelayMs = 1e3, delayBetweenBatchesMs = 500) {
+  const endpoint = useEmulator ? SPARQL_ENDPOINT_EMULATOR : SPARQL_ENDPOINT;
+  const filePath = `${spaceId}.nq`;
+  const graph = graphIRI !== void 0 ? `<${graphIRI}>` : "?g";
+  const constructQuery = `
+    CONSTRUCT { GRAPH ${graph} { ?s ?p ?o } }
+    WHERE { GRAPH ${graph} { ?s ?p ?o } }
+  `;
+  let offset = 0;
+  const fileStream = (0, import_fs2.createWriteStream)(filePath, { flags: "w" });
+  let hasMore = true;
+  while (hasMore) {
+    const queries = Array.from(
+      { length: concurrency },
+      (_, i) => `${constructQuery} LIMIT ${batchSize} OFFSET ${offset + i * batchSize}`
+    );
+    offset += batchSize * concurrency;
+    const results = await Promise.all(
+      queries.map(
+        (q, idx) => retryWithBackoff(
+          () => _doQuery(q, spaceId, endpoint),
+          maxRetries,
+          retryDelayMs,
+          verbose ? `Batch ${offset - batchSize * concurrency + idx * batchSize}` : void 0
+        )
+      )
+    );
+    const batches = results.filter(Boolean);
+    if (batches.length === 0) {
+      hasMore = false;
+      break;
+    }
+    for (const batch of batches) {
+      fileStream.write(batch.trim() + "\n");
+    }
+    if (verbose)
+      process.stdout.write(`Current offset: ${offset.toLocaleString()}\r`);
+    if (delayBetweenBatchesMs > 0)
+      await new Promise((res) => setTimeout(res, delayBetweenBatchesMs));
+  }
+  fileStream.end();
+  if (verbose)
+    console.info(`
+Gzipping to ${filePath}.gz \u23F3`);
+  await _doGzip(filePath);
+  if (verbose)
+    console.info(`Gzipped to ${filePath}.gz \u2705`);
+  return `${filePath}.gz`;
+}
+async function retryWithBackoff(fn, maxRetries, delayMs, label) {
+  let attempt = 0;
+  let lastErr = null;
+  while (attempt < maxRetries) {
+    try {
+      const result = await fn();
+      if (result !== null && result !== void 0)
+        return result;
+    } catch (err) {
+      lastErr = err;
+    }
+    attempt++;
+    if (label)
+      console.warn(`${label}: Retry ${attempt}/${maxRetries}`);
+    await new Promise(
+      (res) => setTimeout(res, delayMs * Math.pow(2, attempt - 1))
+    );
+  }
+  if (label)
+    console.error(`${label}: Failed after ${maxRetries} retries`, lastErr);
+  return null;
+}
+async function _doGzip(filePath) {
+  const gzFilePath = `${filePath}.gz`;
+  await new Promise((resolve2, reject) => {
+    const gzip = (0, import_zlib.createGzip)();
+    const source = (0, import_fs3.createReadStream)(filePath);
+    const dest = (0, import_fs2.createWriteStream)(gzFilePath);
+    (0, import_promises5.pipeline)(source, gzip, dest).then(resolve2).catch(reject);
+  });
+  await (0, import_promises6.unlink)(filePath);
+}
+async function _doQuery(query3, spaceId, url) {
+  const token = await (0, import_auth9.getAuth)().currentUser?.getIdToken();
+  try {
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "x-project-id": spaceId,
+        authorization: `Bearer ${token}`,
+        "Content-Type": "application/sparql-query",
+        Accept: "application/n-quads"
+      },
+      body: query3
+    });
+    if (!res.ok) {
+      console.error(`Error: ${res.status} ${res.statusText}`);
+      return null;
+    }
+    return await res.text();
+  } catch (e) {
+    console.error(e);
+    return null;
+  }
+}
+
+// apps/desktop/cue-cli/src/helpers/graph-create.ts
+var import_auth10 = require("firebase/auth");
+async function createGraph(id) {
+  const token = await (0, import_auth10.getAuth)().currentUser?.getIdToken();
+  const dataSetUrl = SPARQL_ENDPOINT_EMULATOR.replace("/query", `/$/datasets`);
+  const res = await fetch(dataSetUrl, {
+    method: "POST",
+    headers: {
+      "x-project-id": id,
+      authorization: `Bearer ${token}`,
+      "content-type": "text/turtle"
+    },
+    body: _getTemplate(id)
+  });
+  if (!res.ok) {
+    throw new Error(`Failed to create graph: ${res.statusText}`);
+  }
+}
+function _getTemplate(partition, base = "fuseki-base-new/fuseki") {
+  return `@prefix :       <http://base/#> .
+    @prefix fuseki: <http://jena.apache.org/fuseki#> .
+    @prefix rdfs:   <http://www.w3.org/2000/01/rdf-schema#> .
+    @prefix rdf:    <http://www.w3.org/1999/02/22-rdf-syntax-ns#> .
+    @prefix tdb2:   <http://jena.apache.org/2016/tdb#> .
+    @prefix skos:   <http://www.w3.org/2004/02/skos/core#> .
+    @prefix text:   <http://jena.apache.org/text#> .
+    @prefix qcy:    <${qaecyPrefixes["qcy"]}> .
+    @prefix qcye:  <${qaecyPrefixes["qcy-e"]}> .
+
+
+    :tdb_dataset_readwrite a tdb2:DatasetTDB2;
+        tdb2:location  "${base}/databases/${partition}/tdb";
+        tdb2:unionDefaultGraph true ;
+        tdb2:transactionMode "transactional" ;
+        tdb2:transactionLogType "journal" ;
+        tdb2:blockFileSize "32M" ;
+        tdb2:blockCacheSize "1G" ;
+        tdb2:fileMode "direct" .
+
+    :service_tdb_all  a  fuseki:Service;
+        fuseki:name      "${partition}" ;
+        rdfs:label       "TDB2 ${partition}";
+        fuseki:dataset   :tdb_dataset_readwrite;
+        fuseki:allowedUsers             "admin";
+        fuseki:endpoint  [ fuseki:name       "update";
+                        fuseki:operation  fuseki:update
+                        ];
+        fuseki:endpoint  [ fuseki:name       "query";
+                        fuseki:operation  fuseki:query
+                        ];
+        fuseki:endpoint  [ fuseki:name       "get";
+                        fuseki:operation  fuseki:gsp-r
+                        ];
+        fuseki:endpoint  [ fuseki:name       "shacl";
+                        fuseki:operation  fuseki:shacl
+                        ];
+        fuseki:endpoint  [ fuseki:name       "data";
+                        fuseki:operation  fuseki:gsp-rw
+                        ];
+        fuseki:endpoint  [ fuseki:name       "sparql";
+                        fuseki:operation  fuseki:query
+                        ].`;
+}
+
+// apps/desktop/cue-cli/src/helpers/graph-upload.ts
+var import_auth11 = require("firebase/auth");
+var import_fs5 = require("fs");
+async function uploadToLocalGraph(id, filePath, mimeType = "application/n-quads", zipped = false) {
+  const stream = (0, import_fs5.createReadStream)(filePath);
+  const token = await (0, import_auth11.getAuth)().currentUser?.getIdToken();
+  const dataUrl = SPARQL_ENDPOINT_EMULATOR.replace("/query", "/data");
+  const headers = {
+    "x-project-id": id,
+    authorization: `Bearer ${token}`,
+    "Content-Type": mimeType
   };
+  if (zipped) {
+    headers["Content-Encoding"] = "gzip";
+  }
+  const res = await fetch(dataUrl, {
+    method: "POST",
+    headers,
+    body: stream,
+    duplex: "half"
+  });
+  const text = await res.text();
+  console.log(text);
+  if (!res.ok) {
+    console.error(`Failed to upload graph: ${res.statusText}`);
+    return;
+  }
 }
 
-// apps/desktop/cue-cli/src/helpers/upload-file.ts
-var import_promises6 = require("fs/promises");
-async function uploadFile(file, spaceId, userId, providerId) {
-  const firebase = CueFirebase.getInstance();
-  const rawFileMetadata = uploadedFileMetadata(
-    file.relativePath,
-    spaceId,
-    userId,
-    file.md5,
-    providerId
-  );
-  const storage = firebase.storageRaw;
-  const fileRef = (0, import_storage5.ref)(storage, rawFileMetadata.blob_name);
-  const fileBuffer = await (0, import_promises6.readFile)(file.fullPath);
-  const maxRetries = 3;
-  let attempt = 0;
-  let lastError = null;
-  while (attempt < maxRetries) {
-    try {
-      await new Promise((resolve2, reject) => {
-        const uploadTask = (0, import_storage5.uploadBytesResumable)(fileRef, fileBuffer, {
-          customMetadata: rawFileMetadata
-        });
-        uploadTask.on(
-          "state_changed",
-          null,
-          (error) => {
-            const blobName = rawFileMetadata.blob_name;
-            console.error("[uploadFile] Error uploading file:", {
-              filePath: file.fullPath,
-              relativePath: file.relativePath,
-              md5: file.md5,
-              blobName,
-              blobNameLength: blobName?.length,
-              blobNameIsUnusual: blobName && (blobName.length > 256 || /[^\w\-./]/.test(blobName)),
-              errorCode: error?.code,
-              errorMessage: error?.message,
-              errorPayload: error,
-              fileBufferSize: fileBuffer?.length,
-              rawFileMetadataKeys: Object.keys(rawFileMetadata),
-              rawFileMetadataLength: Object.keys(rawFileMetadata).length,
-              attempt
-            });
-            reject(error);
-          },
-          () => resolve2()
-        );
-        if (!uploadTask) {
-          console.error("[uploadFile] Upload task could not be created:", {
-            filePath: file.fullPath,
-            relativePath: file.relativePath,
-            md5: file.md5,
-            blobName: rawFileMetadata.blob_name,
-            attempt
-          });
-          reject(new Error("Upload task could not be created"));
-        }
-      });
-      lastError = null;
-      break;
-    } catch (err) {
-      lastError = err;
-      attempt++;
-      if (attempt < maxRetries) {
-        console.warn(`[uploadFile] Retry attempt ${attempt} for file: ${file.fullPath}`);
-        await new Promise((res) => setTimeout(res, 1e3 * attempt));
+// apps/desktop/cue-cli/src/cue-cli-dump.ts
+async function dumpHandler(options) {
+  const { space, verbose, emulators, jelly, query: query3, load } = options;
+  try {
+    const { isSuperAdmin } = await authenticate(emulators, space, options.key, verbose);
+    if (!isSuperAdmin) {
+      console.error("Sorry - this tool is only for super admin users");
+      process.exit(1);
+    }
+    if (verbose)
+      console.info("Dumping graph \u23F3");
+    let filePath = "";
+    if (jelly) {
+      if (verbose)
+        console.info("Setting: Jelly format");
+      if (verbose)
+        console.time("Downloaded graph \u2705");
+      filePath = await dumpRdfGraphToFileJelly(space, emulators, verbose);
+      if (verbose)
+        console.timeEnd("Downloaded graph \u2705");
+    } else {
+      if (verbose)
+        console.time("Downloaded and zipped graph \u2705");
+      if (query3) {
+        if (verbose)
+          console.info("Setting: Construct query");
+        filePath = await dumpRdfGraphToFileConstruct(space, emulators, verbose);
+      } else {
+        if (verbose)
+          console.info("Setting: /data endpoint");
+        filePath = await dumpRdfGraphToFile(space, emulators, verbose);
       }
+      if (verbose)
+        console.timeEnd("Downloaded and zipped graph \u2705");
     }
+    console.info(`File written: ${filePath}`);
+    if (load && !emulators) {
+      if (verbose)
+        console.info(`Creating local RDF graph with id: ${space} \u23F3`);
+      await createGraph(space);
+      if (verbose)
+        console.info(`Created local RDF graph \u2705`);
+      if (verbose)
+        console.info(`Uploading file to local RDF graph \u23F3`);
+      await uploadToLocalGraph(
+        space,
+        filePath,
+        jelly ? "application/jelly+json" : "application/n-quads",
+        jelly ? false : true
+      );
+      if (verbose)
+        console.info(`Uploaded file to local RDF graph \u2705`);
+    }
+  } catch (err) {
+    console.error("Error:", err);
+    process.exit(1);
   }
-  if (lastError) {
-    throw lastError;
-  }
-  return rawFileMetadata;
 }
 
-// apps/desktop/cue-cli/src/helpers/upload-file-rdf.ts
+// apps/desktop/cue-cli/src/helpers/repair-remote-ttl.ts
 var import_storage6 = require("firebase/storage");
-async function uploadFileRDF(file, rawFileMetadata, verbose) {
+async function repairRemoteTTL(space, subString, regex, substituteString) {
   const firebase = CueFirebase.getInstance();
-  const ttlMetadata = turtleFileMetadata(
-    rawFileMetadata.blob_name,
-    SERVICE_ID,
-    file.locationUUID
-  );
-  const writer = fileLocationRaw(rawFileMetadata, file.size);
-  const namespace = `${RDF_BASE}${ttlMetadata.space_id}/`;
-  const triples = await serializeRDF(namespace, writer);
   const storage = firebase.storageProcessed;
-  const fileRef = (0, import_storage6.ref)(storage, ttlMetadata.blob_name);
-  const existing = await (0, import_storage6.getMetadata)(fileRef).catch(() => null);
-  if (existing) {
+  console.log("Fetching files from storage bucket 'triples' containing substring:", subString);
+  const listResult = await (0, import_storage6.listAll)((0, import_storage6.ref)(storage, `${space}/triples`));
+  for (const fileRef of listResult.items) {
+    if (subString && !fileRef.name.match(subString))
+      continue;
+    const stream = await (0, import_storage6.getStream)(fileRef);
+    const reader = stream.getReader();
+    const chunks = [];
+    let done = false;
+    while (!done) {
+      const { value, done: streamDone } = await reader.read();
+      if (value) {
+        chunks.push(value);
+      }
+      done = streamDone;
+    }
+    let fileContent = Buffer.concat(chunks).toString("utf8");
+    let modified = false;
+    if (substituteString && regex) {
+      const newContent = fileContent.replace(regex, substituteString);
+      if (newContent !== fileContent) {
+        fileContent = newContent;
+        modified = true;
+      }
+    }
+    if (modified) {
+      const buffer = Buffer.from(fileContent, "utf8");
+      let existingMetadata = {};
+      try {
+        existingMetadata = await (0, import_storage6.getMetadata)(fileRef);
+      } catch (err) {
+        console.warn(`Could not fetch metadata for ${fileRef.name}, proceeding with default.`);
+      }
+      const customMetadata = { ...existingMetadata.customMetadata || {}, stored: "False" };
+      const metadata = { customMetadata };
+      await (0, import_storage6.uploadBytesResumable)((0, import_storage6.ref)(storage, `${space}/triples/${fileRef.name}`), buffer, metadata);
+      console.log(`Fixed ${fileRef.name} \u2705`);
+    } else {
+      console.log(`No changes for ${fileRef.name}`);
+    }
+  }
+}
+
+// apps/desktop/cue-cli/src/cue-cli-repair-ttl.ts
+async function repairTtlHandler(options) {
+  const { space, verbose, emulators, processor, from, to } = options;
+  try {
+    const { isSuperAdmin } = await authenticate(emulators, space, options.key, verbose);
+    if (!isSuperAdmin) {
+      console.error("Sorry - this tool is only for super admin users");
+      process.exit(1);
+    }
     if (verbose)
-      console.info(
-        `Graph data ${file.relativePath} already exists but still in loading queue - skipping \u26A0\uFE0F`
-      );
-    return;
+      console.info(`Repairing TTL files for processor ${processor} \u23F3`);
+    await repairRemoteTTL(space, processor, new RegExp(from, "g"), to);
+  } catch (err) {
+    console.error("Error:", err);
+    process.exit(1);
   }
-  await (0, import_storage6.uploadBytes)(fileRef, new Uint8Array(Buffer.from(triples, "utf-8")), {
-    customMetadata: ttlMetadata
-  });
 }
 
 // apps/desktop/cue-cli/src/helpers/emit-idle.ts
@@ -5912,15 +6834,36 @@ async function publishMessage(topicName, data, useEmulator) {
 // apps/desktop/cue-cli/src/cue-cli-sync.ts
 var import_promises7 = require("fs/promises");
 var import_fs6 = require("fs");
-var import_path4 = require("path");
+var import_path5 = require("path");
+var readline = __toESM(require("readline"));
+function askConfirm(question) {
+  const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+  return new Promise((resolve2) => {
+    rl.question(question, (answer) => {
+      rl.close();
+      resolve2(answer.trim().toLowerCase() === "y");
+    });
+  });
+}
 async function syncHandler(options) {
   const { space, path, verbose, provider, emulators, zip } = options;
   try {
-    const { userId } = await authenticate(emulators, options.key, verbose);
+    const cue = new CueNode({
+      apiKey: FIREBASE_CONFIG().apiKey,
+      appId: FIREBASE_CONFIG().appId,
+      measurementId: FIREBASE_CONFIG().measurementId,
+      environment: emulators ? "emulator" : "production"
+    });
+    const key = options.key ?? process.env.CUE_API_KEY;
+    if (!key) {
+      console.error(
+        "API key is required. Provide it via --key option or CUE_API_KEY environment variable."
+      );
+      process.exit(1);
+    }
     if (verbose)
       console.info("Building sync base \u23F3");
-    const qh = async (query) => queryHandler(query, space, emulators);
-    const resolvedPath = (0, import_path4.resolve)(path);
+    const resolvedPath = (0, import_path5.resolve)(path);
     const pathStat = await (0, import_promises7.stat)(resolvedPath);
     const isFile = pathStat.isFile();
     let localFiles;
@@ -5928,18 +6871,20 @@ async function syncHandler(options) {
       if (verbose)
         console.info(`Path is a file, syncing single file: ${resolvedPath}`);
       const md5 = await fromReadStream((0, import_fs6.createReadStream)(resolvedPath));
-      const relativePath = (0, import_path4.basename)(resolvedPath);
+      const relativePath = (0, import_path5.basename)(resolvedPath);
       const contentUUID = contextBasedGuid(md5);
       const locationUUID = generateFileUUID(relativePath, provider);
-      localFiles = [{
-        relativePath,
-        fullPath: resolvedPath,
-        md5,
-        contentUUID,
-        locationUUID,
-        mtimeMs: pathStat.mtimeMs,
-        size: pathStat.size
-      }];
+      localFiles = [
+        {
+          relativePath,
+          fullPath: resolvedPath,
+          md5,
+          contentUUID,
+          locationUUID,
+          mtimeMs: pathStat.mtimeMs,
+          size: pathStat.size
+        }
+      ];
     } else {
       localFiles = await listLocalFiles(
         path,
@@ -5951,89 +6896,33 @@ async function syncHandler(options) {
         zip
       );
     }
-    const remoteFiles = await listRemoteFiles(space, provider, qh, verbose);
-    const report = await compareLocalRemote(localFiles, remoteFiles);
-    if (verbose) {
-      console.info("Built sync base \u2705");
-      console.info("");
-      console.info(`Total local files: ${localFiles.length}`);
-      console.info(`Total remote files: ${remoteFiles.length}`);
-      console.info(
-        `Total files to sync: ${report.localNotOnRemote.length + report.localNotOnRemotePathOnly.length}`
-      );
-      console.info("");
-    }
-    let syncCount = report.syncCount;
-    let syncSize = report.syncSize;
-    if (report.synctPctCount !== 0 && verbose) {
-      console.info(
-        `Synced percentage: ${Math.round(
-          report.synctPctCount * 100
-        )} % ( ${syncCount}/${report.totalCount} files )`
-      );
-      console.info(
-        `Synchronized size:: ${Math.round(
-          report.synctPctSize * 100
-        )}% ( ${fileSizePretty(syncSize)}/${fileSizePretty(report.totalSize)} )`
-      );
-      console.info("");
-    }
-    if (verbose && report.localNotOnRemote.length)
-      console.info("Syncing missing files \u23F3");
-    let rdfWritten = false;
-    let failedUploads = 0;
-    for (const file of report.localNotOnRemote) {
-      let rawFileMetadata;
-      try {
-        rawFileMetadata = await uploadFile(file, space, userId, provider);
-        await uploadFileRDF(file, rawFileMetadata, verbose);
-        syncCount += 1;
-        syncSize += file.size || 0;
-        const pct = Math.floor(syncCount / report.totalCount * 100);
-        if (verbose && report.totalCount > 0 && syncCount % Math.ceil(report.totalCount / 100) === 0) {
-          console.info(
-            `Progress: ${pct}% (${syncCount}/$${report.totalCount} files, ${fileSizePretty(syncSize)}/${fileSizePretty(
-              report.totalSize
-            )})`
-          );
-        }
-        rdfWritten = true;
-      } catch (err) {
-        failedUploads += 1;
-        console.error(`[syncHandler] Failed to upload file: ${file.fullPath}`);
-        if (verbose) {
-          console.error("[syncHandler] Upload error details:", err);
-        }
-        continue;
-      }
+    if (verbose)
+      console.info("Built sync base \u2705\n");
+    const costRecords = await cue.api.sync.scanCost(localFiles);
+    const totalUnits = costRecords.reduce((sum, r) => sum + r.units, 0);
+    console.info("Cost estimate:");
+    for (const r of costRecords) {
+      console.info(`  .${r.ext}: ${r.count} file(s) \u2192 ${r.units} unit(s)`);
     }
-    const zipDeletePromise = zip && !isFile ? deleteUnzipped(path) : Promise.resolve();
-    if (verbose && report.localNotOnRemotePathOnly.length)
-      console.info(
-        `Starting sync of missing file locations (on provider "${provider}") \u23F3`
-      );
-    for (const file of report.localNotOnRemotePathOnly) {
-      const rawFileMetadata = uploadedFileMetadata(
-        file.relativePath,
-        space,
-        userId,
-        file.md5,
-        provider
-      );
-      await uploadFileRDF(file, rawFileMetadata, verbose);
-      syncCount += 1;
-      syncSize += file.size || 0;
-      const pct = Math.floor(syncCount / report.totalCount * 100);
-      if (verbose && report.totalCount > 0 && syncCount % Math.ceil(report.totalCount / 100) === 0) {
-        console.info(
-          `Progress: ${pct}% (${syncCount}/$${report.totalCount} files, ${fileSizePretty(syncSize)}/${fileSizePretty(
-            report.totalSize
-          )})`
-        );
-      }
-      rdfWritten = true;
+    console.info(`  Total: ${totalUnits} unit(s) across ${localFiles.length} file(s)
+`);
+    const confirmed = await askConfirm("Continue with sync? (y/n) ");
+    if (!confirmed) {
+      console.info("Sync cancelled.");
+      process.exit(0);
     }
-    if (rdfWritten && emulators) {
+    if (verbose)
+      console.info("Authenticating \u23F3");
+    const user = await cue.auth.signInWithApiKey(key, space);
+    if (verbose)
+      console.info("Authenticated \u2705\n");
+    const result = await cue.api.sync.sync(localFiles, {
+      spaceId: space,
+      providerId: provider,
+      userId: user.uid,
+      verbose
+    });
+    if (result.rdfWritten && emulators) {
       if (verbose) {
         console.info("");
         console.info(`Throwing RDF_WRITING_IDLE topic (only in emulators) \u23F3`);
@@ -6049,18 +6938,23 @@ async function syncHandler(options) {
           console.warn("Continuing despite PubSub error in emulator mode...");
       }
     }
+    const zipDeletePromise = zip && !isFile ? deleteUnzipped(path) : Promise.resolve();
     await zipDeletePromise;
     if (zip && verbose)
       console.info("Cleaned up unzipped files \u2705");
     if (verbose) {
       console.info("");
+      console.info(
+        `Synced: ${result.syncCount}/${result.totalCount} files (${fileSizePretty(result.syncSize)}/${fileSizePretty(result.totalSize)})`
+      );
       console.info(`Sync finished \u{1F680}\u{1F680}\u{1F680}`);
-      if (failedUploads > 0) {
-        console.warn(`Total files failed to upload: ${failedUploads}`);
+      if (result.failedUploads > 0) {
+        console.warn(`Total files failed to upload: ${result.failedUploads}`);
       }
     }
+    process.exit(0);
   } catch (err) {
-    console.error("Error:", err);
+    console.error("[syncHandler] Unexpected error:", err);
     process.exit(1);
   }
 }
@@ -6070,22 +6964,22 @@ var import_fs7 = require("fs");
 var import_zlib2 = require("zlib");
 
 // libs/js/rdf-tools/src/lib/nq-to-nt.ts
-var import_n35 = require("n3");
-var { quad, defaultGraph } = import_n35.DataFactory;
+var import_n36 = require("n3");
+var { quad, defaultGraph } = import_n36.DataFactory;
 
 // libs/js/rdf-tools/src/lib/remove-rdf-star.ts
-var import_n36 = require("n3");
+var import_n37 = require("n3");
 var import_stream2 = require("stream");
 function isRDFStarTerm(term) {
   return term.termType === "Quad";
 }
 function removeRDFStar(inputStream, starCount) {
-  const parser = new import_n36.Parser({ format: "N-Quads*" });
+  const parser = new import_n37.Parser({ format: "N-Quads*" });
   const outputStream = new import_stream2.PassThrough();
-  const writer = new import_n36.StreamWriter({ format: "N-Quads" });
+  const writer = new import_n37.StreamWriter({ format: "N-Quads" });
   writer.pipe(outputStream);
   let count = 0;
-  parser.parse(inputStream, (error, quad2, prefixes3) => {
+  parser.parse(inputStream, (error, quad2, prefixes4) => {
     if (error) {
       outputStream.emit("error", error);
       writer.end();
@@ -6153,11 +7047,11 @@ async function utilRemoveRdfStarHandler(options) {
 var import_fs8 = require("fs");
 
 // libs/js/rdf-compare/src/lib/js-rdf-compare.ts
-var import_n37 = require("n3");
+var import_n38 = require("n3");
 var import_jsonld = require("jsonld");
 function parseTurtle(content) {
   return new Promise((resolve2, reject) => {
-    const parser = new import_n37.Parser({ format: "Turtle" });
+    const parser = new import_n38.Parser({ format: "Turtle" });
     const quads = [];
     parser.parse(content, (error, quad2) => {
       if (error)
@@ -6171,7 +7065,7 @@ function parseTurtle(content) {
 }
 function quadsToNQuads(quads) {
   return new Promise((resolve2, reject) => {
-    const writer = new import_n37.Writer({ format: "N-Quads" });
+    const writer = new import_n38.Writer({ format: "N-Quads" });
     writer.addQuads(quads);
     writer.end((error, result) => {
       if (error)
@@ -6248,10 +7142,10 @@ Triples only in file 2 (${result.triplesOnlyInFile2.size}):`);
 // apps/desktop/cue-cli/src/main.ts
 var packageJson;
 try {
-  packageJson = JSON.parse((0, import_fs9.readFileSync)((0, import_path5.join)(__dirname, "package.json"), "utf8"));
+  packageJson = JSON.parse((0, import_fs9.readFileSync)((0, import_path6.join)(__dirname, "package.json"), "utf8"));
 } catch {
   try {
-    packageJson = JSON.parse((0, import_fs9.readFileSync)((0, import_path5.join)(__dirname, "../package.json"), "utf8"));
+    packageJson = JSON.parse((0, import_fs9.readFileSync)((0, import_path6.join)(__dirname, "../package.json"), "utf8"));
   } catch {
     packageJson = { version: "0.0.0" };
     console.warn("Could not find package.json, using fallback version");