@keboola/api-client 49.0.0 → 50.0.0

package/dist/index.js

@@ -1,61 +1,102 @@
-import { t as createProject } from "./project-ClH22nzH.js";
-import { t as collectByOffset } from "./collectByOffset-2XzJqmvr.js";
-import { t as createAuthClient, v as collectByCursor, y as nextCursorOf } from "./authClient-2e8ZmzSP.js";
-import { t as concurrent } from "./concurrent-BacWxPwi.js";
-import { t as dedupe } from "./dedupe-Cky1gSUu.js";
-import { a as poller, c as Result, d as delay, i as failureOf, l as asError, n as jobStatus, o as clamp, r as emitter, s as finiteOr, u as lazy } from "./transientRetries-B4iusp69.js";
-import { n as createEmitter, t as createStore } from "./store-C9FQCHGe.js";
-import { a as StorageJobError, c as retryAfterSeconds, d as manageErrorCode, f as series, l as readableReason, o as isStorageJobError, s as ServiceUnavailableError, t as createStorageClient, u as isManageError } from "./storage-CChfKlrb.js";
-import { n as keboolaUID, t as createTagSdk } from "./tag-hh-1nhNr.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-B44z6BSO.js";
-import { t as UserError } from "./UserError-By_Zckmc.js";
-import { _ as KeboolaHttpHeader, a as isTimeoutError, d as normalizeBaseUrl, g as HttpStatus, i as isFetchClientError, m as CREDENTIAL_HEADERS, n as isAbortError, o as HttpContentType, p as ApiError, r as isApiError, s as HttpHeader, v as REDACTED, y as redactHeaders } from "./createFetchClient-CkHdS_IG.js";
-import { n as HtmlResponseError, r as isHtmlResponseError } from "./validateConnectionStatus-DyrYpn0G.js";
-import { n as ManagementClientAuthError, t as ManagementSessionMintError } from "./ManagementSessionMintError-4Pkn5Oob.js";
-import { n as isQueryJobError, t as QueryJobError } from "./QueryJobError-ZZZ043Nm.js";
-import { n as isQueueJobError, t as QueueJobError } from "./QueueJobError-8bThS_Mc.js";
-import { n as isSyncActionError, t as SyncActionError } from "./SyncActionError-CoZFsdUk.js";
-import { i as parseOrThrow, n as formatValidationIssues, r as isValidationError, t as ValidationError } from "./ValidationError-DjhtNMfZ.js";
-import { t as createGenericFetchClient } from "./createGenericFetchClient-CQdNcPC3.js";
-import { t as createImportClient } from "./import-FWy_wQZ1.js";
-import { n as isManagementClientAuthError, r as isManagementSessionMintError, t as createManagementClient } from "./management-C9w3DNhs.js";
-import { l as ServiceId, u as ProjectFeature } from "./constants-VpSwBtCb.js";
-import { t as createStorageTable } from "./storageTable-BldTNyEk.js";
-import { i as createKaiMemorySdk } from "./kaiMemory-C9di17bd.js";
-import { i as createSemanticLayerSdk } from "./semanticLayer-DvjS_nzo.js";
+import { t as UserError } from "./UserError-BxoOJJ_u.js";
+import { _ as KeboolaHttpHeader, a as isTimeoutError, d as normalizeBaseUrl, g as HttpStatus, i as isFetchClientError, m as CREDENTIAL_HEADERS, n as isAbortError, o as HttpContentType, p as ApiError, r as isApiError, s as HttpHeader, v as REDACTED, y as redactHeaders } from "./createFetchClient-DlGCbltR.js";
+import { n as HtmlResponseError, r as isHtmlResponseError } from "./validateConnectionStatus-DYwWeWVo.js";
+import { a as series, c as ServiceUnavailableError, d as isManageError, f as manageErrorCode, l as retryAfterSeconds, o as StorageJobError, s as isStorageJobError, t as createStorageClient, u as readableReason } from "./storage-BpOLWT6h.js";
+import { n as ManagementClientAuthError, t as ManagementSessionMintError } from "./ManagementSessionMintError-DNMbYauw.js";
+import { n as isQueryJobError, t as QueryJobError } from "./QueryJobError-Iq9O90Uh.js";
+import { n as isQueueJobError, t as QueueJobError } from "./QueueJobError-BJNUINXW.js";
+import { n as isSyncActionError, t as SyncActionError } from "./SyncActionError-DuGcDbkd.js";
+import { i as parseOrThrow, n as formatValidationIssues, r as isValidationError, t as ValidationError } from "./ValidationError-BsdFDGY2.js";
+import { t as createGenericFetchClient } from "./createGenericFetchClient-wGxemBwR.js";
+import { t as createImportClient } from "./import-CT1Ce5Rp.js";
+import { d as collectByCursor, f as nextCursorOf, t as createAuthClient } from "./authClient-oB5ydxWp.js";
+import { t as collectByOffset } from "./collectByOffset-i8Tdoze7.js";
+import { t as concurrent } from "./concurrent-BtsT10Xe.js";
+import { t as dedupe } from "./dedupe-Bu0d2i_w.js";
+import { a as poller, c as Result, d as delay, i as failureOf, l as asError, n as jobStatus, o as clamp, r as emitter, s as finiteOr, u as lazy } from "./transientRetries-BKqmb85B.js";
+import { n as createEmitter, t as createStore } from "./store-HP0zRcLz.js";
+import { n as keboolaUID, t as createTagSdk } from "./tag-BwjbG3tT.js";
+import { t as generateUUID } from "./generateUUID-DE9sNyJF.js";
+import { t as isPlainObject } from "./isPlainObject-BxsT8_t2.js";
+import { n as isEmptyDeep, t as schemaGuidedMerge } from "./schemaGuidedMerge-DFNqj9Nz.js";
+import { n as isManagementClientAuthError, r as isManagementSessionMintError, t as createManagementClient } from "./management-BcGHyxAP.js";
+import { u as ServiceId } from "./constants-BMSHGwOR.js";
+import { i as createKaiMemorySdk } from "./kaiMemory-oir_qCo_.js";
+import { i as createSemanticLayerSdk } from "./semanticLayer-BdPW_wLo.js";
 import { createVaultSdk } from "./sdk/vault/index.js";
 import { createAiClient } from "./ai/index.js";
-import { t as parseLogLines } from "./appLogs-KslK7qHr.js";
+import { t as parseLogLines } from "./appLogs-DFcPwVk8.js";
 import { createAppsClient } from "./apps/index.js";
 import { createBillingClient } from "./billing/index.js";
 import { createChatClient } from "./chat/index.js";
-import { t as createComponentsMcpClient } from "./componentsMcp-CHobIsuU.js";
-import { t as createDataScienceClient } from "./dataScience-AwPMeGfz.js";
+import { t as createComponentsMcpClient } from "./componentsMcp-BrB4js6b.js";
+import { t as createDataScienceClient } from "./dataScience-CXmkEOAi.js";
 import { createEditorClient } from "./editor/index.js";
 import { createEncryptionClient } from "./encryption/index.js";
-import { t as createKaiAgentClient } from "./kaiAgent-CYvrS8oZ.js";
-import { t as createMetastoreClient } from "./metastore-Ywq08DBz.js";
+import { t as createKaiAgentClient } from "./kaiAgent-D2TiMDjW.js";
+import { t as createMetastoreClient } from "./metastore-CGsgxjng.js";
 import { createNotificationsClient } from "./notifications/index.js";
-import { t as createOauthClient } from "./oauth-GXmZ9agP.js";
+import { t as createOauthClient } from "./oauth-ByCdISsV.js";
 import { createOmnisearchClient } from "./omnisearch/index.js";
-import { t as createQueryServiceClient } from "./queryService-C-pZha5p.js";
-import { t as createQueueClient } from "./queue-D6-x4OGF.js";
+import { t as createQueryServiceClient } from "./queryService-x8kq8Z2-.js";
+import { t as createQueueClient } from "./queue-BiIs9fX4.js";
 import { createSchedulerClient } from "./scheduler/index.js";
 import { createStreamClient } from "./stream/index.js";
-import { t as createSyncActionsClient } from "./syncActions-DM8vP7p3.js";
+import { t as createSyncActionsClient } from "./syncActions-giPLTfje.js";
 import { createTelemetryClient } from "./telemetry/index.js";
 import { createVaultClient } from "./vault/index.js";
-import { n as isUnauthorized, t as createBearerAuthMiddleware } from "./middleware-GOfx8Apu.js";
+import { n as isUnauthorized, t as createBearerAuthMiddleware } from "./middleware-8zaJWcyU.js";
+import { t as createProject } from "./project-DmuC0bMK.js";
 import { createQueryServiceSdk } from "./sdk/queryService/index.js";
 import * as z$1 from "zod";
-//#region src/utils/assert.ts
+// 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",
+	SignInEnded: "sign-in-ended",
+	AlreadyAuthenticated: "already-authenticated",
+	NoStorageToken: "no-storage-token",
+	NoManagementToken: "no-management-token",
+	MissingProject: "missing-project",
+	NotBearer: "not-bearer",
+	NotReady: "not-ready",
+	InvalidBuildTransition: "invalid-build-transition"
+};
+const MESSAGES = {
+	[KeboolaErrorType.Unconfigured]: "The session is not configured — set a baseUrl first.",
+	[KeboolaErrorType.NotAuthenticated]: "The session is not authenticated — sign in first.",
+	[KeboolaErrorType.SignInEnded]: "The sign-in this operation started under has ended — its result belongs to nobody.",
+	[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);
+	}
+};
+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/utils/assert.ts
 function assert(value, message) {
 	if (value == null) throw new Error(message);
 }
-//#endregion
-//#region src/utils/ensure.ts
+// src/utils/ensure.ts
 /**
 * Read a key, or build its value and keep it.
 *
@@ -70,8 +111,7 @@ const ensure = (map, key, build) => {
 	map.set(key, created);
 	return created;
 };
-//#endregion
-//#region src/utils/async/coalesce.ts
+// src/utils/async/coalesce.ts
 /**
 * Coalesces concurrent triggers onto a single, never-parallel run of `task`.
 *
@@ -101,8 +141,7 @@ const coalesce = (task) => {
 		return waiter.promise;
 	};
 };
-//#endregion
-//#region src/utils/store/derivedStore.ts
+// src/utils/store/derivedStore.ts
 const isPlainObjectOrArray = (value) => {
 	if (Array.isArray(value)) return true;
 	const proto = Object.getPrototypeOf(value);
@@ -137,8 +176,7 @@ const createDerivedStore = ({ source, dependsOn, build, keyEquals = shallowEqual
 		dispose
 	};
 };
-//#endregion
-//#region src/utils/store/derivedAsyncStore.ts
+// src/utils/store/derivedAsyncStore.ts
 const createDerivedAsyncStore = ({ source, dependsOn, build, keyEquals = shallowEqual }) => {
 	const store = createStore({ state: "idle" });
 	let currentKey = null;
@@ -206,8 +244,7 @@ const createDerivedAsyncStore = ({ source, dependsOn, build, keyEquals = shallow
 		settled
 	};
 };
-//#endregion
-//#region src/utils/async/poll/registry.ts
+// src/utils/async/poll/registry.ts
 const DEFAULT_LIMIT = 50;
 const isFinished = ({ snapshot }) => snapshot.state !== "idle" && snapshot.state !== "requesting" && snapshot.state !== "polling";
 const createPollRegistry = ({ limit = DEFAULT_LIMIT } = {}) => {
@@ -259,8 +296,7 @@ const createPollRegistry = ({ limit = DEFAULT_LIMIT } = {}) => {
 		stopAll: (reason) => entries.get().forEach((entry) => entry.stop(reason))
 	};
 };
-//#endregion
-//#region src/utils/async/queueSeries.ts
+// src/utils/async/queueSeries.ts
 const isPromiseLike = (value) => (typeof value === "object" && value !== null || typeof value === "function") && "then" in value && typeof value.then === "function";
 /**
 * Queues tasks added over time so a slower earlier task cannot finish after and overwrite a later one.
@@ -300,8 +336,7 @@ const queueSeries = () => {
 		onIdle
 	};
 };
-//#endregion
-//#region src/utils/deepMerge.ts
+// 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
@@ -317,8 +352,7 @@ const deepMerge = (base, patch) => {
 	}
 	return out;
 };
-//#endregion
-//#region src/utils/persistor/adapters.ts
+// src/utils/persistor/adapters.ts
 const createNullStorage = () => ({
 	getItem: () => null,
 	setItem: () => {},
@@ -367,8 +401,7 @@ const createWebStorage = (pick) => {
 };
 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
+// src/utils/persistor/persistor.ts
 const createPersistor = ({ storage = createNullStorage(), key, schema, defaultValue, encode = JSON.stringify, decode = JSON.parse }) => {
 	const writes = queueSeries();
 	const _load = async () => {
@@ -422,82 +455,7 @@ const createPersistor = ({ storage = createNullStorage(), key, schema, defaultVa
 		locked
 	};
 };
-//#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));
-};
-const createProjectRefreshMiddleware = (shouldRefresh, requestRefresh) => (next) => async (request) => {
-	const response = await next(request);
-	if (shouldRefresh(request.request)) await requestRefresh();
-	return response;
-};
-/**
-* The live project store, re-verified (coalesced) after a token-mutating request or a re-scope.
-*/
-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
-	};
-};
-//#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",
-	SignInEnded: "sign-in-ended",
-	AlreadyAuthenticated: "already-authenticated",
-	NoStorageToken: "no-storage-token",
-	NoManagementToken: "no-management-token",
-	MissingProject: "missing-project",
-	NotBearer: "not-bearer",
-	NotReady: "not-ready",
-	InvalidBuildTransition: "invalid-build-transition",
-	StackActive: "stack-active"
-};
-const MESSAGES = {
-	[KeboolaErrorType.Unconfigured]: "The session is not configured — set a baseUrl first.",
-	[KeboolaErrorType.NotAuthenticated]: "The session is not authenticated — sign in first.",
-	[KeboolaErrorType.SignInEnded]: "The sign-in this operation started under has ended — its result belongs to nobody.",
-	[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.",
-	[KeboolaErrorType.StackActive]: "The active stack cannot be closed — select another first."
-};
-var KeboolaError = class KeboolaError extends Error {
-	type;
-	constructor(type) {
-		super(MESSAGES[type]);
-		this.type = type;
-		this.name = "KeboolaError";
-		Object.setPrototypeOf(this, KeboolaError.prototype);
-	}
-};
-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);
-}
-//#endregion
-//#region src/serviceClientRegistry/utils.ts
+// 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.
@@ -512,8 +470,7 @@ const createDummyClient = ({ onCall }) => {
 	});
 	return createProxy();
 };
-//#endregion
-//#region src/serviceClientRegistry/createServiceClientRegistry.ts
+// src/serviceClientRegistry/createServiceClientRegistry.ts
 const createServiceClientRegistry = () => ({ getServiceBaseUrl, onUnavailable }) => {
 	const dummy = (serviceId, clientName) => createDummyClient({ onCall: (path, args) => {
 		onUnavailable?.({
@@ -552,8 +509,7 @@ const createServiceClientRegistry = () => ({ getServiceBaseUrl, onUnavailable })
 	};
 	return registry;
 };
-//#endregion
-//#region src/keboola/createApi.ts
+// src/keboola/createApi.ts
 const createApi = (state) => new Proxy({}, { get(_target, property) {
 	if (isBuiltInProperty(property)) return void 0;
 	if (property === "auth") {
@@ -570,8 +526,7 @@ const createApi = (state) => new Proxy({}, { get(_target, property) {
 	assert$1(clients, KeboolaErrorType.NotReady);
 	return clients[property];
 } });
-//#endregion
-//#region src/keboola/createMiddlewareFor.ts
+// src/keboola/createMiddlewareFor.ts
 const createMiddlewareFor = (middlewares) => {
 	return (target, baseline = []) => {
 		if (Array.isArray(middlewares)) return [...baseline, ...middlewares];
@@ -584,8 +539,7 @@ const createMiddlewareFor = (middlewares) => {
 		];
 	};
 };
-//#endregion
-//#region src/keboola/legacy/createConfig.ts
+// src/keboola/legacy/createConfig.ts
 const createConfig = () => {
 	const store = createStore({
 		baseUrl: null,
@@ -622,25 +576,7 @@ const createConfig = () => {
 		debug
 	};
 };
-//#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"
-	};
-};
-//#endregion
-//#region src/domain/stack.ts
+// src/domain/stack.ts
 const isServiceId = (id) => Object.values(ServiceId).includes(id);
 const SERVICE_URL_OVERRIDES = { "kai-assistant": (url) => `${url}/api` };
 const createStack = ({ stackInfo, clientServiceUrls }) => {
@@ -677,8 +613,7 @@ const createStack = ({ stackInfo, clientServiceUrls }) => {
 		hasComponent
 	};
 };
-//#endregion
-//#region src/sdks/variables/variablesSdk.ts
+// 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) => {
@@ -759,14 +694,8 @@ const createVariablesSdk = ({ storageClient }) => {
 		}
 	};
 };
-//#endregion
-//#region src/keboola/createSdk.ts
-const createSdk = ({ storage, services, context }) => ({
-	configuration: createConfigurationSdk({
-		storageClient: storage,
-		encryptionClient: services.encryption,
-		context
-	}),
+// src/keboola/createSdk.ts
+const createSdk = ({ storage, services }) => ({
 	tag: createTagSdk({ metastoreClient: services.metastore }),
 	semanticLayer: createSemanticLayerSdk({ metastoreClient: services.metastore }),
 	kaiMemory: createKaiMemorySdk({ metastoreClient: services.metastore }),
@@ -776,8 +705,7 @@ const createSdk = ({ storage, services, context }) => ({
 	}),
 	variables: createVariablesSdk({ storageClient: storage })
 });
-//#endregion
-//#region src/keboola/createServiceClients.ts
+// src/keboola/createServiceClients.ts
 const withPath = (serviceBaseUrl, path) => typeof serviceBaseUrl === "string" ? `${serviceBaseUrl}${path}` : async () => `${await serviceBaseUrl()}${path}`;
 const createServiceClients = ({ baseUrl, auth, getServiceBaseUrl, middlewareFor, attachTokenMiddleware }) => createServiceClientRegistry()({
 	getServiceBaseUrl,
@@ -953,8 +881,7 @@ const createServiceClients = ({ baseUrl, auth, getServiceBaseUrl, middlewareFor,
 		auth
 	})
 }).build();
-//#endregion
-//#region src/keboola/legacy/createProjectClients.ts
+// src/keboola/legacy/createProjectClients.ts
 const createAttachStorageToken = (getToken) => (next) => (request) => {
 	request.request.headers.set(KeboolaHttpHeader.STORAGE_API_TOKEN, getToken());
 	return next(request);
@@ -965,72 +892,41 @@ const createProjectClients = async ({ baseUrl, getStorageToken, onStorageTokenRe
 		token: getStorageToken()
 	};
 	const attach = createAttachStorageToken(getStorageToken);
-	const _storage = createStorageClient({
+	const stackInfo = await createStorageClient({
 		baseUrl,
 		auth,
 		middlewares: [attach]
-	});
-	const [stackInfo, sapiToken, devBranches] = await Promise.all([
-		_storage.getStackInfo({ exclude: "componentDetails" }),
-		_storage.tokens.verify(),
-		_storage.branches.getDevBranches()
-	]);
+	}).getStackInfo({ exclude: "componentDetails" });
 	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]),
+		middlewares: middlewareFor("storage", []),
 		onRefreshToken: onStorageTokenRefreshed
 	});
 	const { client: services, meta: serviceMeta } = createServiceClients({
 		baseUrl,
 		auth,
-		getServiceBaseUrl: context.stack.getServiceUrl,
+		getServiceBaseUrl: stack.getServiceUrl,
 		middlewareFor,
 		attachTokenMiddleware: attach
 	});
 	return {
-		context,
+		baseUrl: normalizeBaseUrl(baseUrl),
+		stack,
 		serviceMeta,
 		storage,
 		...services,
 		sdk: createSdk({
 			storage,
-			services,
-			context
+			services
 		})
 	};
 };
-//#endregion
-//#region src/keboola/legacy/keboola.ts
+// src/keboola/legacy/keboola.ts
 const createLegacyKeboola = (options = {}) => {
 	const config = createConfig();
 	const middlewareFor = createMiddlewareFor(options.middlewares);
@@ -1110,160 +1006,74 @@ const createLegacyKeboola = (options = {}) => {
 		session
 	};
 };
-//#endregion
-//#region src/keboola/bearer/state/factories.ts
-/**
-* Everything the table constructs: the entries themselves, and the failures reading them produces.
-*
-* Nothing here touches the store — a factory takes what it is told and returns a value, so the
-* namespaces the tables build on can be read without following a dependency.
-*/
-const projectEntryId = (baseUrl, projectId) => `${baseUrl}#${projectId}`;
-/** What every project entry of one stack shares — the one thing a per-stack teardown matches on. */
-const projectEntryPrefix = (baseUrl) => `${baseUrl}#`;
-const isUnderStack = (baseUrl) => (id) => id.startsWith(projectEntryPrefix(baseUrl));
-const anonymousAuth = () => ({ status: "anonymous" });
-const restoringAuth = () => ({ status: "restoring" });
-const authenticatedAuth = (credential) => ({
-	status: "authenticated",
-	credential
-});
-const credential = (input) => ({
-	...input,
-	issuedAt: Date.now()
-});
-const grant = (credential) => credential.type === "token" ? {
+// src/keboola/bearer/state/auth.ts
+const grantOf = (credential) => credential.type === "token" ? {
 	type: "token",
 	refreshToken: credential.refreshToken
 } : {
 	type: "cookie",
 	sessionId: credential.sessionId
 };
-const expiredCredential = (credential) => ({
-	...credential,
-	issuedAt: Date.now() - credential.expiresIn * 1e3
-});
-const stack = (baseUrl) => ({
-	baseUrl,
-	context: "idle",
-	epoch: 0,
-	auth: anonymousAuth(),
-	retained: null
-});
-const project = (baseUrl, projectId) => ({
-	id: projectEntryId(baseUrl, projectId),
-	baseUrl,
-	projectId,
-	context: "idle"
-});
-const stackAddress = (baseUrl) => ({
-	baseUrl,
-	projectId: null
-});
-const projectAddress = (baseUrl, projectId) => ({
-	baseUrl,
-	projectId
-});
-const table = (defaultBaseUrl) => ({
-	active: stackAddress(defaultBaseUrl),
-	stacks: { [defaultBaseUrl]: stack(defaultBaseUrl) },
-	projects: {}
+const stamped = (input) => ({
+	...input,
+	issuedAt: Date.now()
 });
-const Entry = {
-	projectEntryId,
-	isUnderStack,
-	stack,
-	project,
-	stackAddress,
-	projectAddress,
-	table,
-	anonymousAuth,
-	restoringAuth,
-	authenticatedAuth,
-	credential,
-	grant,
-	expiredCredential
-};
-/**
-* Every failure the table can produce.
-*
-* - The typed ones carry a `KeboolaErrorType` a consumer branches on; the rest are plain `Error`s
-*   whose message names the entry, because nothing branches on them.
-*/
-const Errors = {
-	notAuthenticated: () => new KeboolaError(KeboolaErrorType.NotAuthenticated),
-	stackActive: () => new KeboolaError(KeboolaErrorType.StackActive),
-	/** A stack that was never opened — nothing has been configured for it. */
-	unconfigured: () => new KeboolaError(KeboolaErrorType.Unconfigured),
-	alreadyAuthenticated: () => new KeboolaError(KeboolaErrorType.AlreadyAuthenticated),
-	notReady: () => new KeboolaError(KeboolaErrorType.NotReady),
-	alreadyRestoring: (baseUrl) => /* @__PURE__ */ new Error(`Stack "${baseUrl}" is already being restored`),
-	notRestoring: (baseUrl) => /* @__PURE__ */ new Error(`Stack "${baseUrl}" is not being restored`),
-	grantTypeChanged: (from, to) => /* @__PURE__ */ new Error(`A ${from} grant cannot become ${to}`),
-	nothingRetained: (baseUrl) => /* @__PURE__ */ new Error(`Stack "${baseUrl}" retains no credential`),
-	missingProject: (id) => /* @__PURE__ */ new Error(`No project "${id}"`)
-};
-const authenticated = (auth) => auth.status === "authenticated" ? Result.success(auth.credential) : Result.failure(Errors.notAuthenticated());
-//#endregion
-//#region src/keboola/bearer/state/auth.ts
-/**
-* Fire-once per sign-in: the first report of a dead credential returns `true`, the rest `false`,
-* and `authenticate` re-arms it. Held beside the table because it is not state anyone restores.
-*/
-const createExpiryLatch = () => {
-	const notified = /* @__PURE__ */ new Map();
-	return {
-		arm: (baseUrl) => notified.set(baseUrl, false),
-		forget: (baseUrl) => notified.delete(baseUrl),
-		report: (baseUrl) => {
-			if (notified.get(baseUrl)) return false;
-			notified.set(baseUrl, true);
-			return true;
-		}
-	};
-};
+const credentialOf = (auth) => auth.status === "authenticated" ? Result.success(auth.credential) : Result.failure(new KeboolaError(KeboolaErrorType.NotAuthenticated));
 /**
 * The stack's credential and its sign-in pin.
 *
 * - `epoch` moves on `authenticate` and `signOut` and never on a rotation, so it is exactly "which
 *   sign-in is this" — what an in-flight exchange compares itself against.
 */
-const createAuth = ({ stacks, projects, expiry }) => {
-	const requireUnauthenticated = (baseUrl) => Result.andThen(stacks.get(baseUrl), (stack) => stack.auth.status === "authenticated" ? Result.failure(Errors.alreadyAuthenticated()) : Result.success(stack));
-	const requireAnonymous = (baseUrl) => Result.andThen(requireUnauthenticated(baseUrl), (stack) => stack.auth.status === "restoring" ? Result.failure(Errors.alreadyRestoring(baseUrl)) : Result.success(stack));
-	const requireRestoring = (baseUrl) => Result.andThen(stacks.get(baseUrl), (stack) => stack.auth.status === "restoring" ? Result.success(stack) : Result.failure(Errors.notRestoring(baseUrl)));
+const createAuth = (stacks) => {
+	const expired = /* @__PURE__ */ new Set();
+	const requireCredential = (baseUrl) => Result.andThen(stacks.get(baseUrl), (stack) => credentialOf(stack.auth));
+	const requireUnauthenticated = (baseUrl) => Result.andThen(stacks.get(baseUrl), (stack) => stack.auth.status === "authenticated" ? Result.failure(new KeboolaError(KeboolaErrorType.AlreadyAuthenticated)) : Result.success(stack));
+	const requireAnonymous = (baseUrl) => Result.andThen(requireUnauthenticated(baseUrl), (stack) => stack.auth.status === "restoring" ? Result.failure(/* @__PURE__ */ new Error(`Stack "${baseUrl}" is already being restored`)) : Result.success(stack));
+	const requireRestoring = (baseUrl) => Result.andThen(stacks.get(baseUrl), (stack) => stack.auth.status === "restoring" ? Result.success(stack) : Result.failure(/* @__PURE__ */ new Error(`Stack "${baseUrl}" is not being restored`)));
 	const startRestore = (baseUrl) => Result.map(requireAnonymous(baseUrl), (stack) => stacks.set({
 		...stack,
-		auth: Entry.restoringAuth()
+		auth: { status: "restoring" }
 	}));
 	const cancelRestore = (baseUrl) => Result.map(requireRestoring(baseUrl), (stack) => stacks.set({
 		...stack,
-		auth: Entry.anonymousAuth()
+		auth: { status: "anonymous" }
 	}));
 	const authenticate = (baseUrl, input) => Result.map(requireUnauthenticated(baseUrl), (stack) => {
-		expiry.arm(baseUrl);
+		expired.delete(baseUrl);
 		return stacks.set({
 			...stack,
 			epoch: stack.epoch + 1,
-			auth: Entry.authenticatedAuth(Entry.credential(input)),
+			auth: {
+				status: "authenticated",
+				credential: stamped(input)
+			},
 			retained: null
 		});
 	});
-	const applyRefresh = (baseUrl, input) => Result.andThen(stacks.requireCredential(baseUrl), (credential) => credential.type !== input.type ? Result.failure(Errors.grantTypeChanged(credential.type, input.type)) : Result.map(stacks.get(baseUrl), (stack) => stacks.set({
+	const applyRefresh = (baseUrl, input) => Result.andThen(requireCredential(baseUrl), (credential) => credential.type !== input.type ? Result.failure(/* @__PURE__ */ new Error(`A ${credential.type} grant cannot become ${input.type}`)) : Result.map(stacks.get(baseUrl), (stack) => stacks.set({
 		...stack,
-		auth: Entry.authenticatedAuth(Entry.credential(input))
+		auth: {
+			status: "authenticated",
+			credential: stamped(input)
+		}
 	})));
-	const forceExpire = (baseUrl) => Result.andThen(stacks.requireCredential(baseUrl), (credential) => Result.map(stacks.get(baseUrl), (stack) => stacks.set({
+	const forceExpire = (baseUrl) => Result.andThen(requireCredential(baseUrl), (credential) => Result.map(stacks.get(baseUrl), (stack) => stacks.set({
 		...stack,
-		auth: Entry.authenticatedAuth(Entry.expiredCredential(credential))
+		auth: {
+			status: "authenticated",
+			credential: {
+				...credential,
+				issuedAt: Date.now() - credential.expiresIn * 1e3
+			}
+		}
 	})));
 	const signOut = (baseUrl, { retain = false } = {}) => Result.map(stacks.get(baseUrl), (stack) => {
-		projects.closeAll(baseUrl);
-		const retained = retain ? Result.unwrapOr(Result.map(authenticated(stack.auth), (credential) => ({ grant: Entry.grant(credential) })), stack.retained) : null;
+		const retained = retain ? Result.unwrapOr(Result.map(credentialOf(stack.auth), (credential) => ({ grant: grantOf(credential) })), stack.retained) : null;
 		return stacks.set({
 			...stack,
 			epoch: stack.epoch + 1,
-			auth: Entry.anonymousAuth(),
+			auth: { status: "anonymous" },
 			retained
 		});
 	});
@@ -1275,9 +1085,14 @@ const createAuth = ({ stacks, projects, expiry }) => {
 		...stack,
 		retained: null
 	}));
-	const requireRetained = (baseUrl) => Result.andThen(stacks.get(baseUrl), (stack) => stack.retained ? Result.success(stack.retained) : Result.failure(Errors.nothingRetained(baseUrl)));
+	const requireRetained = (baseUrl) => Result.andThen(stacks.get(baseUrl), (stack) => stack.retained ? Result.success(stack.retained) : Result.failure(/* @__PURE__ */ new Error(`Stack "${baseUrl}" retains no credential`)));
+	const notifyExpired = (baseUrl) => {
+		if (expired.has(baseUrl)) return false;
+		expired.add(baseUrl);
+		return true;
+	};
 	const getEpoch = (baseUrl) => Result.map(stacks.get(baseUrl), (stack) => stack.epoch);
-	const getAccessToken = (baseUrl) => Result.unwrapOr(Result.map(stacks.requireCredential(baseUrl), ({ accessToken }) => accessToken), null);
+	const getAccessToken = (baseUrl) => Result.unwrapOr(Result.map(requireCredential(baseUrl), ({ accessToken }) => accessToken), null);
 	return {
 		startRestore,
 		cancelRestore,
@@ -1288,171 +1103,26 @@ const createAuth = ({ stacks, projects, expiry }) => {
 		retain,
 		dropRetained,
 		requireRetained,
-		notifyExpired: expiry.report,
-		requireCredential: stacks.requireCredential,
+		notifyExpired,
+		requireCredential,
 		getEpoch,
 		getAccessToken
 	};
 };
-//#endregion
-//#region src/keboola/bearer/state/projects.ts
-/** The projects open under a stack, and what authorizes a request to one. */
-const createProjects = ({ store, stacks }) => {
-	const has = (id) => id in store.get().projects;
-	const get = (id) => {
-		const project = store.get().projects[id];
-		return project ? Result.success(project) : Result.failure(Errors.missingProject(id));
-	};
-	const list = (baseUrl) => Object.values(store.get().projects).filter((project) => project.baseUrl === baseUrl);
-	/** Every open project with this id, whatever stack it sits on — a project number is not unique. */
-	const findAll = (projectId) => Object.values(store.get().projects).filter((project) => project.projectId === projectId);
-	const set = (project) => {
-		const state = store.get();
-		store.set({
-			...state,
-			projects: {
-				...state.projects,
-				[project.id]: project
-			}
-		});
-		return project;
-	};
-	const update = (id, updater) => Result.map(get(id), (project) => set(updater(project)));
-	const removeMany = (ids, nextActive) => {
-		const state = store.get();
-		const projects = { ...state.projects };
-		for (const id of ids) delete projects[id];
-		store.set({
-			...state,
-			active: nextActive,
-			projects
-		});
-	};
-	const requireCredential = (id) => Result.andThen(get(id), (project) => stacks.requireCredential(project.baseUrl));
-	const open = (baseUrl, projectId) => {
-		const id = Entry.projectEntryId(baseUrl, projectId);
-		if (has(id)) return get(id);
-		return Result.map(stacks.requireCredential(baseUrl), () => set(Entry.project(baseUrl, projectId)));
-	};
-	const close = (id) => Result.tap(get(id), ({ baseUrl, projectId }) => {
-		const { active } = store.get();
-		const isScoped = active.baseUrl === baseUrl && active.projectId === projectId;
-		removeMany([id], isScoped ? Entry.stackAddress(baseUrl) : active);
-	});
-	/** Every project under a stack, with the scope falling back to the stack itself. */
-	const closeAll = (baseUrl) => {
-		const ids = list(baseUrl).map((project) => project.id);
-		const { active } = store.get();
-		removeMany(ids, active.baseUrl === baseUrl ? Entry.stackAddress(baseUrl) : active);
-	};
-	const updateContext = (id, context) => update(id, (project) => ({
-		...project,
-		context
-	}));
-	return {
-		has,
-		get,
-		list,
-		findAll,
-		set,
-		update,
-		open,
-		close,
-		closeAll,
-		updateContext,
-		requireCredential
-	};
-};
-//#endregion
-//#region src/keboola/bearer/state/scope.ts
-/**
-* What `api.*` addresses: the `active` slot, and the address in it resolved against the tables it
-* points into.
-*
-* The tables never write here — they read `active` through the pure helpers in `address.ts`, so
-* that this can depend on them rather than the other way round.
-*/
-const createScope = ({ store, stacks, projects }) => {
-	const get = () => store.get().active;
-	const isSame = (a, b) => a === b || a.baseUrl === b.baseUrl && a.projectId === b.projectId;
-	const set = (active) => {
-		if (isSame(store.get().active, active)) return;
-		store.set({
-			...store.get(),
-			active
-		});
-	};
-	const locate = (active) => {
-		const stack = stacks.get(active.baseUrl);
-		if (!stack.success) return null;
-		if (active.projectId === null) return {
-			stack: stack.data,
-			project: null
-		};
-		const project = projects.get(Entry.projectEntryId(active.baseUrl, active.projectId));
-		if (!project.success) return null;
-		return {
-			stack: stack.data,
-			project: project.data
-		};
-	};
-	const getActive = () => {
-		const location = locate(get());
-		if (!location) throw new Error(`The scope names no row: ${JSON.stringify(get())}`);
-		return location;
-	};
-	const getActiveStack = () => getActive().stack;
-	const activateStack = (baseUrl) => Result.map(stacks.get(baseUrl), (stack) => {
-		const next = Entry.stackAddress(stack.baseUrl);
-		set(next);
-		return next;
-	});
-	const activateProject = (baseUrl, projectId) => Result.map(projects.requireCredential(Entry.projectEntryId(baseUrl, projectId)), () => {
-		const next = Entry.projectAddress(baseUrl, projectId);
-		set(next);
-		return next;
-	});
-	const selectStack = (baseUrl) => {
-		const stack = stacks.ensure(baseUrl);
-		return Result.map(activateStack(stack.baseUrl), () => stack);
-	};
-	const selectProject = (projectId) => {
-		const { baseUrl } = getActiveStack();
-		const project = projects.open(baseUrl, projectId);
-		if (!project.success) return project;
-		return Result.map(activateProject(baseUrl, projectId), () => project.data);
-	};
-	const deactivate = () => {
-		const active = get();
-		if (active.projectId === null) return;
-		set(Entry.stackAddress(active.baseUrl));
-	};
-	const requireActiveProject = () => {
-		const { project } = getActive();
-		return project ? Result.success(project) : Result.failure(Errors.notReady());
-	};
-	return {
-		get,
-		getActive,
-		activateStack,
-		activateProject,
-		selectStack,
-		selectProject,
-		deactivate,
-		getActiveStack,
-		requireActiveProject
-	};
-};
-//#endregion
-//#region src/keboola/bearer/state/stacks.ts
-/** One entry per stack: the entries, and the verbs that open and close them. */
-const createStacks = ({ store, forgetExpiry }) => {
-	const has = (baseUrl) => baseUrl in store.get().stacks;
+// src/keboola/bearer/state/stacks.ts
+const newStack = (baseUrl) => ({
+	baseUrl,
+	context: "idle",
+	epoch: 0,
+	auth: { status: "anonymous" },
+	retained: null
+});
+/** One entry per stack, and the verbs that open and select them. */
+const createStacks = (store) => {
 	const get = (baseUrl) => {
 		const stack = store.get().stacks[baseUrl];
-		return stack ? Result.success(stack) : Result.failure(Errors.unconfigured());
+		return stack ? Result.success(stack) : Result.failure(new KeboolaError(KeboolaErrorType.Unconfigured));
 	};
-	const list = () => Object.values(store.get().stacks);
 	const set = (stack) => {
 		const state = store.get();
 		store.set({
@@ -1465,26 +1135,24 @@ const createStacks = ({ store, forgetExpiry }) => {
 		return stack;
 	};
 	const update = (baseUrl, updater) => Result.map(get(baseUrl), (stack) => set(updater(stack)));
-	const requireCredential = (baseUrl) => Result.andThen(get(baseUrl), (stack) => authenticated(stack.auth));
 	const ensure = (baseUrl) => {
 		const existing = get(baseUrl);
 		if (existing.success) return existing.data;
-		return set(Entry.stack(baseUrl));
+		return set(newStack(baseUrl));
+	};
+	const getActive = () => {
+		const { active } = store.get();
+		const stack = get(active);
+		if (!stack.success) throw new Error(`The active stack has no row: ${active}`);
+		return stack.data;
 	};
-	const close = (baseUrl) => {
-		const stack = get(baseUrl);
-		if (!stack.success) return stack;
+	const select = (baseUrl) => {
+		const stack = ensure(baseUrl);
 		const state = store.get();
-		if (state.active.baseUrl === baseUrl) return Result.failure(Errors.stackActive());
-		const stacks = { ...state.stacks };
-		delete stacks[baseUrl];
-		const projects = Object.fromEntries(Object.entries(state.projects).filter(([, project]) => project.baseUrl !== baseUrl));
-		store.set({
-			active: state.active,
-			stacks,
-			projects
+		if (state.active !== baseUrl) store.set({
+			...state,
+			active: baseUrl
 		});
-		forgetExpiry(baseUrl);
 		return stack;
 	};
 	const updateContext = (baseUrl, context) => update(baseUrl, (stack) => ({
@@ -1492,56 +1160,42 @@ const createStacks = ({ store, forgetExpiry }) => {
 		context
 	}));
 	return {
-		has,
 		get,
-		list,
 		set,
 		update,
 		ensure,
-		close,
-		updateContext,
-		requireCredential
+		getActive,
+		select,
+		updateContext
 	};
 };
-//#endregion
-//#region src/keboola/bearer/state/state.ts
+// src/keboola/bearer/state/state.ts
 /**
 * The stack table and the rules over it, one namespace per concern.
 *
-* - Built in dependency order: a project reads its stack's credential, and the scope resolves
-*   the active address against both tables.
+* - Starts active on its default stack, which is its one row.
 */
 const createState = (defaultBaseUrl) => {
-	const store = createStore(Entry.table(defaultBaseUrl));
-	const expiry = createExpiryLatch();
-	const stacks = createStacks({
-		store,
-		forgetExpiry: expiry.forget
-	});
-	const projects = createProjects({
-		store,
-		stacks
-	});
-	const scope = createScope({
-		store,
-		stacks,
-		projects
-	});
-	const auth = createAuth({
-		stacks,
-		projects,
-		expiry
+	const store = createStore({
+		active: defaultBaseUrl,
+		stacks: { [defaultBaseUrl]: newStack(defaultBaseUrl) }
 	});
+	const stacks = createStacks(store);
+	const auth = createAuth(stacks);
 	return {
 		store: store.asReadable(),
 		stacks,
-		projects,
-		auth,
-		scope
+		auth
 	};
 };
-//#endregion
-//#region src/keboola/bearer/credentials/renewal.ts
+// src/keboola/bearer/credentials/credentials.ts
+const DEFAULT_REFRESH_THRESHOLD = .9;
+const signInEnded = () => new KeboolaError(KeboolaErrorType.SignInEnded);
+const toRestoreStatus = (outcome) => {
+	if (outcome === void 0 || outcome === "skipped") return "empty";
+	if (outcome === "refused") return "expired";
+	return outcome;
+};
 const renew = async (client, grant) => {
 	if (grant.type === "cookie") {
 		const { accessToken, expiresIn, sessionId } = await client.token.refreshWithSession({ sessionId: grant.sessionId });
@@ -1561,55 +1215,29 @@ const renew = async (client, grant) => {
 		refreshToken
 	};
 };
-//#endregion
-//#region src/keboola/bearer/credentials/credentials.ts
-const DEFAULT_REFRESH_THRESHOLD = .9;
-const signInEnded = () => new KeboolaError(KeboolaErrorType.SignInEnded);
-const toRestoreStatus = (outcome) => {
-	if (outcome === void 0 || outcome === "skipped") return "empty";
-	if (outcome === "refused") return "expired";
-	return outcome;
-};
 const createCredentials = ({ state, persistor, middlewares, refreshThreshold = DEFAULT_REFRESH_THRESHOLD, onSignedOut, onExpired }) => {
 	const rotationMap = /* @__PURE__ */ new Map();
-	const generations = /* @__PURE__ */ new Map();
-	const generationOf = (baseUrl) => generations.get(baseUrl) ?? 0;
+	const markSignIn = (baseUrl) => {
+		const epoch = Result.unwrap(state.auth.getEpoch(baseUrl));
+		return () => Result.unwrapOr(state.auth.getEpoch(baseUrl), -1) === epoch;
+	};
 	const refresh = async (baseUrl, grant) => {
 		const client = createAuthClient({
 			baseUrl,
 			middlewares
 		});
-		const epochBefore = Result.unwrap(state.auth.getEpoch(baseUrl));
-		const generationBefore = generationOf(baseUrl);
+		const isSameSignIn = markSignIn(baseUrl);
 		const refreshed = await Result.tryCatchAsync(() => renew(client, grant));
-		return Result.unwrapOr(state.auth.getEpoch(baseUrl), -1) === epochBefore && generationOf(baseUrl) === generationBefore ? refreshed : Result.failure(signInEnded());
+		return isSameSignIn() ? refreshed : Result.failure(signInEnded());
 	};
-	/**
-	* A stack's teardown, from the credential's side.
-	*
-	* - Bumps the generation, so an in-flight rotation can no longer write.
-	* - Drops the deduped entry, so nothing joins that rotation.
-	*/
-	const forget = (baseUrl) => {
-		generations.set(baseUrl, generationOf(baseUrl) + 1);
-		rotationMap.delete(baseUrl);
-	};
-	/**
-	* The rotation, and the one place a credential is declared dead.
-	*
-	* - Renews by the credential's grant: the refresh token, or the session id with the cookie.
-	* - A refused refresh token or session is unambiguous.
-	* - The triggering 401 is not (an unreachable project answers the same), so never sign out on a replay.
-	*/
 	const getGrantForRotation = async (store, baseUrl, credential) => {
-		const epochBefore = Result.unwrap(state.auth.getEpoch(baseUrl));
-		const generationBefore = generationOf(baseUrl);
+		const isSameSignIn = markSignIn(baseUrl);
 		const hydrated = await Result.tryCatchAsync(() => store.read());
 		if (!hydrated.success) return hydrated;
-		if (Result.unwrapOr(state.auth.getEpoch(baseUrl), -1) !== epochBefore || generationOf(baseUrl) !== generationBefore) return Result.failure(signInEnded());
+		if (!isSameSignIn()) return Result.failure(signInEnded());
 		const persistedStack = hydrated.data.stacks.find((stack) => stack.baseUrl === baseUrl);
 		if (persistedStack && persistedStack.credential === null) return Result.failure(signInEnded());
-		return Result.success(persistedStack?.credential ?? Entry.grant(credential));
+		return Result.success(persistedStack?.credential ?? grantOf(credential));
 	};
 	const rotateOnce = async (baseUrl) => persistor.locked(async (store) => {
 		const credential = state.auth.requireCredential(baseUrl);
@@ -1647,17 +1275,6 @@ const createCredentials = ({ state, persistor, middlewares, refreshThreshold = D
 		await store.persistStack(baseUrl, state.store.get());
 		return "restored";
 	});
-	const restoreProjects = (baseUrl, projects) => {
-		for (const { projectId } of projects) state.projects.open(baseUrl, projectId);
-	};
-	/**
-	* Every persisted stack back into the table, with whatever credential it can hand back.
-	*
-	* - Never writes the scope. `lastActive` is what was scoped when the session was stored, for the
-	*   caller to select.
-	* - `status` reports what became of `lastActive`'s credential; the client reads it to decide
-	*   when persistence may start.
-	*/
 	const restore = async () => {
 		const hydrated = await persistor.locked((store) => store.read()).catch((error) => {
 			console.warn("createCredentials: the stored session could not be read", error);
@@ -1669,15 +1286,13 @@ const createCredentials = ({ state, persistor, middlewares, refreshThreshold = D
 		};
 		const { stacks, current } = hydrated;
 		const scoped = stacks.find(({ baseUrl }) => baseUrl === current?.baseUrl);
-		const restored = stacks.map(async ({ baseUrl, credential, retained, projects }) => {
+		const restored = stacks.map(async ({ baseUrl, credential, retained }) => {
 			state.stacks.ensure(baseUrl);
 			if (!credential && !retained) return "unreachable";
 			if (Result.unwrapOr(state.auth.getEpoch(baseUrl), 0) > 0) return "skipped";
 			if (retained) state.auth.retain(baseUrl, retained);
 			if (!credential) return "unreachable";
-			const outcome = await restoreStack(baseUrl, credential);
-			if (outcome === "restored") restoreProjects(baseUrl, projects);
-			return outcome;
+			return restoreStack(baseUrl, credential);
 		});
 		const results = await Promise.all(restored);
 		const scopedOutcome = scoped?.credential ? results[stacks.indexOf(scoped)] : void 0;
@@ -1686,23 +1301,12 @@ const createCredentials = ({ state, persistor, middlewares, refreshThreshold = D
 			status: toRestoreStatus(scopedOutcome)
 		};
 	};
-	/**
-	* Signs a retained stack back in from the grant it kept.
-	*
-	* - `restored` and `refused` empty the slot; `unreachable` keeps it for another try.
-	* - Throws when the stack retains nothing.
-	*/
 	const restoreRetained = async (baseUrl) => {
 		const { grant } = Result.unwrap(state.auth.requireRetained(baseUrl));
 		return restoreStack(baseUrl, grant, true);
 	};
-	const isStale = (baseUrl) => {
-		const ageing = Result.map(state.auth.requireCredential(baseUrl), ({ issuedAt, expiresIn }) => Date.now() >= issuedAt + expiresIn * 1e3 * refreshThreshold);
-		return Result.unwrapOr(ageing, false);
-	};
 	/**
-	* Drops the slot so the next sign-in's requests don't join the dying rotation.
-	*
+	* - Drops the rotation, so the next sign-in's requests don't join the dying one.
 	* - Writes nothing: the caller persists the stack, under the lock it holds or takes.
 	*/
 	const signOut = (baseUrl, options) => {
@@ -1718,7 +1322,8 @@ const createCredentials = ({ state, persistor, middlewares, refreshThreshold = D
 		onExpired?.(baseUrl);
 	};
 	const renewIfStale = async (baseUrl) => {
-		if (isStale(baseUrl)) await rotate(baseUrl);
+		const isStale = Result.map(state.auth.requireCredential(baseUrl), ({ issuedAt, expiresIn }) => Date.now() >= issuedAt + expiresIn * 1e3 * refreshThreshold);
+		if (Result.unwrapOr(isStale, false)) await rotate(baseUrl);
 	};
 	const middleware = (baseUrl) => createBearerAuthMiddleware({ getAccessToken: async ({ forceRefresh = false } = {}) => {
 		if (forceRefresh) {
@@ -1734,187 +1339,18 @@ const createCredentials = ({ state, persistor, middlewares, refreshThreshold = D
 		renewIfStale,
 		restore,
 		restoreRetained,
-		signOut,
-		forget
+		signOut
 	};
 };
-//#endregion
-//#region src/keboola/bearer/context/resource.ts
+// src/keboola/bearer/perProject.ts
+const projectKey = ({ baseUrl, projectId }) => `${baseUrl}#${projectId}`;
 /**
-* Owns fetching one async value per key — a caller names what it needs and never orchestrates the
-* request. Backs the stack and project contexts.
+* One handle per project, and the one call that drops it.
 *
-* - One fetch per key: concurrent askers share it, a landed value is never refetched.
-* - A failure is held, not thrown away — nothing here needs a rejection handler.
-* - Status lives here and nowhere else; a consumer that has to mirror it subscribes.
+* Every client belongs to the credential that built it — a client set carries its middleware
+* chain — so the handle dies with the sign-in, and `forgetUnder` is the only thing that ends one.
 */
-const createResource = ({ key, fetch }) => {
-	const entries = /* @__PURE__ */ new Map();
-	const changes = createEmitter();
-	const set = (id, entry) => {
-		entries.set(id, entry);
-		changes.emit({
-			key: id,
-			status: entry.status
-		});
-	};
-	const run = (id, input) => {
-		const settle = (next) => {
-			if (entries.get(id) === entry) set(id, {
-				input,
-				...next
-			});
-			return next;
-		};
-		const attempt = async () => await fetch(input);
-		const entry = {
-			input,
-			status: "pending",
-			settled: attempt().then((value) => settle({
-				status: "ready",
-				value
-			}), (error) => settle({
-				status: "errored",
-				error
-			}))
-		};
-		set(id, entry);
-		return entry;
-	};
-	const get = (id) => {
-		const entry = entries.get(id);
-		return entry?.status === "ready" ? entry.value : null;
-	};
-	const getAsync = async (input) => {
-		const id = key(input);
-		const cached = entries.get(id);
-		const entry = cached === void 0 || cached.status === "errored" ? run(id, input) : cached;
-		const settled = entry.status === "pending" ? await entry.settled : entry;
-		if (settled.status === "errored") throw settled.error;
-		return settled.value;
-	};
-	const forget = (matches) => {
-		for (const id of entries.keys()) if (matches(id)) entries.delete(id);
-	};
-	const prefetch = (input) => {
-		const id = key(input);
-		if (!entries.has(id)) run(id, input);
-	};
-	const retry = (id) => {
-		const entry = entries.get(id);
-		if (entry !== void 0) run(id, entry.input);
-	};
-	return {
-		get,
-		getAsync,
-		prefetch,
-		retry,
-		forget,
-		subscribe: changes.subscribe
-	};
-};
-//#endregion
-//#region src/keboola/bearer/context/project.ts
-const createProjectContext = ({ state, credentials, stackContext }) => {
-	const resource = createResource({
-		key: (project) => project.id,
-		fetch: async ({ baseUrl, projectId }) => {
-			const withProjectId = (next) => (request) => {
-				request.request.headers.set(KeboolaHttpHeader.PROJECT_ID, String(projectId));
-				return next(request);
-			};
-			const client = createStorageClient({
-				baseUrl,
-				auth: {
-					type: "bearer",
-					token: "",
-					projectId
-				},
-				middlewares: [(next) => withProjectId(credentials.middleware(baseUrl)(next))]
-			});
-			const [token, devBranches] = await Promise.all([
-				client.tokens.verify(),
-				client.branches.getDevBranches(),
-				stackContext.getAsync(baseUrl)
-			]);
-			return {
-				token,
-				defaultBranch: createDefaultBranch({ devBranches })
-			};
-		}
-	});
-	resource.subscribe(({ key, status }) => {
-		state.projects.updateContext(key, status);
-	});
-	const subscriber = ({ projects }) => {
-		for (const project of Object.values(projects)) resource.prefetch(project);
-	};
-	/**
-	* Dropped with the sign-in that fetched them: a verified token is what a credential answered
-	* for, so it belongs to that credential and not to the project id it was keyed by.
-	*/
-	const forgetUnder = (baseUrl) => resource.forget(Entry.isUnderStack(baseUrl));
-	/** One project, closed on purpose. */
-	const forget = (id) => resource.forget((key) => key === id);
-	return {
-		subscriber,
-		get: resource.get,
-		getAsync: resource.getAsync,
-		retry: resource.retry,
-		forget,
-		forgetUnder
-	};
-};
-//#endregion
-//#region src/keboola/bearer/context/stack.ts
-const STACK_INDEX_TIMEOUT_MS = 3e4;
-const createStackContext = (state) => {
-	const resource = createResource({
-		key: (baseUrl) => baseUrl,
-		fetch: (baseUrl) => createStorageClient({
-			baseUrl,
-			auth: {
-				type: "sapi-token",
-				token: ""
-			}
-		}).getStackInfo({ exclude: "componentDetails" }, AbortSignal.timeout(STACK_INDEX_TIMEOUT_MS))
-	});
-	resource.subscribe(({ key, status }) => {
-		state.stacks.updateContext(key, status);
-	});
-	const subscriber = ({ stacks }) => {
-		for (const { baseUrl } of Object.values(stacks)) resource.prefetch(baseUrl);
-	};
-	/** Dropped with the stack itself — a stack that comes back re-reads its index. */
-	const forget = (baseUrl) => resource.forget((key) => key === baseUrl);
-	return {
-		subscriber,
-		get: resource.get,
-		getAsync: resource.getAsync,
-		retry: resource.retry,
-		forget
-	};
-};
-//#endregion
-//#region src/keboola/bearer/perProject.ts
-const once = (build) => {
-	let value = null;
-	return () => value ??= build();
-};
-/**
-* Everything one project derives, and the one call that drops it.
-*
-* Every field belongs to the credential that built it — a client set carries its middleware chain,
-* the storage client holds a `liveProject` seeded with its token, a fetched context *is* what it
-* answered for `tokens.verify` — so the record dies with the sign-in, and `forgetUnder` is the
-* only thing that ends one.
-*/
-const createPerProject = ({ state, credentials, middlewareFor, stack, clientServiceUrls, buildApi }) => {
-	const context = createProjectContext({
-		state,
-		credentials,
-		stackContext: stack.context
-	});
+const createPerProject = ({ state, credentials, middlewareFor, stack }) => {
 	const attachFor = ({ baseUrl, projectId }) => {
 		const withProjectId = (next) => (request) => {
 			request.request.headers.set(KeboolaHttpHeader.PROJECT_ID, String(projectId));
@@ -1922,131 +1358,72 @@ const createPerProject = ({ state, credentials, middlewareFor, stack, clientServ
 		};
 		return (next) => withProjectId(credentials.middleware(baseUrl)(next));
 	};
-	const buildClients = ({ baseUrl, projectId }, attach) => createServiceClients({
-		baseUrl,
-		auth: {
-			type: "bearer",
-			token: "",
-			projectId
-		},
-		getServiceBaseUrl: (serviceId) => async () => {
-			const stackInfo = await stack.context.getAsync(baseUrl);
-			const serviceUrl = createStack({
-				stackInfo,
-				clientServiceUrls
-			}).getServiceUrl(serviceId);
-			assert$1(serviceUrl, KeboolaErrorType.NotReady);
-			return serviceUrl;
-		},
-		middlewareFor,
-		attachTokenMiddleware: attach
+	const authFor = ({ projectId }) => ({
+		type: "bearer",
+		token: "",
+		projectId
 	});
 	/**
-	* `api.storage` and `api.context`, built together: both read one live token — the storage client
-	* carries its re-verify middleware, the context reports the project it re-verifies.
+	* One project's surface: the stack's fields from `perStack`, the rest built for the project.
 	*
-	* - Both fetches it reads are already running. `NotReady` covers the window before they land,
-	*   which the table reports as `project.context`.
-	* - `storage` is gated on the stack index too, though it addresses the project's own `baseUrl`
-	*   and does not need it — that is the gate as it stands, not a requirement.
+	* - Checked per property read but `baseUrl`: `SignInEnded` once the sign-in it was built under
+	*   ends, and `NotAuthenticated` before one lands.
 	*/
-	const buildLive = (project, attach) => {
-		const stackInfo = stack.context.get(project.baseUrl);
-		assert$1(stackInfo, KeboolaErrorType.NotReady);
-		const fetched = context.get(project.id);
-		assert$1(fetched, KeboolaErrorType.NotReady);
-		const { baseUrl, projectId } = project;
-		const auth = {
-			type: "bearer",
-			token: "",
-			projectId
-		};
-		const reader = createStorageClient({
-			baseUrl,
-			auth,
-			middlewares: [attach]
+	const build = (project) => {
+		let isLive = true;
+		const attach = attachFor(project);
+		const storage = createStorageClient({
+			baseUrl: project.baseUrl,
+			auth: authFor(project),
+			middlewares: middlewareFor("storage", [attach])
 		});
-		const liveProject = createLiveProject({
-			initialToken: fetched.token,
-			verify: () => reader.tokens.verify()
+		const { client, meta } = createServiceClients({
+			baseUrl: project.baseUrl,
+			auth: authFor(project),
+			getServiceBaseUrl: (serviceId) => async () => {
+				const serviceUrl = (await stack.context.getAsync(project.baseUrl)).getServiceUrl(serviceId);
+				assert$1(serviceUrl, KeboolaErrorType.NotReady);
+				return serviceUrl;
+			},
+			middlewareFor,
+			attachTokenMiddleware: attach
 		});
-		const storageTableStore = createDerivedStore({
-			source: liveProject.store,
-			build: createStorageTable,
-			dependsOn: (live) => ({
-				useLegacyBucketPrefix: !live.hasFeature(ProjectFeature.DisableLegacyBucketPrefix),
-				hasProtectedDefaultBranch: live.hasFeature(ProjectFeature.SoxProtectedDefaultBranch),
-				hasStorageBranches: live.hasFeature(ProjectFeature.StorageBranches)
-			})
+		const sdk = createSdk({
+			storage,
+			services: client
 		});
 		return {
-			storage: createStorageClient({
-				baseUrl,
-				auth,
-				middlewares: middlewareFor("storage", [attach, liveProject.middleware])
-			}),
-			context: {
-				baseUrl,
-				stack: createStack({
-					stackInfo,
-					clientServiceUrls
-				}),
-				defaultBranch: fetched.defaultBranch,
-				get project() {
-					return liveProject.getProject();
-				},
-				get st() {
-					return storageTableStore.get();
-				}
-			}
-		};
-	};
-	const build = (project) => {
-		const attach = attachFor(project);
-		const live = once(() => buildLive(project, attach));
-		const clients = once(() => buildClients(project, attach));
-		const sdk = once(() => createSdk({
-			storage: live().storage,
-			services: clients().client,
-			context: live().context
-		}));
-		return {
-			api: buildApi(project),
-			get clients() {
-				return clients();
-			},
-			get storage() {
-				return live().storage;
-			},
-			get context() {
-				return live().context;
-			},
-			get sdk() {
-				return sdk();
+			api: new Proxy({}, { get: (_target, property) => {
+				if (isBuiltInProperty(property)) return void 0;
+				if (property === "baseUrl") return project.baseUrl;
+				if (!isLive) throw new KeboolaError(KeboolaErrorType.SignInEnded);
+				Result.unwrap(state.auth.requireCredential(project.baseUrl));
+				if (property === "stack" || property === "auth" || property === "management") return stack.get(project.baseUrl)[property];
+				if (property === "storage") return storage;
+				if (property === "sdk") return sdk;
+				if (property === "serviceMeta") return meta;
+				return client[property];
+			} }),
+			end: () => {
+				isLive = false;
 			}
 		};
 	};
 	const derived = /* @__PURE__ */ new Map();
-	const get = (project) => ensure(derived, project.id, () => build(project));
-	/** One project, closed on purpose — a handle for it stops answering from the next read. */
-	const forget = (id) => {
-		derived.delete(id);
-		context.forget(id);
-	};
+	const get = (project) => ensure(derived, projectKey(project), () => build(project)).api;
 	const forgetUnder = (baseUrl) => {
-		const isUnder = Entry.isUnderStack(baseUrl);
-		for (const id of derived.keys()) if (isUnder(id)) derived.delete(id);
-		context.forgetUnder(baseUrl);
+		for (const [key, record] of derived) {
+			if (!key.startsWith(`${baseUrl}#`)) continue;
+			record.end();
+			derived.delete(key);
+		}
 	};
 	return {
-		context,
 		get,
-		forget,
 		forgetUnder
 	};
 };
-//#endregion
-//#region src/keboola/bearer/persistor.ts
+// src/keboola/bearer/persistor.ts
 /**
 * Where a bearer session is persisted, under whichever adapter the client was given.
 *
@@ -2072,17 +1449,23 @@ const persistedGrantSchema = z$1.discriminatedUnion("type", [z$1.object({
 	type: z$1.literal("cookie"),
 	sessionId: z$1.string()
 })]);
-/** A record per project rather than a bare id, so a project can grow a field without a migration. */
-const persistedProjectSchema = z$1.object({ projectId: z$1.number() });
 const persistedStackSchema = z$1.object({
 	baseUrl: z$1.string(),
 	credential: persistedGrantSchema.nullable().catch(null),
 	retained: z$1.object({ grant: persistedGrantSchema }).nullable().default(null).catch(null),
-	projects: z$1.array(persistedProjectSchema)
+	/**
+	* Written empty, never read.
+	* - An older build parses a stack without it as corrupt, and signs out.
+	*/
+	projects: z$1.array(z$1.unknown())
 });
 const persistedSessionSchema = z$1.object({
 	current: z$1.object({
 		baseUrl: z$1.string(),
+		/**
+		* Written `null`, never read: the project is the app's to keep.
+		* - An older build parses a `current` without it as corrupt, and signs out.
+		*/
 		projectId: z$1.number().nullable()
 	}).nullable(),
 	stacks: z$1.array(persistedStackSchema)
@@ -2091,22 +1474,21 @@ const EMPTY_PERSISTED_SESSION = {
 	current: null,
 	stacks: []
 };
-const projectsOf = (projects, baseUrl) => Object.values(projects).filter((project) => project.baseUrl === baseUrl).map(({ projectId }) => ({ projectId }));
 const grantsOf = (stack) => ({
-	credential: stack.auth.status === "authenticated" ? Entry.grant(stack.auth.credential) : null,
+	credential: stack.auth.status === "authenticated" ? grantOf(stack.auth.credential) : null,
 	retained: stack.retained
 });
 /**
 * The stored session, rewritten from the table except for the grants.
 *
-* - Scope, stack list and open projects come from memory.
+* - Scope and stack list come from memory.
 * - `credential` and `retained` stay as stored: a grant another document rotated must not be put
 *   back by a snapshot of this one's older table.
 */
-const mergeSnapshot = (stored, { active, stacks, projects }) => ({
+const mergeSnapshot = (stored, { active, stacks }) => ({
 	current: {
-		baseUrl: active.baseUrl,
-		projectId: active.projectId
+		baseUrl: active,
+		projectId: null
 	},
 	stacks: Object.values(stacks).map(({ baseUrl }) => {
 		const kept = stored.stacks.find((stack) => stack.baseUrl === baseUrl);
@@ -2114,15 +1496,15 @@ const mergeSnapshot = (stored, { active, stacks, projects }) => ({
 			baseUrl,
 			credential: kept?.credential ?? null,
 			retained: kept?.retained ?? null,
-			projects: projectsOf(projects, baseUrl)
+			projects: []
 		};
 	})
 });
-const upsertStack = (stored, baseUrl, update) => {
-	const index = stored.stacks.findIndex((stack) => stack.baseUrl === baseUrl);
+const upsertStack = (stored, row) => {
+	const index = stored.stacks.findIndex((stack) => stack.baseUrl === row.baseUrl);
 	const stacks = [...stored.stacks];
-	if (index < 0) stacks.push(update(void 0));
-	else stacks[index] = update(stacks[index]);
+	if (index < 0) stacks.push(row);
+	else stacks[index] = row;
 	return {
 		...stored,
 		stacks
@@ -2143,14 +1525,14 @@ const createSessionPersistor = (storage) => {
 		schema: persistedSessionSchema,
 		defaultValue: EMPTY_PERSISTED_SESSION
 	});
-	const persistStack = (cell, baseUrl, { stacks, projects }) => {
+	const persistStack = (cell, baseUrl, { stacks }) => {
 		const stack = stacks[baseUrl];
 		if (stack === void 0) return Promise.resolve();
-		return cell.modify((stored) => upsertStack(stored, baseUrl, (existing) => ({
+		return cell.modify((stored) => upsertStack(stored, {
 			baseUrl,
 			...grantsOf(stack),
-			projects: existing?.projects ?? projectsOf(projects, baseUrl)
-		})));
+			projects: []
+		}));
 	};
 	const locked = (task) => persistor.locked((cell) => task({
 		read: cell.read,
@@ -2174,18 +1556,92 @@ const createSessionPersistor = (storage) => {
 		snapshot
 	};
 };
-//#endregion
-//#region src/keboola/bearer/perStack.ts
+// src/keboola/bearer/context.ts
+const STACK_INDEX_TIMEOUT_MS = 3e4;
 /**
-* Everything one stack derives, and the one call that drops it.
+* One parsed stack index per stack; `createStack` applies the dev and production overrides.
+*
+* - One fetch per stack: concurrent askers share it, a landed index is never refetched.
+* - A failure is held until a retry; nothing here needs a rejection handler.
+* - Every status change is copied onto the stack's row, for the consumers that render it.
+*/
+const createStackContext = ({ state, clientServiceUrls }) => {
+	const entries = /* @__PURE__ */ new Map();
+	const set = (baseUrl, entry) => {
+		entries.set(baseUrl, entry);
+		state.stacks.updateContext(baseUrl, entry.status);
+	};
+	const fetchStack = async (baseUrl) => {
+		const stackInfo = await createStorageClient({
+			baseUrl,
+			auth: {
+				type: "sapi-token",
+				token: ""
+			}
+		}).getStackInfo({ exclude: "componentDetails" }, AbortSignal.timeout(STACK_INDEX_TIMEOUT_MS));
+		return createStack({
+			stackInfo,
+			clientServiceUrls
+		});
+	};
+	const run = (baseUrl) => {
+		const settle = (next) => {
+			set(baseUrl, next);
+			return next;
+		};
+		const entry = {
+			status: "pending",
+			settled: fetchStack(baseUrl).then((value) => settle({
+				status: "ready",
+				value
+			}), (error) => settle({
+				status: "errored",
+				error
+			}))
+		};
+		set(baseUrl, entry);
+		return entry;
+	};
+	const get = (baseUrl) => {
+		const entry = entries.get(baseUrl);
+		return entry?.status === "ready" ? entry.value : null;
+	};
+	const getAsync = async (baseUrl) => {
+		const cached = entries.get(baseUrl);
+		const entry = cached === void 0 || cached.status === "errored" ? run(baseUrl) : cached;
+		const settled = entry.status === "pending" ? await entry.settled : entry;
+		if (settled.status === "errored") throw settled.error;
+		return settled.value;
+	};
+	const subscriber = ({ stacks }) => {
+		for (const { baseUrl } of Object.values(stacks)) if (!entries.has(baseUrl)) run(baseUrl);
+	};
+	return {
+		subscriber,
+		get,
+		getAsync
+	};
+};
+// src/keboola/bearer/perStack.ts
+/**
+* Everything one stack derives.
 *
 * Outlives a sign-out, unlike anything in `perProject`: both clients read the credential live per
 * request, so neither belongs to one sign-in, and the stack index is public.
 */
-const createPerStack = ({ state, credentials, middlewareFor }) => {
-	const context = createStackContext(state);
+const createPerStack = ({ state, credentials, middlewareFor, clientServiceUrls }) => {
+	const context = createStackContext({
+		state,
+		clientServiceUrls
+	});
 	const derived = /* @__PURE__ */ new Map();
 	const get = (baseUrl) => ensure(derived, baseUrl, () => ({
+		baseUrl,
+		get stack() {
+			const parsed = context.get(baseUrl);
+			assert$1(parsed, KeboolaErrorType.NotReady);
+			return parsed;
+		},
 		auth: createAuthClient({
 			baseUrl,
 			middlewares: middlewareFor("auth", [credentials.middleware(baseUrl)])
@@ -2199,18 +1655,12 @@ const createPerStack = ({ state, credentials, middlewareFor }) => {
 			middlewares: middlewareFor("management", [credentials.middleware(baseUrl)])
 		})
 	}));
-	const forget = (baseUrl) => {
-		derived.delete(baseUrl);
-		context.forget(baseUrl);
-	};
 	return {
 		context,
-		get,
-		forget
+		get
 	};
 };
-//#endregion
-//#region src/keboola/bearer/keboola.ts
+// src/keboola/bearer/keboola.ts
 /**
 * The bearer client: the session table, its two scopes, and the surface they back.
 *
@@ -2230,65 +1680,41 @@ const createKeboola = ({ defaultBaseUrl, storage, middlewares, clientServiceUrls
 	const perStack = createPerStack({
 		state,
 		credentials,
-		middlewareFor
+		middlewareFor,
+		clientServiceUrls
 	});
 	const perProject = createPerProject({
 		state,
 		credentials,
 		middlewareFor,
-		stack: perStack,
-		clientServiceUrls,
-		buildApi: (project) => createApiFor({
-			stackUrl: () => project.baseUrl,
-			project: () => Result.unwrap(state.projects.get(project.id)),
-			pinned: true
-		})
+		stack: perStack
 	});
 	state.store.subscribe(perStack.context.subscriber);
 	perStack.context.subscriber(state.store.get());
-	state.store.subscribe(perProject.context.subscriber);
-	const selectStack = (baseUrl) => Result.unwrap(state.scope.selectStack(normalizeBaseUrl(baseUrl)));
-	const selectProject = (projectId) => Result.unwrap(state.scope.selectProject(projectId));
-	/** The scoped stack, or a named one — normalised to key like `select`. */
-	const requireStackUrl = (baseUrl) => baseUrl === void 0 ? state.scope.getActiveStack().baseUrl : normalizeBaseUrl(baseUrl);
-	/** The scoped project, or the row a table id names — on whichever stack that is. */
-	const requireProjectEntry = (id) => id === void 0 ? Result.unwrap(state.scope.requireActiveProject()) : Result.unwrap(state.projects.get(id));
+	const selectStack = (baseUrl) => state.stacks.select(normalizeBaseUrl(baseUrl));
+	/** The active stack, or a named one — normalised to key like `select`. */
+	const requireStackUrl = (baseUrl) => baseUrl === void 0 ? state.stacks.getActive().baseUrl : normalizeBaseUrl(baseUrl);
+	/** A project id is unique only within its stack: it always names one on the active stack. */
+	const onActiveStack = (projectId) => ({
+		baseUrl: requireStackUrl(),
+		projectId
+	});
 	/**
-	* The scoped project, or a named open one.
+	* Auth headers for a non-fetch transport (the chat stream), renewed first once near expiry.
 	*
-	* - An id is ambiguous across stacks: the active stack decides, else the single one open elsewhere.
+	* - No middleware recovers a 401 there.
+	* - Pinned to the stack active at the call: a stack switch mid-renewal does not re-point it.
+	* - Throws `NotAuthenticated` if that stack signed out meanwhile.
 	*/
-	const requireProject = (projectId) => {
-		if (projectId === void 0) return Result.unwrap(state.scope.requireActiveProject());
-		const scoped = state.projects.get(Entry.projectEntryId(requireStackUrl(), projectId));
-		if (scoped.success) return scoped.data;
-		const [only, ...rest] = state.projects.findAll(projectId);
-		return only !== void 0 && rest.length === 0 ? only : Result.unwrap(scoped);
-	};
-	const headersFor = (project) => {
-		const credential = Result.unwrap(state.auth.requireCredential(project.baseUrl));
+	const getAuthHeadersAsync = async (projectId) => {
+		const { baseUrl } = onActiveStack(projectId);
+		await credentials.renewIfStale(baseUrl);
+		const credential = Result.unwrap(state.auth.requireCredential(baseUrl));
 		return {
 			[HttpHeader.AUTHORIZATION]: `Bearer ${credential.accessToken}`,
-			[KeboolaHttpHeader.PROJECT_ID]: String(project.projectId)
+			[KeboolaHttpHeader.PROJECT_ID]: String(projectId)
 		};
 	};
-	/**
-	* Auth headers for a non-fetch transport (the chat stream).
-	*
-	* - A read, not a rotation: no middleware recovers a 401 there; the fetch clients keep it fresh.
-	*/
-	const getAuthHeaders = (projectId) => headersFor(requireProject(projectId));
-	/**
-	* `getAuthHeaders`, with the token renewed first once it nears expiry.
-	*
-	* - Pinned to the project resolved at the call: a scope move during the renewal does not re-point it.
-	* - Throws like the read if that project closed, or its stack signed out, meanwhile.
-	*/
-	const getAuthHeadersAsync = async (projectId) => {
-		const project = requireProject(projectId);
-		await credentials.renewIfStale(project.baseUrl);
-		return headersFor(Result.unwrap(state.projects.get(project.id)));
-	};
 	const toCredential = (input) => {
 		if (input.type !== "token") return input;
 		const { refreshToken } = input;
@@ -2299,51 +1725,30 @@ const createKeboola = ({ defaultBaseUrl, storage, middlewares, clientServiceUrls
 		};
 	};
 	const authenticate = (input) => {
-		const { baseUrl } = state.scope.getActiveStack();
+		const { baseUrl } = state.stacks.getActive();
 		const signedIn = Result.unwrap(state.auth.authenticate(baseUrl, toCredential(input)));
 		persistor.locked((store) => store.persistStack(baseUrl, state.store.get())).catch((error) => {
 			console.warn("createKeboola: the sign-in could not be stored", error);
 		});
 		return signedIn;
 	};
-	/**
-	* The flat product surface: `auth` and `management` per stack, the rest per project.
-	*
-	* - Both resolvers run per property read: that re-points the active handle and makes a pinned
-	*   one throw once its project is gone.
-	*/
-	const createApiFor = (resolve) => new Proxy({}, { get: (_target, property) => {
-		if (isBuiltInProperty(property)) return void 0;
-		if (property === "auth" || property === "management") {
-			if (resolve.pinned) resolve.project();
-			return perStack.get(resolve.stackUrl())[property];
+	const active = () => perStack.get(state.stacks.getActive().baseUrl);
+	const stackApi = {
+		get baseUrl() {
+			return active().baseUrl;
+		},
+		get stack() {
+			return active().stack;
+		},
+		get auth() {
+			return active().auth;
+		},
+		get management() {
+			return active().management;
 		}
-		const derived = perProject.get(resolve.project());
-		if (property === "context") return derived.context;
-		if (property === "storage") return derived.storage;
-		if (property === "sdk") return derived.sdk;
-		const { client, meta } = derived.clients;
-		if (property === "serviceMeta") return meta;
-		return client[property];
-	} });
-	const activeApi = createApiFor({
-		stackUrl: () => state.scope.getActiveStack().baseUrl,
-		project: () => Result.unwrap(state.scope.requireActiveProject())
-	});
-	/** The scoped project's surface. Re-points when the scope moves. */
-	const getActiveApi = () => activeApi;
-	/**
-	* One project's surface, on the active stack — one credential serves all of them.
-	*
-	* - Pinned: never re-points; stops once the project closes (`session.project.close`, sign-out).
-	* - Memoised per project: a React `key` or a hook dep compares handles by identity.
-	*/
-	const getApi = (projectId) => {
-		const { baseUrl } = state.scope.getActiveStack();
-		const project = Entry.project(baseUrl, projectId);
-		Result.unwrapOr(state.projects.open(baseUrl, projectId), null);
-		return perProject.get(project).api;
 	};
+	const getStackApi = () => stackApi;
+	const getProjectApi = (projectId) => perProject.get(onActiveStack(projectId));
 	/**
 	* The scope's sign-in, or a named stack's — and everything that sign-in derived.
 	*
@@ -2369,28 +1774,6 @@ const createKeboola = ({ defaultBaseUrl, storage, middlewares, clientServiceUrls
 		signOut();
 		return authenticate(input);
 	};
-	/**
-	* Leave one project: its row and everything built for it; its handles stop answering.
-	*
-	* - Counterpart of `getApi(projectId)`; without it the project is held and persisted until sign-out.
-	*/
-	const closeProject = (projectId) => {
-		const id = Entry.projectEntryId(requireStackUrl(), projectId);
-		const closed = Result.unwrapOr(state.projects.close(id), null);
-		if (closed === null) return null;
-		perProject.forget(id);
-		return closed;
-	};
-	const closeStack = (baseUrl) => {
-		const target = normalizeBaseUrl(baseUrl);
-		if (state.scope.get().baseUrl === target) throw new KeboolaError(KeboolaErrorType.StackActive);
-		const closed = Result.unwrapOr(state.stacks.close(target), null);
-		if (closed === null) return null;
-		perProject.forgetUnder(target);
-		perStack.forget(target);
-		credentials.forget(target);
-		return closed;
-	};
 	let persisting = false;
 	/**
 	* Persistence starts only once the restore has settled.
@@ -2432,12 +1815,12 @@ const createKeboola = ({ defaultBaseUrl, storage, middlewares, clientServiceUrls
 		enablePersistenceOnSignIn();
 		throw error;
 	}));
-	const getActiveStack = state.scope.getActiveStack;
+	const getActiveStack = state.stacks.getActive;
 	const isAuthenticated = () => getActiveStack().auth.status === "authenticated";
 	/**
 	* Picks up where the stored session left off, once.
 	*
-	* 1. A stored stack becomes active again, with its project if its credential came back.
+	* 1. The stored stack becomes active again.
 	* 2. Nothing stored, or the restore failed: `defaultBaseUrl` stays active; a failure rethrows.
 	* 3. The caller got there first (a select, sign-in or sign-out): its scope and sign-ins stand.
 	*
@@ -2445,9 +1828,7 @@ const createKeboola = ({ defaultBaseUrl, storage, middlewares, clientServiceUrls
 	* - Other stacks still come back, persistence still starts; repeat calls share one promise.
 	*/
 	const resume = lazy(() => restore().then(({ lastActive, status }) => {
-		if (!lastActive || callerScoped) return status;
-		const stack = selectStack(lastActive.baseUrl);
-		if (lastActive.projectId !== null && stack.auth.status === "authenticated") selectProject(lastActive.projectId);
+		if (lastActive && !callerScoped) selectStack(lastActive.baseUrl);
 		return status;
 	}));
 	let callerScoped = false;
@@ -2456,8 +1837,8 @@ const createKeboola = ({ defaultBaseUrl, storage, middlewares, clientServiceUrls
 		return verb(...args);
 	};
 	return {
-		getActiveApi,
-		getApi,
+		getStackApi,
+		getProjectApi,
 		session: {
 			getState: state.store.get,
 			subscribe: state.store.subscribe,
@@ -2469,23 +1850,9 @@ const createKeboola = ({ defaultBaseUrl, storage, middlewares, clientServiceUrls
 					const stack = selectStack(baseUrl);
 					return persistScope().then(() => stack);
 				}),
-				close: closeStack,
-				retryContext: perStack.context.retry,
 				getContext: (baseUrl) => perStack.context.get(requireStackUrl(baseUrl)),
 				getContextAsync: (baseUrl) => perStack.context.getAsync(requireStackUrl(baseUrl))
 			},
-			project: {
-				/** Scoped on return; resolves once that is stored, for a caller leaving the document. */
-				select: byCaller((projectId) => {
-					const project = selectProject(projectId);
-					return persistScope().then(() => project);
-				}),
-				close: closeProject,
-				deactivate: state.scope.deactivate,
-				retryContext: perProject.context.retry,
-				getContext: (id) => perProject.context.get(id ?? requireProjectEntry().id),
-				getContextAsync: (id) => perProject.context.getAsync(requireProjectEntry(id))
-			},
 			auth: {
 				authenticate: byCaller(authenticate),
 				replace: byCaller(replace),
@@ -2494,15 +1861,12 @@ const createKeboola = ({ defaultBaseUrl, storage, middlewares, clientServiceUrls
 				/** Whether the active stack holds a credential — `restoring` is not one yet. */
 				isAuthenticated,
 				isAuthenticatedAsync: () => resume().then(isAuthenticated),
-				rotate: (baseUrl) => credentials.rotate(baseUrl).then(Result.unwrap),
-				getHeaders: getAuthHeaders,
 				getHeadersAsync: getAuthHeadersAsync
 			}
 		}
 	};
 };
-//#endregion
-//#region src/middlewares/loggingMiddleware.ts
+// src/middlewares/loggingMiddleware.ts
 const CORRELATION_ID_HEADER = "X-Correlation-ID";
 const ALWAYS_REDACTED_HEADERS = [...CREDENTIAL_HEADERS, "set-cookie"];
 const ALWAYS_REDACTED_QUERY_PARAMS = /* @__PURE__ */ new Set([
@@ -2620,8 +1984,7 @@ const createLoggingMiddleware = (options = {}) => {
 		}
 	};
 };
-//#endregion
-//#region src/middlewares/retryMiddleware.ts
+// src/middlewares/retryMiddleware.ts
 const DEFAULT_MAX_RETRIES = 5;
 const DEFAULT_RETRYABLE_STATUSES = [
 	HttpStatus.INTERNAL_SERVER_ERROR,
@@ -2649,8 +2012,7 @@ const createRetryMiddleware = (options) => {
 		throw new Error("unreachable");
 	};
 };
-//#endregion
-//#region src/middlewares/uiVersionMiddleware.ts
+// src/middlewares/uiVersionMiddleware.ts
 /** Stamps `X-KBC-Ui-Version`; an empty `uiVersion` sends no header. */
 const createUiVersionMiddleware = (uiVersion) => {
 	if (!uiVersion) return (next) => next;
@@ -2659,8 +2021,7 @@ const createUiVersionMiddleware = (uiVersion) => {
 		return next(request);
 	};
 };
-//#endregion
-//#region src/domain/adminAccount.ts
+// src/domain/adminAccount.ts
 /**
 * The admin behind a Manage token: `GET /manage/tokens/verify`, with the admin-level helpers.
 *
@@ -2683,7 +2044,22 @@ const createAdminAccount = ({ managementToken }) => {
 		managementToken
 	};
 };
-//#endregion
-export { ApiError, HtmlResponseError, HttpContentType, HttpHeader, KeboolaError, KeboolaErrorType, KeboolaHttpHeader, ManagementClientAuthError, ManagementSessionMintError, QueryJobError, QueueJobError, Result, SESSION_STORAGE_KEY, ServiceUnavailableError, StorageJobError, SyncActionError, UserError, ValidationError, asError, assert, coalesce, collectByCursor, collectByOffset, concurrent, createAdminAccount, createDerivedAsyncStore, createDerivedStore, createEmitter, createGenericFetchClient, createKeboola, createLegacyKeboola, createLocalStorage, createLoggingMiddleware, createMemoryStorage, createNullStorage, createPersistor, createPollRegistry, createQueryServiceSdk, createRetryMiddleware, createSessionStorage, createStore, createUiVersionMiddleware, dedupe, deepMerge, delay, emitter, ensure, failureOf, formatValidationIssues, generateUUID, isAbortError, isApiError, isEmptyDeep, isFetchClientError, isHtmlResponseError, isKeboolaError, isManageError, isManagementClientAuthError, isManagementSessionMintError, isPlainObject, isQueryJobError, isQueueJobError, isStorageJobError, isStorageTokenMutatingRequest, isSyncActionError, isTimeoutError, isValidationError, jobStatus, keboolaUID, lazy, manageErrorCode, nextCursorOf, parseLogLines, parseOrThrow, poller, queueSeries, readableReason, retryAfterSeconds, schemaGuidedMerge, series, shallowEqual };
+// 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"
+	};
+};
+export { ApiError, HtmlResponseError, HttpContentType, HttpHeader, KeboolaError, KeboolaErrorType, KeboolaHttpHeader, ManagementClientAuthError, ManagementSessionMintError, QueryJobError, QueueJobError, Result, SESSION_STORAGE_KEY, ServiceUnavailableError, StorageJobError, SyncActionError, UserError, ValidationError, asError, assert, coalesce, collectByCursor, collectByOffset, concurrent, createAdminAccount, createDefaultBranch, createDerivedAsyncStore, createDerivedStore, createEmitter, createGenericFetchClient, createKeboola, createLegacyKeboola, createLocalStorage, createLoggingMiddleware, createMemoryStorage, createNullStorage, createPersistor, createPollRegistry, createProject, createQueryServiceSdk, createRetryMiddleware, createSessionStorage, createStore, createUiVersionMiddleware, dedupe, deepMerge, delay, emitter, ensure, failureOf, formatValidationIssues, generateUUID, isAbortError, isApiError, isEmptyDeep, isFetchClientError, isHtmlResponseError, isKeboolaError, isManageError, isManagementClientAuthError, isManagementSessionMintError, isPlainObject, isQueryJobError, isQueueJobError, isStorageJobError, isSyncActionError, isTimeoutError, isValidationError, jobStatus, keboolaUID, lazy, manageErrorCode, nextCursorOf, parseLogLines, parseOrThrow, poller, queueSeries, readableReason, retryAfterSeconds, schemaGuidedMerge, series, shallowEqual };
 
 //# sourceMappingURL=index.js.map