@qaecy/cue-cli 0.0.34 → 0.0.36

package/main.js

@@ -29,6 +29,223 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
   mod
 ));
 
+// libs/js/id-builders/src/lib/id-builders.ts
+function contextBasedGuid(contextString, verbose = false) {
+  const namespace = "daca0510-72b5-48ba-9091-b918ca18136b";
+  contextString = replaceSpecialChars(contextString, verbose);
+  return (0, import_uuid2.v5)(contextString, namespace);
+}
+function replaceSpecialChars(str, verbose = false) {
+  let result = str;
+  for (const char in replacements) {
+    result = result.replace(new RegExp(char, "g"), replacements[char]);
+  }
+  if (verbose && result !== str)
+    console.info(`${str} -> ${result}`);
+  return result;
+}
+function generateFileUUID(filepath, providerId = "") {
+  return contextBasedGuid(`${providerId}${filepath}`);
+}
+var import_uuid2, replacements;
+var init_id_builders = __esm({
+  "libs/js/id-builders/src/lib/id-builders.ts"() {
+    import_uuid2 = require("uuid");
+    replacements = {
+      "\xE4": "ae",
+      "a\u0308": "ae",
+      "\xC4": "AE",
+      "\xF6": "oe",
+      "\xD6": "OE",
+      "\xFC": "ue",
+      "u\u0308": "ue",
+      "\xDC": "UE",
+      "U\u0308": "UE",
+      "\xDF": "ss",
+      "\xE6": "ae",
+      "\xC6": "AE",
+      "\xF8": "oe",
+      "\xD8": "OE",
+      "\xE5": "aa",
+      "\xC5": "AA",
+      "\xE1": "a",
+      "\xC1": "A",
+      "\xF0": "d",
+      "\xD0": "D",
+      "\xE9": "e",
+      "\xC9": "E",
+      "\xED": "i",
+      "\xCD": "I",
+      "\xF3": "o",
+      "\xD3": "O",
+      "\xFA": "u",
+      "\xDA": "U",
+      "\xFD": "y",
+      "\xDD": "Y",
+      "\xFE": "th",
+      "\xDE": "Th"
+    };
+  }
+});
+
+// libs/js/id-builders/src/lib/id-extractor.ts
+var extractIdsFromPath, extractIdsFromRawPath, extractIdsFromPathDerived;
+var init_id_extractor = __esm({
+  "libs/js/id-builders/src/lib/id-extractor.ts"() {
+    extractIdsFromPath = (filePath) => {
+      if (filePath.startsWith("/")) {
+        filePath = filePath.slice(1);
+      }
+      const pathParts = filePath.split("/");
+      const projectId = pathParts[0];
+      const fileName = pathParts.pop();
+      let documentUUID = "";
+      let suffix = ".";
+      let processor = "";
+      let fileUUID;
+      if (fileName !== void 0) {
+        const fnParts = fileName.split("_");
+        documentUUID = fnParts[0];
+        if (documentUUID.includes("?"))
+          documentUUID = documentUUID.split("?")[0];
+        let processorPart = fnParts[1];
+        if (fnParts.length === 3) {
+          fileUUID = fnParts[1];
+          processorPart = fnParts[2];
+        }
+        suffix += processorPart.split(".").pop()?.toLowerCase() ?? "";
+        processor = processorPart.split(".")[0] ?? "";
+      }
+      const identifier = fileUUID !== void 0 ? `${documentUUID}_${fileUUID}` : documentUUID;
+      return { projectId, identifier, suffix, processor, documentUUID, fileUUID };
+    };
+    extractIdsFromRawPath = (filePath) => {
+      if (filePath.startsWith("/")) {
+        filePath = filePath.slice(1);
+      }
+      const pathParts = filePath.split("/");
+      const projectId = pathParts[0];
+      const fileName = pathParts.pop() ?? "";
+      const suffix = `.${fileName.split(".").pop()?.toLowerCase()}`;
+      const documentUUID = fileName.replace(/\.[^.]+$/, "");
+      return { projectId, documentUUID, suffix };
+    };
+    extractIdsFromPathDerived = (filePath) => {
+      if (filePath.startsWith("/")) {
+        filePath = filePath.slice(1);
+      }
+      const pathParts = filePath.split("/");
+      const projectId = pathParts[0];
+      const dir = pathParts[1];
+      let identifier = pathParts[2];
+      if (identifier.includes("?"))
+        identifier = identifier.split("?")[0];
+      if (identifier.includes("."))
+        identifier = identifier.replace(/\.[^.]+$/, "");
+      const fileName = pathParts.pop() ?? "";
+      const suffix = `.${fileName.split(".").pop()?.toLowerCase()}`;
+      const documentUUID = fileName.replace(/\.[^.]+$/, "");
+      return { projectId, documentUUID, suffix, identifier, dir };
+    };
+  }
+});
+
+// libs/js/id-builders/src/lib/id-validator.ts
+var isValidUUID;
+var init_id_validator = __esm({
+  "libs/js/id-builders/src/lib/id-validator.ts"() {
+    isValidUUID = (uuid) => {
+      const uuidRegex = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+      return uuidRegex.test(uuid);
+    };
+  }
+});
+
+// libs/js/id-builders/src/lib/md5-builder.ts
+async function fromString(text) {
+  return new Promise((resolve2) => {
+    const spark = new import_spark_md5.default();
+    spark.append(text);
+    const hash = spark.end();
+    resolve2(hash);
+  });
+}
+async function fromBuffer(file) {
+  return new Promise((resolve2) => {
+    const spark = new import_spark_md5.default.ArrayBuffer();
+    spark.append(file);
+    const hash = spark.end();
+    resolve2(hash);
+  });
+}
+async function fromReadStream(readStream) {
+  return new Promise((resolve2, reject) => {
+    const spark = new import_spark_md5.default.ArrayBuffer();
+    readStream.on("data", (chunk) => {
+      spark.append(chunk);
+    });
+    readStream.on("end", () => {
+      resolve2(spark.end());
+    });
+    readStream.on("error", (err) => reject(err));
+  });
+}
+async function fromFile(file, verbose = false) {
+  return new Promise((resolve2, reject) => {
+    const blobSlice = File.prototype.slice, chunkSize = 2097152, chunks = Math.ceil(file.size / chunkSize), spark = new import_spark_md5.default.ArrayBuffer(), fileReader = new FileReader();
+    let currentChunk = 0;
+    fileReader.onload = function(e) {
+      if (verbose)
+        console.log("read chunk nr", currentChunk + 1, "of", chunks);
+      spark.append(e.target.result);
+      currentChunk++;
+      if (currentChunk < chunks) {
+        loadNext();
+      } else {
+        const hash = spark.end();
+        resolve2(hash);
+      }
+    };
+    fileReader.onerror = function() {
+      reject("Building MD5 failed");
+    };
+    function loadNext() {
+      const start = currentChunk * chunkSize, end = start + chunkSize >= file.size ? file.size : start + chunkSize;
+      fileReader.readAsArrayBuffer(blobSlice.call(file, start, end));
+    }
+    loadNext();
+  });
+}
+var import_spark_md5;
+var init_md5_builder = __esm({
+  "libs/js/id-builders/src/lib/md5-builder.ts"() {
+    import_spark_md5 = __toESM(require("spark-md5"));
+  }
+});
+
+// libs/js/id-builders/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  contextBasedGuid: () => contextBasedGuid,
+  extractIdsFromPath: () => extractIdsFromPath,
+  extractIdsFromPathDerived: () => extractIdsFromPathDerived,
+  extractIdsFromRawPath: () => extractIdsFromRawPath,
+  fromBuffer: () => fromBuffer,
+  fromFile: () => fromFile,
+  fromReadStream: () => fromReadStream,
+  fromString: () => fromString,
+  generateFileUUID: () => generateFileUUID,
+  isValidUUID: () => isValidUUID
+});
+var init_src = __esm({
+  "libs/js/id-builders/src/index.ts"() {
+    init_id_builders();
+    init_id_extractor();
+    init_id_validator();
+    init_md5_builder();
+  }
+});
+
 // libs/js/sync-tools/src/lib/helpers/worker-pool.js
 var worker_pool_exports = {};
 __export(worker_pool_exports, {
@@ -91,16 +308,92 @@ var init_worker_pool = __esm({
   }
 });
 
+// libs/js/sync-tools/src/lib/helpers/md5-builder-node.ts
+var md5_builder_node_exports = {};
+__export(md5_builder_node_exports, {
+  md5FromWorker: () => md5FromWorker,
+  md5NoWorker: () => md5NoWorker
+});
+async function md5FromWorker(filePaths, hashWorkerPath, verbose = false, logIntervalPct = 1) {
+  const { WorkerPool: WorkerPool2 } = await Promise.resolve().then(() => (init_worker_pool(), worker_pool_exports));
+  const pool = new WorkerPool2(hashWorkerPath);
+  const hashes = filePaths.map((filePath) => pool.hashFile(filePath));
+  if (verbose) {
+    let completed = 0;
+    let lastPct = 0;
+    hashes.forEach(
+      (promise) => promise.then(() => {
+        completed++;
+        const pct = Math.floor(completed / filePaths.length * 100);
+        if (pct - lastPct >= logIntervalPct) {
+          lastPct = pct;
+          console.info(`MD5 progress: ${completed}/${filePaths.length} (${pct}%)`);
+        }
+      })
+    );
+  }
+  const ret = await Promise.all(hashes);
+  await pool.close();
+  return ret;
+}
+async function md5NoWorker(filePaths, verbose) {
+  if (verbose)
+    console.info(`Calculating MD5 hashes for ${filePaths.length} files...`);
+  const concurrency = 50;
+  const hashes = [];
+  for (let i = 0; i < filePaths.length; i += concurrency) {
+    const chunk = filePaths.slice(i, i + concurrency);
+    const chunkHashes = await Promise.all(
+      chunk.map(async (f) => {
+        const { createReadStream: createReadStream5 } = await import("fs");
+        const { fromReadStream: fromReadStream2 } = await Promise.resolve().then(() => (init_src(), src_exports));
+        const stream = createReadStream5(f);
+        return fromReadStream2(stream);
+      })
+    );
+    hashes.push(...chunkHashes);
+    if (verbose) {
+      const pct = Math.min(
+        100,
+        Math.round((i + chunk.length) / filePaths.length * 100)
+      );
+      console.info(
+        `MD5 progress: ${pct}% (${i + chunk.length}/${filePaths.length})`
+      );
+    }
+  }
+  if (verbose)
+    console.info(`Calculated MD5 hashes for ${filePaths.length} files.`);
+  return hashes;
+}
+var init_md5_builder_node = __esm({
+  "libs/js/sync-tools/src/lib/helpers/md5-builder-node.ts"() {
+  }
+});
+
 // apps/desktop/cue-cli/src/main.ts
 var import_commander = require("commander");
-var import_fs9 = require("fs");
-var import_path6 = require("path");
+var import_fs8 = require("fs");
+var import_path4 = require("path");
 
 // apps/desktop/cue-cli/src/variables.ts
 var import_path = require("path");
-var EMULATOR_API_GATEWAY_PORT = process.env.CUE_EMULATOR_API_GATEWAY_PORT ?? "8093";
+var EMULATOR_API_GATEWAY_PORT = process.env.CUE_EMULATOR_API_GATEWAY_PORT ?? "18093";
 var EMULATOR_API_GATEWAY_BASE = `http://localhost:${EMULATOR_API_GATEWAY_PORT}`;
 var TOKEN_ENDPOINT_EMULATOR = `${EMULATOR_API_GATEWAY_BASE}/token`;
+var EMULATOR_AUTH_PORT = process.env.CUE_EMULATOR_AUTH_PORT ?? "9099";
+var EMULATOR_AUTH_HOST = `localhost:${EMULATOR_AUTH_PORT}`;
+var EMULATOR_STORAGE_PORT = parseInt(process.env.CUE_EMULATOR_STORAGE_PORT ?? "9199", 10);
+var EMULATOR_FIRESTORE_PORT = parseInt(process.env.CUE_EMULATOR_FIRESTORE_PORT ?? "8080", 10);
+var getEmulatorEndpoints = () => ({
+  gatewayUrl: EMULATOR_API_GATEWAY_BASE,
+  tokenUrl: TOKEN_ENDPOINT_EMULATOR,
+  authEmulatorUrl: `http://${EMULATOR_AUTH_HOST}`,
+  storageEmulatorHost: "localhost",
+  storageEmulatorPort: EMULATOR_STORAGE_PORT,
+  firestoreEmulatorHost: "localhost",
+  firestoreEmulatorPort: EMULATOR_FIRESTORE_PORT
+});
 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`;
@@ -224,61 +517,761 @@ var COLLECTION_USER_TERMS_ACCEPT = "userTermsAcceptance";
 var COLLECTION_TIERS = "tiers";
 
 // libs/js/firebase/src/lib/firebase.ts
-var import_storage = require("firebase/storage");
-var import_firestore = require("firebase/firestore");
+var import_storage2 = require("firebase/storage");
+var import_firestore2 = require("firebase/firestore");
 var import_auth = require("firebase/auth");
 var import_app = require("firebase/app");
-var CueFirebase = class _CueFirebase {
-  static _instance;
-  _muted = true;
-  _emulator = false;
-  constructor(config, auth, muted = false) {
-    this._muted = muted;
-    this._init(config, auth);
-  }
-  static getInstance(config, auth, muted = false) {
-    if (!_CueFirebase._instance) {
-      if (config === void 0)
-        throw new Error("Config needed for instantiation!");
-      if (!muted)
-        console.info("Creating new CueFirebase instance");
-      _CueFirebase._instance = new _CueFirebase(config, auth, muted);
+
+// 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;
     }
-    return _CueFirebase._instance;
   }
-  _functionAcceptTerms;
-  _functionEmitMessage;
-  _functionGetUserInfo;
-  _functionChangeUserRoleOnProject;
-  _functionInviteUserToProject;
-  _functionRemoveUserFromProject;
-  _storageProcessed;
-  _storageRaw;
-  _storageLogs;
-  _storageChatSessions;
-  _storagePublic;
-  _storagePersistence;
-  _collectionChatSessions;
-  _collectionOrganizations;
-  _collectionProjects;
-  _collectionRDFWriting;
-  _collectionAPIKeys;
-  _collectionUsers;
-  _collectionUserTermsAcceptance;
-  _collectionTiers;
-  _auth;
-  _app;
-  get functionAcceptTerms() {
-    return this._functionAcceptTerms;
+  async ping() {
+    const query4 = "ASK { }";
+    const res = await this.query(query4);
+    return res.boolean;
   }
-  get functionEmitMessage() {
-    return this._functionEmitMessage;
+  async query(query4, 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: query4 })
+      });
+    } catch (err) {
+      throw new Error(
+        `Fuseki is not accessible at ${this.queryEndpoint}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`Fuseki query failed (HTTP ${res.status}): ${body}`);
+    }
+    return await res.json();
   }
-  get functionGetUserInfo() {
-    return this._functionGetUserInfo;
+  async subset(query4, 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: query4 })
+    });
+    if (accept === "application/ld+json") {
+      return await res.json();
+    }
+    return await res.text();
   }
-  get functionInviteUserToProject() {
-    return this._functionInviteUserToProject;
+  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()
+    };
+  }
+};
+
+// libs/js/databases/src/lib/graph/qlever.ts
+var import_n3 = require("n3");
+var QLeverLockedError = class extends Error {
+  constructor(body) {
+    super(`QLever is locked (rebuild in progress): ${body}`);
+    this.name = "QLeverLockedError";
+  }
+};
+var QLever = class _QLever {
+  queryEndpoint;
+  updateEndpoint;
+  dataEndpoint;
+  baseHeaders;
+  static RELEVANT_HEADER_KEYS = [
+    "authorization",
+    "Authorization",
+    "x-project-id",
+    "x-user-roles"
+    // add more if needed
+  ];
+  /** Max retries on 423 Locked (rebuild in progress). */
+  static LOCKED_MAX_RETRIES = parseInt(
+    (typeof process !== "undefined" ? process.env["QLEVER_LOCKED_MAX_RETRIES"] : void 0) ?? "10",
+    10
+  );
+  /** Base delay (ms) for exponential backoff on 423. */
+  static LOCKED_BASE_DELAY_MS = parseInt(
+    (typeof process !== "undefined" ? process.env["QLEVER_LOCKED_BASE_DELAY_MS"] : void 0) ?? "2000",
+    10
+  );
+  /**
+   * Retry an async write operation on 423 Locked with exponential backoff + jitter.
+   * 423 means qlever accessor has an ongoing rebuild; we should wait and retry.
+   */
+  static async _retryOnLocked(fn) {
+    const maxRetries = _QLever.LOCKED_MAX_RETRIES;
+    const baseDelayMs = _QLever.LOCKED_BASE_DELAY_MS;
+    let lastError;
+    for (let attempt = 0; attempt <= maxRetries; attempt++) {
+      try {
+        return await fn();
+      } catch (err) {
+        lastError = err;
+        if (err instanceof QLeverLockedError && attempt < maxRetries) {
+          const jitter = 0.5 + Math.random();
+          const delay = baseDelayMs * Math.pow(2, attempt) * jitter;
+          await new Promise((resolve2) => setTimeout(resolve2, delay));
+          continue;
+        }
+        throw err;
+      }
+    }
+    throw lastError;
+  }
+  constructor(graphOptions) {
+    this.queryEndpoint = graphOptions.queryEndpoint;
+    this.updateEndpoint = graphOptions.updateEndpoint;
+    this.dataEndpoint = this.updateEndpoint.replace(/\/update$/, "/data");
+    this.baseHeaders = Object.fromEntries(
+      Object.entries(graphOptions.originalHeaders || {}).filter(
+        ([key]) => _QLever.RELEVANT_HEADER_KEYS.includes(key)
+      )
+    );
+    this.baseHeaders["x-user-roles"] = "admin";
+  }
+  async ping() {
+    const query4 = "ASK { }";
+    const res = await this.query(query4);
+    return res.boolean;
+  }
+  async query(query4, 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: query4 })
+      });
+    } catch (err) {
+      throw new Error(
+        `QLever is not accessible at ${this.queryEndpoint}: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+    if (!res.ok) {
+      const body = await res.text();
+      throw new Error(`QLever query failed (HTTP ${res.status}): ${body}`);
+    }
+    return await res.json();
+  }
+  async subset(query4, 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: query4 })
+    });
+    return await res.text();
+  }
+  async update(update) {
+    return _QLever._retryOnLocked(async () => {
+      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();
+        if (res.status === 423)
+          throw new QLeverLockedError(body);
+        throw new Error(`SPARQL update failed (HTTP ${res.status}): ${body}`);
+      }
+      return await res.json();
+    });
+  }
+  /**
+   * Insert quads via the /data endpoint, grouped by named graph.
+   * This is preferred over SPARQL INSERT DATA for QLever because
+   * the /data endpoint correctly registers named graphs in the index.
+   */
+  async insertData(quads) {
+    await this._postToDataEndpoint(quads, this.dataEndpoint);
+  }
+  /**
+   * Delete quads via the /data/delete endpoint, grouped by named graph.
+   */
+  async deleteData(quads) {
+    await this._postToDataEndpoint(quads, `${this.dataEndpoint}/delete`);
+  }
+  async _postToDataEndpoint(quads, baseUrl) {
+    const nquads = await this._quadsToNQuads(quads);
+    const body = await _gzip(Buffer.from(nquads, "utf-8"));
+    await _QLever._retryOnLocked(async () => {
+      const res = await fetch(baseUrl, {
+        method: "POST",
+        headers: {
+          ...this.baseHeaders,
+          "Content-Type": "application/n-quads",
+          "Content-Encoding": "gzip"
+        },
+        body
+      });
+      if (!res.ok) {
+        const text = await res.text();
+        if (res.status === 423)
+          throw new QLeverLockedError(text);
+        throw new Error(`QLever data POST failed (HTTP ${res.status}): ${text}`);
+      }
+    });
+  }
+  _quadsToNQuads(quads) {
+    return new Promise((resolve2, reject) => {
+      const writer = new import_n3.Writer({ format: "application/n-quads" });
+      writer.addQuads(quads);
+      writer.end((err, result) => err ? reject(err) : resolve2(result));
+    });
+  }
+};
+async function _gzip(input) {
+  const cs = new CompressionStream("gzip");
+  const writer = cs.writable.getWriter();
+  writer.write(new Uint8Array(input));
+  writer.close();
+  const chunks = [];
+  const reader = cs.readable.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done)
+      break;
+    chunks.push(value);
+  }
+  const total = chunks.reduce((n, c) => n + c.byteLength, 0);
+  const out = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    out.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return out.buffer;
+}
+
+// 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}`);
+    }
+  }
+  _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);
+  }
+  /** Returns true if this backend supports the /data bulk-insert endpoint (QLever only). */
+  supportsDataEndpoint() {
+    return this.options.graphType === "qlever";
+  }
+  /**
+   * Insert quads using the backend's preferred bulk-insert mechanism.
+   * For QLever: uses the /data endpoint (correctly registers named graphs).
+   * For Fuseki: falls back to SPARQL INSERT DATA.
+   */
+  insertData(quads) {
+    if (this.options.graphType === "qlever") {
+      return this._db.insertData(quads);
+    }
+    return Promise.reject(new Error("insertData not supported for Fuseki \u2014 use update() with SPARQL INSERT DATA"));
+  }
+  /**
+   * Delete quads using the backend's preferred bulk-delete mechanism.
+   * For QLever: uses the /data/delete endpoint.
+   * For Fuseki: falls back to SPARQL DELETE DATA.
+   */
+  deleteData(quads) {
+    if (this.options.graphType === "qlever") {
+      return this._db.deleteData(quads);
+    }
+    return Promise.reject(new Error("deleteData not supported for Fuseki \u2014 use update() with SPARQL DELETE DATA"));
+  }
+};
+
+// libs/js/databases/src/lib/blob/blob.ts
+var import_storage = require("firebase/storage");
+var CueBlobStorage = class {
+  constructor(options) {
+    this.options = options;
+  }
+  /** Paths known to be absent, keyed as `bucket:path`. Avoids repeat 404 requests. */
+  _knownMissing = /* @__PURE__ */ new Set();
+  // ─── Storage bucket resolution ────────────────────────────────────────────
+  _bucket(name) {
+    switch (name) {
+      case "raw":
+        return this.options.storageRaw;
+      case "processed":
+        return this.options.storageProcessed;
+      case "logs":
+        return this.options.storageLogs;
+      case "chatSessions":
+        return this.options.storageChatSessions;
+      case "public":
+        return this.options.storagePublic;
+      case "persistence":
+        return this.options.storagePersistence;
+    }
+  }
+  // ─── Downloads ────────────────────────────────────────────────────────────
+  /** Get an authenticated download URL. Returns undefined if the file does not exist. */
+  async getDownloadURL(bucket, path) {
+    const fileRef = (0, import_storage.ref)(this._bucket(bucket), path);
+    try {
+      return await (0, import_storage.getDownloadURL)(fileRef);
+    } catch (err) {
+      if (err?.code === "storage/object-not-found")
+        return void 0;
+      throw err;
+    }
+  }
+  /**
+   * Download URL with a `?t=<updated>` suffix, bypassing caches.
+   * Returns undefined if the file does not exist.
+   */
+  async getCacheBustedUrl(bucket, path) {
+    const key = `${bucket}:${path}`;
+    if (this._knownMissing.has(key))
+      return void 0;
+    const fileRef = (0, import_storage.ref)(this._bucket(bucket), path);
+    try {
+      const metadata = await (0, import_storage.getMetadata)(fileRef);
+      const url = await (0, import_storage.getDownloadURL)(fileRef);
+      return `${url}&t=${encodeURIComponent(metadata.updated)}`;
+    } catch (err) {
+      if (err?.code === "storage/object-not-found" || err?.status === 404) {
+        this._knownMissing.add(key);
+        console.debug(`[CueBlobStorage] ${path} not found (404 OK \u2014 optional cache file)`);
+        return void 0;
+      }
+      throw err;
+    }
+  }
+  /** Download a file as a Blob. Returns undefined if the file does not exist. */
+  async getFile(bucket, path) {
+    const fileRef = (0, import_storage.ref)(this._bucket(bucket), path);
+    try {
+      return await (0, import_storage.getBlob)(fileRef);
+    } catch (err) {
+      if (err?.code === "storage/object-not-found")
+        return void 0;
+      throw err;
+    }
+  }
+  /** Returns true if the file exists. */
+  async fileExists(bucket, path) {
+    return await this.getDownloadURL(bucket, path) !== void 0;
+  }
+  /**
+   * Download a file from the public bucket and return its contents as a string.
+   * Uses a cache-busted URL to ensure the latest version is fetched.
+   */
+  async downloadPublic(blobName) {
+    const fileRef = (0, import_storage.ref)(this.options.storagePublic, blobName);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const raceAbort = (p) => Promise.race([
+      p,
+      new Promise((_, reject) => {
+        controller.signal.addEventListener(
+          "abort",
+          () => reject(new DOMException(`Download timed out: ${blobName}`, "AbortError"))
+        );
+      })
+    ]);
+    try {
+      const [url, metadata] = await Promise.all([
+        raceAbort((0, import_storage.getDownloadURL)(fileRef)),
+        raceAbort((0, import_storage.getMetadata)(fileRef))
+      ]);
+      const cacheBustedUrl = `${url}&t=${encodeURIComponent(metadata.updated)}`;
+      const res = await fetch(cacheBustedUrl, { signal: controller.signal });
+      if (!res.ok)
+        throw new Error(`HTTP ${res.status}`);
+      return res.text();
+    } catch (err) {
+      const isTimeout = err instanceof Error && err.name === "AbortError";
+      throw new Error(isTimeout ? `Download timed out: ${blobName}` : err instanceof Error ? err.message : String(err));
+    } finally {
+      clearTimeout(timeout);
+    }
+  }
+  // ─── Metadata ─────────────────────────────────────────────────────────────
+  /** Read file metadata. Returns undefined if the file does not exist. */
+  async getMetadata(bucket, path) {
+    const fileRef = (0, import_storage.ref)(this._bucket(bucket), path);
+    try {
+      const m = await (0, import_storage.getMetadata)(fileRef);
+      return {
+        updated: m.updated,
+        contentType: m.contentType,
+        size: m.size,
+        customMetadata: m.customMetadata
+      };
+    } catch (err) {
+      if (err?.code === "storage/object-not-found")
+        return void 0;
+      throw err;
+    }
+  }
+  /** Update custom metadata on an existing file. */
+  async setMetadata(bucket, path, customMetadata) {
+    const fileRef = (0, import_storage.ref)(this._bucket(bucket), path);
+    await (0, import_storage.updateMetadata)(fileRef, { customMetadata });
+  }
+  // ─── Uploads ──────────────────────────────────────────────────────────────
+  /**
+   * Resumable upload. Returns an {@link UploadHandle} with progress callbacks
+   * and pause/resume/cancel controls. Use for large files or files where
+   * upload progress needs to be surfaced in the UI.
+   */
+  uploadResumable(bucket, path, data, customMetadata) {
+    const fileRef = (0, import_storage.ref)(this._bucket(bucket), path);
+    const task = (0, import_storage.uploadBytesResumable)(fileRef, data, customMetadata ? { customMetadata } : void 0);
+    return {
+      complete: () => new Promise((resolve2, reject) => task.then(() => resolve2(), reject)),
+      pause: () => task.pause(),
+      resume: () => task.resume(),
+      cancel: () => task.cancel(),
+      onProgress: (cb) => {
+        const unsub = task.on("state_changed", (snap) => {
+          cb(snap.bytesTransferred, snap.totalBytes);
+        });
+        return () => unsub();
+      }
+    };
+  }
+  /**
+   * Simple one-shot upload. Waits for completion before resolving.
+   * Use for small files where progress feedback is not needed.
+   */
+  async uploadBytes(bucket, path, data, customMetadata) {
+    const fileRef = (0, import_storage.ref)(this._bucket(bucket), path);
+    await (0, import_storage.uploadBytes)(fileRef, data, customMetadata ? { customMetadata } : void 0);
+  }
+  /** Upload a string or base64-encoded value. */
+  async uploadString(bucket, path, data, format = import_storage.StringFormat.RAW, customMetadata) {
+    const fileRef = (0, import_storage.ref)(this._bucket(bucket), path);
+    await (0, import_storage.uploadString)(fileRef, data, format, customMetadata ? { customMetadata } : void 0);
+  }
+  // ─── Listing ──────────────────────────────────────────────────────────────
+  /** List all item names directly under `prefix` in the given bucket. */
+  async listFiles(bucket, prefix) {
+    const listRef = (0, import_storage.ref)(this._bucket(bucket), prefix);
+    const result = await (0, import_storage.listAll)(listRef);
+    return result.items.map((item) => item.name);
+  }
+  /**
+   * Recursively list all file full-paths under `prefix` in the given bucket.
+   * Returns full storage paths (not just names).
+   */
+  async listFilesRecursive(bucket, prefix) {
+    const storage = this._bucket(bucket);
+    const collectFiles = async (path) => {
+      const listResult = await (0, import_storage.listAll)((0, import_storage.ref)(storage, path));
+      let files = listResult.items.map((item) => item.fullPath);
+      for (const folder of listResult.prefixes) {
+        files = files.concat(await collectFiles(folder.fullPath));
+      }
+      return files;
+    };
+    return collectFiles(prefix);
+  }
+  /**
+   * Delete all files under `prefix` recursively.
+   * Returns the number of files deleted.
+   */
+  async deleteDirectory(bucket, prefix) {
+    const { deleteObject } = await import("firebase/storage");
+    const storage = this._bucket(bucket);
+    let deletedCount = 0;
+    const deleteAll = async (path) => {
+      const listResult = await (0, import_storage.listAll)((0, import_storage.ref)(storage, path));
+      for (const item of listResult.items) {
+        await deleteObject(item);
+        deletedCount++;
+      }
+      for (const folder of listResult.prefixes) {
+        await deleteAll(folder.fullPath);
+      }
+    };
+    await deleteAll(prefix);
+    return deletedCount;
+  }
+  // ─── Legacy helpers kept for CueBlobStorage consumers ────────────────────
+  // (used by loaders / processors that were already depending on CueBlobStorage)
+  /** Upload binary data to the raw bucket with retry logic. */
+  async uploadRaw(blobName, data, metadata, maxRetries = 3, signal, onProgress) {
+    const fileRef = (0, import_storage.ref)(this.options.storageRaw, blobName);
+    let attempt = 0;
+    let lastError;
+    while (attempt < maxRetries) {
+      try {
+        await new Promise((resolve2, reject) => {
+          if (signal?.aborted) {
+            reject(new DOMException("Upload cancelled", "AbortError"));
+            return;
+          }
+          const task = (0, import_storage.uploadBytesResumable)(fileRef, data, { customMetadata: metadata });
+          const onAbort = () => {
+            task.cancel();
+            reject(new DOMException("Upload cancelled", "AbortError"));
+          };
+          signal?.addEventListener("abort", onAbort, { once: true });
+          task.on(
+            "state_changed",
+            (snapshot) => {
+              if (onProgress) {
+                const pct = Math.round(snapshot.bytesTransferred / snapshot.totalBytes * 100);
+                onProgress(pct);
+              }
+            },
+            (error) => {
+              signal?.removeEventListener("abort", onAbort);
+              reject(error);
+            },
+            () => {
+              signal?.removeEventListener("abort", onAbort);
+              resolve2();
+            }
+          );
+        });
+        return;
+      } catch (err) {
+        if (signal?.aborted || err instanceof DOMException && err.name === "AbortError") {
+          throw err;
+        }
+        lastError = err;
+        attempt++;
+        if (attempt < maxRetries) {
+          await new Promise((res) => setTimeout(res, 1e3 * attempt));
+        }
+      }
+    }
+    throw lastError;
+  }
+  /**
+   * Upload data to the processed bucket.
+   * Skips upload and returns `false` if the blob already exists.
+   */
+  async uploadProcessed(blobName, data, metadata) {
+    const fileRef = (0, import_storage.ref)(this.options.storageProcessed, blobName);
+    const existing = await (0, import_storage.getMetadata)(fileRef).catch(() => null);
+    if (existing)
+      return false;
+    await (0, import_storage.uploadBytes)(fileRef, data, { customMetadata: metadata });
+    return true;
+  }
+  /** List all blob names directly under `prefix` in the raw bucket. */
+  async listRaw(prefix) {
+    const listRef = (0, import_storage.ref)(this.options.storageRaw, prefix);
+    const result = await (0, import_storage.listAll)(listRef);
+    return result.items.map((item) => item.name);
+  }
+};
+
+// libs/js/databases/src/lib/doc/firestore.ts
+var import_firestore = require("firebase/firestore");
+var FirestoreDocStore = class {
+  _db;
+  constructor(app) {
+    this._db = (0, import_firestore.getFirestore)(app);
+  }
+  subscribeToDoc(col, id, callback) {
+    const ref6 = (0, import_firestore.doc)(this._db, col, id);
+    return (0, import_firestore.onSnapshot)(ref6, (snapshot) => {
+      callback(snapshot.exists() ? snapshot.data() : null);
+    });
+  }
+  subscribeToCollection(col, filters, callback, options) {
+    const constraints = this._buildConstraints(filters, options);
+    const q = (0, import_firestore.query)((0, import_firestore.collection)(this._db, col), ...constraints);
+    return (0, import_firestore.onSnapshot)(q, (snapshot) => {
+      callback(
+        snapshot.docs.map((d) => ({ id: d.id, data: d.data() }))
+      );
+    });
+  }
+  async getDoc(col, id) {
+    const ref6 = (0, import_firestore.doc)(this._db, col, id);
+    const snapshot = await (0, import_firestore.getDoc)(ref6);
+    return snapshot.exists() ? snapshot.data() : null;
+  }
+  async queryDocs(col, filters, options) {
+    const constraints = this._buildConstraints(filters, options);
+    const q = (0, import_firestore.query)((0, import_firestore.collection)(this._db, col), ...constraints);
+    const snapshot = await (0, import_firestore.getDocs)(q);
+    return snapshot.docs.map((d) => ({ id: d.id, data: d.data() }));
+  }
+  async setDoc(col, id, data) {
+    const ref6 = (0, import_firestore.doc)(this._db, col, id);
+    await (0, import_firestore.setDoc)(ref6, data);
+  }
+  async updateDoc(col, id, data) {
+    const ref6 = (0, import_firestore.doc)(this._db, col, id);
+    await (0, import_firestore.updateDoc)(ref6, data);
+  }
+  async addDoc(col, data) {
+    const ref6 = await (0, import_firestore.addDoc)((0, import_firestore.collection)(this._db, col), data);
+    return ref6.id;
+  }
+  async deleteDoc(col, id) {
+    const ref6 = (0, import_firestore.doc)(this._db, col, id);
+    await (0, import_firestore.deleteDoc)(ref6);
+  }
+  _buildConstraints(filters, options) {
+    const constraints = filters.map(
+      (f) => (0, import_firestore.where)(f.field, f.op, f.value)
+    );
+    const extras = [];
+    if (options?.orderBy) {
+      extras.push((0, import_firestore.orderBy)(options.orderBy.field, options.orderBy.direction));
+    }
+    if (options?.limit) {
+      extras.push((0, import_firestore.limit)(options.limit));
+    }
+    return [...constraints, ...extras];
+  }
+};
+
+// libs/js/firebase/src/lib/firebase.ts
+var CueFirebase = class _CueFirebase {
+  static _instance;
+  _muted = true;
+  _emulator = false;
+  constructor(config, auth, muted = false) {
+    this._muted = muted;
+    this._init(config, auth);
+  }
+  static getInstance(config, auth, muted = false) {
+    if (!_CueFirebase._instance) {
+      if (config === void 0)
+        throw new Error("Config needed for instantiation!");
+      if (!muted)
+        console.info("Creating new CueFirebase instance");
+      _CueFirebase._instance = new _CueFirebase(config, auth, muted);
+    }
+    return _CueFirebase._instance;
+  }
+  _functionAcceptTerms;
+  _functionEmitMessage;
+  _functionGetUserInfo;
+  _functionChangeUserRoleOnProject;
+  _functionInviteUserToProject;
+  _functionRemoveUserFromProject;
+  _storageProcessed;
+  _storageRaw;
+  _storageLogs;
+  _storageChatSessions;
+  _storagePublic;
+  _storagePersistence;
+  _collectionChatSessions;
+  _collectionOrganizations;
+  _collectionProjects;
+  _collectionRDFWriting;
+  _collectionAPIKeys;
+  _collectionUsers;
+  _collectionUserTermsAcceptance;
+  _collectionTiers;
+  _auth;
+  _app;
+  _docStore;
+  _blobStore;
+  get functionAcceptTerms() {
+    return this._functionAcceptTerms;
+  }
+  get functionEmitMessage() {
+    return this._functionEmitMessage;
+  }
+  get functionGetUserInfo() {
+    return this._functionGetUserInfo;
+  }
+  get functionInviteUserToProject() {
+    return this._functionInviteUserToProject;
   }
   get functionChangeUserRoleOnProject() {
     return this._functionChangeUserRoleOnProject;
@@ -334,6 +1327,14 @@ var CueFirebase = class _CueFirebase {
   get auth() {
     return this._auth;
   }
+  /** Provider-agnostic document store backed by Firestore. */
+  get docStore() {
+    return this._docStore;
+  }
+  /** Provider-agnostic blob store backed by Firebase Storage. */
+  get blobStore() {
+    return this._blobStore;
+  }
   get emulatorMode() {
     return this._emulator;
   }
@@ -370,31 +1371,40 @@ var CueFirebase = class _CueFirebase {
       functions,
       FUNCTION_REMOVE_USER_FROM_PROJECT_PATH
     );
-    this._storageProcessed = (0, import_storage.getStorage)(app, BUCKET_PROCESSED);
-    this._storageRaw = (0, import_storage.getStorage)(app, BUCKET_RAW);
-    this._storageChatSessions = (0, import_storage.getStorage)(app, BUCKET_CHAT_SESSIONS);
-    this._storageLogs = (0, import_storage.getStorage)(app, BUCKET_LOGS);
-    this._storagePublic = (0, import_storage.getStorage)(app, BUCKET_PUBLIC);
-    this._storagePersistence = (0, import_storage.getStorage)(app, BUCKET_PERSISTENCE);
-    this._collectionChatSessions = (0, import_firestore.collection)(
-      (0, import_firestore.getFirestore)(app),
+    this._storageProcessed = (0, import_storage2.getStorage)(app, BUCKET_PROCESSED);
+    this._storageRaw = (0, import_storage2.getStorage)(app, BUCKET_RAW);
+    this._storageChatSessions = (0, import_storage2.getStorage)(app, BUCKET_CHAT_SESSIONS);
+    this._storageLogs = (0, import_storage2.getStorage)(app, BUCKET_LOGS);
+    this._storagePublic = (0, import_storage2.getStorage)(app, BUCKET_PUBLIC);
+    this._storagePersistence = (0, import_storage2.getStorage)(app, BUCKET_PERSISTENCE);
+    this._collectionChatSessions = (0, import_firestore2.collection)(
+      (0, import_firestore2.getFirestore)(app),
       COLLECTION_CHAT_SESSIONS
     );
-    this._collectionOrganizations = (0, import_firestore.collection)(
-      (0, import_firestore.getFirestore)(app),
+    this._collectionOrganizations = (0, import_firestore2.collection)(
+      (0, import_firestore2.getFirestore)(app),
       COLLECTION_ORGANIZATIONS
     );
-    this._collectionProjects = (0, import_firestore.collection)((0, import_firestore.getFirestore)(app), COLLECTION_PROJECTS);
-    this._collectionRDFWriting = (0, import_firestore.collection)((0, import_firestore.getFirestore)(app), COLLECTION_RDF_WRITING);
-    this._collectionAPIKeys = (0, import_firestore.collection)((0, import_firestore.getFirestore)(app), COLLECTION_API_KEYS);
-    this._collectionUsers = (0, import_firestore.collection)((0, import_firestore.getFirestore)(app), COLLECTION_USERS);
-    this._collectionUserTermsAcceptance = (0, import_firestore.collection)(
-      (0, import_firestore.getFirestore)(app),
+    this._collectionProjects = (0, import_firestore2.collection)((0, import_firestore2.getFirestore)(app), COLLECTION_PROJECTS);
+    this._collectionRDFWriting = (0, import_firestore2.collection)((0, import_firestore2.getFirestore)(app), COLLECTION_RDF_WRITING);
+    this._collectionAPIKeys = (0, import_firestore2.collection)((0, import_firestore2.getFirestore)(app), COLLECTION_API_KEYS);
+    this._collectionUsers = (0, import_firestore2.collection)((0, import_firestore2.getFirestore)(app), COLLECTION_USERS);
+    this._collectionUserTermsAcceptance = (0, import_firestore2.collection)(
+      (0, import_firestore2.getFirestore)(app),
       COLLECTION_USER_TERMS_ACCEPT
     );
-    this._collectionTiers = (0, import_firestore.collection)((0, import_firestore.getFirestore)(app), COLLECTION_TIERS);
+    this._collectionTiers = (0, import_firestore2.collection)((0, import_firestore2.getFirestore)(app), COLLECTION_TIERS);
     this._auth = auth === void 0 ? (0, import_auth.getAuth)(app) : auth;
     this._app = app;
+    this._docStore = new FirestoreDocStore(app);
+    this._blobStore = new CueBlobStorage({
+      storageRaw: this._storageRaw,
+      storageProcessed: this._storageProcessed,
+      storageLogs: this._storageLogs,
+      storageChatSessions: this._storageChatSessions,
+      storagePublic: this._storagePublic,
+      storagePersistence: this._storagePersistence
+    });
     this._emulator = config.useEmulator || false;
     if (config.useEmulator) {
       this.attachEmulators();
@@ -439,14 +1449,14 @@ var CueFirebase = class _CueFirebase {
     }
     const functions = (0, import_functions.getFunctions)(this._app, GCP_REGION);
     (0, import_auth.connectAuthEmulator)(this._auth, authEmulatorUrl);
-    (0, import_firestore.connectFirestoreEmulator)((0, import_firestore.getFirestore)(this._app), firestoreHost, firestorePort);
+    (0, import_firestore2.connectFirestoreEmulator)((0, import_firestore2.getFirestore)(this._app), firestoreHost, firestorePort);
     (0, import_functions.connectFunctionsEmulator)(functions, "localhost", 5001);
-    (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);
+    (0, import_storage2.connectStorageEmulator)(this._storageProcessed, storageHost, storagePort);
+    (0, import_storage2.connectStorageEmulator)(this._storageRaw, storageHost, storagePort);
+    (0, import_storage2.connectStorageEmulator)(this._storageChatSessions, storageHost, storagePort);
+    (0, import_storage2.connectStorageEmulator)(this._storageLogs, storageHost, storagePort);
+    (0, import_storage2.connectStorageEmulator)(this._storagePublic, storageHost, storagePort);
+    (0, import_storage2.connectStorageEmulator)(this._storagePersistence, storageHost, storagePort);
     if (!this._muted)
       console.info("Firebase emulators attached");
   }
@@ -456,7 +1466,7 @@ var CueFirebase = class _CueFirebase {
 var import_uuid = require("uuid");
 
 // libs/js/sync-tools/src/lib/list-remote-files.ts
-var import_storage2 = require("firebase/storage");
+var import_storage3 = require("firebase/storage");
 
 // libs/js/prefixes/src/lib/qaecy-prefixes.ts
 var qaecyPrefixes = {
@@ -3717,11 +4727,11 @@ async function listRemoteFiles(spaceId, providerId, queryHandler2, verbose = fal
   const storage = firebase.storageRaw;
   if (!storage)
     throw new Error("Firebase storage is not initialized");
-  const listRef = (0, import_storage2.ref)(storage, spaceId);
+  const listRef = (0, import_storage3.ref)(storage, spaceId);
   if (verbose)
     console.info(`Listing files in raw space: ${spaceId}`);
   const [blobFiles, locationDataMap] = await Promise.all([
-    (0, import_storage2.listAll)(listRef),
+    (0, import_storage3.listAll)(listRef),
     getGraphFiles(providerId, queryHandler2)
   ]);
   const files = [];
@@ -3770,134 +4780,13 @@ async function getGraphFiles(providerId, queryHandler2) {
 }
 
 // libs/js/sync-tools/src/lib/list-local-files.ts
-var import_path2 = require("path");
-
-// libs/js/id-builders/src/lib/id-builders.ts
-var import_uuid2 = require("uuid");
-var replacements = {
-  "\xE4": "ae",
-  "a\u0308": "ae",
-  "\xC4": "AE",
-  "\xF6": "oe",
-  "\xD6": "OE",
-  "\xFC": "ue",
-  "u\u0308": "ue",
-  "\xDC": "UE",
-  "U\u0308": "UE",
-  "\xDF": "ss",
-  "\xE6": "ae",
-  "\xC6": "AE",
-  "\xF8": "oe",
-  "\xD8": "OE",
-  "\xE5": "aa",
-  "\xC5": "AA",
-  "\xE1": "a",
-  "\xC1": "A",
-  "\xF0": "d",
-  "\xD0": "D",
-  "\xE9": "e",
-  "\xC9": "E",
-  "\xED": "i",
-  "\xCD": "I",
-  "\xF3": "o",
-  "\xD3": "O",
-  "\xFA": "u",
-  "\xDA": "U",
-  "\xFD": "y",
-  "\xDD": "Y",
-  "\xFE": "th",
-  "\xDE": "Th"
-};
-function contextBasedGuid(contextString, verbose = false) {
-  const namespace = "daca0510-72b5-48ba-9091-b918ca18136b";
-  contextString = replaceSpecialChars(contextString, verbose);
-  return (0, import_uuid2.v5)(contextString, namespace);
-}
-function replaceSpecialChars(str, verbose = false) {
-  let result = str;
-  for (const char in replacements) {
-    result = result.replace(new RegExp(char, "g"), replacements[char]);
-  }
-  if (verbose && result !== str)
-    console.info(`${str} -> ${result}`);
-  return result;
-}
-function generateFileUUID(filepath, providerId = "") {
-  return contextBasedGuid(`${providerId}${filepath}`);
+init_src();
+async function _path() {
+  return import("path");
 }
-
-// libs/js/id-builders/src/lib/md5-builder.ts
-var import_spark_md5 = __toESM(require("spark-md5"));
-async function fromReadStream(readStream) {
-  return new Promise((resolve2, reject) => {
-    const spark = new import_spark_md5.default.ArrayBuffer();
-    readStream.on("data", (chunk) => {
-      spark.append(chunk);
-    });
-    readStream.on("end", () => {
-      resolve2(spark.end());
-    });
-    readStream.on("error", (err) => reject(err));
-  });
-}
-
-// libs/js/sync-tools/src/lib/helpers/md5-builder-node.ts
-var import_fs = require("fs");
-async function md5FromWorker(filePaths, hashWorkerPath, verbose = false, logIntervalPct = 1) {
-  const { WorkerPool: WorkerPool2 } = await Promise.resolve().then(() => (init_worker_pool(), worker_pool_exports));
-  const pool = new WorkerPool2(hashWorkerPath);
-  const hashes = filePaths.map((filePath) => pool.hashFile(filePath));
-  if (verbose) {
-    let completed = 0;
-    let lastPct = 0;
-    hashes.forEach(
-      (promise) => promise.then(() => {
-        completed++;
-        const pct = Math.floor(completed / filePaths.length * 100);
-        if (pct - lastPct >= logIntervalPct) {
-          lastPct = pct;
-          console.info(`MD5 progress: ${completed}/${filePaths.length} (${pct}%)`);
-        }
-      })
-    );
-  }
-  const ret = await Promise.all(hashes);
-  await pool.close();
-  return ret;
-}
-async function md5NoWorker(filePaths, verbose) {
-  if (verbose)
-    console.info(`Calculating MD5 hashes for ${filePaths.length} files...`);
-  const concurrency = 50;
-  const hashes = [];
-  for (let i = 0; i < filePaths.length; i += concurrency) {
-    const chunk = filePaths.slice(i, i + concurrency);
-    const chunkHashes = await Promise.all(
-      chunk.map((f) => {
-        const stream = (0, import_fs.createReadStream)(f);
-        return fromReadStream(stream);
-      })
-    );
-    hashes.push(...chunkHashes);
-    if (verbose) {
-      const pct = Math.min(
-        100,
-        Math.round((i + chunk.length) / filePaths.length * 100)
-      );
-      console.info(
-        `MD5 progress: ${pct}% (${i + chunk.length}/${filePaths.length})`
-      );
-    }
-  }
-  if (verbose)
-    console.info(`Calculated MD5 hashes for ${filePaths.length} files.`);
-  return hashes;
+async function _fs() {
+  return import("fs/promises");
 }
-
-// libs/js/sync-tools/src/lib/list-local-files.ts
-var import_promises = require("fs/promises");
-var import_promises2 = require("fs/promises");
-var import_jszip = __toESM(require("jszip"));
 var IGNORED = {
   dirs: ["node_modules", ".git", ".hg", ".svn", ".DS_Store"],
   suffix: [".tmp", ".part", ".crdownload"]
@@ -3931,10 +4820,13 @@ async function listLocalFiles(dir, providerId = "", verbose = false, logInterval
     console.warn(
       `More than 10,000 files found in ${dir}. This may take a while...`
     );
-  const hashes = hashWorkerPath ? await md5FromWorker(fullPaths, hashWorkerPath, verbose, logIntervalPct) : await md5NoWorker(fullPaths, verbose);
-  const stats = await Promise.all(fullPaths.map((f) => (0, import_promises.stat)(f)));
+  const { md5FromWorker: md5FromWorker2, md5NoWorker: md5NoWorker2 } = await Promise.resolve().then(() => (init_md5_builder_node(), md5_builder_node_exports));
+  const hashes = hashWorkerPath ? await md5FromWorker2(fullPaths, hashWorkerPath, verbose, logIntervalPct) : await md5NoWorker2(fullPaths, verbose);
+  const { stat } = await _fs();
+  const { relative } = await _path();
+  const stats = await Promise.all(fullPaths.map((f) => stat(f)));
   return fullPaths.map((f, i) => {
-    const relativePath = (0, import_path2.relative)(dir, f);
+    const relativePath = relative(dir, f);
     const md5 = hashes[i];
     const contentUUID = contextBasedGuid(md5);
     const locationUUID = generateFileUUID(relativePath, providerId);
@@ -3944,11 +4836,13 @@ async function listLocalFiles(dir, providerId = "", verbose = false, logInterval
 }
 async function filesInLocalDirRecursive(dir, filterFunc = () => true, excludeDirs = true) {
   const results = [];
+  const { readdir } = await _fs();
+  const { join: join4 } = await _path();
   async function traverseDir(currentDir) {
     try {
-      const entries = await (0, import_promises.readdir)(currentDir, { withFileTypes: true });
+      const entries = await readdir(currentDir, { withFileTypes: true });
       for (const entry of entries) {
-        const fullPath = (0, import_path2.join)(currentDir, entry.name);
+        const fullPath = join4(currentDir, entry.name);
         if (entry.isFile()) {
           if (filterFunc(entry)) {
             results.push(fullPath);
@@ -3990,23 +4884,26 @@ async function unzipFile(zipPath, recursive = true, options) {
   if (currentDepth > maxRecursionDepth) {
     throw new Error(`Zip extraction aborted: exceeded max recursion depth (${maxRecursionDepth})`);
   }
+  const { mkdir: mkdir2, readFile, writeFile: writeFile2 } = await _fs();
+  const { join: join4 } = await _path();
+  const { default: JSZip } = await import("jszip");
   const targetDir = zipPath.replace(/\.zip$/i, "") + UNZIPPED_SUFFIX;
-  await (0, import_promises2.mkdir)(targetDir, { recursive: true });
-  const data = await (0, import_promises.readFile)(zipPath);
-  const zip = await import_jszip.default.loadAsync(data);
+  await mkdir2(targetDir, { recursive: true });
+  const data = await readFile(zipPath);
+  const zip = await JSZip.loadAsync(data);
   const extractPromises = [];
   for (const [relativePath, file] of Object.entries(zip.files)) {
     if (!file.dir) {
       const pathParts = relativePath.split("/");
-      const fileTargetDir = (0, import_path2.join)(targetDir, ...pathParts.slice(0, -1));
-      const targetPath = (0, import_path2.join)(fileTargetDir, pathParts[pathParts.length - 1]);
+      const fileTargetDir = join4(targetDir, ...pathParts.slice(0, -1));
+      const targetPath = join4(fileTargetDir, pathParts[pathParts.length - 1]);
       await ensureDir(fileTargetDir);
       const promise = file.async("nodebuffer").then(async (content) => {
         totalUncompressedSize.value += content.length;
         if (totalUncompressedSize.value > maxUncompressedSize) {
           throw new Error(`Zip extraction aborted: exceeded max uncompressed size (${maxUncompressedSize} bytes)`);
         }
-        await (0, import_promises.writeFile)(targetPath, content);
+        await writeFile2(targetPath, content);
         if (recursive && targetPath.toLowerCase().endsWith(".zip")) {
           await unzipFile(targetPath, true, {
             maxUncompressedSize,
@@ -4022,18 +4919,20 @@ async function unzipFile(zipPath, recursive = true, options) {
   await Promise.all(extractPromises);
 }
 async function ensureDir(path) {
-  await (0, import_promises2.mkdir)(path, { recursive: true });
+  const { mkdir: mkdir2 } = await _fs();
+  await mkdir2(path, { recursive: true });
 }
 async function deleteUnzipped(dir) {
+  const { rm } = await _fs();
   const paths = await filesInLocalDirRecursive(dir, (entry) => entry.name.toLowerCase().endsWith(UNZIPPED_SUFFIX), false);
   for (const p of paths) {
-    await (0, import_promises.rm)(p, { recursive: true, force: true });
+    await rm(p, { recursive: true, force: true });
   }
 }
 
 // apps/desktop/cue-cli/src/helpers/query-handler.ts
 var import_auth2 = require("firebase/auth");
-async function queryHandler(query3, spaceId, useEmulator) {
+async function queryHandler(query4, spaceId, useEmulator) {
   const endpoint = useEmulator ? SPARQL_ENDPOINT_EMULATOR : SPARQL_ENDPOINT;
   const token = await (0, import_auth2.getAuth)().currentUser?.getIdToken();
   const res = await fetch(endpoint, {
@@ -4044,7 +4943,7 @@ async function queryHandler(query3, spaceId, useEmulator) {
       "Content-Type": "application/sparql-query",
       Accept: "application/sparql-results+json"
     },
-    body: query3
+    body: query4
   });
   if (!res.ok) {
     console.error(
@@ -4066,13 +4965,138 @@ function fileSizePretty(size) {
 
 // libs/js/cue-sdk/src/lib/cue.ts
 var import_app2 = require("firebase/app");
+var import_storage5 = require("firebase/storage");
 
 // libs/js/cue-sdk/src/lib/auth.ts
 var import_auth3 = require("firebase/auth");
+
+// libs/js/cue-sdk/src/lib/signal.ts
+init_src();
+var CueSignal = class {
+  _value;
+  _listeners = /* @__PURE__ */ new Set();
+  constructor(initial) {
+    this._value = initial;
+  }
+  get() {
+    return this._value;
+  }
+  set(value) {
+    this._value = value;
+    for (const fn of this._listeners)
+      fn();
+  }
+  subscribe(listener) {
+    this._listeners.add(listener);
+    return () => this._listeners.delete(listener);
+  }
+  /** Returns a read-only view of this signal. */
+  asReadonly() {
+    return this;
+  }
+};
+function cueComputed(deps, compute) {
+  const listeners = /* @__PURE__ */ new Set();
+  let cached = compute();
+  let dirty = false;
+  const unsubs = [];
+  const notify = () => {
+    dirty = true;
+    for (const fn of listeners)
+      fn();
+  };
+  for (const dep of deps) {
+    unsubs.push(dep.subscribe(notify));
+  }
+  return {
+    get() {
+      if (dirty) {
+        cached = compute();
+        dirty = false;
+      }
+      return cached;
+    },
+    subscribe(fn) {
+      listeners.add(fn);
+      return () => listeners.delete(fn);
+    },
+    destroy() {
+      for (const unsub of unsubs)
+        unsub();
+      listeners.clear();
+    }
+  };
+}
+async function staleWhileRevalidate(query4, fetchFresh, onData, cache) {
+  const cacheKey = contextBasedGuid(query4);
+  let staleId;
+  if (cache) {
+    const stale = await cache.get(cacheKey);
+    if (stale !== void 0) {
+      onData(stale, true);
+      staleId = contextBasedGuid(JSON.stringify(stale));
+    }
+  }
+  const fresh = await fetchFresh();
+  onData(fresh, false);
+  if (cache) {
+    const freshId = contextBasedGuid(JSON.stringify(fresh));
+    if (freshId !== staleId) {
+      cache.set(cacheKey, fresh).catch(
+        (err) => console.error("[staleWhileRevalidate] Cache write failed:", err)
+      );
+    }
+  }
+  return fresh;
+}
+
+// libs/js/cue-sdk/src/variables.ts
+var DEFAULT_SDK_CONFIG = {
+  apiKey: "AIzaSyAiW42QBx9HS4Khu88pCW7MV66IhBAQul0",
+  appId: "1:151132927589:web:d2ffdb377dfadfd23ab88c",
+  measurementId: "G-YT4PK6HGZD"
+};
+var FIREBASE_PROJECT_ID = "qaecy-mvp-406413";
+var FIREBASE_SENDER_ID = "734737865998";
+var GCP_REGION2 = "europe-west6";
+var COLLECTION_API_KEYS2 = "apiKeys";
+var COLLECTION_ORGANIZATIONS2 = "organizations";
+var COLLECTION_PROJECTS2 = "projects";
+var BUCKET_CHAT_SESSIONS2 = "spaces_chats_eu_west6";
+var BUCKET_RAW2 = "spaces_raw_eu_west6";
+var BUCKET_PROCESSED2 = "spaces_processed_eu_west6";
+var BUCKET_LOGS2 = "spaces_logs_eu_west6";
+var BUCKET_PUBLIC2 = "cue_public_eu_west6";
+var BUCKET_PERSISTENCE2 = "db_persistence_eu_west6";
+var ENDPOINT_CONSUMPTION = "/data-views/admin/consumption";
+var ENDPOINT_CREATE_PROJECT = "/commands/admin/project";
+var ENDPOINT_SEARCH = "/assistant/search";
+var ENDPOINT_FUSEKI_QUERY = "/triplestore/query";
+var ENDPOINT_FUSEKI_UPDATE = "/triplestore/update";
+var ENDPOINT_QLEVER_QUERY = "/qlever-server/qlever/query";
+var ENDPOINT_QLEVER_UPDATE = "/qlever-server/qlever/update";
+var ENDPOINT_FSS_BATCH = "/commands/file-system-structure/batch";
 var MICROSOFT_PROVIDER_ID = "microsoft.com";
+var SUPERADMIN_ROLE = "superadmin";
+var RESOURCE_BASE = "https://cue.qaecy.com/r/";
+
+// libs/js/cue-sdk/src/lib/auth.ts
 var CueAuth = class {
   _auth;
   _endpoints;
+  _userSignal = new CueSignal(null);
+  _tokenSignal = new CueSignal(null);
+  _isSuperAdminSignal = new CueSignal(false);
+  _userIdsSignal;
+  _stopTokenListener;
+  /** Reactive auth state — emits the signed-in `User`, or `null` when signed out. */
+  user;
+  /** Reactive Firebase ID token — refreshes automatically; `null` when signed out. */
+  token;
+  /** `true` when the current user has the `superadmin` custom claim. */
+  isSuperAdmin;
+  /** All unique UIDs for the current user (Firebase UID + linked provider UIDs). */
+  userIds;
   constructor(app, useEmulator = false, endpoints) {
     this._auth = (0, import_auth3.getAuth)(app);
     this._endpoints = endpoints;
@@ -4081,6 +5105,35 @@ var CueAuth = class {
         disableWarnings: true
       });
     }
+    this.user = this._userSignal.asReadonly();
+    this.token = this._tokenSignal.asReadonly();
+    this.isSuperAdmin = this._isSuperAdminSignal.asReadonly();
+    this._userIdsSignal = cueComputed([this._userSignal], () => {
+      const u = this._userSignal.get();
+      if (!u)
+        return [];
+      const ids = /* @__PURE__ */ new Set([u.uid]);
+      u.providerData.forEach((p) => ids.add(p.uid));
+      return Array.from(ids);
+    });
+    this.userIds = this._userIdsSignal;
+    this._stopTokenListener = (0, import_auth3.onIdTokenChanged)(this._auth, async (user) => {
+      this._userSignal.set(user);
+      if (user) {
+        const token = await user.getIdToken();
+        this._tokenSignal.set(token);
+        const result = await (0, import_auth3.getIdTokenResult)(user);
+        this._isSuperAdminSignal.set(result.claims["role"] === SUPERADMIN_ROLE);
+      } else {
+        this._tokenSignal.set(null);
+        this._isSuperAdminSignal.set(false);
+      }
+    });
+  }
+  /** Stop all internal Firebase listeners. Call when the `Cue` instance is no longer needed. */
+  destroy() {
+    this._stopTokenListener();
+    this._userIdsSignal.destroy?.();
   }
   async signIn(provider, credentials) {
     if (provider === "password") {
@@ -4097,6 +5150,36 @@ var CueAuth = class {
     const result = await (0, import_auth3.signInWithPopup)(this._auth, firebaseProvider);
     return result.user;
   }
+  /**
+   * Initiate a redirect-based sign-in (mobile / iframe contexts where popups
+   * are blocked). Call `checkRedirectResult()` on the next page load to
+   * retrieve the result.
+   */
+  async signInWithRedirect(provider) {
+    const firebaseProvider = provider === "google" ? new import_auth3.GoogleAuthProvider() : new import_auth3.OAuthProvider(MICROSOFT_PROVIDER_ID);
+    await (0, import_auth3.signInWithRedirect)(this._auth, firebaseProvider);
+  }
+  /**
+   * Retrieve the result of a redirect sign-in. Returns the signed-in `User`
+   * or `null` if there is no pending redirect result.
+   * Call this once on app startup before showing a sign-in UI.
+   */
+  async checkRedirectResult() {
+    const result = await (0, import_auth3.getRedirectResult)(this._auth);
+    return result?.user ?? null;
+  }
+  /**
+   * One-shot async check — returns `true` if the current user has the
+   * `superadmin` custom claim. For reactive use, read `cue.auth.isSuperAdmin`
+   * (the signal) instead.
+   */
+  async checkSuperAdmin() {
+    const user = this._auth.currentUser;
+    if (!user)
+      return false;
+    const tokenResult = await (0, import_auth3.getIdTokenResult)(user);
+    return tokenResult.claims["role"] === SUPERADMIN_ROLE;
+  }
   /** Sign in with a Cue API key */
   async signInWithApiKey(cueApiKey, projectId) {
     const response = await fetch(this._endpoints.tokenUrl, {
@@ -4131,6 +5214,30 @@ var CueAuth = class {
       return null;
     return user.getIdToken(forceRefresh);
   }
+  /**
+   * Executes a fetch with a Bearer token. On a 401 response the token is
+   * force-refreshed and the request is retried once before throwing.
+   */
+  async authenticatedFetch(url, init = {}) {
+    const makeRequest = async (forceRefresh) => {
+      const token = await this.getToken(forceRefresh);
+      if (!token)
+        throw new Error("Not authenticated. Call cue.auth.signIn() first.");
+      const { headers: existingHeaders, ...rest } = init;
+      return fetch(url, {
+        ...rest,
+        headers: {
+          ...existingHeaders,
+          Authorization: `Bearer ${token}`
+        }
+      });
+    };
+    let response = await makeRequest(false);
+    if (response.status === 401) {
+      response = await makeRequest(true);
+    }
+    return response;
+  }
   /** Raw Firebase Auth instance, for advanced use cases */
   get firebaseAuth() {
     return this._auth;
@@ -4138,9 +5245,6 @@ var CueAuth = class {
 };
 
 // libs/js/cue-sdk/src/lib/api.ts
-var ENDPOINT_SEARCH = "/assistant/search";
-var ENDPOINT_SPARQL = "/triplestore/query";
-var ENDPOINT_CONSUMPTION = "/data-views/admin/consumption";
 var CueApi = class {
   constructor(_auth, _gatewayUrl, projects, sync) {
     this._auth = _auth;
@@ -4148,9 +5252,6 @@ var CueApi = class {
     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).
@@ -4169,18 +5270,22 @@ var CueApi = class {
    * 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 ?? []
-      })
-    });
+    const response = await this._auth.authenticatedFetch(
+      `${this._gatewayUrl}${ENDPOINT_SEARCH}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json", "cue-project-id": request.projectId },
+        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}`);
+      throw new Error(
+        `Search request failed: ${response.status} ${response.statusText}`
+      );
     }
     return response.json();
   }
@@ -4188,48 +5293,71 @@ var CueApi = class {
    * 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 })
-    });
+  async sparql(query4, projectId, graphType) {
+    console.log(graphType);
+    const endpoint = graphType === "qlever" ? ENDPOINT_QLEVER_QUERY : ENDPOINT_FUSEKI_QUERY;
+    console.log(`Executing SPARQL query against ${endpoint} for project ${projectId} with graph type ${graphType ?? "fuseki"}`);
+    const urlencoded = new URLSearchParams();
+    urlencoded.append("query", query4);
+    const response = await this._auth.authenticatedFetch(
+      `${this._gatewayUrl}${endpoint}`,
+      {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/x-www-form-urlencoded",
+          "Accept": "application/sparql-results+json",
+          "x-project-id": projectId,
+          "cue-project-id": projectId
+        },
+        body: urlencoded
+      }
+    );
     if (!response.ok) {
-      throw new Error(`SPARQL query failed: ${response.status} ${response.statusText}`);
+      throw new Error(
+        `SPARQL query failed: ${response.status} ${response.statusText}`
+      );
     }
     return response.json();
   }
-  async getConsumption(projectId, tier) {
-    const headers = await this._authHeaders();
-    const response = await fetch(`${this._gatewayUrl}${ENDPOINT_CONSUMPTION}`, {
-      headers: {
-        ...headers,
-        "x-project-id": projectId,
-        ...tier ? { "x-tier": tier } : {}
+  async getConsumption(projectId) {
+    const response = await this._auth.authenticatedFetch(
+      `${this._gatewayUrl}${ENDPOINT_CONSUMPTION}`,
+      {
+        headers: {
+          "Content-Type": "application/json",
+          "x-project-id": projectId,
+          "cue-project-id": projectId
+        }
       }
-    });
+    );
     if (!response.ok) {
-      throw new Error(`Failed to fetch consumption: ${response.status} ${response.statusText}`);
+      throw new Error(
+        `Failed to fetch consumption: ${response.status} ${response.statusText}`
+      );
     }
     return response.json();
   }
 };
 
 // libs/js/cue-sdk/src/lib/project.ts
-var import_firestore2 = require("firebase/firestore");
-var COLLECTION_PROJECTS2 = "projects";
+var import_firestore3 = require("firebase/firestore");
+var import_functions2 = require("firebase/functions");
 var CueProjects = class {
   constructor(_auth, app, useEmulator = false, endpoints) {
     this._auth = _auth;
-    this._db = (0, import_firestore2.getFirestore)(app);
+    this._db = (0, import_firestore3.getFirestore)(app);
+    this._functions = (0, import_functions2.getFunctions)(app, GCP_REGION2);
+    this._gatewayUrl = endpoints?.gatewayUrl ?? "";
     if (useEmulator) {
       const host = endpoints?.firestoreEmulatorHost ?? "localhost";
       const port = endpoints?.firestoreEmulatorPort ?? 8080;
-      (0, import_firestore2.connectFirestoreEmulator)(this._db, host, port);
+      (0, import_firestore3.connectFirestoreEmulator)(this._db, host, port);
+      (0, import_functions2.connectFunctionsEmulator)(this._functions, "localhost", 5001);
     }
   }
   _db;
+  _functions;
+  _gatewayUrl;
   _requireUser() {
     const user = this._auth.currentUser;
     if (!user)
@@ -4241,60 +5369,31 @@ var CueProjects = class {
    * 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.`);
-    }
-    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;
+    const response = await this._auth.authenticatedFetch(`${this._gatewayUrl}${ENDPOINT_CREATE_PROJECT}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(options)
+    });
+    if (!response.ok) {
+      const body = await response.text().catch(() => "");
+      throw new Error(`Failed to create project: ${response.status} ${response.statusText}${body ? ` \u2014 ${body}` : ""}`);
+    }
+    return response.json();
   }
   /**
-   * 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.
+   * List all projects where the authenticated user appears in the members array.
+   * Access is gated by Firestore rules which check membership.
    */
   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);
-        }
-      }
-    }
-    return results;
+    const col = (0, import_firestore3.collection)(this._db, COLLECTION_PROJECTS2);
+    const snap = await (0, import_firestore3.getDocs)((0, import_firestore3.query)(col, (0, import_firestore3.where)("members", "array-contains", userId), (0, import_firestore3.limit)(100)));
+    return snap.docs.map((d) => d.data());
   }
   /** 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);
+    const ref6 = (0, import_firestore3.doc)((0, import_firestore3.collection)(this._db, COLLECTION_PROJECTS2), projectId);
+    const snap = await (0, import_firestore3.getDoc)(ref6);
     if (!snap.exists())
       return null;
     return snap.data();
@@ -4306,28 +5405,49 @@ var CueProjects = class {
   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)(),
+    const ref6 = (0, import_firestore3.doc)(this._db, "clientSync", projectId);
+    await (0, import_firestore3.setDoc)(ref6, {
+      unitsConsumed: (0, import_firestore3.increment)(units),
+      lastUpdated: (0, import_firestore3.serverTimestamp)(),
       lastUserId: userId
     }, { merge: true });
   }
+  /**
+   * Invite a user to a project by email. Returns the invited user's uid and display name.
+   */
+  async inviteUserToProject(email, projectId, role) {
+    const fn = (0, import_functions2.httpsCallable)(this._functions, "inviteUserToProject");
+    const res = await fn({ email, spaceId: projectId, role });
+    return res.data;
+  }
+  /** Change an existing member's role on a project. */
+  async changeUserRoleOnProject(uid, projectId, role) {
+    const fn = (0, import_functions2.httpsCallable)(this._functions, "changeUserRoleOnProject");
+    await fn({ uid, spaceId: projectId, role });
+  }
+  /** Remove a member from a project. */
+  async removeUserFromProject(uid, projectId) {
+    const fn = (0, import_functions2.httpsCallable)(this._functions, "removeUserFromProject");
+    await fn({ uid, spaceId: projectId });
+  }
 };
 
 // libs/js/cue-sdk/src/lib/profile.ts
 var import_auth4 = require("firebase/auth");
-var import_firestore3 = require("firebase/firestore");
-var COLLECTION_API_KEYS2 = "apiKeys";
+var import_firestore4 = require("firebase/firestore");
+var import_functions3 = require("firebase/functions");
 var CueProfile = class {
   constructor(_auth, app, useEmulator, emulatorHost, emulatorPort) {
     this._auth = _auth;
-    this._db = (0, import_firestore3.getFirestore)(app);
+    this._db = (0, import_firestore4.getFirestore)(app);
+    this._functions = (0, import_functions3.getFunctions)(app, GCP_REGION2);
     if (useEmulator) {
-      (0, import_firestore3.connectFirestoreEmulator)(this._db, emulatorHost, emulatorPort);
+      (0, import_firestore4.connectFirestoreEmulator)(this._db, emulatorHost, emulatorPort);
+      (0, import_functions3.connectFunctionsEmulator)(this._functions, "localhost", 5001);
     }
   }
   _db;
+  _functions;
   _apiKeyDocRef;
   /** Whether the current user has an active API key. */
   async hasAPIKey() {
@@ -4408,512 +5528,1197 @@ var CueProfile = class {
     const alphabet = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
     const randomKey = Array.from(globalThis.crypto.getRandomValues(new Uint8Array(150)), (b) => alphabet[b & 63]).join("");
     const data = { key: `cue-${randomKey}`, uid, expiration };
-    const col = (0, import_firestore3.collection)(this._db, COLLECTION_API_KEYS2);
-    this._apiKeyDocRef = await (0, import_firestore3.addDoc)(col, data);
+    const col = (0, import_firestore4.collection)(this._db, COLLECTION_API_KEYS2);
+    this._apiKeyDocRef = await (0, import_firestore4.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);
+    await (0, import_firestore4.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 };
+    const doc3 = (await (0, import_firestore4.getDoc)(this._apiKeyDocRef)).data();
+    return { key: doc3.key, expiration: doc3.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);
+    const col = (0, import_firestore4.collection)(this._db, COLLECTION_API_KEYS2);
+    const q = (0, import_firestore4.query)(col, (0, import_firestore4.where)("uid", "==", uid), (0, import_firestore4.limit)(1));
+    const snapshot = await (0, import_firestore4.getDocs)(q);
     if (!snapshot.empty)
       this._apiKeyDocRef = snapshot.docs[0].ref;
     return !snapshot.empty;
   }
+  /** Returns all organizations the current user is a member of. */
+  async listOrganizations() {
+    const uid = this._auth.currentUser?.uid;
+    if (!uid)
+      throw new Error("Not authenticated. Call cue.auth.signIn() first.");
+    const col = (0, import_firestore4.collection)(this._db, COLLECTION_ORGANIZATIONS2);
+    const q = (0, import_firestore4.query)(col, (0, import_firestore4.where)("members", "array-contains", uid));
+    const snap = await (0, import_firestore4.getDocs)(q);
+    return snap.docs.map((d) => d.data());
+  }
   _requireUser() {
     const user = this._auth.currentUser;
     if (!user)
       throw new Error("Not authenticated");
     return user;
   }
+  /**
+   * Fetch display name and email for a list of user UIDs.
+   * Uses the `getUserInfo` Firebase callable function.
+   */
+  async getUserInfo(uids) {
+    const fn = (0, import_functions3.httpsCallable)(this._functions, "getUserInfo");
+    const res = await fn({ uids });
+    return res.data;
+  }
+  /** Record that the current user has accepted the terms of service. */
+  async acceptTerms() {
+    const fn = (0, import_functions3.httpsCallable)(this._functions, "acceptTerms");
+    await fn({});
+  }
 };
 
-// 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
-  }
+// libs/js/cue-sdk/src/lib/privileges.ts
+var ROLE_HIERARCHY = ["superadmin", "admin", "syncer", "member"];
+var REQUIRED_ROLES = {
+  createEntities: "admin",
+  createProvider: "superadmin",
+  changeContentCategories: "syncer",
+  deleteDocuments: "superadmin",
+  deleteUserFromProject: "admin",
+  downloadDocuments: "member",
+  editContentCategories: "syncer",
+  editPublicReposAvailableToAgent: "admin",
+  editTier: "admin",
+  inviteUserToProject: "member",
+  renameDocuments: "superadmin",
+  uploadDocuments: "syncer",
+  viewEntities: "member"
 };
-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
+function defaultPrivileges() {
+  return {
+    changeContentCategories: false,
+    createEntities: false,
+    createProvider: false,
+    deleteDocuments: false,
+    deleteUserFromProject: false,
+    downloadDocuments: false,
+    editContentCategories: false,
+    editPublicReposAvailableToAgent: false,
+    editTier: false,
+    inviteUserToProject: false,
+    renameDocuments: false,
+    uploadDocuments: false,
+    viewEntities: false
+  };
+}
+var CuePrivileges = class {
+  constructor(_isSuperAdmin) {
+    this._isSuperAdmin = _isSuperAdmin;
+    this._projectRoles = new CueSignal([]);
+    this.privileges = cueComputed(
+      [this._projectRoles, _isSuperAdmin],
+      () => this._compute()
     );
   }
-  /** Override in subclasses to provide a custom CueApi (e.g. with sync). */
-  _buildApi(projects) {
-    return new CueApi(this.auth, this._endpoints.gatewayUrl, projects);
+  _projectRoles;
+  /**
+   * Reactive signal — current user's privileges for the selected project.
+   * Recomputes automatically when `setProjectRoles()` is called or when
+   * the `isSuperAdmin` signal changes.
+   */
+  privileges;
+  /**
+   * Set the user's roles for the currently selected project.
+   *
+   * Roles are expanded along the hierarchy: `admin` automatically includes
+   * `syncer` and `member`; `syncer` includes `member`. Pass an empty array
+   * to reset to the lowest privilege level.
+   */
+  setProjectRoles(roles) {
+    const expanded = this._expand(roles);
+    const current = this._projectRoles.get();
+    const same = current.length === expanded.length && current.every((r, i) => r === expanded[i]);
+    if (!same) {
+      this._projectRoles.set(expanded);
+    }
   }
-  /** Convenience: get the current user's Firebase ID token */
-  getToken(forceRefresh = false) {
-    return this.auth.getToken(forceRefresh);
+  _expand(roles) {
+    if (this._isSuperAdmin.get()) {
+      return ["superadmin", "admin", "syncer", "member"];
+    }
+    const highestIdx = ROLE_HIERARCHY.findIndex((r) => roles.includes(r));
+    if (highestIdx === -1)
+      return [];
+    return Array.from(ROLE_HIERARCHY.slice(highestIdx));
+  }
+  _compute() {
+    const roles = this._projectRoles.get();
+    const result = defaultPrivileges();
+    for (const key of Object.keys(REQUIRED_ROLES)) {
+      result[key] = roles.includes(REQUIRED_ROLES[key]);
+    }
+    return result;
   }
 };
 
-// libs/js/cue-sdk/src/lib/cue-node.ts
+// libs/js/cue-sdk/src/lib/cache.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;
-    }
+var CueCache = class {
+  constructor(_storage) {
+    this._storage = _storage;
   }
-  async ping() {
-    const query3 = "ASK { }";
-    const res = await this.query(query3);
-    return res.boolean;
+  // ── Query cache ────────────────────────────────────────────────────────────
+  async getQueryCache(projectId, id) {
+    return this._get(`portal/projects/${projectId}/queries`, id);
   }
-  async query(query3, accept = "application/sparql-results+json") {
-    let res;
+  async setQueryCache(projectId, id, payload) {
+    return this._set(`portal/projects/${projectId}/queries`, id, payload);
+  }
+  // ── Agent session cache ────────────────────────────────────────────────────
+  async getAgentSessionCache(projectId, id) {
+    return this._get(`portal/projects/${projectId}/agent`, id);
+  }
+  async setAgentSessionCache(projectId, id, payload) {
+    return this._set(`portal/projects/${projectId}/agent`, id, payload);
+  }
+  // ── User-project cache ─────────────────────────────────────────────────────
+  async getUserProjectCache(projectId, userId, id) {
+    return this._get(`portal/projects/${projectId}/users/${userId}`, id);
+  }
+  async setUserProjectCache(projectId, userId, id, payload) {
+    return this._set(
+      `portal/projects/${projectId}/users/${userId}`,
+      id,
+      payload
+    );
+  }
+  // ── Internal helpers ───────────────────────────────────────────────────────
+  async _get(basePath, id) {
     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 })
-      });
+      const blob = await (0, import_storage4.getBlob)((0, import_storage4.ref)(this._storage, `${basePath}/${id}.json.gz`));
+      const compressed = await blob.arrayBuffer();
+      const ds = new DecompressionStream("gzip");
+      const writer = ds.writable.getWriter();
+      const reader = ds.readable.getReader();
+      writer.write(new Uint8Array(compressed));
+      writer.close();
+      const chunks = [];
+      let result = await reader.read();
+      while (!result.done) {
+        chunks.push(result.value);
+        result = await reader.read();
+      }
+      const totalLength = chunks.reduce((s, c) => s + c.length, 0);
+      const out = new Uint8Array(totalLength);
+      let offset = 0;
+      for (const chunk of chunks) {
+        out.set(chunk, offset);
+        offset += chunk.length;
+      }
+      return JSON.parse(new TextDecoder().decode(out));
     } catch (err) {
-      throw new Error(
-        `Fuseki is not accessible at ${this.queryEndpoint}: ${err instanceof Error ? err.message : String(err)}`
-      );
+      if (_isNotFound(err))
+        return void 0;
+      throw err;
     }
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`Fuseki query failed (HTTP ${res.status}): ${body}`);
+  }
+  async _set(basePath, id, payload) {
+    const input = new TextEncoder().encode(JSON.stringify(payload));
+    const cs = new CompressionStream("gzip");
+    const writer = cs.writable.getWriter();
+    const reader = cs.readable.getReader();
+    writer.write(new Uint8Array(input));
+    writer.close();
+    const chunks = [];
+    let result = await reader.read();
+    while (!result.done) {
+      chunks.push(result.value);
+      result = await reader.read();
     }
-    return await res.json();
+    const totalLength = chunks.reduce((s, c) => s + c.length, 0);
+    const buffer = new Uint8Array(totalLength);
+    let offset = 0;
+    for (const chunk of chunks) {
+      buffer.set(chunk, offset);
+      offset += chunk.length;
+    }
+    await (0, import_storage4.uploadBytes)(
+      (0, import_storage4.ref)(this._storage, `${basePath}/${id}.json.gz`),
+      buffer,
+      { contentType: "application/gzip" }
+    );
   }
-  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
+};
+function _isNotFound(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "storage/object-not-found";
+}
+
+// libs/js/cue-sdk/src/lib/schema.ts
+var CueProjectSchema = class {
+  constructor(_api, _projectId, language, _queryCache, _graphType) {
+    this._api = _api;
+    this._projectId = _projectId;
+    this._queryCache = _queryCache;
+    this._graphType = _graphType;
+    this._language = new CueSignal(language);
+    this._contentCategories = new CueSignal([]);
+    this._entityCategories = new CueSignal([]);
+    this._relationships = new CueSignal([]);
+    this.availableContentCategories = this._contentCategories.asReadonly();
+    this.availableEntityCategories = this._entityCategories.asReadonly();
+    this.availableEntityRelationships = this._relationships.asReadonly();
+    this._load(language).catch(
+      (err) => console.error("[CueProjectSchema] Initial load failed:", err)
+    );
+  }
+  _cache = /* @__PURE__ */ new Map();
+  _language;
+  _contentCategories;
+  _entityCategories;
+  _relationships;
+  /** Currently active content categories for the selected language. */
+  availableContentCategories;
+  /** Currently active entity categories for the selected language. */
+  availableEntityCategories;
+  /** Currently active entity relationship types for the selected language. */
+  availableEntityRelationships;
+  /** Returns the currently active language. */
+  get language() {
+    return this._language.get();
+  }
+  /**
+   * Switch the active language. If the data for this language has already been
+   * fetched it is applied immediately from cache; otherwise a new SPARQL fetch
+   * is triggered.
+   */
+  setLanguage(lang) {
+    if (this._language.get() === lang)
+      return;
+    this._language.set(lang);
+    this._load(lang).catch(
+      (err) => console.error("[CueProjectSchema] Language switch failed:", err)
+    );
+  }
+  /**
+   * Force a re-fetch for the current language, bypassing the cache.
+   * Useful when the triplestore data has changed.
+   */
+  async refresh() {
+    const lang = this._language.get();
+    this._cache.delete(lang);
+    await this._load(lang);
+  }
+  // ── Private helpers ─────────────────────────────────────────────────────────
+  async _load(lang) {
+    const memCached = this._cache.get(lang);
+    if (memCached) {
+      this._apply(memCached);
+      return;
+    }
+    const qContent = this._buildCategoriesQuery(lang, "ContentCategory");
+    const qEntity = this._buildCategoriesQuery(lang, "EntityCategory");
+    const qRels = this._buildRelationshipsQuery(lang);
+    await staleWhileRevalidate(
+      qContent + qEntity + qRels,
+      async () => {
+        const [contentCategories, entityCategories, relationships] = await Promise.all([
+          this._runCategoriesQuery(qContent),
+          this._runCategoriesQuery(qEntity),
+          this._runRelationshipsQuery(qRels)
+        ]);
+        return { contentCategories, entityCategories, relationships };
       },
-      method: "POST",
-      body: new URLSearchParams({ query: query3 })
+      (snapshot) => {
+        this._cache.set(lang, snapshot);
+        if (this._language.get() === lang)
+          this._apply(snapshot);
+      },
+      this._queryCache
+    );
+  }
+  _apply(snapshot) {
+    this._contentCategories.set(snapshot.contentCategories);
+    this._entityCategories.set(snapshot.entityCategories);
+    this._relationships.set(snapshot.relationships);
+  }
+  async _fetchCategories(lang, type) {
+    return this._runCategoriesQuery(this._buildCategoriesQuery(lang, type));
+  }
+  _buildCategoriesQuery(lang, type) {
+    return `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+PREFIX skos: <${prefixCC["skos"]}>
+SELECT ?iri ?parent (SAMPLE(?l) AS ?label)
+WHERE {
+    ?iri a qcy:${type} .
+    OPTIONAL { ?iri skos:prefLabel ?lang_label FILTER(LANG(?lang_label) = "${lang}") }
+    OPTIONAL { ?iri skos:prefLabel ?no_lang_label }
+    BIND(COALESCE(?lang_label, ?no_lang_label) AS ?l)
+    OPTIONAL { ?iri skos:broader ?parent }
+}
+GROUP BY ?iri ?parent`;
+  }
+  async _runCategoriesQuery(query4) {
+    const data = await this._api.sparql(query4, this._projectId, this._graphType);
+    return data.results.bindings.filter((b) => b["iri"] !== void 0).map((b) => {
+      const iri = b["iri"].value;
+      return {
+        iri,
+        label: b["label"]?.value ?? iri.split("#").at(-1) ?? iri,
+        parent: b["parent"]?.value
+      };
     });
-    if (accept === "application/ld+json") {
-      return await res.json();
-    }
-    return await res.text();
   }
-  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 })
+  async _fetchRelationships(lang) {
+    return this._runRelationshipsQuery(this._buildRelationshipsQuery(lang));
+  }
+  _buildRelationshipsQuery(lang) {
+    return `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+PREFIX rdfs: <${prefixCC["rdfs"]}>
+SELECT ?iri ?parent (SAMPLE(?l) AS ?label)
+WHERE {
+    ?x qcy:relatedEntity ?y ;
+        ?iri ?y .
+    OPTIONAL { ?iri rdfs:label ?lang_label FILTER(LANG(?lang_label) = "${lang}") }
+    OPTIONAL { ?iri rdfs:label ?no_lang_label }
+    BIND(COALESCE(?lang_label, ?no_lang_label) AS ?l)
+    OPTIONAL { ?iri rdfs:subPropertyOf ?parent }
+}
+GROUP BY ?iri ?parent`;
+  }
+  async _runRelationshipsQuery(query4) {
+    const data = await this._api.sparql(query4, this._projectId, this._graphType);
+    return data.results.bindings.filter((b) => b["iri"] !== void 0).map((b) => {
+      const iri = b["iri"].value;
+      return {
+        iri,
+        label: b["label"]?.value ?? iri.split("#").at(-1) ?? iri,
+        parent: b["parent"]?.value
+      };
     });
-    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()
-    };
   }
 };
 
-// libs/js/databases/src/lib/graph/qlever.ts
-var import_zlib = require("zlib");
-var import_n3 = require("n3");
-var QLeverLockedError = class extends Error {
-  constructor(body) {
-    super(`QLever is locked (rebuild in progress): ${body}`);
-    this.name = "QLeverLockedError";
+// libs/js/cue-sdk/src/lib/entities.ts
+var OSM_ENDPOINT = "https://qlever.dev/api/osm-planet";
+var EXCLUDE_OSM_RELATION = true;
+var CueProjectEntities = class {
+  constructor(_api, _projectId, rdfBase = RESOURCE_BASE, _queryCache, _graphType) {
+    this._api = _api;
+    this._projectId = _projectId;
+    this._queryCache = _queryCache;
+    this._graphType = _graphType;
+    this.baseURL = `${rdfBase}${_projectId}/`;
+    this.entityInfoMap = this._entityInfoMapComputed;
+    this.entityGraph = this._entityGraph.asReadonly();
+    this._entityOSMMap.subscribe(() => this._checkPendingOSMFetches());
+    this._fetchEntityGraph().catch(
+      (err) => console.error("[CueProjectEntities] Entity graph fetch failed:", err)
+    );
+  }
+  /** Full RDF base URL for this project, e.g. `https://cue.qaecy.com/r/{pid}/` */
+  baseURL;
+  // ── Internal writable slices ───────────────────────────────────────────────
+  _entityDetails = new CueSignal({});
+  _entityDocuments = new CueSignal({});
+  _entityRelationships = new CueSignal({});
+  _entityOSMMap = new CueSignal({});
+  _osmWKTMap = new CueSignal({});
+  _fetchingOSMIds = /* @__PURE__ */ new Set();
+  _entityGraph = new CueSignal(void 0);
+  // ── Derived signals ────────────────────────────────────────────────────────
+  _entityInfoMapComputed = cueComputed(
+    [
+      this._entityDetails,
+      this._entityDocuments,
+      this._entityRelationships,
+      this._entityOSMMap,
+      this._osmWKTMap
+    ],
+    () => this._computeEntityInfoMap()
+  );
+  /** Merged per-entity detail map. Updated reactively as data arrives. */
+  entityInfoMap;
+  /** Project-level category graph (fetched once per project). */
+  entityGraph;
+  // ── Public helpers ─────────────────────────────────────────────────────────
+  /**
+   * Constructs the full RDF IRI for the given entity UUID.
+   * Use this to bridge the UUID-based batch APIs and the IRI-based per-entity APIs.
+   */
+  entityIri(uuid) {
+    return `${this.baseURL}${uuid}`;
+  }
+  /**
+   * Resets all entity state and re-fetches the entity graph.
+   * Call when the active project changes.
+   */
+  reset() {
+    this._entityDetails.set({});
+    this._entityDocuments.set({});
+    this._entityRelationships.set({});
+    this._entityOSMMap.set({});
+    this._osmWKTMap.set({});
+    this._entityGraph.set(void 0);
+    this._fetchingOSMIds.clear();
+    this._fetchEntityGraph().catch(
+      (err) => console.error("[CueProjectEntities] Entity graph fetch failed after reset:", err)
+    );
+  }
+  // ── Public imperative API ──────────────────────────────────────────────────
+  /**
+   * Lazily batch-fetches core data (label + categories) for the given entity
+   * UUIDs. Already-fetched UUIDs are skipped.
+   *
+   * Data is merged into `entityInfoMap` once the SPARQL response arrives.
+   */
+  requestEntityData(uuids, includeMentionCount = false) {
+    const newUUIDs = uuids.filter((id) => this._entityDetails.get()[id] === void 0);
+    if (newUUIDs.length === 0)
+      return;
+    const values = newUUIDs.map((id) => `r:${id}`).join(" ");
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+PREFIX r: <${this.baseURL}>
+SELECT ?id (SAMPLE(?val) AS ?value) (GROUP_CONCAT(DISTINCT STR(?cat); SEPARATOR=";") AS ?categories) ?mentionCount
+WHERE {
+    VALUES ?iri { ${values} }
+    ?iri qcy:hasEntityCategory ?cat ;
+         qcy:value ?val
+    BIND(REPLACE(STR(?iri), "^.*/([^/]*)$", "$1") AS ?id)
+    ${includeMentionCount ? `{SELECT ?iri (COUNT(?mention) AS ?mentionCount)
+     WHERE { ?mention qcy:resolvesTo ?iri } GROUP BY ?iri}` : ""}
+}
+GROUP BY ?id ?mentionCount`;
+    this._api.sparql(q, this._projectId, this._graphType).then((data) => {
+      const result = data;
+      const updates = { ...this._entityDetails.get() };
+      result.results.bindings.forEach((b) => {
+        if (!b["id"])
+          return;
+        const id = b["id"].value;
+        updates[id] = {
+          value: b["value"]?.value ?? "",
+          categories: b["categories"]?.value?.split(";").filter(Boolean) ?? [],
+          mentionCount: b["mentionCount"] ? parseInt(b["mentionCount"].value, 10) : void 0
+        };
+      });
+      this._entityDetails.set(updates);
+    }).catch(
+      (err) => console.error("[CueProjectEntities] requestEntityData failed:", err)
+    );
   }
-};
-var QLever = class _QLever {
-  queryEndpoint;
-  updateEndpoint;
-  dataEndpoint;
-  baseHeaders;
-  static RELEVANT_HEADER_KEYS = [
-    "authorization",
-    "Authorization",
-    "x-project-id",
-    "x-user-roles"
-    // add more if needed
-  ];
-  /** Max retries on 423 Locked (rebuild in progress). */
-  static LOCKED_MAX_RETRIES = parseInt(process.env["QLEVER_LOCKED_MAX_RETRIES"] ?? "10", 10);
-  /** Base delay (ms) for exponential backoff on 423. */
-  static LOCKED_BASE_DELAY_MS = parseInt(process.env["QLEVER_LOCKED_BASE_DELAY_MS"] ?? "2000", 10);
   /**
-   * Retry an async write operation on 423 Locked with exponential backoff + jitter.
-   * 423 means qlever accessor has an ongoing rebuild; we should wait and retry.
+   * Lazily fetches OSM location data for the given entity UUIDs.
+   * Already-fetched UUIDs are skipped.
+   *
+   * OSM WKT geometry is fetched in a second pass via a federated SPARQL SERVICE
+   * query and merged into `entityInfoMap` reactively once it arrives.
    */
-  static async _retryOnLocked(fn) {
-    const maxRetries = _QLever.LOCKED_MAX_RETRIES;
-    const baseDelayMs = _QLever.LOCKED_BASE_DELAY_MS;
-    let lastError;
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        return await fn();
-      } catch (err) {
-        lastError = err;
-        if (err instanceof QLeverLockedError && attempt < maxRetries) {
-          const jitter = 0.5 + Math.random();
-          const delay = baseDelayMs * Math.pow(2, attempt) * jitter;
-          await new Promise((resolve2) => setTimeout(resolve2, delay));
-          continue;
-        }
-        throw err;
-      }
+  async requestEntityLocations(uuids) {
+    const newUUIDs = uuids.filter((id) => this._entityOSMMap.get()[id] === void 0);
+    if (newUUIDs.length === 0)
+      return;
+    const osmInit = { ...this._entityOSMMap.get() };
+    for (const id of newUUIDs)
+      osmInit[id] = { direct: [], indirect: [] };
+    this._entityOSMMap.set(osmInit);
+    const values = newUUIDs.map((id) => `r:${id}`).join(" ");
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+PREFIX r: <${this.baseURL}>
+SELECT ?id ?osm ?direct ?rels ?entityUUID
+WHERE {
+  VALUES ?iri { ${values} }
+  {
+    SELECT ?iri ?osm ?direct
+    WHERE {
+      ?iri qcy:similarTo ?osm .
+      FILTER STRSTARTS(STR(?osm), "https://www.openstreetmap.org/")
+      BIND(true AS ?direct)
     }
-    throw lastError;
   }
-  constructor(graphOptions) {
-    this.queryEndpoint = graphOptions.queryEndpoint;
-    this.updateEndpoint = graphOptions.updateEndpoint;
-    this.dataEndpoint = this.updateEndpoint.replace(/\/update$/, "/data");
-    this.baseHeaders = Object.fromEntries(
-      Object.entries(graphOptions.originalHeaders || {}).filter(
-        ([key]) => _QLever.RELEVANT_HEADER_KEYS.includes(key)
-      )
-    );
-    this.baseHeaders["x-user-roles"] = "admin";
+  UNION
+  {
+    SELECT ?iri ?osm ?direct ?entityUUID (GROUP_CONCAT(STR(?rel); SEPARATOR=";") AS ?rels)
+    WHERE {
+      ?iri qcy:relatedEntity ?loc .
+      ?iri ?rel ?loc .
+      ?loc qcy:similarTo ?osm .
+      FILTER STRSTARTS(STR(?osm), "https://www.openstreetmap.org/")
+      FILTER(?rel != qcy:relatedEntity)
+      BIND(false AS ?direct)
+      BIND(REPLACE(STR(?loc), "^.*/([^/]*)$", "$1") AS ?entityUUID)
+    } GROUP BY ?iri ?osm ?direct ?entityUUID
+  }
+  BIND(REPLACE(STR(?iri), "^.*/([^/]*)$", "$1") AS ?id)
+}`;
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const update = { ...this._entityOSMMap.get() };
+    data.results.bindings.forEach((b) => {
+      if (!b["id"] || !b["osm"])
+        return;
+      const id = b["id"].value;
+      const osm = b["osm"].value;
+      const direct = b["direct"]?.value === "true";
+      const rels = b["rels"]?.value?.split(";").filter(Boolean) ?? [];
+      const entityUUID = b["entityUUID"]?.value;
+      const entry = update[id] ?? { direct: [], indirect: [] };
+      if (direct) {
+        entry.direct.push(osm);
+      } else if (entityUUID) {
+        entry.indirect.push({ osm, viaRels: rels, entityUUID });
+      }
+      update[id] = entry;
+    });
+    this._entityOSMMap.set(update);
   }
-  async ping() {
-    const query3 = "ASK { }";
-    const res = await this.query(query3);
-    return res.boolean;
+  /**
+   * Fetches incoming and outgoing relationships for a single entity IRI.
+   * Neighbouring entity core data is opportunistically populated into
+   * `entityInfoMap` as a side-effect.
+   *
+   * The result is stored in `entityInfoMap[uuid].relationshipData` and also
+   * returned directly for callers that need an immediate value.
+   */
+  async fetchEntityRelationships(iri) {
+    const uuid = iri.replace(/^.*\/([^/]*)$/, "$1");
+    this._entityRelationships.set({
+      ...this._entityRelationships.get(),
+      [uuid]: { incoming: [], outgoing: [] }
+    });
+    const [outgoing, incoming] = await Promise.all([
+      this._fetchOutgoingRelationships(iri),
+      this._fetchIncomingRelationships(iri)
+    ]);
+    const result = { outgoing, incoming };
+    this._entityRelationships.set({ ...this._entityRelationships.get(), [uuid]: result });
+    return result;
   }
-  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(
-        `QLever is not accessible at ${this.queryEndpoint}: ${err instanceof Error ? err.message : String(err)}`
-      );
+  /**
+   * Fetches UUIDs of documents that reference the given entity IRI.
+   * Also triggers a core-data fetch for the entity itself if not yet loaded.
+   *
+   * Returns document UUIDs. Full document data will be populated by the
+   * document service (future `CueProjectDocuments`).
+   */
+  async fetchEntityDocuments(iri) {
+    const uuid = iri.replace(/^.*\/([^/]*)$/, "$1");
+    this._entityDocuments.set({ ...this._entityDocuments.get(), [uuid]: [] });
+    if (this._entityDetails.get()[uuid] === void 0) {
+      this.requestEntityData([uuid]);
     }
-    if (!res.ok) {
-      const body = await res.text();
-      throw new Error(`QLever query failed (HTTP ${res.status}): ${body}`);
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT DISTINCT ?id
+WHERE {
+    BIND(<${iri}> AS ?iri)
+    ?doc a qcy:FileContent ;
+         qcy:about ?iri .
+    BIND(REPLACE(STR(?doc), "^.*/([^/]*)$", "$1") AS ?id)
+}`;
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const ids = data.results.bindings.filter((b) => b["id"] !== void 0).map((b) => b["id"].value);
+    this._entityDocuments.set({ ...this._entityDocuments.get(), [uuid]: ids });
+    return ids;
+  }
+  // ── Private helpers ────────────────────────────────────────────────────────
+  _computeEntityInfoMap() {
+    const details = this._entityDetails.get();
+    const docs = this._entityDocuments.get();
+    const rels = this._entityRelationships.get();
+    const osmMap = this._entityOSMMap.get();
+    const wktMap = this._osmWKTMap.get();
+    const allIds = /* @__PURE__ */ new Set([
+      ...Object.keys(details),
+      ...Object.keys(osmMap).filter((k) => {
+        const e = osmMap[k];
+        return e.direct.length > 0 || e.indirect.length > 0;
+      })
+    ]);
+    const result = {};
+    for (const id of allIds) {
+      const data = details[id];
+      const osmData = osmMap[id];
+      let directMapGeometries;
+      let indirectMapGeometries;
+      if (osmData) {
+        const directSet = /* @__PURE__ */ new Set();
+        directMapGeometries = osmData.direct.filter(
+          (osm) => wktMap[osm] !== void 0 && !directSet.has(osm) && Boolean(directSet.add(osm))
+        ).map((osm) => ({ osmIRI: osm, wkt: wktMap[osm] }));
+        const byRel = /* @__PURE__ */ new Map();
+        for (const { osm, viaRels, entityUUID } of osmData.indirect) {
+          const wkt = wktMap[osm];
+          if (!wkt)
+            continue;
+          for (const rel of viaRels) {
+            const key = `${rel}:${entityUUID}`;
+            const entry = byRel.get(key) ?? { geometries: [], entityUUID };
+            if (!entry.geometries.some((g) => g.osmIRI === osm)) {
+              entry.geometries.push({ osmIRI: osm, wkt });
+              byRel.set(key, entry);
+            }
+          }
+        }
+        if (byRel.size > 0) {
+          indirectMapGeometries = Array.from(byRel.entries()).map(
+            ([key, { geometries, entityUUID }]) => ({
+              rel: key.split(":")[0],
+              geometries,
+              entityUUID
+            })
+          );
+        }
+      }
+      result[id] = {
+        value: data?.value ?? "",
+        categories: data?.categories ?? [],
+        mentionCount: data?.mentionCount,
+        documentRefs: docs[id],
+        relationshipData: rels[id],
+        directMapGeometries,
+        indirectMapGeometries
+      };
     }
-    return await res.json();
+    return result;
   }
-  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 })
+  async _fetchOutgoingRelationships(iri) {
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT ?rel ?related (SAMPLE(?val) AS ?nodeValue) (GROUP_CONCAT(STR(?cat); SEPARATOR=";") AS ?categories)
+WHERE {
+    BIND(<${iri}> AS ?s)
+    ?s qcy:relatedEntity ?related ;
+       ?rel ?related .
+    ?related qcy:hasEntityCategory ?cat ;
+             qcy:value ?val
+    FILTER(?rel != qcy:relatedEntity)
+}
+GROUP BY ?rel ?related`;
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const result = [];
+    const detailsUpdate = { ...this._entityDetails.get() };
+    data.results.bindings.forEach((b) => {
+      if (!b["rel"] || !b["related"])
+        return;
+      const nodeCategories = b["categories"]?.value?.split(";").filter(Boolean) ?? [];
+      result.push({
+        relIRI: b["rel"].value,
+        nodeIRI: b["related"].value,
+        nodeValue: b["nodeValue"]?.value ?? "",
+        nodeCategories
+      });
+      const nodeUUID = b["related"].value.replace(/^.*\/([^/]*)$/, "$1");
+      detailsUpdate[nodeUUID] = {
+        value: b["nodeValue"]?.value ?? "",
+        categories: nodeCategories
+      };
     });
-    return await res.text();
+    this._entityDetails.set(detailsUpdate);
+    return result;
   }
-  async update(update) {
-    return _QLever._retryOnLocked(async () => {
-      const res = await fetch(this.updateEndpoint, {
-        headers: {
-          ...this.baseHeaders,
-          "Content-Type": "application/x-www-form-urlencoded"
-        },
-        method: "POST",
-        body: new URLSearchParams({ update })
+  async _fetchIncomingRelationships(iri) {
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT ?rel ?relating (SAMPLE(?val) AS ?nodeValue) (GROUP_CONCAT(STR(?cat); SEPARATOR=";") AS ?categories)
+WHERE {
+    BIND(<${iri}> AS ?s)
+    ?relating qcy:relatedEntity ?s ;
+              ?rel ?s .
+    ?relating qcy:hasEntityCategory ?cat ;
+              qcy:value ?val
+    FILTER(?rel != qcy:relatedEntity)
+}
+GROUP BY ?rel ?relating`;
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const result = [];
+    const detailsUpdate = { ...this._entityDetails.get() };
+    data.results.bindings.forEach((b) => {
+      if (!b["rel"] || !b["relating"])
+        return;
+      const nodeCategories = b["categories"]?.value?.split(";").filter(Boolean) ?? [];
+      result.push({
+        relIRI: b["rel"].value,
+        nodeIRI: b["relating"].value,
+        nodeValue: b["nodeValue"]?.value ?? "",
+        nodeCategories
       });
-      if (!res.ok) {
-        const body = await res.text();
-        if (res.status === 423)
-          throw new QLeverLockedError(body);
-        throw new Error(`SPARQL update failed (HTTP ${res.status}): ${body}`);
+      const nodeUUID = b["relating"].value.replace(/^.*\/([^/]*)$/, "$1");
+      detailsUpdate[nodeUUID] = {
+        value: b["nodeValue"]?.value ?? "",
+        categories: nodeCategories
+      };
+    });
+    this._entityDetails.set(detailsUpdate);
+    return result;
+  }
+  async _fetchEntityGraph() {
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT ?e1Cat ?e2Cat (COUNT(?e1) AS ?e1Count) (COUNT(?e2) AS ?e2Count)
+WHERE {
+    ?e1 a qcy:CanonicalEntity ;
+        qcy:hasEntityCategory ?e1Cat ;
+        qcy:relatedEntity ?e2 .
+    ?e2 qcy:hasEntityCategory ?e2Cat
+}
+GROUP BY ?e1Cat ?e2Cat`;
+    await staleWhileRevalidate(
+      q,
+      async () => {
+        const data = await this._api.sparql(q, this._projectId, this._graphType);
+        const entities = [];
+        const relations = [];
+        data.results.bindings.forEach((b) => {
+          if (!b["e1Cat"] || !b["e2Cat"])
+            return;
+          const e1Cat = b["e1Cat"].value;
+          const e2Cat = b["e2Cat"].value;
+          const e1Size = b["e1Count"] ? parseInt(b["e1Count"].value, 10) || 20 : 20;
+          const e2Size = b["e2Count"] ? parseInt(b["e2Count"].value, 10) || 20 : 20;
+          if (!entities.some((n) => n.iri === e1Cat))
+            entities.push({ iri: e1Cat, size: e1Size });
+          if (!entities.some((n) => n.iri === e2Cat))
+            entities.push({ iri: e2Cat, size: e2Size });
+          relations.push({ sourceID: e1Cat, targetID: e2Cat });
+        });
+        return { entities, relations };
+      },
+      (graph) => this._entityGraph.set(graph),
+      this._queryCache
+    );
+  }
+  /** Detects new OSM IRIs in the OSM map that don't yet have WKT and fetches them. */
+  _checkPendingOSMFetches() {
+    const osmMap = this._entityOSMMap.get();
+    const wktMap = this._osmWKTMap.get();
+    const pending = [];
+    for (const entry of Object.values(osmMap)) {
+      for (const osm of entry.direct) {
+        if (!wktMap[osm] && !this._fetchingOSMIds.has(osm))
+          pending.push(osm);
       }
-      return await res.json();
+      for (const { osm } of entry.indirect) {
+        if (!wktMap[osm] && !this._fetchingOSMIds.has(osm))
+          pending.push(osm);
+      }
+    }
+    if (pending.length === 0)
+      return;
+    for (const osm of pending)
+      this._fetchingOSMIds.add(osm);
+    this._fetchOSMLocations(pending).catch(
+      (err) => console.error("[CueProjectEntities] OSM WKT fetch failed:", err)
+    );
+  }
+  async _fetchOSMLocations(osmIRIs) {
+    const filtered = EXCLUDE_OSM_RELATION ? osmIRIs.filter((iri) => !iri.includes("/relation/")) : osmIRIs;
+    if (filtered.length === 0)
+      return;
+    const values = filtered.map((iri) => `<${iri}>`).join(" ");
+    const q = `PREFIX geo: <${prefixCC["geo"]}>
+SELECT * WHERE {
+    VALUES ?s { ${values} }
+    SERVICE <${OSM_ENDPOINT}> {
+        ?s geo:hasGeometry/geo:asWKT ?wkt
+    }
+}`;
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const update = { ...this._osmWKTMap.get() };
+    data.results.bindings.forEach((b) => {
+      if (!b["s"] || !b["wkt"])
+        return;
+      update[b["s"].value] = b["wkt"].value;
+      this._fetchingOSMIds.delete(b["s"].value);
     });
+    this._osmWKTMap.set(update);
   }
+};
+
+// libs/js/cue-sdk/src/lib/documents.ts
+var CueProjectDocuments = class {
+  constructor(_api, _projectId, language, rdfBase = RESOURCE_BASE, _queryCache, _graphType) {
+    this._api = _api;
+    this._projectId = _projectId;
+    this._queryCache = _queryCache;
+    this._graphType = _graphType;
+    this.baseURL = `${rdfBase}${_projectId}/`;
+    this._language = language;
+    this.documentInfoMap = this._documentInfoMap.asReadonly();
+    this.projectDocumentsData = this._projectDocumentsData.asReadonly();
+  }
+  /** Full RDF base URL for this project, e.g. `https://cue.qaecy.com/r/{pid}/` */
+  baseURL;
+  _language;
+  _documentInfoMap = new CueSignal({});
+  _projectDocumentsData = new CueSignal({
+    duplicateCount: 0,
+    documentsBySuffix: {},
+    documentsByContentCategory: {}
+  });
+  /** Lazily populated per-document detail map. */
+  documentInfoMap;
+  /** Project-level document overview (grouped counts + sizes). */
+  projectDocumentsData;
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
   /**
-   * Insert quads via the /data endpoint, grouped by named graph.
-   * This is preferred over SPARQL INSERT DATA for QLever because
-   * the /data endpoint correctly registers named graphs in the index.
+   * Resets all document state. Call when the active project changes.
+   * Follow with `fetchOverview()` once the triplestore is ready.
    */
-  async insertData(quads) {
-    await this._postToDataEndpoint(quads, this.dataEndpoint);
+  reset() {
+    this._documentInfoMap.set({});
+    this._projectDocumentsData.set({
+      duplicateCount: 0,
+      documentsBySuffix: {},
+      documentsByContentCategory: {}
+    });
   }
   /**
-   * Delete quads via the /data/delete endpoint, grouped by named graph.
+   * Updates the active language and clears the document info map so that
+   * language-sensitive fields (subject, summary) are re-fetched on the next
+   * `requestDocumentData()` call.
    */
-  async deleteData(quads) {
-    await this._postToDataEndpoint(quads, `${this.dataEndpoint}/delete`);
-  }
-  async _postToDataEndpoint(quads, baseUrl) {
-    const nquads = await this._quadsToNQuads(quads);
-    const body = new Uint8Array((0, import_zlib.gzipSync)(Buffer.from(nquads, "utf-8")));
-    await _QLever._retryOnLocked(async () => {
-      const res = await fetch(baseUrl, {
-        method: "POST",
-        headers: {
-          ...this.baseHeaders,
-          "Content-Type": "application/n-quads",
-          "Content-Encoding": "gzip"
-        },
-        body
-      });
-      if (!res.ok) {
-        const text = await res.text();
-        if (res.status === 423)
-          throw new QLeverLockedError(text);
-        throw new Error(`QLever data POST failed (HTTP ${res.status}): ${text}`);
-      }
-    });
+  setLanguage(lang) {
+    if (this._language === lang)
+      return;
+    this._language = lang;
+    this._documentInfoMap.set({});
   }
-  _quadsToNQuads(quads) {
-    return new Promise((resolve2, reject) => {
-      const writer = new import_n3.Writer({ format: "application/n-quads" });
-      writer.addQuads(quads);
-      writer.end((err, result) => err ? reject(err) : resolve2(result));
+  // ── Public API ─────────────────────────────────────────────────────────────
+  /**
+   * Fetches the three-part project overview (by suffix, by content category,
+   * duplicate count) in parallel and writes them as a single atomic update to
+   * `projectDocumentsData`. Safe to call again to refresh.
+   */
+  async fetchOverview() {
+    this._projectDocumentsData.set({
+      duplicateCount: 0,
+      documentsBySuffix: {},
+      documentsByContentCategory: {}
     });
+    const qSuffix = this._buildDocumentsBySuffixQuery();
+    const qCategory = this._buildDocumentsByContentCategoryQuery();
+    const qDuplicates = this._buildDuplicateCountQuery();
+    await staleWhileRevalidate(
+      qSuffix + qCategory + qDuplicates,
+      async () => {
+        const [bySuffix, byCategory, duplicateCount] = await Promise.all([
+          this._runDocumentsBySuffixQuery(qSuffix),
+          this._runDocumentsByContentCategoryQuery(qCategory),
+          this._runDuplicateCountQuery(qDuplicates)
+        ]);
+        return { duplicateCount, documentsBySuffix: bySuffix, documentsByContentCategory: byCategory };
+      },
+      (overview) => this._projectDocumentsData.set(overview),
+      this._queryCache
+    );
   }
-};
+  /**
+   * Lazily batch-fetches core metadata for the given document UUIDs.
+   * Already-cached UUIDs are skipped. Data is merged into `documentInfoMap`
+   * once the SPARQL response arrives.
+   */
+  requestDocumentData(uuids) {
+    const newUUIDs = uuids.filter((id) => this._documentInfoMap.get()[id] === void 0);
+    if (newUUIDs.length === 0)
+      return;
+    const values = newUUIDs.map((id) => `r:${id}`).join(" ");
+    const lang = this._language;
+    const q = `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+PREFIX r: <${this.baseURL}>
+SELECT ?id ?contentIRI ?suffix ?size ?subject ?summary
+    (SAMPLE(?fp) AS ?path)
+    (GROUP_CONCAT(DISTINCT ?tag; SEPARATOR=";") AS ?tags)
+    (GROUP_CONCAT(DISTINCT STR(?cat); SEPARATOR=";") AS ?categories)
+WHERE {
+    VALUES ?contentIRI { ${values} }
+    ?contentIRI qcy:sizeBytes ?size ;
+                qcy:hasFileLocation ?loc .
+    ?loc qcy:filePath ?fp ;
+         qcy:suffix ?suffix .
+    OPTIONAL { ?contentIRI qcy:hasContentCategory ?cat }
+    OPTIONAL { ?contentIRI qcy:tag ?tag }
+    OPTIONAL { ?loc qcy:remoteProviderId ?pid }
 
-// 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}`);
+    OPTIONAL { ?contentIRI qcy:subject ?lang_subj FILTER(LANG(?lang_subj) = "${lang}") }
+    OPTIONAL { ?contentIRI qcy:subject ?no_lang_subj }
+    BIND(COALESCE(?lang_subj, ?no_lang_subj) AS ?subject)
+
+    OPTIONAL { ?contentIRI qcy:textSummary ?lang_summary FILTER(LANG(?lang_summary) = "${lang}") }
+    OPTIONAL { ?contentIRI qcy:textSummary ?no_lang_summary }
+    BIND(COALESCE(?lang_summary, ?no_lang_summary) AS ?summary)
+
+    BIND(REPLACE(STR(?contentIRI), "^.*/([^/]*)$", "$1") AS ?id)
+}
+GROUP BY ?id ?contentIRI ?suffix ?size ?subject ?summary`;
+    this._api.sparql(q, this._projectId).then((data) => {
+      const result = data;
+      const updates = { ...this._documentInfoMap.get() };
+      result.results.bindings.forEach((b) => {
+        if (!b["id"] || !b["contentIRI"])
+          return;
+        const id = b["id"].value;
+        updates[id] = {
+          id,
+          contentIRI: b["contentIRI"].value,
+          path: b["path"]?.value ?? "",
+          suffix: b["suffix"]?.value ?? "",
+          size: b["size"] ? parseInt(b["size"].value, 10) : 0,
+          tags: b["tags"]?.value?.split(";").filter(Boolean) ?? [],
+          categories: b["categories"]?.value?.split(";").filter(Boolean) ?? [],
+          subject: b["subject"]?.value,
+          summary: b["summary"]?.value,
+          providerId: b["pid"]?.value
+        };
+      });
+      this._documentInfoMap.set(updates);
+    }).catch(
+      (err) => console.error("[CueProjectDocuments] requestDocumentData failed:", err)
+    );
+  }
+  // ── Private helpers ────────────────────────────────────────────────────────
+  async _fetchDocumentsBySuffix() {
+    return this._runDocumentsBySuffixQuery(this._buildDocumentsBySuffixQuery());
+  }
+  _buildDocumentsBySuffixQuery() {
+    return `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT ?ext (SUM(?size) AS ?totalSize) (COUNT(*) AS ?docCount)
+WHERE {
+  {
+    SELECT DISTINCT ?fc ?ext ?size
+    WHERE {
+      ?fc a qcy:FileContent ;
+          qcy:sizeBytes ?size ;
+          qcy:hasFileLocation/qcy:suffix ?ext .
+      FILTER NOT EXISTS { ?x qcy:alternativeRepresentation ?fc }
     }
   }
-  _db;
-  ping() {
-    return this._db.ping();
+}
+GROUP BY ?ext
+ORDER BY DESC(?docCount)`;
+  }
+  async _runDocumentsBySuffixQuery(q) {
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const result = {};
+    data.results.bindings.forEach((b) => {
+      if (!b["ext"])
+        return;
+      result[b["ext"].value] = {
+        size: b["totalSize"] ? parseInt(b["totalSize"].value, 10) : 0,
+        count: b["docCount"] ? parseInt(b["docCount"].value, 10) : 0
+      };
+    });
+    return result;
   }
-  query(queryString, accept) {
-    return this._db.query(queryString, accept);
+  async _fetchDocumentsByContentCategory() {
+    return this._runDocumentsByContentCategoryQuery(this._buildDocumentsByContentCategoryQuery());
   }
-  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
-      );
+  _buildDocumentsByContentCategoryQuery() {
+    return `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT ?cat (SUM(?size) AS ?totalSize) (COUNT(*) AS ?docCount)
+WHERE {
+  {
+    SELECT DISTINCT ?fc ?cat ?size
+    WHERE {
+      ?fc a qcy:FileContent ;
+          qcy:hasContentCategory ?cat ;
+          qcy:sizeBytes ?size .
+      FILTER NOT EXISTS { ?x qcy:alternativeRepresentation ?fc }
     }
-    return this._db.subset(queryString, accept);
   }
-  update(updateString) {
-    return this._db.update(updateString);
+}
+GROUP BY ?cat
+ORDER BY DESC(?docCount)`;
+  }
+  async _runDocumentsByContentCategoryQuery(q) {
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const result = {};
+    data.results.bindings.forEach((b) => {
+      if (!b["cat"])
+        return;
+      result[b["cat"].value] = {
+        size: b["totalSize"] ? parseInt(b["totalSize"].value, 10) : 0,
+        count: b["docCount"] ? parseInt(b["docCount"].value, 10) : 0
+      };
+    });
+    return result;
   }
-  /** Returns true if this backend supports the /data bulk-insert endpoint (QLever only). */
-  supportsDataEndpoint() {
-    return this.options.graphType === "qlever";
+  async _fetchDuplicateCount() {
+    return this._runDuplicateCountQuery(this._buildDuplicateCountQuery());
+  }
+  _buildDuplicateCountQuery() {
+    return `PREFIX qcy: <${qaecyPrefixes["qcy"]}>
+SELECT (COUNT(*) AS ?count)
+WHERE {
+  SELECT ?fc
+  WHERE {
+    ?fc a qcy:FileContent ;
+        qcy:hasFileLocation ?fl .
+    FILTER NOT EXISTS { ?x qcy:alternativeRepresentation ?fc }
+  }
+  GROUP BY ?fc
+  HAVING (COUNT(?fl) > 1)
+}`;
+  }
+  async _runDuplicateCountQuery(q) {
+    const data = await this._api.sparql(q, this._projectId, this._graphType);
+    const first = data.results.bindings[0];
+    return first?.["count"] ? parseInt(first["count"].value, 10) : 0;
+  }
+};
+
+// libs/js/cue-sdk/src/lib/project-view.ts
+var CueProjectView = class {
+  constructor(_api, _projectId, { language, queryCache, rdfBase = RESOURCE_BASE, graphType }) {
+    this._api = _api;
+    this._projectId = _projectId;
+    this.schema = new CueProjectSchema(_api, _projectId, language, queryCache, graphType);
+    this.entities = new CueProjectEntities(_api, _projectId, rdfBase, queryCache, graphType);
+    this.documents = new CueProjectDocuments(_api, _projectId, language, rdfBase, queryCache, graphType);
+    this.availableContentCategories = this.schema.availableContentCategories;
+    this.availableEntityCategories = this.schema.availableEntityCategories;
+    this.availableEntityRelationships = this.schema.availableEntityRelationships;
+    this.entityInfoMap = this.entities.entityInfoMap;
+    this.entityGraph = this.entities.entityGraph;
+    this.documentInfoMap = this.documents.documentInfoMap;
+    this.projectDocumentsData = this.documents.projectDocumentsData;
+    this.searchResults = this._searchResults.asReadonly();
+    this.documents.fetchOverview().catch((err) => console.error("[CueProjectView] fetchOverview failed:", err));
+  }
+  /** Direct access to the schema data class (available categories / relationships). */
+  schema;
+  /** Direct access to the entity data class. */
+  entities;
+  /** Direct access to the document data class. */
+  documents;
+  // ── Proxied signals ────────────────────────────────────────────────────────
+  /** Available content category definitions for this project. Auto-fetched on init. */
+  availableContentCategories;
+  /** Available entity category definitions for this project. Auto-fetched on init. */
+  availableEntityCategories;
+  /** Available entity relationship types. Auto-fetched on init. */
+  availableEntityRelationships;
+  /** Merged per-entity detail map. Populated lazily via `requestEntityData()` etc. */
+  entityInfoMap;
+  /** Project-level entity co-occurrence graph. Fetched once on init. */
+  entityGraph;
+  /** Per-document info map. Populated lazily via `requestDocumentData()`. */
+  documentInfoMap;
+  /** Project document overview (counts by suffix and category). Fetched on init. */
+  projectDocumentsData;
+  // ── Search state ───────────────────────────────────────────────────────────
+  _searchResults = new CueSignal(void 0);
+  /** The result of the most recent `search()` call. `undefined` before first search. */
+  searchResults;
+  _destroyed = false;
+  // ── Entity methods ─────────────────────────────────────────────────────────
+  /**
+   * Lazily batch-fetch core data (label + categories) for the given entity UUIDs.
+   * Already-fetched UUIDs are skipped. Populates `entityInfoMap`.
+   */
+  requestEntityData(uuids, includeMentionCount = false) {
+    if (this._destroyed)
+      return;
+    this.entities.requestEntityData(uuids, includeMentionCount);
   }
   /**
-   * Insert quads using the backend's preferred bulk-insert mechanism.
-   * For QLever: uses the /data endpoint (correctly registers named graphs).
-   * For Fuseki: falls back to SPARQL INSERT DATA.
+   * Lazily fetch OSM location data for the given entity UUIDs.
+   * Already-fetched UUIDs are skipped. Populates `entityInfoMap` geometry fields.
    */
-  insertData(quads) {
-    if (this.options.graphType === "qlever") {
-      return this._db.insertData(quads);
-    }
-    return Promise.reject(new Error("insertData not supported for Fuseki \u2014 use update() with SPARQL INSERT DATA"));
+  async requestEntityLocations(uuids) {
+    if (this._destroyed)
+      return;
+    return this.entities.requestEntityLocations(uuids);
   }
   /**
-   * Delete quads using the backend's preferred bulk-delete mechanism.
-   * For QLever: uses the /data/delete endpoint.
-   * For Fuseki: falls back to SPARQL DELETE DATA.
+   * Fetch incoming and outgoing relationships for a single entity IRI.
+   * Result is stored in `entityInfoMap[uuid].relationshipData`.
    */
-  deleteData(quads) {
-    if (this.options.graphType === "qlever") {
-      return this._db.deleteData(quads);
-    }
-    return Promise.reject(new Error("deleteData not supported for Fuseki \u2014 use update() with SPARQL DELETE DATA"));
+  async fetchEntityRelationships(iri) {
+    if (this._destroyed)
+      throw new Error("CueProjectView is destroyed");
+    return this.entities.fetchEntityRelationships(iri);
   }
-};
-
-// libs/js/databases/src/lib/blob/blob.ts
-var import_storage3 = require("firebase/storage");
-var CueBlobStorage = class {
-  constructor(options) {
-    this.options = options;
+  /**
+   * Fetch UUIDs of documents that reference the given entity IRI.
+   * Result is stored in `entityInfoMap[uuid].documentRefs`.
+   */
+  async fetchEntityDocuments(iri) {
+    if (this._destroyed)
+      throw new Error("CueProjectView is destroyed");
+    return this.entities.fetchEntityDocuments(iri);
+  }
+  /** Constructs the full RDF IRI for an entity UUID. */
+  entityIri(uuid) {
+    return this.entities.entityIri(uuid);
   }
+  // ── Document methods ───────────────────────────────────────────────────────
   /**
-   * Upload binary data to the raw storage bucket with retry logic.
+   * Lazily batch-fetch document info for the given UUIDs.
+   * Already-fetched UUIDs are skipped. Populates `documentInfoMap`.
    */
-  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));
-        }
-      }
+  requestDocumentData(uuids) {
+    if (this._destroyed)
+      return;
+    this.documents.requestDocumentData(uuids);
+  }
+  // ── Search ─────────────────────────────────────────────────────────────────
+  /**
+   * Run a natural-language search against the project.
+   * The result is stored in `searchResults` and replaces any previous result.
+   */
+  async search(term, options) {
+    if (this._destroyed)
+      return;
+    const result = await this._api.search({
+      term,
+      projectId: this._projectId,
+      categories: options?.categories
+    });
+    if (!this._destroyed) {
+      this._searchResults.set(result);
     }
-    throw lastError;
   }
+  // ── Lifecycle ──────────────────────────────────────────────────────────────
   /**
-   * Upload data to the processed storage bucket.
-   * Skips upload and returns `false` if the blob already exists.
+   * Switch the active language for schema labels and document text fields.
+   * Schema responses are cached per language (instant if previously loaded).
+   * The document info map is cleared and lazily re-populated on next access.
    */
-  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;
+  setLanguage(lang) {
+    if (this._destroyed)
+      return;
+    this.schema.setLanguage(lang);
+    this.documents.setLanguage(lang);
   }
   /**
-   * List all blob names directly under `prefix` in the raw storage bucket.
+   * Reset all entity and document state and re-fetch the project overview.
+   * Prefer creating a fresh `CueProjectView` when switching projects.
+   * Use `reset()` only when the same project's data needs to be invalidated.
    */
-  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);
+  reset() {
+    if (this._destroyed)
+      return;
+    this.entities.reset();
+    this.documents.reset();
+    this._searchResults.set(void 0);
+    this.documents.fetchOverview().catch((err) => console.error("[CueProjectView] fetchOverview failed after reset:", err));
   }
   /**
-   * Download a file from the public bucket and return its contents as a string.
+   * Tear down this view instance. Clears all reactive state and blocks further
+   * updates. Call from the Angular adapter's `ngOnDestroy` or equivalent.
    */
-  async downloadPublic(blobName) {
-    const fileRef = (0, import_storage3.ref)(this.options.storagePublic, blobName);
-    const controller = new AbortController();
-    const timeout = setTimeout(() => controller.abort(), 1e4);
-    try {
-      const [url, metadata] = await Promise.all([
-        (0, import_storage3.getDownloadURL)(fileRef),
-        (0, import_storage3.getMetadata)(fileRef)
-      ]);
-      const cacheBustedUrl = `${url}&t=${encodeURIComponent(metadata.updated)}`;
-      const res = await fetch(cacheBustedUrl, { signal: controller.signal });
-      if (!res.ok)
-        throw new Error(`HTTP ${res.status}`);
-      return res.text();
-    } catch (err) {
-      const isTimeout = err instanceof Error && err.name === "AbortError";
-      throw new Error(isTimeout ? `Download timed out: ${blobName}` : err instanceof Error ? err.message : String(err));
-    } finally {
-      clearTimeout(timeout);
-    }
+  destroy() {
+    this._destroyed = true;
+    this._searchResults.set(void 0);
   }
 };
 
-// libs/js/cue-sdk/src/lib/sync.ts
-var import_promises3 = require("fs/promises");
-var import_path3 = require("path");
-var import_url = require("url");
-var import_os = require("os");
+// libs/js/file-metadata-helpers/src/lib/js-file-metadata-helpers.ts
+init_src();
 
 // libs/js/models/src/lib/file-extensions.ts
 var fileExtensionsInfo = {
@@ -5815,9 +7620,11 @@ var import_uuid5 = require("uuid");
 
 // libs/js/rdf-document-writers/src/lib/alternative-representation.ts
 var import_n33 = require("n3");
+init_src();
 
 // libs/js/rdf-document-writers/src/lib/file-location.ts
 var import_n32 = require("n3");
+init_src();
 var { namedNode, literal } = import_n32.DataFactory;
 var a = namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
 var prefixes = {
@@ -5840,6 +7647,7 @@ var { namedNode: namedNode3, literal: literal2 } = import_n34.DataFactory;
 var a2 = namedNode3("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
 
 // libs/js/rdf-document-writers/src/lib/document-file.ts
+init_src();
 var import_n35 = require("n3");
 
 // libs/js/rdf-document-writers/src/lib/file-suffix.ts
@@ -5858,6 +7666,7 @@ 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_n36 = require("n3");
 var import_uuid6 = require("uuid");
+init_src();
 var { namedNode: namedNode5, literal: literal4 } = import_n36.DataFactory;
 var a4 = namedNode5("http://www.w3.org/1999/02/22-rdf-syntax-ns#type");
 var prefixes3 = {
@@ -5898,29 +7707,59 @@ function uploadedFileMetadata(originalName, projectId, userId, md5, providerId,
 }
 
 // libs/js/cue-sdk/src/lib/sync.ts
+async function _readNodeFile(fullPath) {
+  if (typeof window !== "undefined") {
+    throw new Error(
+      `Cannot read file from path "${fullPath}" in a browser environment. Provide file.data (Uint8Array) instead.`
+    );
+  }
+  const { readFile } = await import("fs/promises");
+  return readFile(fullPath);
+}
 var _scanFn = null;
 var _wasmInitPromise = null;
+var _browserWasmBaseUrl = null;
 async function _initWasm() {
-  const wasmDir = (0, import_path3.join)(__dirname, "assets", "wasm");
-  const wasmBinary = await (0, import_promises3.readFile)((0, import_path3.join)(wasmDir, "dir_scanner_wasm_bg.wasm"));
-  const glueUrl = (0, import_url.pathToFileURL)((0, import_path3.join)(wasmDir, "dir_scanner_wasm.mjs")).href;
-  const mod = await import(
-    /* @vite-ignore */
-    glueUrl
-  );
-  await mod.default({ module_or_path: wasmBinary });
-  _scanFn = mod.scan;
+  if (typeof window !== "undefined") {
+    if (!_browserWasmBaseUrl) {
+      throw new Error(
+        "WASM scanner is not configured for browser use. Call configureScanWasm(baseUrl) during app initialisation."
+      );
+    }
+    const wasmResponse = await fetch(`${_browserWasmBaseUrl}/dir_scanner_wasm_bg.wasm`);
+    if (!wasmResponse.ok) {
+      throw new Error(`Failed to fetch WASM binary: ${wasmResponse.status} ${wasmResponse.statusText}`);
+    }
+    const wasmBinary = new Uint8Array(await wasmResponse.arrayBuffer());
+    const glueUrl = `${_browserWasmBaseUrl}/dir_scanner_wasm.mjs`;
+    const mod = await import(
+      /* @vite-ignore */
+      glueUrl
+    );
+    await mod.default({ module_or_path: wasmBinary });
+    _scanFn = mod.scan;
+  } else {
+    const { readFile } = await import("fs/promises");
+    const { join: join4 } = await import("path");
+    const { pathToFileURL } = await import("url");
+    const wasmDir = join4(__dirname, "assets", "wasm");
+    const wasmBinary = await readFile(join4(wasmDir, "dir_scanner_wasm_bg.wasm"));
+    const glueUrl = pathToFileURL(join4(wasmDir, "dir_scanner_wasm.mjs")).href;
+    const mod = await import(
+      /* @vite-ignore */
+      glueUrl
+    );
+    await mod.default({ module_or_path: wasmBinary });
+    _scanFn = mod.scan;
+  }
 }
 var DEFAULT_GRAPH_TYPE = "fuseki";
-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 ENDPOINT_FSS_BATCH = "/commands/file-system-structure/batch";
 var FSS_BATCH_CHUNK_SIZE = 1e3;
 var PENDING_LS_PREFIX = "cue:pending:";
-function _pendingFilePath(spaceId) {
-  return (0, import_path3.join)((0, import_os.tmpdir)(), `cue-sync-pending-${spaceId}.json`);
+async function _pendingFilePath(spaceId) {
+  const { tmpdir } = await import("os");
+  const { join: join4 } = await import("path");
+  return join4(tmpdir(), `cue-sync-pending-${spaceId}.json`);
 }
 async function _loadPending(spaceId) {
   if (typeof window !== "undefined") {
@@ -5928,7 +7767,7 @@ async function _loadPending(spaceId) {
     return raw ? JSON.parse(raw) : null;
   }
   try {
-    const raw = await (0, import_promises3.readFile)(_pendingFilePath(spaceId), "utf-8");
+    const raw = await (await import("fs/promises")).readFile(await _pendingFilePath(spaceId), "utf-8");
     return JSON.parse(raw);
   } catch {
     return null;
@@ -5940,7 +7779,7 @@ async function _savePending(batch) {
     window.localStorage.setItem(`${PENDING_LS_PREFIX}${batch.spaceId}`, data);
     return;
   }
-  await (0, import_promises3.writeFile)(_pendingFilePath(batch.spaceId), data, "utf-8");
+  await (await import("fs/promises")).writeFile(await _pendingFilePath(batch.spaceId), data, "utf-8");
 }
 async function _clearPending(spaceId) {
   if (typeof window !== "undefined") {
@@ -5948,7 +7787,7 @@ async function _clearPending(spaceId) {
     return;
   }
   try {
-    await (0, import_promises3.unlink)(_pendingFilePath(spaceId));
+    await (await import("fs/promises")).unlink(await _pendingFilePath(spaceId));
   } catch {
   }
 }
@@ -5964,18 +7803,30 @@ var CueSyncApi = class {
   _pendingItems = [];
   _pendingSpaceId = null;
   _flushTimer = null;
+  _legacy = false;
   /** @internal Injected by CueApi after construction to avoid circular dependency. */
   _bindApi(api) {
     this._api = api;
   }
   /**
-   * Flushes any pending metadata items from a previous interrupted sync.
-   * Safe to call even when there is nothing new to upload.
+   * Initialises browser-mode sync for a project space.
+   * - Flushes any metadata items that were queued but not sent in a previous session
+   *   (persisted in `localStorage`).
+   * - Starts the 60-second periodic flush timer.
+   *
+   * Call this once when the file manager component is created (or when the active
+   * project changes) so that interrupted uploads are recovered immediately.
    */
-  async flushPendingMetadata(spaceId, verbose) {
-    const token = await this._auth.getToken();
-    if (!token)
-      throw new Error("Not authenticated. Call cue.auth.signIn() first.");
+  async initBrowserSync(spaceId) {
+    await this._initPendingBatch(spaceId);
+  }
+  /**
+   * Flushes any pending file-location metadata from a previously interrupted sync.
+   * Safe to call even when there are no new files to upload (e.g. when the process
+   * died after uploading to blob storage but before the commands-API batch POST).
+   */
+  async flushPendingMetadata(spaceId, verbose, legacy) {
+    this._legacy = legacy ?? false;
     const existing = await _loadPending(spaceId);
     if (!existing || existing.items.length === 0)
       return;
@@ -5985,7 +7836,7 @@ var CueSyncApi = class {
     try {
       this._pendingSpaceId = spaceId;
       this._pendingItems = [];
-      await this._flushBatch(existing.items, spaceId, token, verbose);
+      await this._flushBatch(existing.items, spaceId, verbose);
       console.info("Metadata uploaded \u2705");
     } catch (err) {
       throw new Error(`METADATA_SYNC_FAILED: ${err instanceof Error ? err.message : String(err)}`);
@@ -6006,7 +7857,7 @@ var CueSyncApi = class {
     const tier = project?.projectSettings?.tier ?? "l";
     const [remoteFiles, consumption, creditMap, tierNames] = await Promise.all([
       this._listRemoteFiles(graph, spaceId, providerId, verbose),
-      this._api?.getConsumption(spaceId, tier) ?? Promise.reject(new Error("CueSyncApi is not bound to a CueApi instance")),
+      this._api?.getConsumption(spaceId) ?? Promise.reject(new Error("CueSyncApi is not bound to a CueApi instance")),
       this._fetchUnitCreditMap(verbose),
       this._fetchTierNames()
     ]);
@@ -6040,18 +7891,17 @@ var CueSyncApi = class {
     };
   }
   async sync(localFiles, options) {
-    const { spaceId, providerId, userId, verbose, onProgress } = options;
+    const { spaceId, providerId, userId, verbose, onProgress, legacy } = options;
+    this._legacy = legacy ?? false;
     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 project = await this._projects.getProject(spaceId);
-    const tier = project?.projectSettings?.tier ?? "l";
     const [remoteFiles, consumption] = await Promise.all([
       this._listRemoteFiles(graph, spaceId, providerId, verbose),
-      this._api?.getConsumption(spaceId, tier) ?? Promise.reject(new Error("CueSyncApi is not bound to a CueApi instance"))
+      this._api?.getConsumption(spaceId) ?? Promise.reject(new Error("CueSyncApi is not bound to a CueApi instance"))
     ]);
     const { unitsAvailable } = consumption;
     const report = await compareLocalRemote(localFiles, remoteFiles);
@@ -6076,7 +7926,7 @@ var CueSyncApi = class {
         );
       }
     }
-    await this._initPendingBatch(spaceId, token, verbose);
+    await this._initPendingBatch(spaceId, verbose);
     if (verbose && toUpload.length)
       console.info("Syncing missing files \u23F3");
     for (const file of toUpload) {
@@ -6090,10 +7940,10 @@ var CueSyncApi = class {
         );
         if (!rawMeta.blob_name)
           throw new Error(`blob_name missing for ${file.relativePath}`);
-        const fileBuffer = await (0, import_promises3.readFile)(file.fullPath);
+        const fileBuffer = file.data ?? new Uint8Array(await _readNodeFile(file.fullPath));
         await this._blob.uploadRaw(
           rawMeta.blob_name,
-          new Uint8Array(fileBuffer),
+          fileBuffer,
           rawMeta
         );
         await this._queueFileLocation({
@@ -6131,7 +7981,7 @@ var CueSyncApi = class {
     }
     await this._drainPending(verbose);
     this._stopFlushTimer();
-    const postSyncConsumption = await (this._api?.getConsumption(spaceId, tier) ?? Promise.resolve({ creditsAvailable: 0 }));
+    const postSyncConsumption = await (this._api?.getConsumption(spaceId) ?? Promise.resolve({ creditsAvailable: 0 }));
     return {
       syncCount,
       syncSize,
@@ -6224,7 +8074,11 @@ WHERE {
     }
     return map;
   }
-  async _initPendingBatch(spaceId, token, verbose) {
+  async _initPendingBatch(spaceId, verbose) {
+    if (this._flushTimer !== null) {
+      clearInterval(this._flushTimer);
+      this._flushTimer = null;
+    }
     this._pendingSpaceId = spaceId;
     this._pendingItems = [];
     const existing = await _loadPending(spaceId);
@@ -6233,7 +8087,7 @@ WHERE {
       if (verbose)
         console.info(`Flushing ${existing.items.length} pending file location(s) from previous sync \u23F3`);
       try {
-        await this._flushBatch(existing.items, spaceId, token, verbose);
+        await this._flushBatch(existing.items, spaceId, verbose);
         console.info("Metadata uploaded \u2705");
       } catch (err) {
         throw new Error(`METADATA_SYNC_FAILED: ${err instanceof Error ? err.message : String(err)}`);
@@ -6255,22 +8109,29 @@ WHERE {
       await _savePending({ spaceId: this._pendingSpaceId, items: this._pendingItems });
     }
   }
+  /**
+   * Flush all queued file-location items to the commands API in a single batch.
+   * Call this once after a group of `syncBrowserFile` calls completes so that
+   * all items are sent together rather than one POST per file.
+   */
+  async drainPending() {
+    await this._drainPending();
+  }
   async _drainPending(verbose) {
     if (!this._pendingSpaceId || this._pendingItems.length === 0)
       return;
-    const token = await this._auth.getToken();
-    if (!token)
+    if (!this._auth.currentUser)
       return;
-    await this._flushBatch(this._pendingItems, this._pendingSpaceId, token, verbose);
+    await this._flushBatch(this._pendingItems, this._pendingSpaceId, verbose);
   }
-  async _flushBatch(items, spaceId, token, verbose) {
+  async _flushBatch(items, spaceId, verbose) {
     const snapshot = [...items];
     if (this._pendingSpaceId === spaceId)
       this._pendingItems = [];
     await _clearPending(spaceId);
     try {
       for (let i = 0; i < snapshot.length; i += FSS_BATCH_CHUNK_SIZE) {
-        await this._postFssBatch(snapshot.slice(i, i + FSS_BATCH_CHUNK_SIZE), spaceId, token);
+        await this._postFssBatch(snapshot.slice(i, i + FSS_BATCH_CHUNK_SIZE), spaceId);
       }
       if (verbose)
         console.info(`Wrote ${snapshot.length} file location(s) to commands API \u2705`);
@@ -6281,15 +8142,15 @@ WHERE {
       throw err;
     }
   }
-  async _postFssBatch(items, spaceId, token) {
+  async _postFssBatch(items, spaceId) {
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 15e3);
+    const url = this._legacy ? `${this._gatewayUrl}${ENDPOINT_FSS_BATCH}?blob=true` : `${this._gatewayUrl}${ENDPOINT_FSS_BATCH}`;
     let response;
     try {
-      response = await fetch(`${this._gatewayUrl}${ENDPOINT_FSS_BATCH}`, {
+      response = await this._auth.authenticatedFetch(url, {
         method: "POST",
         headers: {
-          Authorization: `Bearer ${token}`,
           "Content-Type": "application/json",
           "x-project-id": spaceId
         },
@@ -6333,7 +8194,8 @@ WHERE {
       const entries = await Promise.all(
         batch.map(async (f) => ({
           originalPath: f.relativePath,
-          data: new Uint8Array(await (0, import_promises3.readFile)(f.fullPath))
+          // Use pre-loaded data if available (browser), otherwise read from disk (Node.js).
+          data: f.data ?? new Uint8Array(await _readNodeFile(f.fullPath))
         }))
       );
       const records = _scanFn(entries);
@@ -6350,6 +8212,94 @@ WHERE {
     }
     return Array.from(merged.values());
   }
+  /**
+   * Compute the credit cost for a set of local files without uploading anything.
+   * Intended for browser use where the full {@link previewSync} (which requires a
+   * remote file listing) would be too heavy for a quick estimate.
+   *
+   * @param localFiles - Files to analyse.  Each entry must carry `data` when
+   *   called from a browser context.
+   * @param spaceId    - Project/space identifier used to fetch the tier settings.
+   * @returns Per-extension cost breakdown and the number of credits currently
+   *   available in the project.
+   */
+  async computeCredits(localFiles, spaceId) {
+    const project = await this._projects.getProject(spaceId);
+    const tier = project?.projectSettings?.tier ?? "l";
+    console.info(`Computing credit cost for ${localFiles.length} file(s) using tier "${tier}"...`);
+    const consumptionPromise = (this._api?.getConsumption(spaceId) ?? Promise.resolve({ creditsAvailable: 0, unitsAvailable: 0 })).then((r) => {
+      console.info("[computeCredits] getConsumption resolved:", r);
+      return r;
+    }).catch((err) => {
+      console.warn("[computeCredits] getConsumption failed, defaulting to 0:", err?.message ?? err);
+      return { creditsAvailable: 0, unitsAvailable: 0 };
+    });
+    const creditMapPromise = this._fetchUnitCreditMap().then((m) => {
+      console.info("[computeCredits] creditMap resolved, keys:", Object.keys(m));
+      return m;
+    }).catch((err) => {
+      console.warn("[computeCredits] fetchUnitCreditMap failed, using default rates:", err?.message ?? err);
+      return {};
+    });
+    const scanPromise = localFiles.length > 0 ? (console.info(`[computeCredits] starting WASM scan of ${localFiles.length} file(s)...`), this.scanCost(localFiles).then((r) => {
+      console.info(`[computeCredits] WASM scan done: ${r.length} ext(s)`);
+      return r;
+    })) : Promise.resolve([]);
+    const [costRecords, creditMap, consumption] = await Promise.all([
+      scanPromise,
+      creditMapPromise,
+      consumptionPromise
+    ]);
+    console.info(`[computeCredits] all resolved \u2014 ${costRecords.length} ext(s), creditsAvailable: ${consumption.creditsAvailable}`);
+    let creditsToConsume = 0;
+    for (const r of costRecords) {
+      const tierMap = creditMap[tier];
+      const creditPerUnit = tierMap?.[r.ext] ?? 1;
+      const credits = r.units * creditPerUnit;
+      creditsToConsume += credits;
+      r.credits = Math.round(credits);
+    }
+    return {
+      costRecords,
+      creditsToConsume: Math.round(creditsToConsume),
+      creditsAvailable: consumption.creditsAvailable
+    };
+  }
+  /**
+   * Upload a single browser-supplied file and write its metadata to the knowledge graph.
+   *
+   * Unlike {@link sync} (which performs a full remote comparison), this method is
+   * designed for the web file-manager flow where the user has already confirmed the
+   * upload via the credit modal.  The file's binary data must be provided in
+   * `file.data`; the `file.fullPath` field is ignored.
+   *
+   * Cancellation is supported via `options.signal`.  Aborting the signal cancels
+   * the Firebase Storage upload; metadata is never written for a cancelled upload.
+   *
+   * @param file    - `LocalFile` with `data` populated (e.g. from `File.arrayBuffer()`).
+   * @param options - Upload options including project/provider/user context and an
+   *   optional `AbortSignal` for cancellation and `onProgress` for tracking.
+   */
+  async syncBrowserFile(file, options) {
+    const { spaceId, providerId, userId, signal, onProgress } = options;
+    if (!file.data) {
+      throw new Error("syncBrowserFile requires file.data (Uint8Array). Read the file with File.arrayBuffer() first.");
+    }
+    const rawMeta = uploadedFileMetadata(file.relativePath, spaceId, userId, file.md5, providerId);
+    if (!rawMeta.blob_name)
+      throw new Error(`blob_name missing for ${file.relativePath}`);
+    await this._blob.uploadRaw(
+      rawMeta.blob_name,
+      file.data,
+      rawMeta,
+      3,
+      signal,
+      onProgress
+    );
+    await this._queueFileLocation(
+      { relativePath: file.relativePath, md5: file.md5, size: file.size, providerId, fileContentExists: false }
+    );
+  }
   async _fetchTierNames() {
     try {
       const text = await this._blob.downloadPublic("tier-names.json");
@@ -6381,28 +8331,201 @@ WHERE {
   }
 };
 
+// libs/js/cue-sdk/src/lib/cue.ts
+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:18093",
+    tokenUrl: "http://localhost:18093/token",
+    authEmulatorUrl: "http://localhost:9099",
+    storageEmulatorHost: "localhost",
+    storageEmulatorPort: 9199,
+    firestoreEmulatorHost: "localhost",
+    firestoreEmulatorPort: 8080
+  }
+};
+var Cue = class _Cue {
+  auth;
+  api;
+  projects;
+  profile;
+  privileges;
+  cache;
+  _app;
+  _endpoints;
+  _isEmulator;
+  constructor(config = {}) {
+    const usingDefaults = !config.apiKey && !config.appId && !config.measurementId;
+    if (usingDefaults) {
+      console.warn(
+        "Using default SDK app settings. Contact QAECY for your own configuration for any production code."
+      );
+    }
+    const apiKey = config.apiKey ?? DEFAULT_SDK_CONFIG.apiKey;
+    const appId = config.appId ?? DEFAULT_SDK_CONFIG.appId;
+    const measurementId = config.measurementId ?? DEFAULT_SDK_CONFIG.measurementId;
+    const env = config.environment ?? "production";
+    this._endpoints = { ...ENDPOINTS[env], ...config.endpoints };
+    this._isEmulator = env === "emulator";
+    this._app = (0, import_app2.getApps)().find((a5) => a5.name === "[DEFAULT]") ?? (0, import_app2.initializeApp)({
+      apiKey,
+      appId,
+      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);
+    this.projects = new CueProjects(this.auth, this._app, this._isEmulator, this._endpoints);
+    this.api = this._buildApi(this.projects);
+    this.profile = new CueProfile(
+      this.auth,
+      this._app,
+      this._isEmulator,
+      this._endpoints.firestoreEmulatorHost,
+      this._endpoints.firestoreEmulatorPort
+    );
+    this.privileges = new CuePrivileges(this.auth.isSuperAdmin);
+    const storagePersistence = (0, import_storage5.getStorage)(this._app, BUCKET_PERSISTENCE2);
+    if (this._isEmulator) {
+      (0, import_storage5.connectStorageEmulator)(storagePersistence, this._endpoints.storageEmulatorHost, this._endpoints.storageEmulatorPort);
+    }
+    this.cache = new CueCache(storagePersistence);
+  }
+  /**
+   * Create a `Cue` instance from an already-initialized Firebase app.
+   *
+   * Use this when the host application (e.g. cue-portal via `CueFirebase`) has
+   * already called `initializeApp()`. Reusing the same `FirebaseApp` means the
+   * SDK shares the same auth state and Firestore instance — no second login is
+   * needed and `getToken()` returns the portal user's token directly.
+   *
+   * Emulator connections are skipped because the host app already set them up.
+   *
+   * @example
+   * // In an Angular service after CueFirebase is ready:
+   * const cue = Cue.fromApp(CueFirebase.getInstance().app!, {
+   *   environment: 'emulator',
+   * });
+   */
+  static fromApp(app, config = {}) {
+    const env = config.environment ?? "production";
+    const endpoints = { ...ENDPOINTS[env], ...config.endpoints };
+    const auth = new CueAuth(app, false, endpoints);
+    const projects = new CueProjects(auth, app, false, endpoints);
+    const storageRaw = (0, import_storage5.getStorage)(app, BUCKET_RAW2);
+    const storageProcessed = (0, import_storage5.getStorage)(app, BUCKET_PROCESSED2);
+    const storagePublic = (0, import_storage5.getStorage)(app, BUCKET_PUBLIC2);
+    const storageLogs = (0, import_storage5.getStorage)(app, BUCKET_LOGS2);
+    const storageChatSessions = (0, import_storage5.getStorage)(app, BUCKET_CHAT_SESSIONS2);
+    const storagePersistence = (0, import_storage5.getStorage)(app, BUCKET_PERSISTENCE2);
+    const blob = new CueBlobStorage({
+      storageRaw,
+      storageProcessed,
+      storagePublic,
+      storageLogs,
+      storageChatSessions,
+      storagePersistence
+    });
+    const syncApi = new CueSyncApi(auth, projects, blob, endpoints.gatewayUrl);
+    const api = new CueApi(auth, endpoints.gatewayUrl, projects, syncApi);
+    syncApi._bindApi(api);
+    const profile = new CueProfile(auth, app, false, endpoints.firestoreEmulatorHost, endpoints.firestoreEmulatorPort);
+    const instance = Object.create(_Cue.prototype);
+    const privileges = new CuePrivileges(auth.isSuperAdmin);
+    const cache = new CueCache(storagePersistence);
+    Object.assign(instance, {
+      _app: app,
+      _endpoints: endpoints,
+      _isEmulator: env === "emulator",
+      auth,
+      api,
+      projects,
+      profile,
+      privileges,
+      cache
+    });
+    return instance;
+  }
+  /** 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);
+  }
+  /**
+   * Create a `CueProjectView` for the given project, wiring the SDK's query
+   * cache automatically.
+   *
+   * The view auto-fetches the document overview and entity graph on construction
+   * and exposes reactive signals for all project knowledge-graph state.
+   *
+   * @example
+   * ```ts
+   * const view = cue.createProjectView('my-project', { language: 'en' });
+   * view.requestEntityData(['uuid1']);
+   * const info = view.entityInfoMap.get()['uuid1'];
+   * ```
+   */
+  createProjectView(projectId, opts) {
+    const queryCache = opts.queryCache ?? {
+      get: (key) => this.cache.getQueryCache(projectId, key).then((entry) => entry?.results),
+      set: (key, data) => this.cache.setQueryCache(projectId, key, { query: key, results: data })
+    };
+    return new CueProjectView(this.api, projectId, { ...opts, queryCache });
+  }
+};
+
 // libs/js/cue-sdk/src/lib/cue-node.ts
-var BUCKET_RAW2 = "spaces_raw_eu_west6";
-var BUCKET_PROCESSED2 = "spaces_processed_eu_west6";
-var BUCKET_PUBLIC2 = "cue_public_eu_west6";
+var import_storage6 = require("firebase/storage");
 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);
-    const storagePublic = (0, import_storage4.getStorage)(this._app, BUCKET_PUBLIC2);
+    const storageChatSessions = (0, import_storage6.getStorage)(this._app, BUCKET_CHAT_SESSIONS2);
+    const storageLogs = (0, import_storage6.getStorage)(this._app, BUCKET_LOGS2);
+    const storageRaw = (0, import_storage6.getStorage)(this._app, BUCKET_RAW2);
+    const storagePersistence = (0, import_storage6.getStorage)(this._app, BUCKET_PERSISTENCE2);
+    const storageProcessed = (0, import_storage6.getStorage)(this._app, BUCKET_PROCESSED2);
+    const storagePublic = (0, import_storage6.getStorage)(this._app, BUCKET_PUBLIC2);
     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);
-      (0, import_storage4.connectStorageEmulator)(storagePublic, storageHost, storagePort);
+      (0, import_storage6.connectStorageEmulator)(storageRaw, storageHost, storagePort);
+      (0, import_storage6.connectStorageEmulator)(storageProcessed, storageHost, storagePort);
+      (0, import_storage6.connectStorageEmulator)(storagePublic, storageHost, storagePort);
     }
-    const blob = new CueBlobStorage({ storageRaw, storageProcessed, storagePublic });
-    const syncApi = new CueSyncApi(this.auth, projects, blob, this._endpoints.gatewayUrl);
-    const api = new CueApi(this.auth, this._endpoints.gatewayUrl, projects, syncApi);
+    const blob = new CueBlobStorage({
+      storageChatSessions,
+      storageLogs,
+      storageRaw,
+      storagePersistence,
+      storageProcessed,
+      storagePublic
+    });
+    const syncApi = new CueSyncApi(
+      this.auth,
+      projects,
+      blob,
+      this._endpoints.gatewayUrl
+    );
+    const api = new CueApi(
+      this.auth,
+      this._endpoints.gatewayUrl,
+      projects,
+      syncApi
+    );
     syncApi._bindApi(api);
     return api;
   }
@@ -6423,7 +8546,8 @@ async function authenticate(emulators, space, key, verbose = false) {
     apiKey: FIREBASE_CONFIG().apiKey,
     appId: FIREBASE_CONFIG().appId,
     measurementId: FIREBASE_CONFIG().measurementId,
-    environment: emulators ? "emulator" : "production"
+    environment: emulators ? "emulator" : "production",
+    ...emulators ? { endpoints: getEmulatorEndpoints() } : {}
   });
   if (verbose)
     console.info("Authenticating \u23F3");
@@ -6443,7 +8567,7 @@ async function compareHandler(options) {
     await authenticate(emulators, space, options.key, verbose);
     if (verbose)
       console.info("Building compare base \u23F3");
-    const qh = async (query3) => queryHandler(query3, space, emulators);
+    const qh = async (query4) => queryHandler(query4, space, emulators);
     const [localFiles, remoteFiles] = await Promise.all([
       listLocalFiles(
         path,
@@ -6543,23 +8667,23 @@ async function compareHandler(options) {
 }
 
 // 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");
+var import_storage7 = require("firebase/storage");
+var import_path2 = require("path");
+var import_promises = 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 });
+  const listResult = await (0, import_storage7.listAll)((0, import_storage7.ref)(storage, subDir));
+  const outputDir = (0, import_path2.join)(process.cwd(), "downloaded_blobs", bucket, subDir);
+  await (0, import_promises.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));
+    const bytes = await (0, import_storage7.getBytes)(fileRef);
+    const outputPath = (0, import_path2.join)(outputDir, fileRef.name);
+    await (0, import_promises.writeFile)(outputPath, Buffer.from(bytes));
     console.log(`Downloaded ${fileRef.name} to ${outputPath} \u2705`);
   }
 }
@@ -6584,12 +8708,12 @@ async function dumpProcessedHandler(options) {
 }
 
 // apps/desktop/cue-cli/src/helpers/graph-dump.ts
-var import_fs2 = require("fs");
+var import_fs = require("fs");
 var import_stream = require("stream");
-var import_fs3 = require("fs");
-var import_zlib2 = require("zlib");
-var import_promises5 = require("stream/promises");
-var import_promises6 = require("fs/promises");
+var import_fs2 = require("fs");
+var import_zlib = require("zlib");
+var import_promises2 = require("stream/promises");
+var import_promises3 = require("fs/promises");
 var import_auth9 = require("firebase/auth");
 
 // libs/js/size-tools/src/lib/js-size-tools.ts
@@ -6609,7 +8733,7 @@ function humanFileSize(bytes, si = false, dp = 1) {
 }
 
 // apps/desktop/cue-cli/src/helpers/graph-dump.ts
-var import_fs4 = require("fs");
+var import_fs3 = require("fs");
 async function dumpRdfGraphToFileJelly(spaceId, useEmulator = false, verbose = false) {
   return dumpRdfGraphToFile(
     spaceId,
@@ -6625,7 +8749,7 @@ async function dumpRdfGraphToFile(spaceId, useEmulator = false, verbose = false,
   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 ((0, import_fs3.existsSync)(filePath) || (0, import_fs3.existsSync)(`${filePath}.gz`)) {
     if (verbose)
       console.info(`File ${filePath} already exists, skipping download.`);
     return mimeType === "application/n-quads" ? `${filePath}.gz` : filePath;
@@ -6642,7 +8766,7 @@ async function dumpRdfGraphToFile(spaceId, useEmulator = false, verbose = false,
   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 fileStream = (0, import_fs.createWriteStream)(filePath, { flags: "w" });
   const nodeStream = import_stream.Readable.fromWeb(res.body);
   let chunkCount = 0;
   let totalSize = 0;
@@ -6669,7 +8793,7 @@ async function dumpRdfGraphToFile(spaceId, useEmulator = false, verbose = false,
     }
   }, streamTimeout);
   try {
-    await (0, import_promises5.pipeline)(nodeStream, fileStream);
+    await (0, import_promises2.pipeline)(nodeStream, fileStream);
   } finally {
     if (hasDataTimeout) {
       clearTimeout(hasDataTimeout);
@@ -6702,7 +8826,7 @@ async function dumpRdfGraphToFileConstruct(spaceId, useEmulator = false, verbose
     WHERE { GRAPH ${graph} { ?s ?p ?o } }
   `;
   let offset = 0;
-  const fileStream = (0, import_fs2.createWriteStream)(filePath, { flags: "w" });
+  const fileStream = (0, import_fs.createWriteStream)(filePath, { flags: "w" });
   let hasMore = true;
   while (hasMore) {
     const queries = Array.from(
@@ -6767,14 +8891,14 @@ async function retryWithBackoff(fn, maxRetries, delayMs, label) {
 async function _doGzip(filePath) {
   const gzFilePath = `${filePath}.gz`;
   await new Promise((resolve2, reject) => {
-    const gzip = (0, import_zlib2.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);
+    const gzip = (0, import_zlib.createGzip)();
+    const source = (0, import_fs2.createReadStream)(filePath);
+    const dest = (0, import_fs.createWriteStream)(gzFilePath);
+    (0, import_promises2.pipeline)(source, gzip, dest).then(resolve2).catch(reject);
   });
-  await (0, import_promises6.unlink)(filePath);
+  await (0, import_promises3.unlink)(filePath);
 }
-async function _doQuery(query3, spaceId, url) {
+async function _doQuery(query4, spaceId, url) {
   const token = await (0, import_auth9.getAuth)().currentUser?.getIdToken();
   try {
     const res = await fetch(url, {
@@ -6785,7 +8909,7 @@ async function _doQuery(query3, spaceId, url) {
         "Content-Type": "application/sparql-query",
         Accept: "application/n-quads"
       },
-      body: query3
+      body: query4
     });
     if (!res.ok) {
       console.error(`Error: ${res.status} ${res.statusText}`);
@@ -6864,9 +8988,9 @@ function _getTemplate(partition, base = "fuseki-base-new/fuseki") {
 
 // apps/desktop/cue-cli/src/helpers/graph-upload.ts
 var import_auth11 = require("firebase/auth");
-var import_fs5 = require("fs");
+var import_fs4 = require("fs");
 async function uploadToLocalGraph(id, filePath, mimeType = "application/n-quads", zipped = false) {
-  const stream = (0, import_fs5.createReadStream)(filePath);
+  const stream = (0, import_fs4.createReadStream)(filePath);
   const token = await (0, import_auth11.getAuth)().currentUser?.getIdToken();
   const dataUrl = SPARQL_ENDPOINT_EMULATOR.replace("/query", "/data");
   const headers = {
@@ -6893,7 +9017,7 @@ async function uploadToLocalGraph(id, filePath, mimeType = "application/n-quads"
 
 // apps/desktop/cue-cli/src/cue-cli-dump.ts
 async function dumpHandler(options) {
-  const { space, verbose, emulators, jelly, query: query3, load } = options;
+  const { space, verbose, emulators, jelly, query: query4, load } = options;
   try {
     const { isSuperAdmin } = await authenticate(emulators, space, options.key, verbose);
     if (!isSuperAdmin) {
@@ -6914,7 +9038,7 @@ async function dumpHandler(options) {
     } else {
       if (verbose)
         console.time("Downloaded and zipped graph \u2705");
-      if (query3) {
+      if (query4) {
         if (verbose)
           console.info("Setting: Construct query");
         filePath = await dumpRdfGraphToFileConstruct(space, emulators, verbose);
@@ -6951,16 +9075,16 @@ async function dumpHandler(options) {
 }
 
 // apps/desktop/cue-cli/src/helpers/repair-remote-ttl.ts
-var import_storage6 = require("firebase/storage");
+var import_storage8 = 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_storage6.listAll)((0, import_storage6.ref)(storage, `${space}/triples`));
+  const listResult = await (0, import_storage8.listAll)((0, import_storage8.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 stream = await (0, import_storage8.getStream)(fileRef);
     const reader = stream.getReader();
     const chunks = [];
     let done = false;
@@ -6984,13 +9108,13 @@ async function repairRemoteTTL(space, subString, regex, substituteString) {
       const buffer = Buffer.from(fileContent, "utf8");
       let existingMetadata = {};
       try {
-        existingMetadata = await (0, import_storage6.getMetadata)(fileRef);
+        existingMetadata = await (0, import_storage8.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);
+      await (0, import_storage8.uploadBytesResumable)((0, import_storage8.ref)(storage, `${space}/triples/${fileRef.name}`), buffer, metadata);
       console.log(`Fixed ${fileRef.name} \u2705`);
     } else {
       console.log(`No changes for ${fileRef.name}`);
@@ -7017,10 +9141,11 @@ async function repairTtlHandler(options) {
 }
 
 // apps/desktop/cue-cli/src/cue-cli-sync.ts
-var import_promises7 = require("fs/promises");
-var import_fs6 = require("fs");
-var import_path5 = require("path");
+var import_promises4 = require("fs/promises");
+var import_fs5 = require("fs");
+var import_path3 = require("path");
 var readline = __toESM(require("readline"));
+init_src();
 function askConfirm(question) {
   const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((resolve2) => {
@@ -7031,13 +9156,14 @@ function askConfirm(question) {
   });
 }
 async function syncHandler(options) {
-  const { space, path, verbose, provider, emulators, zip } = options;
+  const { space, path, verbose, provider, emulators, zip, legacy } = options;
   try {
     const cue = new CueNode({
       apiKey: FIREBASE_CONFIG().apiKey,
       appId: FIREBASE_CONFIG().appId,
       measurementId: FIREBASE_CONFIG().measurementId,
-      environment: emulators ? "emulator" : "production"
+      environment: emulators ? "emulator" : "production",
+      ...emulators ? { endpoints: getEmulatorEndpoints() } : {}
     });
     const key = options.key ?? process.env.CUE_API_KEY;
     if (!key) {
@@ -7048,15 +9174,15 @@ async function syncHandler(options) {
     }
     if (verbose)
       console.info("Building sync base \u23F3");
-    const resolvedPath = (0, import_path5.resolve)(path);
-    const pathStat = await (0, import_promises7.stat)(resolvedPath);
+    const resolvedPath = (0, import_path3.resolve)(path);
+    const pathStat = await (0, import_promises4.stat)(resolvedPath);
     const isFile = pathStat.isFile();
     let localFiles;
     if (isFile) {
       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_path5.basename)(resolvedPath);
+      const md5 = await fromReadStream((0, import_fs5.createReadStream)(resolvedPath));
+      const relativePath = (0, import_path3.basename)(resolvedPath);
       const contentUUID = contextBasedGuid(md5);
       const locationUUID = generateFileUUID(relativePath, provider);
       localFiles = [
@@ -7117,7 +9243,7 @@ async function syncHandler(options) {
     console.info(`  Credits required: ${Math.round(preview.creditsToConsume)}`);
     console.info(`  Credits available: ${Math.round(preview.creditsAvailable)}
 `);
-    await cue.api.sync.flushPendingMetadata(space, verbose);
+    await cue.api.sync.flushPendingMetadata(space, verbose, legacy);
     if (preview.filesToUpload === 0) {
       console.info("Everything is already synced.");
       process.exit(0);
@@ -7138,6 +9264,7 @@ async function syncHandler(options) {
       providerId: provider,
       userId: user.uid,
       verbose,
+      legacy,
       onProgress: ({ percent, syncCount, totalCount }) => {
         const filled = Math.round(percent / 5);
         const bar = "\u2588".repeat(filled) + "\u2591".repeat(20 - filled);
@@ -7179,8 +9306,8 @@ async function syncHandler(options) {
 }
 
 // apps/desktop/cue-cli/src/cue-cli-util-remove-rdf-star.ts
-var import_fs7 = require("fs");
-var import_zlib3 = require("zlib");
+var import_fs6 = require("fs");
+var import_zlib2 = require("zlib");
 
 // libs/js/rdf-tools/src/lib/nq-to-nt.ts
 var import_n37 = require("n3");
@@ -7227,8 +9354,8 @@ async function utilRemoveRdfStarHandler(options) {
     console.info(`Input: ${input} (${isGzipped ? "gzipped" : "plain"})`);
   if (verbose)
     console.info(`Output: ${output}`);
-  const fileStream = (0, import_fs7.createReadStream)(input);
-  const inputStream = isGzipped ? fileStream.pipe((0, import_zlib3.createGunzip)()) : fileStream;
+  const fileStream = (0, import_fs6.createReadStream)(input);
+  const inputStream = isGzipped ? fileStream.pipe((0, import_zlib2.createGunzip)()) : fileStream;
   let removed = 0;
   const cleanStream = removeRDFStar(inputStream, (count) => {
     removed = count;
@@ -7236,9 +9363,9 @@ async function utilRemoveRdfStarHandler(options) {
       console.info(`Removed RDF-star triples so far: ${count}`);
     }
   });
-  const writeStream = (0, import_fs7.createWriteStream)(output);
+  const writeStream = (0, import_fs6.createWriteStream)(output);
   if (isGzipped) {
-    const gzip = (0, import_zlib3.createGzip)();
+    const gzip = (0, import_zlib2.createGzip)();
     gzip.pipe(writeStream);
     for await (const chunk of cleanStream) {
       gzip.write(chunk);
@@ -7263,7 +9390,7 @@ async function utilRemoveRdfStarHandler(options) {
 }
 
 // apps/desktop/cue-cli/src/cue-cli-util-rdf-compare.ts
-var import_fs8 = require("fs");
+var import_fs7 = require("fs");
 
 // libs/js/rdf-compare/src/lib/js-rdf-compare.ts
 var import_n39 = require("n3");
@@ -7332,8 +9459,8 @@ async function utilRdfCompareHandler(options) {
     console.info(`File 1: ${file1}`);
   if (verbose)
     console.info(`File 2: ${file2}`);
-  const content1 = (0, import_fs8.readFileSync)(file1, "utf8");
-  const content2 = (0, import_fs8.readFileSync)(file2, "utf8");
+  const content1 = (0, import_fs7.readFileSync)(file1, "utf8");
+  const content2 = (0, import_fs7.readFileSync)(file2, "utf8");
   const result = await compareTTL(content1, content2);
   console.info(`File 1 triple count: ${result.file1TripleCount}`);
   console.info(`File 2 triple count: ${result.file2TripleCount}`);
@@ -7361,10 +9488,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_path6.join)(__dirname, "package.json"), "utf8"));
+  packageJson = JSON.parse((0, import_fs8.readFileSync)((0, import_path4.join)(__dirname, "package.json"), "utf8"));
 } catch {
   try {
-    packageJson = JSON.parse((0, import_fs9.readFileSync)((0, import_path6.join)(__dirname, "../package.json"), "utf8"));
+    packageJson = JSON.parse((0, import_fs8.readFileSync)((0, import_path4.join)(__dirname, "../package.json"), "utf8"));
   } catch {
     packageJson = { version: "0.0.0" };
     console.warn("Could not find package.json, using fallback version");
@@ -7372,7 +9499,7 @@ try {
 }
 var program = new import_commander.Command();
 program.name("cue-cli").description("Cue Command Line Interface").version(packageJson.version);
-program.command("sync").description("Sync files to Cue").requiredOption("-s, --space <id>", "Specify the space ID (required)").requiredOption("-p, --path <id>", "Specify the folder path (required)").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("--provider <provider ID>", "Specify the provider ID (eg. sharepoint, drive, dropbox) or leave empty for default provider", "").option("-v, --verbose", "Enable verbose output", false).option("-e, --emulators", "Uses emulators for sync", false).option("-z, --zip", 'Include zipped content (will be unzipped to path "<zip_path>_unzipped". Max uncompressed size: 500 MB, max recursion depth: 3)', false).action(syncHandler);
+program.command("sync").description("Sync files to Cue").requiredOption("-s, --space <id>", "Specify the space ID (required)").requiredOption("-p, --path <id>", "Specify the folder path (required)").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("--provider <provider ID>", "Specify the provider ID (eg. sharepoint, drive, dropbox) or leave empty for default provider", "").option("-v, --verbose", "Enable verbose output", false).option("-e, --emulators", "Uses emulators for sync", false).option("-z, --zip", 'Include zipped content (will be unzipped to path "<zip_path>_unzipped". Max uncompressed size: 500 MB, max recursion depth: 3)', false).option("--legacy", "Write RDF as BLOBs to the processed bucket instead of patching the graph directly", false).action(syncHandler);
 program.command("dump").description("Dump Cue Knowledge Graph data to file\n				Examples:\n				$ cue-cli dump -s <space_id> -l -v\n				$ cue-cli dump -s <space_id> -j -v").requiredOption("-s, --space <id>", "Specify the space ID (required)").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("-v, --verbose", "Enable verbose output", false).option("-e, --emulators", "Uses emulators for sync", false).option("-q, --query", "Uses a construct query to get the dump rather than using the /data endpoint", false).option("-j, --jelly", "Downloads a Jelly file rather than the standard Gzipped NQuads format", false).option("-l, --load", "Loads the dumped file into a local triplestore (requires emulators)", false).action(dumpHandler);
 program.command("compare").description("Compares folder content to files already updated to Cue").requiredOption("-s, --space <id>", "Specify the space ID (required)").requiredOption("-p, --path <id>", "Specify the folder path (required)").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("--provider <provider ID>", "Specify the provider ID (eg. sharepoint, drive, dropbox) or leave empty for default provider", "").option("-v, --verbose", "Enable verbose output", false).option("-e, --emulators", "Uses emulators for sync", false).option("-z, --zip", "Include zipped content (will temporarily unzip files with same logic as when syncing and delete them again after the comparison)", false).action(compareHandler);
 program.command("dump-processed").description("Dump processed files to local folder").requiredOption("-s, --space <id>", "Specify the space ID (required)").requiredOption("-p, --processor <id>", "Id of the processor to dump processed files from (required) [eg. writers-blob, processors-cad-files]").option("-k, --key <api-key>", "Specify the API key (or set CUE_API_KEY env variable)").option("-v, --verbose", "Enable verbose output", false).option("-e, --emulators", "Uses emulators for sync", false).action(dumpProcessedHandler);