@keboola/api-client 27.0.0 → 31.0.0

package/dist/index.js

@@ -1,1804 +1,1763 @@
-import { createVaultSdk } from './chunk-LWQP7OWA.js';
-import { createSemanticLayerSdk } from './chunk-B45B4AYG.js';
-import { createStorageSdk } from './chunk-HGKDXF35.js';
-export { createStorageSdk } from './chunk-HGKDXF35.js';
-export { createQueryServiceSdk } from './chunk-G2SWCC3X.js';
-import { delay } from './chunk-KTKJD4DM.js';
-export { PollException, delay, poll } from './chunk-KTKJD4DM.js';
-import { createConfigurationSdk } from './chunk-DVV35AIS.js';
-export { isEmptyDeep, schemaGuidedMerge } from './chunk-DVV35AIS.js';
-import { createProject } from './chunk-5HEIR4DC.js';
-import './chunk-PSR3N4NC.js';
-import { createStorageTable } from './chunk-ZOREOLGE.js';
-import { createTagSdk } from './chunk-WUFODWZV.js';
-export { keboolaUID } from './chunk-WUFODWZV.js';
-import { generateUUID } from './chunk-T526LPBK.js';
-export { generateUUID } from './chunk-T526LPBK.js';
-import { createQueryServiceClient } from './chunk-UVX733BX.js';
-import { createQueueClient } from './chunk-B4T4QCLB.js';
-export { collect } from './chunk-B4T4QCLB.js';
-import './chunk-22E6IGXR.js';
-import { createStorageClient, ServiceUnavailableError } from './chunk-ON4ILCHP.js';
-export { ServiceUnavailableError, series } from './chunk-ON4ILCHP.js';
-export { QueryJobError, QueryJobTimeoutError, isQueryJobError, isQueryJobTimeoutError } from './chunk-3UBGQFBU.js';
-import { createStreamClient } from './chunk-HZDVMHU6.js';
-import { createSyncActionsClient } from './chunk-NFJKJGXR.js';
-import { ProjectFeature } from './chunk-LNZP2O4P.js';
-import './chunk-NHYL5QPM.js';
-import './chunk-552FC4ZV.js';
-export { SyncActionError, isSyncActionError } from './chunk-YGEJDWGG.js';
-export { ValidationError, isValidationError, parseOrThrow } from './chunk-6ZQBFK2Y.js';
-import { createTelemetryClient } from './chunk-WQ7NNIJ3.js';
-import { createVaultClient } from './chunk-BGJWHTBJ.js';
-export { UserError } from './chunk-G3N5KDEY.js';
-import { createEncryptionClient } from './chunk-KATUDT3E.js';
-import { createImportClient } from './chunk-67P5UI6H.js';
-import { createManagementClient, dedupe } from './chunk-IZ4QM7O4.js';
-export { dedupe, isManagementClientAuthError } from './chunk-IZ4QM7O4.js';
-export { ManagementClientAuthError } from './chunk-CPZME73I.js';
-import { createMetastoreClient } from './chunk-255CHZ3U.js';
-import { createNotificationsClient } from './chunk-2BCH2U57.js';
-import { createOauthClient } from './chunk-24YVNNAG.js';
-import { createOmnisearchClient } from './chunk-KGBWWS6I.js';
-import { createSchedulerClient } from './chunk-FW5GBBKL.js';
-export { concurrent } from './chunk-ERZEQ5JR.js';
-import { createAiClient } from './chunk-TBHJQCAE.js';
-import { createAppsClient } from './chunk-57Q4CY4H.js';
-import { createAuthClient } from './chunk-62LG5KPI.js';
-import { createChatClient } from './chunk-RBN3ITTM.js';
-import './chunk-4RC5E3SL.js';
-import { createDataScienceClient } from './chunk-SYZ5OFNT.js';
-export { parseLogLines } from './chunk-6XFXU5N4.js';
-import { isPlainObject } from './chunk-MSI6FVGG.js';
-export { isPlainObject } from './chunk-MSI6FVGG.js';
-import { createEditorClient } from './chunk-QNF3L4B7.js';
-import { createAuthHeaders } from './chunk-5A3AQIXR.js';
-import { KeboolaHttpHeader, HttpStatus, isApiError, ApiError, normalizeBaseUrl, HttpHeader, createOpenapiFetchClient, createGenericFetchClient } from './chunk-2BQBKU6E.js';
-export { ApiError, HttpContentType, HttpHeader, KeboolaHttpHeader, createGenericFetchClient, isAbortError, isApiError, isFetchClientError } from './chunk-2BQBKU6E.js';
-import * as z2 from 'zod';
-import { z } from 'zod';
-
-// src/utils/assert.ts
+import { t as createProject } from "./project-DWwZv66D.js";
+import { a as poller, c as Result, d as delay, i as poll, l as asError, n as emitter, o as clamp, r as failureOf, s as finiteOr, t as jobStatus, u as lazy } from "./jobStatus-DbMupQEK.js";
+import { n as collect, t as createQueueClient } from "./queue-DpZTm7U7.js";
+import { t as concurrent } from "./concurrent-CH9fbNr3.js";
+import { t as dedupe } from "./dedupe-DYIHgZoG.js";
+import { a as shallowEqual, i as createStore, n as createDerivedStore, r as createEmitter, t as createDerivedAsyncStore } from "./createStore-BNiCRQXa.js";
+import { a as series, i as ServiceUnavailableError, t as createStorageClient } from "./storage-CQxu0EY3.js";
+import { n as keboolaUID, t as createTagSdk } from "./tag-DCsoewjL.js";
+import { t as generateUUID } from "./generateUUID-Dr8l-aoc.js";
+import { t as isPlainObject } from "./isPlainObject-LYW-03uB.js";
+import { n as schemaGuidedMerge, r as isEmptyDeep, t as createConfigurationSdk } from "./configurations-Byt59bIa.js";
+import { t as UserError } from "./UserError-By_Zckmc.js";
+import { a as HttpContentType, f as HttpStatus, i as isFetchClientError, l as normalizeBaseUrl, m as ApiError, n as isAbortError, o as HttpHeader, p as KeboolaHttpHeader, r as isApiError } from "./createFetchClient-B1h3-p65.js";
+import { n as HtmlResponseError, r as isHtmlResponseError } from "./validateConnectionStatus-CBhXmvWC.js";
+import { t as ManagementClientAuthError } from "./ManagementClientAuthError-90pvsej0.js";
+import { i as isQueryJobError, n as isQueryJobTimeoutError, r as QueryJobError, t as QueryJobTimeoutError } from "./QueryJobTimeoutError-C7JbNGOM.js";
+import { n as isSyncActionError, t as SyncActionError } from "./SyncActionError-CoZFsdUk.js";
+import { n as isValidationError, r as parseOrThrow, t as ValidationError } from "./ValidationError-CzPWydEb.js";
+import { t as createGenericFetchClient } from "./createGenericFetchClient-DhpvUSlX.js";
+import { t as createImportClient } from "./import-CExRbskw.js";
+import { t as createOpenapiFetchClient } from "./createOpenapiFetchClient-0_oqhdPv.js";
+import { t as createAuthClient } from "./authClient-XBAUz9g-.js";
+import { n as isManagementClientAuthError, t as createManagementClient } from "./management-Cc8mKfnf.js";
+import { t as createAuthHeaders } from "./auth-CE6Hlc9W.js";
+import { o as ProjectFeature } from "./constants-qeWGfk_7.js";
+import { t as createStorageTable } from "./storageTable-DslXtqNL.js";
+import { createSemanticLayerSdk } from "./sdk/semanticLayer/index.js";
+import { createStorageSdk } from "./sdk/storage/index.js";
+import { createVaultSdk } from "./sdk/vault/index.js";
+import { createAiClient } from "./ai/index.js";
+import { t as parseLogLines } from "./appLogs-CLHhkQJn.js";
+import { createAppsClient } from "./apps/index.js";
+import { createChatClient } from "./chat/index.js";
+import { t as createDataScienceClient } from "./dataScience-jdbSSPYF.js";
+import { createEditorClient } from "./editor/index.js";
+import { createEncryptionClient } from "./encryption/index.js";
+import { t as createMetastoreClient } from "./metastore-CNf1412Z.js";
+import { createNotificationsClient } from "./notifications/index.js";
+import { t as createOauthClient } from "./oauth-ClksaYRY.js";
+import { createOmnisearchClient } from "./omnisearch/index.js";
+import { t as createQueryServiceClient } from "./queryService-BlyAcBxP.js";
+import { createSchedulerClient } from "./scheduler/index.js";
+import { createStreamClient } from "./stream/index.js";
+import { t as createSyncActionsClient } from "./syncActions-AgFiMjRS.js";
+import { t as createTelemetryClient } from "./telemetry-CPiGWpLi.js";
+import { createVaultClient } from "./vault/index.js";
+import { n as isUnauthorized, t as createBearerCredential } from "./credential-dKxArMic.js";
+import { createQueryServiceSdk } from "./sdk/queryService/index.js";
+import * as z$1 from "zod";
+import { z } from "zod";
+//#region src/utils/assert.ts
 function assert(value, message) {
-  if (value == null) {
-    throw new Error(message);
-  }
+	if (value == null) throw new Error(message);
 }
-
-// src/utils/async/coalesce.ts
-var coalesce = (task) => {
-  let running = false;
-  const waiters = [];
-  const drain = async () => {
-    running = true;
-    const batch = waiters.splice(0);
-    try {
-      const result = await task();
-      batch.forEach((waiter) => waiter.resolve(result));
-    } catch (error) {
-      batch.forEach((waiter) => waiter.reject(error));
-    }
-    if (waiters.length > 0) return drain();
-    running = false;
-  };
-  return () => {
-    const waiter = Promise.withResolvers();
-    waiters.push(waiter);
-    if (!running) void drain();
-    return waiter.promise;
-  };
-};
-
-// src/utils/async/lazy.ts
-var lazy = (task) => {
-  let value = null;
-  const runTask = async () => await task();
-  return () => {
-    value ??= runTask().catch((error) => {
-      value = null;
-      throw error;
-    });
-    return value;
-  };
-};
-
-// src/utils/createStore.ts
-var createStore = (initial) => {
-  let value = initial;
-  const listeners = /* @__PURE__ */ new Set();
-  return {
-    get: () => value,
-    set: (next) => {
-      if (Object.is(next, value)) return;
-      value = next;
-      listeners.forEach((listener) => listener(value));
-    },
-    subscribe: (listener) => {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-    dispose: () => {
-      value = initial;
-      listeners.clear();
-    }
-  };
-};
-var isPlainObjectOrArray = (value) => {
-  if (Array.isArray(value)) return true;
-  const proto = Object.getPrototypeOf(value);
-  return proto === Object.prototype || proto === null;
-};
-var shallowEqual = (a, b) => {
-  if (Object.is(a, b)) return true;
-  if (typeof a !== "object" || a === null || typeof b !== "object" || b === null) return false;
-  if (!isPlainObjectOrArray(a) || !isPlainObjectOrArray(b)) return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  return aKeys.length === bKeys.length && aKeys.every((key) => Object.is(a[key], b[key]));
+//#endregion
+//#region src/utils/async/coalesce.ts
+/**
+* Coalesces concurrent triggers onto a single, never-parallel run of `task`.
+* Triggers fired while a run is busy collapse into one trailing run, and each
+* resolves with the first run that started after it — so it never sees stale state.
+*
+* Example — A triggers, then B and C trigger while A's run is still going:
+*   1. trigger A      → run #1 starts
+*   2. trigger B, C   → run #1 busy, so they wait
+*   3. run #1 done    → A resolves
+*   4. run #2 starts  → covers B and C together (one trailing run, not two)
+*   5. run #2 done    → B and C resolve
+*
+* @returns a trigger; each call returns a promise of the task result.
+* @throws The returned promise rejects with whatever `task` throws or rejects
+* with — the caller handles it (try/catch, or `.catch` on `void trigger()`).
+*/
+const coalesce = (task) => {
+	let running = false;
+	const waiters = [];
+	const drain = async () => {
+		running = true;
+		const batch = waiters.splice(0);
+		try {
+			const result = await task();
+			batch.forEach((waiter) => waiter.resolve(result));
+		} catch (error) {
+			batch.forEach((waiter) => waiter.reject(error));
+		}
+		if (waiters.length > 0) return drain();
+		running = false;
+	};
+	return () => {
+		const waiter = Promise.withResolvers();
+		waiters.push(waiter);
+		if (!running) drain();
+		return waiter.promise;
+	};
 };
-var createDerivedStore = ({
-  source,
-  dependsOn,
-  build,
-  keyEquals = shallowEqual
-}) => {
-  let key = dependsOn(source.get());
-  const store = createStore(build(key));
-  const unsubscribe = source.subscribe((state) => {
-    const next = dependsOn(state);
-    if (keyEquals(key, next)) return;
-    key = next;
-    store.set(build(next));
-  });
-  return {
-    get: store.get,
-    subscribe: store.subscribe,
-    dispose: () => {
-      unsubscribe();
-      store.dispose();
-    }
-  };
+//#endregion
+//#region src/utils/async/poll/registry.ts
+const DEFAULT_LIMIT = 50;
+const isFinished = ({ snapshot }) => snapshot.state !== "idle" && snapshot.state !== "polling";
+const createPollRegistry = ({ limit = DEFAULT_LIMIT } = {}) => {
+	const entries = createStore([]);
+	const unsubscribes = /* @__PURE__ */ new Map();
+	const maxEntries = clamp(finiteOr(limit, DEFAULT_LIMIT), 1);
+	let nextKey = 1;
+	const forget = (key) => {
+		unsubscribes.get(key)?.();
+		unsubscribes.delete(key);
+	};
+	const trim = (list) => {
+		let kept = list;
+		while (kept.length > maxEntries) {
+			const dropped = kept.findLast(isFinished) ?? kept.at(-1);
+			if (!dropped) break;
+			forget(dropped.key);
+			kept = kept.filter((entry) => entry !== dropped);
+		}
+		return kept;
+	};
+	const replace = (key, snapshot) => entries.set(entries.get().map((entry) => entry.key === key ? {
+		...entry,
+		snapshot
+	} : entry));
+	const register = (poller) => {
+		const key = nextKey++;
+		const entry = {
+			key,
+			startedAt: Date.now(),
+			snapshot: poller.debug(),
+			stop: poller.stop,
+			start: poller.start
+		};
+		unsubscribes.set(key, poller.subscribe((snapshot) => replace(key, snapshot)));
+		entries.set(trim([entry, ...entries.get()]));
+	};
+	const collect = () => {
+		emitter.subscribe(register);
+	};
+	return {
+		list: entries.get,
+		collect,
+		subscribe: (listener) => entries.subscribe(() => listener()),
+		clear: () => {
+			entries.get().forEach(({ key }) => forget(key));
+			entries.set([]);
+		},
+		stopAll: (reason) => entries.get().forEach((entry) => entry.stop(reason))
+	};
 };
-var createDerivedAsyncStore = ({
-  source,
-  dependsOn,
-  build,
-  keyEquals = shallowEqual
-}) => {
-  const store = createStore({ state: "idle" });
-  let currentKey = null;
-  let generation = 0;
-  let controller = null;
-  const run = (key) => {
-    controller?.abort();
-    controller = new AbortController();
-    const runGeneration = ++generation;
-    store.set({ state: "pending" });
-    build(key, controller.signal).then(
-      (value) => {
-        if (runGeneration === generation) store.set({ state: "ready", value });
-      },
-      (error) => {
-        if (runGeneration === generation) store.set({ state: "errored", error });
-      }
-    );
-  };
-  const sync = (state) => {
-    const next = dependsOn(state);
-    if (next === null) {
-      if (currentKey === null) return;
-      controller?.abort();
-      controller = null;
-      generation += 1;
-      currentKey = null;
-      store.set({ state: "idle" });
-      return;
-    }
-    if (currentKey !== null && keyEquals(currentKey, next)) return;
-    currentKey = next;
-    run(next);
-  };
-  sync(source.get());
-  const unsubscribe = source.subscribe(sync);
-  const readable = {
-    get: store.get,
-    subscribe: store.subscribe,
-    dispose: () => {
-      controller?.abort();
-      unsubscribe();
-      store.dispose();
-    }
-  };
-  const settled = () => new Promise((resolve) => {
-    let unsubscribeSettled = () => {
-    };
-    const check = (state) => {
-      if (state.state === "ready" || state.state === "errored") {
-        unsubscribeSettled();
-        resolve(state);
-      }
-    };
-    unsubscribeSettled = store.subscribe(check);
-    check(store.get());
-  });
-  return { store: readable, settled };
-};
-
-// src/utils/deepMerge.ts
-var deepMerge = (base, patch) => {
-  const out = { ...base };
-  for (const [key, value] of Object.entries(patch)) {
-    if (value === void 0) continue;
-    const current = out[key];
-    out[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
-  }
-  return out;
+//#endregion
+//#region src/utils/deepMerge.ts
+/**
+* Recursively merge `patch` into `base`. Plain-object values are merged key-by-key; every
+* other value (primitives, arrays, or a type mismatch between the two sides) replaces the
+* base value. `undefined` patch values are skipped, so a partial patch leaves untouched
+* fields alone. Pure — neither argument is mutated; the result preserves `base`'s type.
+*/
+const deepMerge = (base, patch) => {
+	const out = { ...base };
+	for (const [key, value] of Object.entries(patch)) {
+		if (value === void 0) continue;
+		const current = out[key];
+		out[key] = isPlainObject(current) && isPlainObject(value) ? deepMerge(current, value) : value;
+	}
+	return out;
 };
-
-// src/utils/persistor/adapters.ts
-var createNullStorage = () => ({
-  getItem: () => null,
-  setItem: () => {
-  },
-  removeItem: () => {
-  }
+//#endregion
+//#region src/utils/persistor/adapters.ts
+const createNullStorage = () => ({
+	getItem: () => null,
+	setItem: () => {},
+	removeItem: () => {}
 });
-var createMemoryStorage = () => {
-  const store = /* @__PURE__ */ new Map();
-  return {
-    getItem: (key) => store.get(key) ?? null,
-    setItem: (key, value) => {
-      store.set(key, value);
-    },
-    removeItem: (key) => {
-      store.delete(key);
-    }
-  };
+const createMemoryStorage = () => {
+	const store = /* @__PURE__ */ new Map();
+	return {
+		getItem: (key) => store.get(key) ?? null,
+		setItem: (key, value) => {
+			store.set(key, value);
+		},
+		removeItem: (key) => {
+			store.delete(key);
+		}
+	};
 };
-var createWebStorage = (pick) => {
-  let web = null;
-  try {
-    web = pick();
-    if (web) {
-      const probe = "__keboola_storage_probe__";
-      web.setItem(probe, probe);
-      web.removeItem(probe);
-    }
-  } catch (err) {
-    console.warn("createWebStorage: web storage unavailable, falling back to memory", err);
-    web = null;
-  }
-  if (!web) return createMemoryStorage();
-  const storage = web;
-  return {
-    getItem: (key) => storage.getItem(key),
-    setItem: (key, value) => {
-      storage.setItem(key, value);
-    },
-    removeItem: (key) => {
-      storage.removeItem(key);
-    }
-  };
+const createWebStorage = (pick) => {
+	let web = null;
+	try {
+		web = pick();
+		if (web) {
+			const probe = "__keboola_storage_probe__";
+			web.setItem(probe, probe);
+			web.removeItem(probe);
+		}
+	} catch (err) {
+		console.warn("createWebStorage: web storage unavailable, falling back to memory", err);
+		web = null;
+	}
+	if (!web) return createMemoryStorage();
+	const storage = web;
+	return {
+		getItem: (key) => storage.getItem(key),
+		setItem: (key, value) => {
+			storage.setItem(key, value);
+		},
+		removeItem: (key) => {
+			storage.removeItem(key);
+		}
+	};
 };
-var createLocalStorage = () => createWebStorage(() => "localStorage" in globalThis ? globalThis.localStorage : null);
-var createSessionStorage = () => createWebStorage(() => "sessionStorage" in globalThis ? globalThis.sessionStorage : null);
-
-// src/utils/persistor/persistor.ts
-var createPersistor = ({
-  storage = createNullStorage(),
-  key,
-  schema,
-  defaultValue,
-  encode = JSON.stringify,
-  decode = JSON.parse
-}) => {
-  const clear = () => {
-    try {
-      storage.removeItem(key);
-    } catch (err) {
-      console.warn(`createPersistor: failed to clear "${key}"`, err);
-    }
-  };
-  const hasPersistedValue = () => {
-    try {
-      return !!storage.getItem(key);
-    } catch (err) {
-      console.warn(`createPersistor: failed to read "${key}", assuming empty`, err);
-      return false;
-    }
-  };
-  const hydrate = () => {
-    let raw;
-    try {
-      raw = storage.getItem(key);
-    } catch (err) {
-      console.warn(`createPersistor: failed to read "${key}", using default`, err);
-      return defaultValue;
-    }
-    if (raw === null) return defaultValue;
-    let decoded;
-    try {
-      decoded = decode(raw);
-    } catch (err) {
-      console.warn(`createPersistor: failed to decode "${key}", resetting`, err);
-      clear();
-      return defaultValue;
-    }
-    const parsed = schema.safeParse(decoded);
-    if (parsed.success) return parsed.data;
-    clear();
-    return defaultValue;
-  };
-  const persist = (value) => {
-    let raw;
-    try {
-      raw = encode(value);
-    } catch (err) {
-      console.warn(`createPersistor: failed to encode "${key}", not persisting`, err);
-      return;
-    }
-    try {
-      storage.setItem(key, raw);
-    } catch (err) {
-      console.warn(`createPersistor: failed to write "${key}"`, err);
-    }
-  };
-  return { hydrate, persist, clear, hasPersistedValue };
+const createLocalStorage = () => createWebStorage(() => "localStorage" in globalThis ? globalThis.localStorage : null);
+const createSessionStorage = () => createWebStorage(() => "sessionStorage" in globalThis ? globalThis.sessionStorage : null);
+//#endregion
+//#region src/utils/persistor/persistor.ts
+const createPersistor = ({ storage = createNullStorage(), key, schema, defaultValue, encode = JSON.stringify, decode = JSON.parse }) => {
+	const clear = () => {
+		try {
+			storage.removeItem(key);
+		} catch (err) {
+			console.warn(`createPersistor: failed to clear "${key}"`, err);
+		}
+	};
+	const hasPersistedValue = () => {
+		try {
+			return !!storage.getItem(key);
+		} catch (err) {
+			console.warn(`createPersistor: failed to read "${key}", assuming empty`, err);
+			return false;
+		}
+	};
+	const hydrate = () => {
+		let raw;
+		try {
+			raw = storage.getItem(key);
+		} catch (err) {
+			console.warn(`createPersistor: failed to read "${key}", using default`, err);
+			return defaultValue;
+		}
+		if (raw === null) return defaultValue;
+		let decoded;
+		try {
+			decoded = decode(raw);
+		} catch (err) {
+			console.warn(`createPersistor: failed to decode "${key}", resetting`, err);
+			clear();
+			return defaultValue;
+		}
+		const parsed = schema.safeParse(decoded);
+		if (parsed.success) return parsed.data;
+		clear();
+		return defaultValue;
+	};
+	const persist = (value) => {
+		let raw;
+		try {
+			raw = encode(value);
+		} catch (err) {
+			console.warn(`createPersistor: failed to encode "${key}", not persisting`, err);
+			return;
+		}
+		try {
+			storage.setItem(key, raw);
+		} catch (err) {
+			console.warn(`createPersistor: failed to write "${key}"`, err);
+		}
+	};
+	return {
+		hydrate,
+		persist,
+		clear,
+		hasPersistedValue
+	};
 };
-
-// src/keboola/createLiveProject.ts
-var STORAGE_TOKEN_MUTATING_PATTERNS = [
-  // Bucket lifecycle (create / delete / register) — changes token.bucketPermissions.
-  // At most one trailing segment, so sub-resources (tables, listing, metadata, refresh)
-  // under /buckets/{id}/... don't trigger a re-verify.
-  /\/buckets(\/[^/]+)?$/,
-  // Project feature toggles — changes token.owner.features. Anchored to
-  // /projects/{id}/features so /manage/features and /users/{id}/features don't match.
-  /\/projects\/[^/]+\/features(\/[^/]+)?$/
-];
-var isStorageTokenMutatingRequest = (request) => {
-  if (request.method === "GET") return false;
-  const { pathname } = new URL(request.url);
-  return STORAGE_TOKEN_MUTATING_PATTERNS.some((pattern) => pattern.test(pathname));
+//#endregion
+//#region src/keboola/createLiveProject.ts
+const STORAGE_TOKEN_MUTATING_PATTERNS = [/\/buckets(\/[^/]+)?$/, /\/projects\/[^/]+\/features(\/[^/]+)?$/];
+const isStorageTokenMutatingRequest = (request) => {
+	if (request.method === "GET") return false;
+	const { pathname } = new URL(request.url);
+	return STORAGE_TOKEN_MUTATING_PATTERNS.some((pattern) => pattern.test(pathname));
 };
-var createProjectRefreshMiddleware = (shouldRefresh, requestRefresh) => (next) => async (request) => {
-  const response = await next(request);
-  if (shouldRefresh(request.request)) await requestRefresh();
-  return response;
+const createProjectRefreshMiddleware = (shouldRefresh, requestRefresh) => (next) => async (request) => {
+	const response = await next(request);
+	if (shouldRefresh(request.request)) await requestRefresh();
+	return response;
 };
-var createLiveProject = ({
-  initialToken,
-  verify
-}) => {
-  const store = createStore(createProject({ sapiToken: initialToken }));
-  const refresh = coalesce(async () => store.set(createProject({ sapiToken: await verify() })));
-  const middleware = createProjectRefreshMiddleware(isStorageTokenMutatingRequest, refresh);
-  return { store, getProject: () => store.get(), subscribe: store.subscribe, middleware, refresh };
+/**
+* The live project store: seeded from the verified token, re-verified (coalesced) after a
+* token-mutating request or an explicit re-scope. Its `middleware` drives the auto re-verify.
+*/
+const createLiveProject = ({ initialToken, verify }) => {
+	const store = createStore(createProject({ sapiToken: initialToken }));
+	const refresh = coalesce(async () => store.set(createProject({ sapiToken: await verify() })));
+	const middleware = createProjectRefreshMiddleware(isStorageTokenMutatingRequest, refresh);
+	return {
+		store,
+		getProject: () => store.get(),
+		subscribe: store.subscribe,
+		middleware,
+		refresh
+	};
 };
-
-// src/keboola/errors.ts
-var KeboolaErrorType = {
-  Unconfigured: "unconfigured",
-  NotAuthenticated: "not-authenticated",
-  AlreadyAuthenticated: "already-authenticated",
-  NoStorageToken: "no-storage-token",
-  NoManagementToken: "no-management-token",
-  MissingProject: "missing-project",
-  NotBearer: "not-bearer",
-  NotReady: "not-ready",
-  InvalidBuildTransition: "invalid-build-transition"
+//#endregion
+//#region src/keboola/errors.ts
+/**
+* The single error the keboola client / session throws. It carries a stable `type` (the switchable
+* contract) and a human-readable message derived from that type — no per-call message strings.
+*/
+const KeboolaErrorType = {
+	Unconfigured: "unconfigured",
+	NotAuthenticated: "not-authenticated",
+	AlreadyAuthenticated: "already-authenticated",
+	NoStorageToken: "no-storage-token",
+	NoManagementToken: "no-management-token",
+	MissingProject: "missing-project",
+	NotBearer: "not-bearer",
+	NotReady: "not-ready",
+	InvalidBuildTransition: "invalid-build-transition"
 };
-var MESSAGES = {
-  [KeboolaErrorType.Unconfigured]: "The session is not configured \u2014 set a baseUrl first.",
-  [KeboolaErrorType.NotAuthenticated]: "The session is not authenticated \u2014 sign in first.",
-  [KeboolaErrorType.AlreadyAuthenticated]: "The session is already authenticated \u2014 reset before authenticating again.",
-  [KeboolaErrorType.NoStorageToken]: "No storage token \u2014 authenticate the storage realm first.",
-  [KeboolaErrorType.NoManagementToken]: "No management token \u2014 authenticate the management realm first.",
-  [KeboolaErrorType.MissingProject]: "A bearer storage session requires a project \u2014 call setProject(projectId) first.",
-  [KeboolaErrorType.NotBearer]: "This operation requires a bearer (OAuth) session.",
-  [KeboolaErrorType.NotReady]: "The client is not ready \u2014 authenticate the storage realm first.",
-  [KeboolaErrorType.InvalidBuildTransition]: "Invalid storage build transition \u2014 the build goes idle \u2192 initializing \u2192 ready | failed."
+const MESSAGES = {
+	[KeboolaErrorType.Unconfigured]: "The session is not configured — set a baseUrl first.",
+	[KeboolaErrorType.NotAuthenticated]: "The session is not authenticated — sign in first.",
+	[KeboolaErrorType.AlreadyAuthenticated]: "The session is already authenticated — reset before authenticating again.",
+	[KeboolaErrorType.NoStorageToken]: "No storage token — authenticate the storage realm first.",
+	[KeboolaErrorType.NoManagementToken]: "No management token — authenticate the management realm first.",
+	[KeboolaErrorType.MissingProject]: "A bearer storage session requires a project — call setProject(projectId) first.",
+	[KeboolaErrorType.NotBearer]: "This operation requires a bearer (OAuth) session.",
+	[KeboolaErrorType.NotReady]: "The client is not ready — authenticate the storage realm first.",
+	[KeboolaErrorType.InvalidBuildTransition]: "Invalid storage build transition — the build goes idle → initializing → ready | failed."
 };
-var KeboolaError = class _KeboolaError extends Error {
-  type;
-  constructor(type) {
-    super(MESSAGES[type]);
-    this.type = type;
-    this.name = "KeboolaError";
-    Object.setPrototypeOf(this, _KeboolaError.prototype);
-  }
+var KeboolaError = class KeboolaError extends Error {
+	type;
+	constructor(type) {
+		super(MESSAGES[type]);
+		this.type = type;
+		this.name = "KeboolaError";
+		Object.setPrototypeOf(this, KeboolaError.prototype);
+	}
 };
-var isKeboolaError = (error) => error instanceof KeboolaError;
-function assert2(value, type) {
-  if (value == null) throw new KeboolaError(type);
+const isKeboolaError = (error) => error instanceof KeboolaError;
+/** Throw a {@link KeboolaError} of `type` when `value` is null/undefined; otherwise narrow it. */
+function assert$1(value, type) {
+	if (value == null) throw new KeboolaError(type);
 }
-
-// src/middlewares/loggingMiddleware.ts
-var CORRELATION_ID_HEADER = "X-Correlation-ID";
-var ALWAYS_REDACTED_HEADERS = [
-  KeboolaHttpHeader.MANAGEMENT_API_TOKEN,
-  KeboolaHttpHeader.STORAGE_API_TOKEN,
-  "authorization",
-  "cookie",
-  "set-cookie"
+//#endregion
+//#region src/middlewares/loggingMiddleware.ts
+const CORRELATION_ID_HEADER = "X-Correlation-ID";
+const ALWAYS_REDACTED_HEADERS = [
+	KeboolaHttpHeader.MANAGEMENT_API_TOKEN,
+	KeboolaHttpHeader.STORAGE_API_TOKEN,
+	"authorization",
+	"cookie",
+	"set-cookie"
 ];
-var ALWAYS_REDACTED_QUERY_PARAMS = /* @__PURE__ */ new Set([
-  "token",
-  "apikey",
-  "api_key",
-  "access_token",
-  "refresh_token",
-  "code",
-  "state",
-  "signature",
-  "sig",
-  "x-amz-signature",
-  "x-amz-credential",
-  "x-amz-security-token",
-  "password",
-  "secret"
+const ALWAYS_REDACTED_QUERY_PARAMS = /* @__PURE__ */ new Set([
+	"token",
+	"apikey",
+	"api_key",
+	"access_token",
+	"refresh_token",
+	"code",
+	"state",
+	"signature",
+	"sig",
+	"x-amz-signature",
+	"x-amz-credential",
+	"x-amz-security-token",
+	"password",
+	"secret"
 ]);
-var REDACTED = "[REDACTED]";
-var getRedactedUrl = (rawUrl) => {
-  const url = new URL(rawUrl);
-  if (url.username) url.username = REDACTED;
-  if (url.password) url.password = REDACTED;
-  url.searchParams.forEach((_value, key) => {
-    if (ALWAYS_REDACTED_QUERY_PARAMS.has(key.toLowerCase())) {
-      url.searchParams.set(key, REDACTED);
-    }
-  });
-  return url.toString();
+const REDACTED = "[REDACTED]";
+const getRedactedUrl = (rawUrl) => {
+	const url = new URL(rawUrl);
+	if (url.username) url.username = REDACTED;
+	if (url.password) url.password = REDACTED;
+	url.searchParams.forEach((_value, key) => {
+		if (ALWAYS_REDACTED_QUERY_PARAMS.has(key.toLowerCase())) url.searchParams.set(key, REDACTED);
+	});
+	return url.toString();
 };
-var ensureCorrelationId = (request) => {
-  const correlationId = request.headers.get(CORRELATION_ID_HEADER) ?? generateUUID();
-  request.headers.set(CORRELATION_ID_HEADER, correlationId);
-  return correlationId;
+const ensureCorrelationId = (request) => {
+	const correlationId = request.headers.get(CORRELATION_ID_HEADER) ?? generateUUID();
+	request.headers.set(CORRELATION_ID_HEADER, correlationId);
+	return correlationId;
 };
-var getRedactedHeaders = (headers, redacted) => {
-  const redactedSet = new Set(
-    [...ALWAYS_REDACTED_HEADERS, ...redacted].map((h) => h.toLowerCase())
-  );
-  const result = {};
-  headers.forEach((value, name) => {
-    result[name] = redactedSet.has(name.toLowerCase()) ? REDACTED : value;
-  });
-  return result;
+const getRedactedHeaders = (headers, redacted) => {
+	const redactedSet = new Set([...ALWAYS_REDACTED_HEADERS, ...redacted].map((h) => h.toLowerCase()));
+	const result = {};
+	headers.forEach((value, name) => {
+		result[name] = redactedSet.has(name.toLowerCase()) ? REDACTED : value;
+	});
+	return result;
 };
-var getRequestLog = (request, redactedHeaders) => ({
-  url: getRedactedUrl(request.url),
-  headers: getRedactedHeaders(request.headers, redactedHeaders)
+const getRequestLog = (request, redactedHeaders) => ({
+	url: getRedactedUrl(request.url),
+	headers: getRedactedHeaders(request.headers, redactedHeaders)
 });
-var getResponseLog = (response, redactedHeaders) => ({
-  status: response.status,
-  statusText: response.statusText,
-  headers: getRedactedHeaders(response.headers, redactedHeaders)
+const getResponseLog = (response, redactedHeaders) => ({
+	status: response.status,
+	statusText: response.statusText,
+	headers: getRedactedHeaders(response.headers, redactedHeaders)
 });
-var redactApiError = (error, redactedHeaders) => new ApiError({
-  request: new Request(getRedactedUrl(error.request.url), {
-    method: error.request.method,
-    headers: getRedactedHeaders(error.request.headers, redactedHeaders)
-  }),
-  response: new Response(null, {
-    status: error.response.status,
-    statusText: error.response.statusText,
-    headers: getRedactedHeaders(error.response.headers, redactedHeaders)
-  }),
-  data: error.data
+const redactApiError = (error, redactedHeaders) => new ApiError({
+	request: new Request(getRedactedUrl(error.request.url), {
+		method: error.request.method,
+		headers: getRedactedHeaders(error.request.headers, redactedHeaders)
+	}),
+	response: new Response(null, {
+		status: error.response.status,
+		statusText: error.response.statusText,
+		headers: getRedactedHeaders(error.response.headers, redactedHeaders)
+	}),
+	data: error.data
 });
-var formatLog = (level, log) => {
-  const parts = [`[${level.toUpperCase()}]`, `${Math.round(log.durationMs)}ms`, log.method];
-  parts.push(log.request.url);
-  if ("response" in log) parts.push(String(log.response.status));
-  return parts.join(" ");
+const formatLog = (level, log) => {
+	const parts = [
+		`[${level.toUpperCase()}]`,
+		`${Math.round(log.durationMs)}ms`,
+		log.method
+	];
+	parts.push(log.request.url);
+	if ("response" in log) parts.push(String(log.response.status));
+	return parts.join(" ");
 };
-var createSafeLogger = (logger, level = "error-only") => {
-  return {
-    info: (log) => {
-      if (level !== "all") return;
-      try {
-        if (logger?.info) {
-          logger.info(log);
-          return;
-        }
-        console.info(formatLog("info", log));
-      } catch {
-      }
-    },
-    error: (log) => {
-      try {
-        if (logger?.error) {
-          logger.error(log);
-          return;
-        }
-        console.error(formatLog("error", log));
-      } catch {
-      }
-    }
-  };
+const createSafeLogger = (logger, level = "error-only") => {
+	return {
+		info: (log) => {
+			if (level !== "all") return;
+			try {
+				if (logger?.info) {
+					logger.info(log);
+					return;
+				}
+				console.info(formatLog("info", log));
+			} catch {}
+		},
+		error: (log) => {
+			try {
+				if (logger?.error) {
+					logger.error(log);
+					return;
+				}
+				console.error(formatLog("error", log));
+			} catch {}
+		}
+	};
 };
-var createLoggingMiddleware = (options = {}) => {
-  const safeLogger = createSafeLogger(options.logger, options.level);
-  const redactHeaders = options.redactHeaders ?? [];
-  return (next) => async (fetchRequest) => {
-    const correlationId = ensureCorrelationId(fetchRequest.request);
-    const start = performance.now();
-    const method = fetchRequest.request.method.toLowerCase();
-    const requestLog = getRequestLog(fetchRequest.request, redactHeaders);
-    try {
-      const result = await next(fetchRequest);
-      safeLogger.info({
-        correlationId,
-        method,
-        durationMs: performance.now() - start,
-        request: requestLog,
-        response: getResponseLog(result.response, redactHeaders)
-      });
-      return result;
-    } catch (error) {
-      if (error instanceof Error)
-        safeLogger.error({
-          correlationId,
-          method,
-          durationMs: performance.now() - start,
-          request: requestLog,
-          error: isApiError(error) ? redactApiError(error, redactHeaders) : error
-        });
-      throw error;
-    }
-  };
+const createLoggingMiddleware = (options = {}) => {
+	const safeLogger = createSafeLogger(options.logger, options.level);
+	const redactHeaders = options.redactHeaders ?? [];
+	return (next) => async (fetchRequest) => {
+		const correlationId = ensureCorrelationId(fetchRequest.request);
+		const start = performance.now();
+		const method = fetchRequest.request.method.toLowerCase();
+		const requestLog = getRequestLog(fetchRequest.request, redactHeaders);
+		try {
+			const result = await next(fetchRequest);
+			safeLogger.info({
+				correlationId,
+				method,
+				durationMs: performance.now() - start,
+				request: requestLog,
+				response: getResponseLog(result.response, redactHeaders)
+			});
+			return result;
+		} catch (error) {
+			if (error instanceof Error) safeLogger.error({
+				correlationId,
+				method,
+				durationMs: performance.now() - start,
+				request: requestLog,
+				error: isApiError(error) ? redactApiError(error, redactHeaders) : error
+			});
+			throw error;
+		}
+	};
 };
-
-// src/middlewares/retryMiddleware.ts
-var DEFAULT_MAX_RETRIES = 5;
-var DEFAULT_RETRYABLE_STATUSES = [
-  HttpStatus.INTERNAL_SERVER_ERROR,
-  HttpStatus.BAD_GATEWAY,
-  HttpStatus.SERVICE_UNAVAILABLE,
-  HttpStatus.GATEWAY_TIMEOUT
+//#endregion
+//#region src/middlewares/retryMiddleware.ts
+const DEFAULT_MAX_RETRIES = 5;
+const DEFAULT_RETRYABLE_STATUSES = [
+	HttpStatus.INTERNAL_SERVER_ERROR,
+	HttpStatus.BAD_GATEWAY,
+	HttpStatus.SERVICE_UNAVAILABLE,
+	HttpStatus.GATEWAY_TIMEOUT
 ];
-var DEFAULT_BACKOFF_FACTOR = 0.3;
-var defaultShouldRetry = (error) => error instanceof ApiError && DEFAULT_RETRYABLE_STATUSES.includes(error.response.status);
-var createRetryMiddleware = (options) => {
-  const {
-    maxRetries = DEFAULT_MAX_RETRIES,
-    backoffFactor = DEFAULT_BACKOFF_FACTOR,
-    shouldRetry = defaultShouldRetry
-  } = options ?? {};
-  if (!Number.isInteger(maxRetries) || maxRetries < 0) {
-    throw new RangeError("maxRetries must be a non-negative integer");
-  }
-  if (!Number.isFinite(backoffFactor) || backoffFactor < 0) {
-    throw new RangeError("backoffFactor must be a finite non-negative number");
-  }
-  return (next) => async (request) => {
-    for (let attempt = 0; attempt <= maxRetries; attempt++) {
-      try {
-        return await next({ ...request, request: request.request.clone() });
-      } catch (error) {
-        if (attempt === maxRetries || !shouldRetry(error, attempt)) {
-          throw error;
-        }
-        const delayMs = backoffFactor * 1e3 * Math.pow(2, attempt);
-        await delay(delayMs, request.request.signal ?? void 0);
-      }
-    }
-    throw new Error("unreachable");
-  };
+const DEFAULT_BACKOFF_FACTOR = .3;
+const defaultShouldRetry = (error) => error instanceof ApiError && DEFAULT_RETRYABLE_STATUSES.includes(error.response.status);
+const createRetryMiddleware = (options) => {
+	const { maxRetries = DEFAULT_MAX_RETRIES, backoffFactor = DEFAULT_BACKOFF_FACTOR, shouldRetry = defaultShouldRetry } = options ?? {};
+	if (!Number.isInteger(maxRetries) || maxRetries < 0) throw new RangeError("maxRetries must be a non-negative integer");
+	if (!Number.isFinite(backoffFactor) || backoffFactor < 0) throw new RangeError("backoffFactor must be a finite non-negative number");
+	return (next) => async (request) => {
+		for (let attempt = 0; attempt <= maxRetries; attempt++) try {
+			return await next({
+				...request,
+				request: request.request.clone()
+			});
+		} catch (error) {
+			if (attempt === maxRetries || !shouldRetry(error, attempt)) throw error;
+			const delayMs = backoffFactor * 1e3 * Math.pow(2, attempt);
+			await delay(delayMs, request.request.signal ?? void 0);
+		}
+		throw new Error("unreachable");
+	};
 };
-
-// src/serviceClientRegistry/utils.ts
-var isBuiltInProperty = (property) => typeof property === "symbol" || property === "then" || property === "constructor" || property === "toString" || property === "valueOf";
-var createDummyClient = ({
-  onCall
-}) => {
-  const createProxy = (path = []) => new Proxy(() => {
-  }, {
-    // Create a new proxy for nested property access
-    get: (_target, prop) => {
-      if (isBuiltInProperty(prop)) return void 0;
-      return createProxy([...path, prop]);
-    },
-    // When called as a function, invoke the interceptor
-    apply: (_target, _thisArgs, args) => onCall(path, args)
-  });
-  return createProxy();
+//#endregion
+//#region src/serviceClientRegistry/utils.ts
+const isBuiltInProperty = (property) => typeof property === "symbol" || property === "then" || property === "constructor" || property === "toString" || property === "valueOf";
+/**
+* Creates a dummy client that intercepts method calls and invokes the provided onCall callback.
+*/
+const createDummyClient = ({ onCall }) => {
+	const createProxy = (path = []) => new Proxy(() => {}, {
+		get: (_target, prop) => {
+			if (isBuiltInProperty(prop)) return void 0;
+			return createProxy([...path, prop]);
+		},
+		apply: (_target, _thisArgs, args) => onCall(path, args)
+	});
+	return createProxy();
 };
-
-// src/serviceClientRegistry/createServiceClientRegistry.ts
-var createServiceClientRegistry = () => ({
-  getServiceBaseUrl,
-  onUnavailable
-}) => {
-  const dummy = (serviceId, clientName) => createDummyClient({
-    onCall: (path, args) => {
-      onUnavailable?.({
-        serviceId,
-        path,
-        args,
-        clientName
-      });
-    }
-  });
-  const configs = [];
-  const resolveClient = ({
-    serviceId,
-    clientFn,
-    clientName
-  }) => {
-    const serviceBaseUrl = getServiceBaseUrl(serviceId);
-    return serviceBaseUrl ? clientFn(serviceBaseUrl) : dummy(serviceId, clientName);
-  };
-  const registry = {
-    add: (config) => {
-      configs.push(config);
-      return registry;
-    },
-    build: () => {
-      const clientMap = {};
-      const clientMeta = [];
-      configs.forEach((config) => {
-        clientMap[config.clientName] = resolveClient(config);
-        clientMeta.push({
-          clientName: config.clientName,
-          serviceId: config.serviceId,
-          isAvailable: !!getServiceBaseUrl(config.serviceId)
-        });
-      });
-      return {
-        client: clientMap,
-        meta: clientMeta
-      };
-    }
-  };
-  return registry;
+//#endregion
+//#region src/serviceClientRegistry/createServiceClientRegistry.ts
+const createServiceClientRegistry = () => ({ getServiceBaseUrl, onUnavailable }) => {
+	const dummy = (serviceId, clientName) => createDummyClient({ onCall: (path, args) => {
+		onUnavailable?.({
+			serviceId,
+			path,
+			args,
+			clientName
+		});
+	} });
+	const configs = [];
+	const resolveClient = ({ serviceId, clientFn, clientName }) => {
+		const serviceBaseUrl = getServiceBaseUrl(serviceId);
+		return serviceBaseUrl ? clientFn(serviceBaseUrl) : dummy(serviceId, clientName);
+	};
+	const registry = {
+		add: (config) => {
+			configs.push(config);
+			return registry;
+		},
+		build: () => {
+			const clientMap = {};
+			const clientMeta = [];
+			configs.forEach((config) => {
+				clientMap[config.clientName] = resolveClient(config);
+				clientMeta.push({
+					clientName: config.clientName,
+					serviceId: config.serviceId,
+					isAvailable: !!getServiceBaseUrl(config.serviceId)
+				});
+			});
+			return {
+				client: clientMap,
+				meta: clientMeta
+			};
+		}
+	};
+	return registry;
 };
-
-// src/keboola/createApi.ts
-var createApi = (state) => new Proxy({}, {
-  get(_target, property) {
-    if (isBuiltInProperty(property)) return void 0;
-    if (property === "auth") {
-      const authClient = state.getAuthClient();
-      assert2(authClient, KeboolaErrorType.Unconfigured);
-      return authClient;
-    }
-    if (property === "management") {
-      const management = state.getManagementClient();
-      assert2(management, KeboolaErrorType.NoManagementToken);
-      return management;
-    }
-    const clients = state.getProjectClients();
-    assert2(clients, KeboolaErrorType.NotReady);
-    return clients[property];
-  }
-});
-
-// src/keboola/createMiddlewareFor.ts
-var createMiddlewareFor = (middlewares) => {
-  return (target, baseline = []) => {
-    if (Array.isArray(middlewares)) return [...baseline, ...middlewares];
-    const all = middlewares?.all ?? [];
-    const targeted = middlewares?.[target] ?? [];
-    return [...baseline, ...all, ...targeted];
-  };
+//#endregion
+//#region src/keboola/createApi.ts
+const createApi = (state) => new Proxy({}, { get(_target, property) {
+	if (isBuiltInProperty(property)) return void 0;
+	if (property === "auth") {
+		const authClient = state.getAuthClient();
+		assert$1(authClient, KeboolaErrorType.Unconfigured);
+		return authClient;
+	}
+	if (property === "management") {
+		const management = state.getManagementClient();
+		assert$1(management, KeboolaErrorType.NoManagementToken);
+		return management;
+	}
+	const clients = state.getProjectClients();
+	assert$1(clients, KeboolaErrorType.NotReady);
+	return clients[property];
+} });
+//#endregion
+//#region src/keboola/createMiddlewareFor.ts
+const createMiddlewareFor = (middlewares) => {
+	return (target, baseline = []) => {
+		if (Array.isArray(middlewares)) return [...baseline, ...middlewares];
+		const all = middlewares?.all ?? [];
+		const targeted = middlewares?.[target] ?? [];
+		return [
+			...baseline,
+			...all,
+			...targeted
+		];
+	};
 };
-
-// src/keboola/bearer/createConfig.ts
-var INITIAL = { status: "anonymous", baseUrl: null };
-var stamp = (tokens) => ({ ...tokens, issuedAt: Date.now() });
-var createConfig = (initial = INITIAL) => {
-  const store = createStore(initial);
-  let expiredNotified = false;
-  const setBaseUrl = (baseUrl) => {
-    if (store.get().status !== "anonymous")
-      throw new KeboolaError(KeboolaErrorType.AlreadyAuthenticated);
-    store.set({ status: "anonymous", baseUrl });
-  };
-  const authenticate = (tokens) => {
-    const state = store.get();
-    if (state.status !== "anonymous") throw new KeboolaError(KeboolaErrorType.AlreadyAuthenticated);
-    if (!state.baseUrl) throw new KeboolaError(KeboolaErrorType.Unconfigured);
-    expiredNotified = false;
-    store.set({ status: "authenticated", baseUrl: state.baseUrl, credential: stamp(tokens) });
-  };
-  const setProjectId = (projectId) => {
-    const state = store.get();
-    if (state.status === "anonymous") throw new KeboolaError(KeboolaErrorType.NotAuthenticated);
-    store.set({
-      status: "scoped",
-      baseUrl: state.baseUrl,
-      credential: state.credential,
-      projectId
-    });
-  };
-  const clearProjectId = () => {
-    const state = store.get();
-    if (state.status !== "scoped") return;
-    store.set({ status: "authenticated", baseUrl: state.baseUrl, credential: state.credential });
-  };
-  const reset = () => {
-    store.set({ status: "anonymous", baseUrl: store.get().baseUrl });
-  };
-  const applyRefresh = (tokens) => {
-    const state = store.get();
-    if (state.status === "anonymous") return;
-    store.set({ ...state, credential: stamp(tokens) });
-  };
-  const forceExpire = () => {
-    const state = store.get();
-    if (state.status === "anonymous") return;
-    const issuedAt = Date.now() - state.credential.expiresIn * 1e3;
-    store.set({ ...state, credential: { ...state.credential, issuedAt } });
-  };
-  const requireCredential = () => {
-    const state = store.get();
-    if (state.status === "anonymous") throw new KeboolaError(KeboolaErrorType.NotAuthenticated);
-    return state.credential;
-  };
-  const getBaseUrl = () => store.get().baseUrl;
-  const notifyExpired = () => {
-    if (expiredNotified) return false;
-    expiredNotified = true;
-    return true;
-  };
-  const debug = () => store.get();
-  const readable = {
-    get: store.get,
-    subscribe: store.subscribe,
-    dispose: store.dispose
-  };
-  return {
-    store: readable,
-    setBaseUrl,
-    authenticate,
-    setProjectId,
-    clearProjectId,
-    reset,
-    applyRefresh,
-    forceExpire,
-    requireCredential,
-    getBaseUrl,
-    notifyExpired,
-    debug
-  };
+//#endregion
+//#region src/keboola/bearer/createConfig.ts
+const INITIAL = {
+	status: "anonymous",
+	baseUrl: null
 };
-
-// src/domain/defaultBranch.ts
-var createDefaultBranch = ({ devBranches }) => {
-  const defaultBranch = devBranches.find((branch) => branch.isDefault);
-  assert(defaultBranch, "No default branch found for the project.");
-  const getType = (branchId) => {
-    if (branchId == null || branchId === "default") return "default";
-    return Number(branchId) === defaultBranch.id ? "default" : "dev";
-  };
-  return {
-    id: defaultBranch.id,
-    name: defaultBranch.name,
-    getType,
-    isDev: (branchId) => getType(branchId) === "dev",
-    isDefault: (branchId) => getType(branchId) === "default"
-  };
+const stamp = (tokens) => ({
+	...tokens,
+	issuedAt: Date.now()
+});
+const createConfig$1 = (initial = INITIAL) => {
+	const store = createStore(initial);
+	let expiredNotified = false;
+	const setBaseUrl = (baseUrl) => {
+		if (store.get().status !== "anonymous") throw new KeboolaError(KeboolaErrorType.AlreadyAuthenticated);
+		store.set({
+			status: "anonymous",
+			baseUrl
+		});
+	};
+	const authenticate = (tokens) => {
+		const state = store.get();
+		if (state.status !== "anonymous") throw new KeboolaError(KeboolaErrorType.AlreadyAuthenticated);
+		if (!state.baseUrl) throw new KeboolaError(KeboolaErrorType.Unconfigured);
+		expiredNotified = false;
+		store.set({
+			status: "authenticated",
+			baseUrl: state.baseUrl,
+			credential: stamp(tokens)
+		});
+	};
+	const setProjectId = (projectId) => {
+		const state = store.get();
+		if (state.status === "anonymous") throw new KeboolaError(KeboolaErrorType.NotAuthenticated);
+		store.set({
+			status: "scoped",
+			baseUrl: state.baseUrl,
+			credential: state.credential,
+			projectId
+		});
+	};
+	/**
+	* Drop the project scope, keeping the credential — the inverse of `setProjectId`, for leaving a
+	* project without signing out. The project clients are keyed on the scope, so they tear down and
+	* the storage build returns to `idle`; the session stays usable for `auth` and `management`.
+	* No-op unless currently scoped.
+	*/
+	const clearProjectId = () => {
+		const state = store.get();
+		if (state.status !== "scoped") return;
+		store.set({
+			status: "authenticated",
+			baseUrl: state.baseUrl,
+			credential: state.credential
+		});
+	};
+	/** Drop the credential (sign out); keeps the configured baseUrl. */
+	const reset = () => {
+		store.set({
+			status: "anonymous",
+			baseUrl: store.get().baseUrl
+		});
+	};
+	/** Apply a token refresh: replace the credential (fresh tokens, new issue time); no-op before auth. */
+	const applyRefresh = (tokens) => {
+		const state = store.get();
+		if (state.status === "anonymous") return;
+		store.set({
+			...state,
+			credential: stamp(tokens)
+		});
+	};
+	/**
+	* Dev/test lever: backdate the current token's issue time by a full lifetime so it reads as
+	* expired, making the refresh policy rotate it on the next request. No-op before auth.
+	*/
+	const forceExpire = () => {
+		const state = store.get();
+		if (state.status === "anonymous") return;
+		const issuedAt = Date.now() - state.credential.expiresIn * 1e3;
+		store.set({
+			...state,
+			credential: {
+				...state.credential,
+				issuedAt
+			}
+		});
+	};
+	/**
+	* The current credential, asserting the session is authenticated (or scoped). Single point for that
+	* check so callers (token attach, refresh) don't each re-narrow the state.
+	*/
+	const requireCredential = () => {
+		const state = store.get();
+		if (state.status === "anonymous") throw new KeboolaError(KeboolaErrorType.NotAuthenticated);
+		return state.credential;
+	};
+	const getBaseUrl = () => store.get().baseUrl;
+	/**
+	* Session-expiry latch (fire-once):
+	* - why: concurrent 401s all report expiry, but the app must sign out once; and the credential /
+	*   auth middleware are long-lived singletons, so the latch can't live in them — it must reset
+	*   per session.
+	* - how: returns `true` only for the first call since the last `authenticate` (which re-arms it),
+	*   so the caller runs its sign-out exactly once per session death.
+	*/
+	const notifyExpired = () => {
+		if (expiredNotified) return false;
+		expiredNotified = true;
+		return true;
+	};
+	const debug = () => store.get();
+	return {
+		store: {
+			get: store.get,
+			subscribe: store.subscribe,
+			dispose: store.dispose
+		},
+		setBaseUrl,
+		authenticate,
+		setProjectId,
+		clearProjectId,
+		reset,
+		applyRefresh,
+		forceExpire,
+		requireCredential,
+		getBaseUrl,
+		notifyExpired,
+		debug
+	};
 };
-
-// src/domain/stack.ts
-var SERVICE_URL_OVERRIDES = {
-  // The service URL for the Kai Assistant is incomplete; we need to add the `/api` suffix to get the full URL for the API.
-  // I assume the service is versioned.
-  "kai-assistant": (url) => `${url}/api`
+//#endregion
+//#region src/domain/defaultBranch.ts
+const createDefaultBranch = ({ devBranches }) => {
+	const defaultBranch = devBranches.find((branch) => branch.isDefault);
+	assert(defaultBranch, "No default branch found for the project.");
+	const getType = (branchId) => {
+		if (branchId == null || branchId === "default") return "default";
+		return Number(branchId) === defaultBranch.id ? "default" : "dev";
+	};
+	return {
+		id: defaultBranch.id,
+		name: defaultBranch.name,
+		getType,
+		isDev: (branchId) => getType(branchId) === "dev",
+		isDefault: (branchId) => getType(branchId) === "default"
+	};
 };
-var createStack = ({ stackInfo, clientServiceUrls }) => {
-  const { services, components, features, ...infoRest } = stackInfo;
-  const serviceMap = new Map(
-    services.map((service) => {
-      const devOverride = clientServiceUrls?.[service.id]?.(service.url);
-      const prodOverride = SERVICE_URL_OVERRIDES[service.id]?.(service.url);
-      const url = devOverride ?? prodOverride ?? service.url;
-      return [service.id, url];
-    })
-  );
-  const componentMap = new Map(components.map((component) => [component.id, component]));
-  const featureSet = new Set(features);
-  const hasFeature = (...feature) => {
-    if (feature.length === 0) return false;
-    return feature.every((x) => featureSet.has(x));
-  };
-  const hasComponent = (...componentId) => {
-    if (componentId.length === 0) return false;
-    return componentId.every((x) => componentMap.has(x));
-  };
-  const getComponent = (componentId) => componentMap.get(componentId) ?? null;
-  const hasService = (serviceId) => serviceMap.has(serviceId);
-  const getServiceUrl = (serviceId) => serviceMap.get(serviceId) ?? null;
-  return {
-    ...infoRest,
-    services,
-    features,
-    components,
-    hasFeature,
-    getServiceUrl,
-    hasService,
-    getComponent,
-    hasComponent
-  };
+//#endregion
+//#region src/domain/stack.ts
+const SERVICE_URL_OVERRIDES = { "kai-assistant": (url) => `${url}/api` };
+const createStack = ({ stackInfo, clientServiceUrls }) => {
+	const { services, components, features, ...infoRest } = stackInfo;
+	const serviceMap = new Map(services.map((service) => {
+		const devOverride = clientServiceUrls?.[service.id]?.(service.url);
+		const prodOverride = SERVICE_URL_OVERRIDES[service.id]?.(service.url);
+		const url = devOverride ?? prodOverride ?? service.url;
+		return [service.id, url];
+	}));
+	const componentMap = new Map(components.map((component) => [component.id, component]));
+	const featureSet = new Set(features);
+	const hasFeature = (...feature) => {
+		if (feature.length === 0) return false;
+		return feature.every((x) => featureSet.has(x));
+	};
+	const hasComponent = (...componentId) => {
+		if (componentId.length === 0) return false;
+		return componentId.every((x) => componentMap.has(x));
+	};
+	const getComponent = (componentId) => componentMap.get(componentId) ?? null;
+	const hasService = (serviceId) => serviceMap.has(serviceId);
+	const getServiceUrl = (serviceId) => serviceMap.get(serviceId) ?? null;
+	return {
+		...infoRest,
+		services,
+		features,
+		components,
+		hasFeature,
+		getServiceUrl,
+		hasService,
+		getComponent,
+		hasComponent
+	};
 };
-
-// src/sdks/variables/variablesSdk.ts
-var VARIABLES_COMPONENT_ID = "keboola.variables";
-var mergeVariableDefinitions = (target, source) => {
-  const targetNames = new Set(target.map((definition) => definition.name));
-  return [...target, ...source.filter((definition) => !targetNames.has(definition.name))];
+//#endregion
+//#region src/sdks/variables/variablesSdk.ts
+const VARIABLES_COMPONENT_ID = "keboola.variables";
+/** Union the definitions by name; on a name conflict the target's definition is kept. */
+const mergeVariableDefinitions = (target, source) => {
+	const targetNames = new Set(target.map((definition) => definition.name));
+	return [...target, ...source.filter((definition) => !targetNames.has(definition.name))];
 };
-var mergeVariableValues = (target, source) => {
-  const sourceByName = new Map(source.map((value) => [value.name, value.value]));
-  const targetNames = new Set(target.map((value) => value.name));
-  return [
-    ...target.map(
-      (value) => sourceByName.has(value.name) ? { ...value, value: sourceByName.get(value.name) } : value
-    ),
-    ...source.filter((value) => !targetNames.has(value.name))
-  ];
+/** Add values missing in the target; on a name conflict the value is updated to the source's. */
+const mergeVariableValues = (target, source) => {
+	const sourceByName = new Map(source.map((value) => [value.name, value.value]));
+	const targetNames = new Set(target.map((value) => value.name));
+	return [...target.map((value) => sourceByName.has(value.name) ? {
+		...value,
+		value: sourceByName.get(value.name)
+	} : value), ...source.filter((value) => !targetNames.has(value.name))];
 };
-var createVariablesSdk = ({ storageClient }) => {
-  const configs = storageClient.configurations;
-  const rows = storageClient.configurationRows;
-  const readVariables = async (configId, valuesRowId, branchId) => {
-    const config = await configs.getConfiguration({
-      componentId: VARIABLES_COMPONENT_ID,
-      configId,
-      branchId
-    });
-    const row = config.rows.find((candidate) => candidate.id === valuesRowId) ?? config.rows[0];
-    const rawDefinitions = config.configuration?.variables;
-    const rawValues = row?.configuration?.values;
-    return {
-      definitions: Array.isArray(rawDefinitions) ? rawDefinitions : [],
-      values: Array.isArray(rawValues) ? rawValues : []
-    };
-  };
-  const createVariables = async (definitions, values, branchId) => {
-    const config = await configs.createConfiguration({
-      branchId,
-      componentId: VARIABLES_COMPONENT_ID,
-      name: "Variables definition",
-      configuration: { variables: definitions }
-    });
-    try {
-      const row = await rows.createConfigurationRow({
-        branchId: String(branchId),
-        componentId: VARIABLES_COMPONENT_ID,
-        configurationId: config.id,
-        name: "Default values",
-        configuration: { values }
-      });
-      return { variablesId: config.id, variablesValuesId: row.id };
-    } catch (error) {
-      await configs.deleteConfiguration({
-        branchId,
-        componentId: VARIABLES_COMPONENT_ID,
-        configId: config.id
-      }).catch((cleanupError) => {
-        if (error instanceof Error && error.cause === void 0) {
-          error.cause = cleanupError;
-        }
-      });
-      throw error;
-    }
-  };
-  return {
-    /** Copy a variables config into a fresh, independent config + values row. */
-    copy: async ({
-      variablesId,
-      variablesValuesId,
-      branchId = "default"
-    }) => {
-      const { definitions, values } = await readVariables(variablesId, variablesValuesId, branchId);
-      return createVariables(definitions, values, branchId);
-    },
-    /** Merge the source's variables into the target's and create a fresh merged config + values row. */
-    merge: async ({
-      targetVariablesId,
-      targetValuesId,
-      sourceVariablesId,
-      sourceValuesId,
-      branchId = "default"
-    }) => {
-      const [target, source] = await Promise.all([
-        readVariables(targetVariablesId, targetValuesId, branchId),
-        readVariables(sourceVariablesId, sourceValuesId, branchId)
-      ]);
-      return createVariables(
-        mergeVariableDefinitions(target.definitions, source.definitions),
-        mergeVariableValues(target.values, source.values),
-        branchId
-      );
-    }
-  };
+/**
+* Orchestration for `keboola.variables` configs: copy a config, or merge two configs into a fresh
+* one (union definitions, upsert values — source wins on a name conflict). Each result is a brand
+* new config + values row, so the caller can reference it without sharing lineage with the source.
+*/
+const createVariablesSdk = ({ storageClient }) => {
+	const configs = storageClient.configurations;
+	const rows = storageClient.configurationRows;
+	const readVariables = async (configId, valuesRowId, branchId) => {
+		const config = await configs.getConfiguration({
+			componentId: VARIABLES_COMPONENT_ID,
+			configId,
+			branchId
+		});
+		const row = config.rows.find((candidate) => candidate.id === valuesRowId) ?? config.rows[0];
+		const rawDefinitions = config.configuration?.variables;
+		const rawValues = row?.configuration?.values;
+		return {
+			definitions: Array.isArray(rawDefinitions) ? rawDefinitions : [],
+			values: Array.isArray(rawValues) ? rawValues : []
+		};
+	};
+	const createVariables = async (definitions, values, branchId) => {
+		const config = await configs.createConfiguration({
+			branchId,
+			componentId: VARIABLES_COMPONENT_ID,
+			name: "Variables definition",
+			configuration: { variables: definitions }
+		});
+		try {
+			const row = await rows.createConfigurationRow({
+				branchId: String(branchId),
+				componentId: VARIABLES_COMPONENT_ID,
+				configurationId: config.id,
+				name: "Default values",
+				configuration: { values }
+			});
+			return {
+				variablesId: config.id,
+				variablesValuesId: row.id
+			};
+		} catch (error) {
+			await configs.deleteConfiguration({
+				branchId,
+				componentId: VARIABLES_COMPONENT_ID,
+				configId: config.id
+			}).catch((cleanupError) => {
+				if (error instanceof Error && error.cause === void 0) error.cause = cleanupError;
+			});
+			throw error;
+		}
+	};
+	return {
+		/** Copy a variables config into a fresh, independent config + values row. */
+		copy: async ({ variablesId, variablesValuesId, branchId = "default" }) => {
+			const { definitions, values } = await readVariables(variablesId, variablesValuesId, branchId);
+			return createVariables(definitions, values, branchId);
+		},
+		/** Merge the source's variables into the target's and create a fresh merged config + values row. */
+		merge: async ({ targetVariablesId, targetValuesId, sourceVariablesId, sourceValuesId, branchId = "default" }) => {
+			const [target, source] = await Promise.all([readVariables(targetVariablesId, targetValuesId, branchId), readVariables(sourceVariablesId, sourceValuesId, branchId)]);
+			return createVariables(mergeVariableDefinitions(target.definitions, source.definitions), mergeVariableValues(target.values, source.values), branchId);
+		}
+	};
 };
-var agentSettingsSchema = z.object({
-  projectId: z.string(),
-  customInstructions: z.string().nullable(),
-  createdAt: z.string(),
-  updatedAt: z.string()
-});
-var toolPermissionValueSchema = z.enum(["always_allow", "always_ask", "blocked"]);
-var userAgentSettingsSchema = z.object({
-  projectId: z.string(),
-  userId: z.string(),
-  customInstructions: z.string().nullable(),
-  toolPermissions: z.record(z.string(), toolPermissionValueSchema).nullable(),
-  createdAt: z.string(),
-  updatedAt: z.string()
-});
-var toolInfoSchema = z.object({
-  name: z.string(),
-  description: z.string(),
-  readOnly: z.boolean()
-});
-var toolsListResponseSchema = z.object({
-  tools: z.array(toolInfoSchema)
+//#endregion
+//#region src/clients/kaiAgent/kaiAgentClient.ts
+const agentSettingsSchema = z.object({
+	projectId: z.string(),
+	customInstructions: z.string().nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string()
 });
-var skillInfoSchema = z.object({
-  name: z.string(),
-  description: z.string().nullable(),
-  source: z.enum(["first-party", "vendored", "project"])
+const toolPermissionValueSchema = z.enum([
+	"always_allow",
+	"always_ask",
+	"blocked"
+]);
+const userAgentSettingsSchema = z.object({
+	projectId: z.string(),
+	userId: z.string(),
+	customInstructions: z.string().nullable(),
+	toolPermissions: z.record(z.string(), toolPermissionValueSchema).nullable(),
+	createdAt: z.string(),
+	updatedAt: z.string()
 });
-var builtInCommandSchema = z.object({
-  name: z.string(),
-  description: z.string()
+const toolInfoSchema = z.object({
+	name: z.string(),
+	description: z.string(),
+	readOnly: z.boolean()
 });
-var skillsListResponseSchema = z.object({
-  skills: z.array(skillInfoSchema),
-  commands: z.array(builtInCommandSchema)
+const toolsListResponseSchema = z.object({ tools: z.array(toolInfoSchema) });
+const skillInfoSchema = z.object({
+	name: z.string(),
+	description: z.string().nullable(),
+	source: z.enum([
+		"first-party",
+		"vendored",
+		"project"
+	])
 });
-var sandboxFileEntrySchema = z.object({
-  name: z.string(),
-  path: z.string(),
-  type: z.enum(["file", "dir"]),
-  size: z.number().int().nonnegative().optional()
+const builtInCommandSchema = z.object({
+	name: z.string(),
+	description: z.string()
 });
-var sandboxFileListingSchema = z.object({
-  entries: z.array(sandboxFileEntrySchema)
+const skillsListResponseSchema = z.object({
+	skills: z.array(skillInfoSchema),
+	commands: z.array(builtInCommandSchema)
 });
-var sandboxFileContentSchema = z.object({
-  content: z.string(),
-  encoding: z.enum(["utf-8", "binary"]),
-  truncated: z.boolean(),
-  size: z.number().int().nonnegative()
+const sandboxFileEntrySchema = z.object({
+	name: z.string(),
+	path: z.string(),
+	type: z.enum(["file", "dir"]),
+	size: z.number().int().nonnegative().optional()
 });
-var sandboxGitBranchSchema = z.object({
-  branch: z.string().nullable()
+const sandboxFileListingSchema = z.object({ entries: z.array(sandboxFileEntrySchema) });
+const sandboxFileContentSchema = z.object({
+	content: z.string(),
+	encoding: z.enum(["utf-8", "binary"]),
+	truncated: z.boolean(),
+	size: z.number().int().nonnegative()
 });
-var votesResponseSchema = z.array(
-  z.object({
-    chatId: z.string(),
-    messageId: z.string(),
-    isUpvoted: z.boolean()
-  })
-);
-var createKaiAgentClient = ({ baseUrl, middlewares, auth }) => {
-  const clientOptions = {
-    baseUrl,
-    middlewares,
-    headers: createAuthHeaders(auth)
-  };
-  const client = createOpenapiFetchClient(clientOptions);
-  const genericClient = createGenericFetchClient(clientOptions);
-  const getHistory = async (params) => {
-    const { data } = await client.get("/api/history", { query: params });
-    return data;
-  };
-  const getChat = async (chatId, signal) => {
-    const { data } = await client.get("/api/chat/{id}", { path: { id: chatId } }, { signal });
-    return data;
-  };
-  const deleteChat = async (chatId) => {
-    const { data } = await client.delete("/api/chat", { query: { id: chatId } });
-    return data;
-  };
-  const createChat = async (request) => {
-    const { response } = await client.post("/api/chat", { body: request });
-    return response;
-  };
-  const getVotes = async (chatId) => {
-    const { data } = await client.get("/api/vote", { query: { chatId } });
-    const result = votesResponseSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid votes response format");
-    }
-    return result.data;
-  };
-  const submitVote = async (params) => {
-    await client.patch("/api/vote", { body: params });
-  };
-  const getUsage = async (signal) => {
-    const { data } = await client.get("/api/usage", {}, { signal });
-    return data;
-  };
-  const approveToolCall = async (chatId, body) => {
-    await client.post("/api/chat/{id}/approval", { path: { id: chatId }, body });
-  };
-  const submitToolOutput = async (chatId, body) => {
-    await client.post("/api/chat/{id}/ui-tool-result", { path: { id: chatId }, body });
-  };
-  const stopChat = async (chatId) => {
-    const { data } = await client.post("/api/chat/{id}/stop", { path: { id: chatId } });
-    return data;
-  };
-  const getSuggestions = async (request, signal) => {
-    const { data } = await client.post("/api/suggestions", { body: request }, { signal });
-    return data;
-  };
-  const getAgentSettings = async (signal) => {
-    const { data } = await genericClient.get("/api/settings", {}, { signal });
-    const result = agentSettingsSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid agent settings response format");
-    }
-    return result.data;
-  };
-  const updateAgentSettings = async (request, signal) => {
-    const { data } = await genericClient.patch(
-      "/api/settings",
-      { body: request },
-      { signal }
-    );
-    const result = agentSettingsSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid agent settings response format");
-    }
-    return result.data;
-  };
-  const getUserAgentSettings = async (signal) => {
-    const { data } = await genericClient.get(
-      "/api/settings/user",
-      {},
-      { signal }
-    );
-    const result = userAgentSettingsSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid user agent settings response format");
-    }
-    return result.data;
-  };
-  const updateUserAgentSettings = async (request, signal) => {
-    const { data } = await genericClient.patch(
-      "/api/settings/user",
-      { body: request },
-      { signal }
-    );
-    const result = userAgentSettingsSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid user agent settings response format");
-    }
-    return result.data;
-  };
-  const getToolsList = async (signal) => {
-    const { data } = await genericClient.get(
-      "/api/settings/tools",
-      {},
-      { signal }
-    );
-    const result = toolsListResponseSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid tools list response format");
-    }
-    return result.data;
-  };
-  const getSkillsList = async (signal) => {
-    const { data } = await genericClient.get("/api/skills", {}, { signal });
-    const result = skillsListResponseSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid skills list response format");
-    }
-    return result.data;
-  };
-  const listSandboxFiles = async (chatId, path, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/files`,
-      { query: path ? { path } : void 0 },
-      { signal }
-    );
-    const result = sandboxFileListingSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox files response format");
-    }
-    return result.data;
-  };
-  const readSandboxFile = async (chatId, path, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/file`,
-      { query: { path } },
-      { signal }
-    );
-    const result = sandboxFileContentSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox file response format");
-    }
-    return result.data;
-  };
-  const getSandboxGitBranch = async (chatId, signal) => {
-    const { data } = await genericClient.get(
-      `/api/chat/${encodeURIComponent(chatId)}/sandbox/git-branch`,
-      {},
-      { signal }
-    );
-    const result = sandboxGitBranchSchema.safeParse(data);
-    if (!result.success) {
-      throw new Error("Invalid sandbox git-branch response format");
-    }
-    return result.data;
-  };
-  const chatStreamUrl = clientOptions.baseUrl + "/api/chat";
-  const healthCheck = async (signal) => {
-    const { data } = await genericClient.get("/health", {}, { signal });
-    return data;
-  };
-  return {
-    healthCheck,
-    getHistory,
-    getChat,
-    deleteChat,
-    createChat,
-    getVotes,
-    submitVote,
-    getUsage,
-    approveToolCall,
-    submitToolOutput,
-    stopChat,
-    getSuggestions,
-    getAgentSettings,
-    updateAgentSettings,
-    getUserAgentSettings,
-    updateUserAgentSettings,
-    getToolsList,
-    getSkillsList,
-    listSandboxFiles,
-    readSandboxFile,
-    getSandboxGitBranch,
-    chatStreamUrl
-  };
+const sandboxGitBranchSchema = z.object({ branch: z.string().nullable() });
+const votesResponseSchema = z.array(z.object({
+	chatId: z.string(),
+	messageId: z.string(),
+	isUpvoted: z.boolean()
+}));
+const createKaiAgentClient = ({ baseUrl, middlewares, auth }) => {
+	const clientOptions = {
+		baseUrl,
+		middlewares,
+		headers: createAuthHeaders(auth)
+	};
+	const client = createOpenapiFetchClient(clientOptions);
+	const genericClient = createGenericFetchClient(clientOptions);
+	const getHistory = async (params) => {
+		const { data } = await client.get("/api/history", { query: params });
+		return data;
+	};
+	const getChat = async (chatId, signal) => {
+		const { data } = await client.get("/api/chat/{id}", { path: { id: chatId } }, { signal });
+		return data;
+	};
+	const deleteChat = async (chatId) => {
+		const { data } = await client.delete("/api/chat", { query: { id: chatId } });
+		return data;
+	};
+	const createChat = async (request) => {
+		const { response } = await client.post("/api/chat", { body: request });
+		return response;
+	};
+	const getVotes = async (chatId) => {
+		const { data } = await client.get("/api/vote", { query: { chatId } });
+		const result = votesResponseSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid votes response format");
+		return result.data;
+	};
+	const submitVote = async (params) => {
+		await client.patch("/api/vote", { body: params });
+	};
+	const getUsage = async (signal) => {
+		const { data } = await client.get("/api/usage", {}, { signal });
+		return data;
+	};
+	const approveToolCall = async (chatId, body) => {
+		await client.post("/api/chat/{id}/approval", {
+			path: { id: chatId },
+			body
+		});
+	};
+	const submitToolOutput = async (chatId, body) => {
+		await client.post("/api/chat/{id}/ui-tool-result", {
+			path: { id: chatId },
+			body
+		});
+	};
+	const stopChat = async (chatId) => {
+		const { data } = await client.post("/api/chat/{id}/stop", { path: { id: chatId } });
+		return data;
+	};
+	const getSuggestions = async (request, signal) => {
+		const { data } = await client.post("/api/suggestions", { body: request }, { signal });
+		return data;
+	};
+	const getAgentSettings = async (signal) => {
+		const { data } = await genericClient.get("/api/settings", {}, { signal });
+		const result = agentSettingsSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid agent settings response format");
+		return result.data;
+	};
+	const updateAgentSettings = async (request, signal) => {
+		const { data } = await genericClient.patch("/api/settings", { body: request }, { signal });
+		const result = agentSettingsSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid agent settings response format");
+		return result.data;
+	};
+	const getUserAgentSettings = async (signal) => {
+		const { data } = await genericClient.get("/api/settings/user", {}, { signal });
+		const result = userAgentSettingsSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid user agent settings response format");
+		return result.data;
+	};
+	const updateUserAgentSettings = async (request, signal) => {
+		const { data } = await genericClient.patch("/api/settings/user", { body: request }, { signal });
+		const result = userAgentSettingsSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid user agent settings response format");
+		return result.data;
+	};
+	const getToolsList = async (signal) => {
+		const { data } = await genericClient.get("/api/settings/tools", {}, { signal });
+		const result = toolsListResponseSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid tools list response format");
+		return result.data;
+	};
+	const getSkillsList = async (signal) => {
+		const { data } = await genericClient.get("/api/skills", {}, { signal });
+		const result = skillsListResponseSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid skills list response format");
+		return result.data;
+	};
+	const listSandboxFiles = async (chatId, path, signal) => {
+		const { data } = await genericClient.get(`/api/chat/${encodeURIComponent(chatId)}/sandbox/files`, { query: path ? { path } : void 0 }, { signal });
+		const result = sandboxFileListingSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid sandbox files response format");
+		return result.data;
+	};
+	const readSandboxFile = async (chatId, path, signal) => {
+		const { data } = await genericClient.get(`/api/chat/${encodeURIComponent(chatId)}/sandbox/file`, { query: { path } }, { signal });
+		const result = sandboxFileContentSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid sandbox file response format");
+		return result.data;
+	};
+	const downloadSandboxFile = async (chatId, path, signal) => {
+		const { data } = await genericClient.get(`/api/chat/${encodeURIComponent(chatId)}/sandbox/file/download`, { query: { path } }, { signal });
+		if (!(data instanceof Blob)) throw new Error("Invalid sandbox file download response format");
+		return data;
+	};
+	const getSandboxGitBranch = async (chatId, signal) => {
+		const { data } = await genericClient.get(`/api/chat/${encodeURIComponent(chatId)}/sandbox/git-branch`, {}, { signal });
+		const result = sandboxGitBranchSchema.safeParse(data);
+		if (!result.success) throw new Error("Invalid sandbox git-branch response format");
+		return result.data;
+	};
+	const chatStreamUrl = clientOptions.baseUrl + "/api/chat";
+	const healthCheck = async (signal) => {
+		const { data } = await genericClient.get("/health", {}, { signal });
+		return data;
+	};
+	return {
+		healthCheck,
+		getHistory,
+		getChat,
+		deleteChat,
+		createChat,
+		getVotes,
+		submitVote,
+		getUsage,
+		approveToolCall,
+		submitToolOutput,
+		stopChat,
+		getSuggestions,
+		getAgentSettings,
+		updateAgentSettings,
+		getUserAgentSettings,
+		updateUserAgentSettings,
+		getToolsList,
+		getSkillsList,
+		listSandboxFiles,
+		readSandboxFile,
+		downloadSandboxFile,
+		getSandboxGitBranch,
+		chatStreamUrl
+	};
 };
-
-// src/keboola/createServiceClients.ts
-var createServiceClients = ({
-  baseUrl,
-  auth,
-  getServiceBaseUrl,
-  middlewareFor,
-  attachTokenMiddleware
-}) => createServiceClientRegistry()({
-  getServiceBaseUrl,
-  onUnavailable: ({ serviceId, path, clientName }) => {
-    throw new ServiceUnavailableError(serviceId, path, clientName);
-  }
+//#endregion
+//#region src/keboola/createServiceClients.ts
+const createServiceClients = ({ baseUrl, auth, getServiceBaseUrl, middlewareFor, attachTokenMiddleware }) => createServiceClientRegistry()({
+	getServiceBaseUrl,
+	onUnavailable: ({ serviceId, path, clientName }) => {
+		throw new ServiceUnavailableError(serviceId, path, clientName);
+	}
 }).add({
-  serviceId: "vault",
-  clientName: "vault",
-  clientFn: (serviceBaseUrl) => createVaultClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("vault", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "vault",
+	clientName: "vault",
+	clientFn: (serviceBaseUrl) => createVaultClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("vault", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "data-science",
-  clientName: "dataScience",
-  clientFn: (serviceBaseUrl) => createDataScienceClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("dataScience", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "data-science",
+	clientName: "dataScience",
+	clientFn: (serviceBaseUrl) => createDataScienceClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("dataScience", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  // Deliberately the `data-science` service: the `/v2` App Deployments surface is the same
-  // sandboxes-service deployment one path prefix over, so it resolves off that URL with `/v2`
-  // appended. The `apps.<stack>` vanity host serves the same routes at its root but is absent
-  // from the stack's service index, so it cannot be resolved.
-  // Second client composing a prefix onto a service URL after `omnisearch` below; at a third,
-  // give `.add()` a `pathPrefix` the registry joins so the join can't be got wrong per call site.
-  serviceId: "data-science",
-  clientName: "apps",
-  clientFn: (serviceBaseUrl) => createAppsClient({
-    baseUrl: `${serviceBaseUrl}/v2`,
-    middlewares: middlewareFor("apps", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "data-science",
+	clientName: "apps",
+	clientFn: (serviceBaseUrl) => createAppsClient({
+		baseUrl: `${serviceBaseUrl}/v2`,
+		middlewares: middlewareFor("apps", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "encryption",
-  clientName: "encryption",
-  clientFn: (serviceBaseUrl) => createEncryptionClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("encryption")
-  })
+	serviceId: "encryption",
+	clientName: "encryption",
+	clientFn: (serviceBaseUrl) => createEncryptionClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("encryption")
+	})
 }).add({
-  serviceId: "editor",
-  clientName: "editor",
-  clientFn: (serviceBaseUrl) => createEditorClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("editor", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "editor",
+	clientName: "editor",
+	clientFn: (serviceBaseUrl) => createEditorClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("editor", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "sync-actions",
-  clientName: "syncActions",
-  clientFn: (serviceBaseUrl) => createSyncActionsClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("syncActions", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "sync-actions",
+	clientName: "syncActions",
+	clientFn: (serviceBaseUrl) => createSyncActionsClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("syncActions", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "telemetry",
-  clientName: "telemetry",
-  clientFn: (serviceBaseUrl) => createTelemetryClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("telemetry", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "telemetry",
+	clientName: "telemetry",
+	clientFn: (serviceBaseUrl) => createTelemetryClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("telemetry", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "query",
-  clientName: "queryService",
-  clientFn: (serviceBaseUrl) => createQueryServiceClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("queryService", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "query",
+	clientName: "queryService",
+	clientFn: (serviceBaseUrl) => createQueryServiceClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("queryService", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "queue",
-  clientName: "queue",
-  clientFn: (serviceBaseUrl) => createQueueClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("queue", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "queue",
+	clientName: "queue",
+	clientFn: (serviceBaseUrl) => createQueueClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("queue", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "kai-assistant",
-  clientName: "chat",
-  clientFn: (serviceBaseUrl) => createChatClient({
-    storageApiUrl: baseUrl,
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("chat", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "kai-assistant",
+	clientName: "chat",
+	clientFn: (serviceBaseUrl) => createChatClient({
+		storageApiUrl: baseUrl,
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("chat", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "ai",
-  clientName: "ai",
-  clientFn: (serviceBaseUrl) => createAiClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("ai", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "ai",
+	clientName: "ai",
+	clientFn: (serviceBaseUrl) => createAiClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("ai", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  // Deliberately the `ai` service: omnisearch is a separate deployment that the ai-service
-  // ingress exposes under `/omnisearch`, so it resolves off that URL with the prefix appended —
-  // the same shape as the `kai-assistant` `/api` override in `domain/stack.ts`.
-  serviceId: "ai",
-  clientName: "omnisearch",
-  clientFn: (serviceBaseUrl) => createOmnisearchClient({
-    baseUrl: `${serviceBaseUrl}/omnisearch`,
-    middlewares: middlewareFor("omnisearch", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "ai",
+	clientName: "omnisearch",
+	clientFn: (serviceBaseUrl) => createOmnisearchClient({
+		baseUrl: `${serviceBaseUrl}/omnisearch`,
+		middlewares: middlewareFor("omnisearch", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "import",
-  clientName: "import",
-  clientFn: (serviceBaseUrl) => createImportClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("import", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "import",
+	clientName: "import",
+	clientFn: (serviceBaseUrl) => createImportClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("import", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "kai-agent",
-  clientName: "kaiAgent",
-  clientFn: (serviceBaseUrl) => createKaiAgentClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("kaiAgent", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "kai-agent",
+	clientName: "kaiAgent",
+	clientFn: (serviceBaseUrl) => createKaiAgentClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("kaiAgent", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "oauth",
-  clientName: "oauth",
-  clientFn: (serviceBaseUrl) => createOauthClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("oauth", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "oauth",
+	clientName: "oauth",
+	clientFn: (serviceBaseUrl) => createOauthClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("oauth", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "scheduler",
-  clientName: "scheduler",
-  clientFn: (serviceBaseUrl) => createSchedulerClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("scheduler", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "scheduler",
+	clientName: "scheduler",
+	clientFn: (serviceBaseUrl) => createSchedulerClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("scheduler", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "stream",
-  clientName: "stream",
-  clientFn: (serviceBaseUrl) => createStreamClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("stream", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "stream",
+	clientName: "stream",
+	clientFn: (serviceBaseUrl) => createStreamClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("stream", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "notification",
-  clientName: "notifications",
-  clientFn: (serviceBaseUrl) => createNotificationsClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("notifications", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "notification",
+	clientName: "notifications",
+	clientFn: (serviceBaseUrl) => createNotificationsClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("notifications", [attachTokenMiddleware]),
+		auth
+	})
 }).add({
-  serviceId: "metastore",
-  clientName: "metastore",
-  clientFn: (serviceBaseUrl) => createMetastoreClient({
-    baseUrl: serviceBaseUrl,
-    middlewares: middlewareFor("metastore", [attachTokenMiddleware]),
-    auth
-  })
+	serviceId: "metastore",
+	clientName: "metastore",
+	clientFn: (serviceBaseUrl) => createMetastoreClient({
+		baseUrl: serviceBaseUrl,
+		middlewares: middlewareFor("metastore", [attachTokenMiddleware]),
+		auth
+	})
 }).build();
-
-// src/keboola/bearer/createProjectClients.ts
-var createProjectClients = async ({
-  baseUrl,
-  projectId,
-  authMiddleware,
-  middlewareFor,
-  clientServiceUrls
-}) => {
-  const auth = { type: "bearer", token: "", projectId };
-  const projectIdMiddleware = (next) => (request) => {
-    request.request.headers.set(KeboolaHttpHeader.PROJECT_ID, String(projectId));
-    return next(request);
-  };
-  const attach = (next) => projectIdMiddleware(authMiddleware(next));
-  const reader = createStorageClient({ baseUrl, auth, middlewares: [attach] });
-  const [stackInfo, sapiToken, devBranches] = await Promise.all([
-    reader.getStackInfo({ exclude: "componentDetails" }),
-    reader.tokens.verify(),
-    reader.branches.getDevBranches()
-  ]);
-  const stack = createStack({ stackInfo, clientServiceUrls });
-  const defaultBranch = createDefaultBranch({ devBranches });
-  const liveProject = createLiveProject({
-    initialToken: sapiToken,
-    verify: () => reader.tokens.verify()
-  });
-  const storageTableStore = createDerivedStore({
-    source: liveProject.store,
-    build: createStorageTable,
-    dependsOn: (project) => ({
-      useLegacyBucketPrefix: !project.hasFeature(ProjectFeature.DisableLegacyBucketPrefix),
-      hasProtectedDefaultBranch: project.hasFeature(ProjectFeature.SoxProtectedDefaultBranch),
-      hasStorageBranches: project.hasFeature(ProjectFeature.StorageBranches)
-    })
-  });
-  const context = {
-    baseUrl: normalizeBaseUrl(baseUrl),
-    stack,
-    defaultBranch,
-    get project() {
-      return liveProject.getProject();
-    },
-    get st() {
-      return storageTableStore.get();
-    }
-  };
-  const storage = createStorageClient({
-    baseUrl,
-    auth,
-    middlewares: middlewareFor("storage", [attach, liveProject.middleware])
-  });
-  const { client: services, meta: serviceMeta } = createServiceClients({
-    baseUrl,
-    auth,
-    getServiceBaseUrl: context.stack.getServiceUrl,
-    middlewareFor,
-    attachTokenMiddleware: attach
-  });
-  const sdk = {
-    configuration: createConfigurationSdk({
-      storageClient: storage,
-      encryptionClient: services.encryption,
-      context
-    }),
-    tag: createTagSdk({ metastoreClient: services.metastore }),
-    semanticLayer: createSemanticLayerSdk({ metastoreClient: services.metastore }),
-    storage: createStorageSdk({ storageClient: storage }),
-    vault: createVaultSdk({ vaultClient: services.vault, encryptionClient: services.encryption }),
-    variables: createVariablesSdk({ storageClient: storage })
-  };
-  return { context, serviceMeta, storage, ...services, sdk };
-};
-
-// src/keboola/bearer/credential.ts
-var DEFAULT_REFRESH_THRESHOLD = 0.9;
-var isUnauthorized = (error) => error instanceof ApiError && error.response.status === HttpStatus.UNAUTHORIZED;
-var createBearerCredential = ({
-  refresh,
-  getToken,
-  onSessionExpired,
-  refreshThreshold = DEFAULT_REFRESH_THRESHOLD
-}) => {
-  const doRefresh = async () => {
-    try {
-      return await refresh();
-    } catch (error) {
-      if (isUnauthorized(error)) onSessionExpired?.();
-      throw error;
-    }
-  };
-  const refreshShared = dedupe(doRefresh);
-  const refreshAt = (timing) => timing.issuedAt + timing.expiresIn * 1e3 * refreshThreshold;
-  const getAccessToken = async ({ forceRefresh = false } = {}) => {
-    const snapshot = getToken();
-    if (snapshot === null) return null;
-    const { accessToken, timing } = snapshot;
-    if (forceRefresh) return refreshShared();
-    if (Date.now() < refreshAt(timing)) return accessToken;
-    return refreshShared().catch(() => accessToken);
-  };
-  return { getAccessToken, notifyExpired: () => onSessionExpired?.() };
+//#endregion
+//#region src/keboola/bearer/createProjectClients.ts
+/**
+* Bearer (OAuth) project surface. Same handshake + assembly as the legacy build. The
+* `Authorization: Bearer` header + transparent refresh come from the engine-shared `authMiddleware`
+* (one instance for management + every project client). This build only adds the project-scoped
+* `X-KBC-ProjectId` header, composed *outside* the auth middleware so the header is present
+* before it clones the request for the 401 replay. Bearer has no static token header, so this
+* combined `attach` rides on every client — including the operational storage and the bootstrap reader.
+*/
+const createProjectClients$1 = async ({ baseUrl, projectId, authMiddleware, middlewareFor, clientServiceUrls }) => {
+	const auth = {
+		type: "bearer",
+		token: "",
+		projectId
+	};
+	const projectIdMiddleware = (next) => (request) => {
+		request.request.headers.set(KeboolaHttpHeader.PROJECT_ID, String(projectId));
+		return next(request);
+	};
+	const attach = (next) => projectIdMiddleware(authMiddleware(next));
+	const reader = createStorageClient({
+		baseUrl,
+		auth,
+		middlewares: [attach]
+	});
+	const [stackInfo, sapiToken, devBranches] = await Promise.all([
+		reader.getStackInfo({ exclude: "componentDetails" }),
+		reader.tokens.verify(),
+		reader.branches.getDevBranches()
+	]);
+	const stack = createStack({
+		stackInfo,
+		clientServiceUrls
+	});
+	const defaultBranch = createDefaultBranch({ devBranches });
+	const liveProject = createLiveProject({
+		initialToken: sapiToken,
+		verify: () => reader.tokens.verify()
+	});
+	const storageTableStore = createDerivedStore({
+		source: liveProject.store,
+		build: createStorageTable,
+		dependsOn: (project) => ({
+			useLegacyBucketPrefix: !project.hasFeature(ProjectFeature.DisableLegacyBucketPrefix),
+			hasProtectedDefaultBranch: project.hasFeature(ProjectFeature.SoxProtectedDefaultBranch),
+			hasStorageBranches: project.hasFeature(ProjectFeature.StorageBranches)
+		})
+	});
+	const context = {
+		baseUrl: normalizeBaseUrl(baseUrl),
+		stack,
+		defaultBranch,
+		get project() {
+			return liveProject.getProject();
+		},
+		get st() {
+			return storageTableStore.get();
+		}
+	};
+	const storage = createStorageClient({
+		baseUrl,
+		auth,
+		middlewares: middlewareFor("storage", [attach, liveProject.middleware])
+	});
+	const { client: services, meta: serviceMeta } = createServiceClients({
+		baseUrl,
+		auth,
+		getServiceBaseUrl: context.stack.getServiceUrl,
+		middlewareFor,
+		attachTokenMiddleware: attach
+	});
+	const sdk = {
+		configuration: createConfigurationSdk({
+			storageClient: storage,
+			encryptionClient: services.encryption,
+			context
+		}),
+		tag: createTagSdk({ metastoreClient: services.metastore }),
+		semanticLayer: createSemanticLayerSdk({ metastoreClient: services.metastore }),
+		storage: createStorageSdk({ storageClient: storage }),
+		vault: createVaultSdk({
+			vaultClient: services.vault,
+			encryptionClient: services.encryption
+		}),
+		variables: createVariablesSdk({ storageClient: storage })
+	};
+	return {
+		context,
+		serviceMeta,
+		storage,
+		...services,
+		sdk
+	};
 };
-
-// src/keboola/bearer/middleware.ts
-var createBearerAuthMiddleware = (credential) => {
-  return (next) => async (request) => {
-    const token = await credential.getAccessToken({ forceRefresh: false });
-    if (token === null) return next(request);
-    const retryRequest = request.request.clone();
-    request.request.headers.set(HttpHeader.AUTHORIZATION, `Bearer ${token}`);
-    try {
-      return await next(request);
-    } catch (error) {
-      if (!isUnauthorized(error)) throw error;
-      const refreshed = await credential.getAccessToken({ forceRefresh: true });
-      if (refreshed === null) throw error;
-      retryRequest.headers.set(HttpHeader.AUTHORIZATION, `Bearer ${refreshed}`);
-      try {
-        return await next({ ...request, request: retryRequest });
-      } catch (retryError) {
-        if (isUnauthorized(retryError)) credential.notifyExpired();
-        throw retryError;
-      }
-    }
-  };
+//#endregion
+//#region src/keboola/bearer/middleware.ts
+/**
+* Bearer auth for every outgoing request:
+* - Stamps the current access token (from the credential) as the `Authorization` header.
+* - On a 401, force-refreshes the token and replays the request once.
+* - If the replay still 401s, the fresh token is rejected → marks the session expired.
+*
+* When the session is anonymous (`getAccessToken` → `null`) the request is passed through untouched
+* with no 401 dance — so pre-auth calls on the auth client (`login`, `refresh`) work and a failed
+* login is never mistaken for session expiry.
+*
+* Holds no token and never touches config — all token and refresh state lives in the credential.
+*/
+const createBearerAuthMiddleware = (credential) => {
+	return (next) => async (request) => {
+		const token = await credential.getAccessToken({ forceRefresh: false });
+		if (token === null) return next(request);
+		const retryRequest = request.request.clone();
+		request.request.headers.set(HttpHeader.AUTHORIZATION, `Bearer ${token}`);
+		try {
+			return await next(request);
+		} catch (error) {
+			if (!isUnauthorized(error)) throw error;
+			const refreshed = await credential.getAccessToken({ forceRefresh: true });
+			if (refreshed === null) throw error;
+			retryRequest.headers.set(HttpHeader.AUTHORIZATION, `Bearer ${refreshed}`);
+			try {
+				return await next({
+					...request,
+					request: retryRequest
+				});
+			} catch (retryError) {
+				if (isUnauthorized(retryError)) credential.notifyExpired();
+				throw retryError;
+			}
+		}
+	};
 };
-var SESSION_KEY = "keboola:bearer-session";
-var persistedSessionSchema = z2.object({
-  baseUrl: z2.string().nullable(),
-  projectId: z2.number().nullable(),
-  refreshToken: z2.string().nullable()
+//#endregion
+//#region src/keboola/bearer/persistor.ts
+const SESSION_KEY = "keboola:bearer-session";
+const persistedSessionSchema = z$1.object({
+	baseUrl: z$1.string().nullable(),
+	projectId: z$1.number().nullable(),
+	refreshToken: z$1.string().nullable()
 });
-var EMPTY_PERSISTED_SESSION = {
-  baseUrl: null,
-  projectId: null,
-  refreshToken: null
+const EMPTY_PERSISTED_SESSION = {
+	baseUrl: null,
+	projectId: null,
+	refreshToken: null
 };
-var createSessionPersistor = (storage) => createPersistor({
-  storage,
-  key: SESSION_KEY,
-  schema: persistedSessionSchema,
-  defaultValue: EMPTY_PERSISTED_SESSION
+const createSessionPersistor = (storage) => createPersistor({
+	storage,
+	key: SESSION_KEY,
+	schema: persistedSessionSchema,
+	defaultValue: EMPTY_PERSISTED_SESSION
 });
-
-// src/keboola/bearer/keboola.ts
-var createKeboola = (options = {}) => {
-  const persistor = createSessionPersistor(options.storage);
-  const config = createConfig();
-  const middlewareFor = createMiddlewareFor(options.middlewares);
-  const retryContention = createRetryMiddleware({
-    shouldRetry: (error) => error instanceof ApiError && error.response.status === HttpStatus.SERVICE_UNAVAILABLE
-  });
-  const authClientBare = createDerivedStore({
-    source: config.store,
-    dependsOn: (state) => state.baseUrl,
-    build: (baseUrl) => baseUrl ? createAuthClient({ baseUrl, middlewares: middlewareFor("auth", [retryContention]) }) : null
-  });
-  const refresh = async () => {
-    const client = authClientBare.get();
-    assert2(client, KeboolaErrorType.NotReady);
-    const refreshed = await client.token.refresh(config.requireCredential().refreshToken);
-    config.applyRefresh(refreshed);
-    return refreshed.accessToken;
-  };
-  const getToken = () => {
-    const state = config.store.get();
-    if (state.status === "anonymous") return null;
-    const { accessToken, issuedAt, expiresIn } = state.credential;
-    return { accessToken, timing: { issuedAt, expiresIn } };
-  };
-  const signOut = () => {
-    config.reset();
-    persistor.clear();
-  };
-  const onSessionExpired = () => {
-    if (config.notifyExpired()) signOut();
-  };
-  const credential = createBearerCredential({ refresh, getToken, onSessionExpired });
-  const authMiddleware = createBearerAuthMiddleware(credential);
-  const authClient = createDerivedStore({
-    source: config.store,
-    dependsOn: (state) => state.baseUrl,
-    build: (baseUrl) => baseUrl ? createAuthClient({
-      baseUrl,
-      middlewares: middlewareFor("auth", [retryContention, authMiddleware])
-    }) : null
-  });
-  const management = createDerivedStore({
-    source: config.store,
-    dependsOn: (state) => state.status === "anonymous" ? null : state.baseUrl,
-    build: (baseUrl) => baseUrl ? createManagementClient({
-      baseUrl,
-      auth: { type: "bearer", token: "" },
-      middlewares: middlewareFor("management", [authMiddleware])
-    }) : null
-  });
-  const projectClientsAsync = createDerivedAsyncStore({
-    source: config.store,
-    // Keyed on baseUrl + projectId only — a rotation (new credential, same project) must not rebuild.
-    dependsOn: (state) => state.status === "scoped" ? { baseUrl: state.baseUrl, projectId: state.projectId } : null,
-    build: ({ baseUrl, projectId }) => {
-      return createProjectClients({
-        baseUrl,
-        authMiddleware,
-        projectId,
-        middlewareFor,
-        clientServiceUrls: options.clientServiceUrls
-      });
-    }
-  });
-  if (options.baseUrl) config.setBaseUrl(options.baseUrl);
-  config.store.subscribe((state) => {
-    if (state.status === "anonymous") return;
-    persistor.persist({
-      baseUrl: state.baseUrl,
-      projectId: state.status === "scoped" ? state.projectId : null,
-      refreshToken: state.credential.refreshToken
-    });
-  });
-  const debug = () => ({
-    type: "Bearer",
-    config: config.debug(),
-    authReady: authClient.get() !== null,
-    managementReady: management.get() !== null,
-    storage: projectClientsAsync.store.get().state
-  });
-  const session = {
-    hasPersistedValue: persistor.hasPersistedValue,
-    setBaseUrl: config.setBaseUrl,
-    isStorageReady: () => projectClientsAsync.store.get().state === "ready",
-    authenticate: (tokens) => config.authenticate(tokens),
-    setProject: config.setProjectId,
-    setProjectAsync: async (projectId) => {
-      config.setProjectId(projectId);
-      await projectClientsAsync.settled();
-    },
-    /**
-     * Leave the current project but stay signed in — the storage build returns to `idle`, so a
-     * consumer gating on it falls back to its project picker. The persisted session is rewritten with
-     * `projectId: null` by the subscription above, so a reload lands on the picker rather than
-     * re-entering the project. Use `reset` to sign out instead.
-     */
-    clearProject: config.clearProjectId,
-    reset: signOut,
-    /**
-     * Dev/test only: mark the current access token as expired so the bearer credential rotates it on
-     * the next request. Pair with any authenticated call (e.g. `api.storage.tokens.verify()`) to force
-     * the rotation immediately and observe the new credential.
-     */
-    debugForceRefresh: config.forceExpire,
-    restore: async () => {
-      const persisted = persistor.hydrate();
-      if (!persisted.refreshToken || !persisted.baseUrl) return { status: "empty" };
-      const configured = config.getBaseUrl();
-      if (configured && configured !== persisted.baseUrl) {
-        persistor.clear();
-        return { status: "empty" };
-      }
-      if (!configured) config.setBaseUrl(persisted.baseUrl);
-      const client = authClientBare.get();
-      assert2(client, KeboolaErrorType.NotReady);
-      try {
-        const refreshed = await client.token.refresh(persisted.refreshToken);
-        config.authenticate(refreshed);
-        if (persisted.projectId !== null) {
-          config.setProjectId(persisted.projectId);
-          await projectClientsAsync.settled();
-        }
-        return { status: "restored" };
-      } catch (err) {
-        if (isUnauthorized(err)) {
-          persistor.clear();
-          return { status: "expired" };
-        }
-        throw err;
-      }
-    },
-    subscribe: (listener) => {
-      const unsubscribeConfig = config.store.subscribe(() => listener(debug()));
-      const unsubscribeBuild = projectClientsAsync.store.subscribe(() => listener(debug()));
-      return () => {
-        unsubscribeConfig();
-        unsubscribeBuild();
-      };
-    },
-    debug
-  };
-  const api = createApi({
-    getAuthClient: () => authClient.get(),
-    getManagementClient: () => management.get(),
-    getProjectClients: () => {
-      const state = projectClientsAsync.store.get();
-      return state.state === "ready" ? state.value : null;
-    }
-  });
-  return { api, session };
+//#endregion
+//#region src/keboola/bearer/keboola.ts
+const createKeboola = (options = {}) => {
+	const persistor = createSessionPersistor(options.storage);
+	const config = createConfig$1();
+	const middlewareFor = createMiddlewareFor(options.middlewares);
+	const retryContention = createRetryMiddleware({ shouldRetry: (error) => error instanceof ApiError && error.response.status === HttpStatus.SERVICE_UNAVAILABLE });
+	const authClientBare = createDerivedStore({
+		source: config.store,
+		dependsOn: (state) => state.baseUrl,
+		build: (baseUrl) => baseUrl ? createAuthClient({
+			baseUrl,
+			middlewares: middlewareFor("auth", [retryContention])
+		}) : null
+	});
+	const refresh = async () => {
+		const client = authClientBare.get();
+		assert$1(client, KeboolaErrorType.NotReady);
+		const refreshed = await client.token.refresh(config.requireCredential().refreshToken);
+		config.applyRefresh(refreshed);
+		return refreshed.accessToken;
+	};
+	const getToken = () => {
+		const state = config.store.get();
+		if (state.status === "anonymous") return null;
+		const { accessToken, issuedAt, expiresIn } = state.credential;
+		return {
+			accessToken,
+			timing: {
+				issuedAt,
+				expiresIn
+			}
+		};
+	};
+	const signOut = () => {
+		config.reset();
+		persistor.clear();
+	};
+	const onSessionExpired = () => {
+		if (config.notifyExpired()) signOut();
+	};
+	const credential = createBearerCredential({
+		refresh,
+		getToken,
+		onSessionExpired
+	});
+	const authMiddleware = createBearerAuthMiddleware(credential);
+	const authClient = createDerivedStore({
+		source: config.store,
+		dependsOn: (state) => state.baseUrl,
+		build: (baseUrl) => baseUrl ? createAuthClient({
+			baseUrl,
+			middlewares: middlewareFor("auth", [retryContention, authMiddleware])
+		}) : null
+	});
+	const management = createDerivedStore({
+		source: config.store,
+		dependsOn: (state) => state.status === "anonymous" ? null : state.baseUrl,
+		build: (baseUrl) => baseUrl ? createManagementClient({
+			baseUrl,
+			auth: {
+				type: "bearer",
+				token: ""
+			},
+			middlewares: middlewareFor("management", [authMiddleware])
+		}) : null
+	});
+	const projectClientsAsync = createDerivedAsyncStore({
+		source: config.store,
+		dependsOn: (state) => state.status === "scoped" ? {
+			baseUrl: state.baseUrl,
+			projectId: state.projectId
+		} : null,
+		build: ({ baseUrl, projectId }) => {
+			return createProjectClients$1({
+				baseUrl,
+				authMiddleware,
+				projectId,
+				middlewareFor,
+				clientServiceUrls: options.clientServiceUrls
+			});
+		}
+	});
+	if (options.baseUrl) config.setBaseUrl(options.baseUrl);
+	config.store.subscribe((state) => {
+		if (state.status === "anonymous") return;
+		persistor.persist({
+			baseUrl: state.baseUrl,
+			projectId: state.status === "scoped" ? state.projectId : null,
+			refreshToken: state.credential.refreshToken
+		});
+	});
+	const debug = () => ({
+		type: "Bearer",
+		config: config.debug(),
+		authReady: authClient.get() !== null,
+		managementReady: management.get() !== null,
+		storage: projectClientsAsync.store.get().state
+	});
+	const session = {
+		hasPersistedValue: persistor.hasPersistedValue,
+		setBaseUrl: config.setBaseUrl,
+		isStorageReady: () => projectClientsAsync.store.get().state === "ready",
+		authenticate: (tokens) => config.authenticate(tokens),
+		setProject: config.setProjectId,
+		setProjectAsync: async (projectId) => {
+			config.setProjectId(projectId);
+			await projectClientsAsync.settled();
+		},
+		/**
+		* Leave the current project but stay signed in — the storage build returns to `idle`, so a
+		* consumer gating on it falls back to its project picker. The persisted session is rewritten with
+		* `projectId: null` by the subscription above, so a reload lands on the picker rather than
+		* re-entering the project. Use `reset` to sign out instead.
+		*/
+		clearProject: config.clearProjectId,
+		reset: signOut,
+		/**
+		* Dev/test only: mark the current access token as expired so the bearer credential rotates it on
+		* the next request. Pair with any authenticated call (e.g. `api.storage.tokens.verify()`) to force
+		* the rotation immediately and observe the new credential.
+		*/
+		debugForceRefresh: config.forceExpire,
+		restore: async () => {
+			const persisted = persistor.hydrate();
+			if (!persisted.refreshToken || !persisted.baseUrl) return { status: "empty" };
+			const configured = config.getBaseUrl();
+			if (configured && configured !== persisted.baseUrl) {
+				persistor.clear();
+				return { status: "empty" };
+			}
+			if (!configured) config.setBaseUrl(persisted.baseUrl);
+			const client = authClientBare.get();
+			assert$1(client, KeboolaErrorType.NotReady);
+			try {
+				const refreshed = await client.token.refresh(persisted.refreshToken);
+				config.authenticate(refreshed);
+				if (persisted.projectId !== null) {
+					config.setProjectId(persisted.projectId);
+					await projectClientsAsync.settled();
+				}
+				return { status: "restored" };
+			} catch (err) {
+				if (isUnauthorized(err)) {
+					persistor.clear();
+					return { status: "expired" };
+				}
+				throw err;
+			}
+		},
+		subscribe: (listener) => {
+			const unsubscribeConfig = config.store.subscribe(() => listener(debug()));
+			const unsubscribeBuild = projectClientsAsync.store.subscribe(() => listener(debug()));
+			return () => {
+				unsubscribeConfig();
+				unsubscribeBuild();
+			};
+		},
+		debug
+	};
+	return {
+		api: createApi({
+			getAuthClient: () => authClient.get(),
+			getManagementClient: () => management.get(),
+			getProjectClients: () => {
+				const state = projectClientsAsync.store.get();
+				return state.state === "ready" ? state.value : null;
+			}
+		}),
+		session
+	};
 };
-
-// src/keboola/legacy/createConfig.ts
-var createConfig2 = () => {
-  const store = createStore({ baseUrl: null, sapiToken: null, managementToken: null });
-  const setBaseUrl = (baseUrl) => {
-    store.set({ ...store.get(), baseUrl });
-  };
-  const authenticate = (tokens) => {
-    const current = store.get();
-    store.set({
-      ...current,
-      sapiToken: tokens.sapiToken ?? current.sapiToken,
-      managementToken: tokens.managementToken ?? current.managementToken
-    });
-  };
-  const getStorageToken = () => store.get().sapiToken ?? "";
-  const setStorageToken = (sapiToken) => store.set({ ...store.get(), sapiToken });
-  const debug = () => store.get();
-  return { store, setBaseUrl, authenticate, getStorageToken, setStorageToken, debug };
+//#endregion
+//#region src/keboola/legacy/createConfig.ts
+const createConfig = () => {
+	const store = createStore({
+		baseUrl: null,
+		sapiToken: null,
+		managementToken: null
+	});
+	const setBaseUrl = (baseUrl) => {
+		store.set({
+			...store.get(),
+			baseUrl
+		});
+	};
+	const authenticate = (tokens) => {
+		const current = store.get();
+		store.set({
+			...current,
+			sapiToken: tokens.sapiToken ?? current.sapiToken,
+			managementToken: tokens.managementToken ?? current.managementToken
+		});
+	};
+	const getStorageToken = () => store.get().sapiToken ?? "";
+	const setStorageToken = (sapiToken) => store.set({
+		...store.get(),
+		sapiToken
+	});
+	/** Current state, for diagnostics. */
+	const debug = () => store.get();
+	return {
+		store,
+		setBaseUrl,
+		authenticate,
+		getStorageToken,
+		setStorageToken,
+		debug
+	};
 };
-
-// src/keboola/legacy/createProjectClients.ts
-var createAttachStorageToken = (getToken) => (next) => (request) => {
-  request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, getToken());
-  return next(request);
+//#endregion
+//#region src/keboola/legacy/createProjectClients.ts
+const createAttachStorageToken = (getToken) => (next) => (request) => {
+	request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, getToken());
+	return next(request);
 };
-var createProjectClients2 = async ({
-  baseUrl,
-  getStorageToken,
-  onStorageTokenRefreshed,
-  middlewareFor,
-  clientServiceUrls
-}) => {
-  const auth = { type: "sapi-token", token: getStorageToken() };
-  const attach = createAttachStorageToken(getStorageToken);
-  const _storage = createStorageClient({ baseUrl, auth, middlewares: [attach] });
-  const [stackInfo, sapiToken, devBranches] = await Promise.all([
-    _storage.getStackInfo({ exclude: "componentDetails" }),
-    _storage.tokens.verify(),
-    _storage.branches.getDevBranches()
-  ]);
-  const stack = createStack({ stackInfo, clientServiceUrls });
-  const defaultBranch = createDefaultBranch({ devBranches });
-  const liveProject = createLiveProject({
-    initialToken: sapiToken,
-    verify: () => _storage.tokens.verify()
-  });
-  const storageTableStore = createDerivedStore({
-    source: liveProject.store,
-    build: createStorageTable,
-    dependsOn: (project) => ({
-      useLegacyBucketPrefix: !project.hasFeature(ProjectFeature.DisableLegacyBucketPrefix),
-      hasProtectedDefaultBranch: project.hasFeature(ProjectFeature.SoxProtectedDefaultBranch),
-      hasStorageBranches: project.hasFeature(ProjectFeature.StorageBranches)
-    })
-  });
-  const context = {
-    baseUrl: normalizeBaseUrl(baseUrl),
-    stack,
-    defaultBranch,
-    get project() {
-      return liveProject.getProject();
-    },
-    get st() {
-      return storageTableStore.get();
-    }
-  };
-  const storage = createStorageClient({
-    baseUrl,
-    auth,
-    middlewares: middlewareFor("storage", [liveProject.middleware]),
-    onRefreshToken: onStorageTokenRefreshed
-  });
-  const { client: services, meta: serviceMeta } = createServiceClients({
-    baseUrl,
-    auth,
-    getServiceBaseUrl: context.stack.getServiceUrl,
-    middlewareFor,
-    attachTokenMiddleware: attach
-  });
-  const sdk = {
-    configuration: createConfigurationSdk({
-      storageClient: storage,
-      encryptionClient: services.encryption,
-      context
-    }),
-    tag: createTagSdk({ metastoreClient: services.metastore }),
-    semanticLayer: createSemanticLayerSdk({ metastoreClient: services.metastore }),
-    storage: createStorageSdk({ storageClient: storage }),
-    vault: createVaultSdk({ vaultClient: services.vault, encryptionClient: services.encryption }),
-    variables: createVariablesSdk({ storageClient: storage })
-  };
-  return { context, serviceMeta, storage, ...services, sdk };
+const createProjectClients = async ({ baseUrl, getStorageToken, onStorageTokenRefreshed, middlewareFor, clientServiceUrls }) => {
+	const auth = {
+		type: "sapi-token",
+		token: getStorageToken()
+	};
+	const attach = createAttachStorageToken(getStorageToken);
+	const _storage = createStorageClient({
+		baseUrl,
+		auth,
+		middlewares: [attach]
+	});
+	const [stackInfo, sapiToken, devBranches] = await Promise.all([
+		_storage.getStackInfo({ exclude: "componentDetails" }),
+		_storage.tokens.verify(),
+		_storage.branches.getDevBranches()
+	]);
+	const stack = createStack({
+		stackInfo,
+		clientServiceUrls
+	});
+	const defaultBranch = createDefaultBranch({ devBranches });
+	const liveProject = createLiveProject({
+		initialToken: sapiToken,
+		verify: () => _storage.tokens.verify()
+	});
+	const storageTableStore = createDerivedStore({
+		source: liveProject.store,
+		build: createStorageTable,
+		dependsOn: (project) => ({
+			useLegacyBucketPrefix: !project.hasFeature(ProjectFeature.DisableLegacyBucketPrefix),
+			hasProtectedDefaultBranch: project.hasFeature(ProjectFeature.SoxProtectedDefaultBranch),
+			hasStorageBranches: project.hasFeature(ProjectFeature.StorageBranches)
+		})
+	});
+	const context = {
+		baseUrl: normalizeBaseUrl(baseUrl),
+		stack,
+		defaultBranch,
+		get project() {
+			return liveProject.getProject();
+		},
+		get st() {
+			return storageTableStore.get();
+		}
+	};
+	const storage = createStorageClient({
+		baseUrl,
+		auth,
+		middlewares: middlewareFor("storage", [liveProject.middleware]),
+		onRefreshToken: onStorageTokenRefreshed
+	});
+	const { client: services, meta: serviceMeta } = createServiceClients({
+		baseUrl,
+		auth,
+		getServiceBaseUrl: context.stack.getServiceUrl,
+		middlewareFor,
+		attachTokenMiddleware: attach
+	});
+	const sdk = {
+		configuration: createConfigurationSdk({
+			storageClient: storage,
+			encryptionClient: services.encryption,
+			context
+		}),
+		tag: createTagSdk({ metastoreClient: services.metastore }),
+		semanticLayer: createSemanticLayerSdk({ metastoreClient: services.metastore }),
+		storage: createStorageSdk({ storageClient: storage }),
+		vault: createVaultSdk({
+			vaultClient: services.vault,
+			encryptionClient: services.encryption
+		}),
+		variables: createVariablesSdk({ storageClient: storage })
+	};
+	return {
+		context,
+		serviceMeta,
+		storage,
+		...services,
+		sdk
+	};
 };
-
-// src/keboola/legacy/keboola.ts
-var createLegacyKeboola = (options = {}) => {
-  const config = createConfig2();
-  const middlewareFor = createMiddlewareFor(options.middlewares);
-  const authClient = createDerivedStore({
-    source: config.store,
-    dependsOn: (state) => state.baseUrl,
-    build: (baseUrl) => baseUrl ? createAuthClient({ baseUrl, middlewares: middlewareFor("auth", []) }) : null
-  });
-  const management = createDerivedStore({
-    source: config.store,
-    dependsOn: (state) => ({ baseUrl: state.baseUrl, token: state.managementToken }),
-    build: ({ baseUrl, token }) => baseUrl ? createManagementClient({
-      baseUrl,
-      auth: token ? { type: "management-token", token } : { type: "management-token" },
-      middlewares: middlewareFor("management", [])
-    }) : null
-  });
-  const build = createDerivedAsyncStore({
-    source: config.store,
-    dependsOn: (state) => state.sapiToken && state.baseUrl ? state.baseUrl : null,
-    build: (baseUrl) => createProjectClients2({
-      baseUrl,
-      getStorageToken: config.getStorageToken,
-      onStorageTokenRefreshed: config.setStorageToken,
-      middlewareFor,
-      clientServiceUrls: options.clientServiceUrls
-    })
-  });
-  if (options.baseUrl) config.setBaseUrl(options.baseUrl);
-  const debug = () => {
-    const info = config.debug();
-    return {
-      type: "Sapi",
-      config: info,
-      authReady: authClient.get() !== null,
-      managementReady: !!info.managementToken,
-      storage: build.store.get().state
-    };
-  };
-  const session = {
-    setBaseUrl: config.setBaseUrl,
-    isStorageReady: () => build.store.get().state === "ready",
-    authenticateStorage: (sapiToken) => config.authenticate({ sapiToken }),
-    authenticateStorageAsync: async (sapiToken) => {
-      config.authenticate({ sapiToken });
-      await build.settled();
-    },
-    authenticateManagement: (managementToken) => config.authenticate({ managementToken }),
-    subscribe: (listener) => {
-      const unsubscribeConfig = config.store.subscribe(() => listener(debug()));
-      const unsubscribeBuild = build.store.subscribe(() => listener(debug()));
-      return () => {
-        unsubscribeConfig();
-        unsubscribeBuild();
-      };
-    },
-    debug
-  };
-  const api = createApi({
-    getAuthClient: () => authClient.get(),
-    getManagementClient: () => management.get(),
-    getProjectClients: () => {
-      const state = build.store.get();
-      return state.state === "ready" ? state.value : null;
-    }
-  });
-  return { api, session };
+//#endregion
+//#region src/keboola/legacy/keboola.ts
+const createLegacyKeboola = (options = {}) => {
+	const config = createConfig();
+	const middlewareFor = createMiddlewareFor(options.middlewares);
+	const authClient = createDerivedStore({
+		source: config.store,
+		dependsOn: (state) => state.baseUrl,
+		build: (baseUrl) => baseUrl ? createAuthClient({
+			baseUrl,
+			middlewares: middlewareFor("auth", [])
+		}) : null
+	});
+	const management = createDerivedStore({
+		source: config.store,
+		dependsOn: (state) => ({
+			baseUrl: state.baseUrl,
+			token: state.managementToken
+		}),
+		build: ({ baseUrl, token }) => baseUrl ? createManagementClient({
+			baseUrl,
+			auth: token ? {
+				type: "management-token",
+				token
+			} : { type: "management-token" },
+			middlewares: middlewareFor("management", [])
+		}) : null
+	});
+	const build = createDerivedAsyncStore({
+		source: config.store,
+		dependsOn: (state) => state.sapiToken && state.baseUrl ? state.baseUrl : null,
+		build: (baseUrl) => createProjectClients({
+			baseUrl,
+			getStorageToken: config.getStorageToken,
+			onStorageTokenRefreshed: config.setStorageToken,
+			middlewareFor,
+			clientServiceUrls: options.clientServiceUrls
+		})
+	});
+	if (options.baseUrl) config.setBaseUrl(options.baseUrl);
+	const debug = () => {
+		const info = config.debug();
+		return {
+			type: "Sapi",
+			config: info,
+			authReady: authClient.get() !== null,
+			managementReady: !!info.managementToken,
+			storage: build.store.get().state
+		};
+	};
+	const session = {
+		setBaseUrl: config.setBaseUrl,
+		isStorageReady: () => build.store.get().state === "ready",
+		authenticateStorage: (sapiToken) => config.authenticate({ sapiToken }),
+		authenticateStorageAsync: async (sapiToken) => {
+			config.authenticate({ sapiToken });
+			await build.settled();
+		},
+		authenticateManagement: (managementToken) => config.authenticate({ managementToken }),
+		subscribe: (listener) => {
+			const unsubscribeConfig = config.store.subscribe(() => listener(debug()));
+			const unsubscribeBuild = build.store.subscribe(() => listener(debug()));
+			return () => {
+				unsubscribeConfig();
+				unsubscribeBuild();
+			};
+		},
+		debug
+	};
+	return {
+		api: createApi({
+			getAuthClient: () => authClient.get(),
+			getManagementClient: () => management.get(),
+			getProjectClients: () => {
+				const state = build.store.get();
+				return state.state === "ready" ? state.value : null;
+			}
+		}),
+		session
+	};
 };
+//#endregion
+export { ApiError, HtmlResponseError, HttpContentType, HttpHeader, KeboolaError, KeboolaErrorType, KeboolaHttpHeader, ManagementClientAuthError, QueryJobError, QueryJobTimeoutError, Result, ServiceUnavailableError, SyncActionError, UserError, ValidationError, asError, assert, coalesce, collect, concurrent, createDerivedAsyncStore, createDerivedStore, createEmitter, createGenericFetchClient, createKeboola, createLegacyKeboola, createLocalStorage, createLoggingMiddleware, createMemoryStorage, createNullStorage, createPersistor, createPollRegistry, createQueryServiceSdk, createRetryMiddleware, createSessionStorage, createStorageSdk, createStore, dedupe, deepMerge, delay, emitter, failureOf, generateUUID, isAbortError, isApiError, isEmptyDeep, isFetchClientError, isHtmlResponseError, isKeboolaError, isManagementClientAuthError, isPlainObject, isQueryJobError, isQueryJobTimeoutError, isStorageTokenMutatingRequest, isSyncActionError, isValidationError, jobStatus, keboolaUID, lazy, parseLogLines, parseOrThrow, poll, poller, schemaGuidedMerge, series, shallowEqual };
 
-export { KeboolaError, KeboolaErrorType, assert, coalesce, createDerivedAsyncStore, createDerivedStore, createKeboola, createLegacyKeboola, createLocalStorage, createLoggingMiddleware, createMemoryStorage, createNullStorage, createPersistor, createRetryMiddleware, createSessionStorage, createStore, deepMerge, isKeboolaError, isStorageTokenMutatingRequest, lazy, shallowEqual };
-//# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map