@cleocode/cleo 2026.9.7 → 2026.9.10

package/studio-dist/server/chunks/project-context-BAXQmgch.js

@@ -0,0 +1,188 @@
+import { g as getNexusDbPath, a as getTasksDbPath, b as getCleoProjectDir, w as withStudioProjectScope } from './cleo-home-_XIqkZaL.js';
+import { existsSync } from 'node:fs';
+import { dirname, join, basename } from 'node:path';
+import { getProjectInfoSync } from '@cleocode/core';
+import { openCleoDbSnapshot } from '@cleocode/core/store/open-cleo-db';
+
+//#region src/lib/server/project-context.ts
+/**
+* Project context resolution for CLEO Studio.
+*
+* The active project is stored as a cookie (`cleo_project_id`).
+* When a project is selected, the studio resolves the project's
+* consolidated project store from the global cleo.db registry,
+* injecting them into database connections for the page load.
+*
+* Task and brain tables share the project store. The cross-project registry
+* lives in the global store; legacy stored domain paths are not authoritative.
+*
+* @task T622
+*/
+/** Cookie name used to persist the active project selection. */
+var PROJECT_COOKIE = "cleo_project_id";
+/** How long the project context cookie lives (7 days). */
+var COOKIE_MAX_AGE = 3600 * 24 * 7;
+/**
+* Read the active project ID from the request cookie.
+* Returns null if no project is selected.
+*/
+function getActiveProjectId(cookies) {
+	return cookies.get("cleo_project_id") ?? null;
+}
+/**
+* Set the active project context cookie.
+*/
+function setActiveProjectId(cookies, projectId) {
+	cookies.set(PROJECT_COOKIE, projectId, {
+		path: "/",
+		maxAge: COOKIE_MAX_AGE,
+		httpOnly: false,
+		sameSite: "lax"
+	});
+}
+/**
+* Clear the active project context cookie.
+*/
+function clearActiveProjectId(cookies) {
+	cookies.delete(PROJECT_COOKIE, { path: "/" });
+}
+/**
+* Resolve project context from the consolidated global registry.
+*
+* Returns null if the project is not registered or the DB rows are missing.
+* Legacy domain-path columns are ignored; canonical paths derive from the selected root.
+* @param projectId - Stable registered project identity selected by the request.
+* @returns The selected project context, or null when the registry or row is absent.
+* @throws When an existing registry cannot be read; diagnostic failure is not absence.
+* @remarks Snapshot reads are read-only and do not apply journal pragmas or rewrite registry rows.
+* @example
+* ```ts
+* const context = resolveProjectContext(projectId);
+* ```
+*/
+function resolveProjectContext(projectId) {
+	const globalDbPath = getNexusDbPath();
+	if (!existsSync(globalDbPath)) return null;
+	const snap = openCleoDbSnapshot(globalDbPath, {
+		readOnly: true,
+		applyPragmas: false
+	});
+	try {
+		const row = snap.db.prepare("SELECT project_id, name, project_path FROM nexus_project_registry WHERE project_id = ?").get(projectId);
+		if (!row) return null;
+		const tasksDbPath = getTasksDbPath(row.project_path);
+		const brainDbPath = tasksDbPath;
+		return {
+			projectId: row.project_id,
+			name: row.name,
+			projectPath: row.project_path,
+			brainDbPath,
+			tasksDbPath,
+			brainDbExists: existsSync(brainDbPath),
+			tasksDbExists: existsSync(tasksDbPath)
+		};
+	} finally {
+		snap.close();
+	}
+}
+/**
+* Resolve the default project context (current project from CLEO_ROOT / cwd).
+* Used as fallback when no project cookie is set.
+* @returns Canonical modern-store paths and the available persisted identity.
+* @throws When existing identity metadata cannot be decoded.
+* @remarks Projects without metadata retain the legacy empty identity; this does not
+* assert that they are registered or have verified portable identity.
+* @example
+* ```ts
+* const context = resolveDefaultProjectContext();
+* ```
+*/
+function resolveDefaultProjectContext() {
+	const projectDir = getCleoProjectDir();
+	const projectPath = dirname(projectDir);
+	const tasksDbPath = getTasksDbPath();
+	const brainDbPath = tasksDbPath;
+	const info = withStudioProjectScope(projectPath, () => getProjectInfoSync(projectPath));
+	if (!info && existsSync(join(projectDir, "project-info.json"))) throw new Error(`Cannot read Studio project identity at ${projectDir}/project-info.json`);
+	return {
+		projectId: info?.projectId || info?.projectHash || "",
+		name: basename(projectPath) || "default",
+		projectPath,
+		brainDbPath,
+		tasksDbPath,
+		brainDbExists: existsSync(brainDbPath),
+		tasksDbExists: existsSync(tasksDbPath)
+	};
+}
+/**
+* List registered projects with canonical modern domain paths.
+* Returns an empty array when the global registry store is absent.
+* @returns Registry projects with current canonical store paths and recorded statistics.
+* @throws When an existing registry cannot be read; failures do not become an empty population.
+* @remarks Recorded statistics retain their existing freshness semantics. Path resolution
+* does not migrate data or claim that project graph contents live in the global registry.
+* @example
+* ```ts
+* const projects = listRegisteredProjects();
+* ```
+*/
+function listRegisteredProjects() {
+	const globalDbPath = getNexusDbPath();
+	if (!existsSync(globalDbPath)) return [];
+	const snap = openCleoDbSnapshot(globalDbPath, {
+		readOnly: true,
+		applyPragmas: false
+	});
+	try {
+		const rows = snap.db.prepare(`SELECT
+          project_id,
+          name,
+          project_path,
+          last_indexed,
+          task_count,
+          stats_json,
+          last_seen,
+          health_status
+        FROM nexus_project_registry
+        ORDER BY last_seen DESC`).all();
+		/**
+		* Strict server-side exclusion: any project whose path contains a `.temp/`
+		* segment is filtered out before reaching the client. This rule is
+		* non-negotiable (cannot be revealed via UI toggle) — `.temp/` is reserved
+		* for ephemeral fixture/scratch state that must never appear in the
+		* project switcher.
+		*/
+		const TEMP_PATH_PATTERN = /(^|\/)\.temp(\/|$)/;
+		return rows.filter((row) => !TEMP_PATH_PATTERN.test(row.project_path)).map((row) => {
+			let nodeCount = 0;
+			let relationCount = 0;
+			let fileCount = 0;
+			try {
+				const stats = JSON.parse(row.stats_json ?? "{}");
+				nodeCount = stats.nodeCount ?? 0;
+				relationCount = stats.relationCount ?? 0;
+				fileCount = stats.fileCount ?? 0;
+			} catch {}
+			const storePath = getTasksDbPath(row.project_path);
+			return {
+				projectId: row.project_id,
+				name: row.name,
+				projectPath: row.project_path,
+				brainDbPath: storePath,
+				tasksDbPath: storePath,
+				lastIndexed: row.last_indexed ?? null,
+				taskCount: row.task_count ?? 0,
+				nodeCount,
+				relationCount,
+				fileCount,
+				lastSeen: row.last_seen,
+				healthStatus: row.health_status
+			};
+		});
+	} finally {
+		snap.close();
+	}
+}
+
+export { resolveDefaultProjectContext as a, clearActiveProjectId as c, getActiveProjectId as g, listRegisteredProjects as l, resolveProjectContext as r, setActiveProjectId as s };
+//# sourceMappingURL=project-context-BAXQmgch.js.map

package/studio-dist/server/chunks/{src-BUqGet2c.js → src-D2rW9bIF.js}

@@ -1,9 +1,426 @@
-import { f as applyPerfPragmas } from './dual-scope-db-DKnWu1KM.js';
-import { h as getCleoHome, r as resolveProjectByCwd, i as resolveCanonicalCleoDir } from './paths-CV7S5-Zm.js';
-import { join, dirname } from 'node:path';
 import { createRequire } from 'node:module';
-import { existsSync } from 'node:fs';
+import { existsSync, readFileSync, realpathSync } from 'node:fs';
+import path, { join, dirname, resolve, isAbsolute } from 'node:path';
+import { applyPerfPragmas } from '@cleocode/core/store/sqlite-pragmas.js';
+import { execFileSync } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import os, { hostname, release, arch, platform, homedir } from 'node:os';
+import process$1 from 'node:process';
+import '@cleocode/core/db';
 
+function isSafeFilename(filename) {
+	if (typeof filename !== "string") return false;
+	const trimmed = filename.trim();
+	return trimmed !== "" && trimmed !== "." && trimmed !== ".." && !filename.includes("/") && !filename.includes("\\") && !filename.includes("\0");
+}
+function assertSafeFilename(filename) {
+	if (typeof filename !== "string") throw new TypeError("Expected a string");
+	if (!isSafeFilename(filename)) throw new Error(`Unsafe filename: ${JSON.stringify(filename)}`);
+}
+//#endregion
+//#region ../../node_modules/.pnpm/env-paths@4.0.0/node_modules/env-paths/index.js
+var homedir$1 = os.homedir();
+var tmpdir = os.tmpdir();
+var { env } = process$1;
+var macos = (name) => {
+	const library = path.join(homedir$1, "Library");
+	return {
+		data: path.join(library, "Application Support", name),
+		config: path.join(library, "Preferences", name),
+		cache: path.join(library, "Caches", name),
+		log: path.join(library, "Logs", name),
+		temp: path.join(tmpdir, name)
+	};
+};
+var windows = (name) => {
+	const appData = env.APPDATA || path.join(homedir$1, "AppData", "Roaming");
+	const localAppData = env.LOCALAPPDATA || path.join(homedir$1, "AppData", "Local");
+	return {
+		data: path.join(localAppData, name, "Data"),
+		config: path.join(appData, name, "Config"),
+		cache: path.join(localAppData, name, "Cache"),
+		log: path.join(localAppData, name, "Log"),
+		temp: path.join(tmpdir, name)
+	};
+};
+var linux = (name) => {
+	const username = path.basename(homedir$1);
+	return {
+		data: path.join(env.XDG_DATA_HOME || path.join(homedir$1, ".local", "share"), name),
+		config: path.join(env.XDG_CONFIG_HOME || path.join(homedir$1, ".config"), name),
+		cache: path.join(env.XDG_CACHE_HOME || path.join(homedir$1, ".cache"), name),
+		log: path.join(env.XDG_STATE_HOME || path.join(homedir$1, ".local", "state"), name),
+		temp: path.join(tmpdir, username, name)
+	};
+};
+function envPaths(name, { suffix = "nodejs" } = {}) {
+	assertSafeFilename(name);
+	if (suffix) name += `-${suffix}`;
+	assertSafeFilename(name);
+	if (process$1.platform === "darwin") return macos(name);
+	if (process$1.platform === "win32") return windows(name);
+	return linux(name);
+}
+//#endregion
+//#region ../paths/dist/platform-paths.js
+/**
+* OS platform-path resolver factory backed by `env-paths`.
+*
+* The factory is parameterised by `appName` + `homeEnvVar` so a single
+* implementation serves every CLEO package that needs XDG-compliant
+* paths — `cleo`, `agents` (CAAMP), or any future tool — without each
+* package re-implementing the same env-paths wrapper, the same tilde
+* expansion, and the same SystemInfo cache.
+*
+* `getPlatformPaths()` reads fresh on every call: env-paths is microsecond-fast
+* and a process-wide cache would mask XDG / APPDATA env-var changes that test
+* code legitimately makes. `getSystemInfo()` IS cached because hostname /
+* platform / arch don't change during a process lifetime.
+*
+* @packageDocumentation
+* @task T1883
+*/
+/**
+* Normalize a home-override env var value to an absolute path.
+*
+* Returns `undefined` for absent / blank values so callers fall back to the
+* env-paths default. Accepts `~`, `~/foo`, absolute paths, and relative paths
+* (which are resolved against `homedir()`).
+*
+* @internal
+*/
+function resolveHomeOverride(value) {
+	if (value === void 0) return void 0;
+	const trimmed = value.trim();
+	if (trimmed.length === 0) return void 0;
+	if (trimmed === "~") return homedir();
+	if (trimmed.startsWith("~/")) return join(homedir(), trimmed.slice(2));
+	if (isAbsolute(trimmed)) return trimmed;
+	return join(homedir(), trimmed);
+}
+/**
+* Create a platform-paths resolver bound to a specific app name and home env var.
+*
+* Returns a resolver with its own internal `SystemInfo` cache. Path reads are
+* always fresh (env-paths is fast); only system info is cached.
+*
+* @param appName - The application name passed to `env-paths` (e.g. `"cleo"`,
+*   `"agents"`).
+* @param homeEnvVar - The env var name that overrides the data directory
+*   (e.g. `"CLEO_HOME"`, `"AGENTS_HOME"`). Tilde-prefixed and relative
+*   values are resolved against `homedir()`.
+*
+* @example
+* ```typescript
+* const cleo = createPlatformPathsResolver('cleo', 'CLEO_HOME');
+* cleo.getPlatformPaths().data; // → "/home/user/.local/share/cleo"  (Linux, no override)
+* ```
+*
+* @public
+*/
+function createPlatformPathsResolver(appName, homeEnvVar, configEnvVar) {
+	let cachedSysInfo = null;
+	function readPlatformPaths() {
+		const ep = envPaths(appName, { suffix: "" });
+		const dataOverride = resolveHomeOverride(process.env[homeEnvVar]);
+		const configOverride = resolveHomeOverride(process.env[configEnvVar]) ;
+		return {
+			data: dataOverride ?? ep.data,
+			config: configOverride ?? ep.config,
+			cache: ep.cache,
+			log: ep.log,
+			temp: ep.temp
+		};
+	}
+	return {
+		getPlatformPaths: readPlatformPaths,
+		getSystemInfo() {
+			if (cachedSysInfo) return cachedSysInfo;
+			cachedSysInfo = {
+				platform: platform(),
+				arch: arch(),
+				release: release(),
+				hostname: hostname(),
+				nodeVersion: process.version,
+				paths: readPlatformPaths()
+			};
+			return cachedSysInfo;
+		},
+		resetCache() {
+			cachedSysInfo = null;
+		}
+	};
+}
+//#endregion
+//#region ../paths/dist/cleo-paths.js
+/**
+* CLEO-bound platform path helpers.
+*
+* Pre-binds {@link createPlatformPathsResolver} to `(appName='cleo', homeEnvVar='CLEO_HOME')`
+* and exposes the cleo-specific helpers every other CLEO package needs:
+* `getCleoHome`, `getCleoPlatformPaths`, `getCleoSystemInfo`, and
+* `getCleoTemplatesTildePath`.
+*
+* @task T1883
+*/
+/**
+* Returns the `node:sqlite` `DatabaseSync` constructor, loaded on first use.
+*
+* Loaded via `createRequire` so that importing this module does not eagerly pull
+* in `node:sqlite` — preserving the lazy-init invariant (T1331/T11280).
+*
+* @internal
+*/
+function getDatabaseSyncCtor() {
+	return createRequire(import.meta.url)("node:sqlite").DatabaseSync;
+}
+var cleoResolver = createPlatformPathsResolver("cleo", "CLEO_HOME", "CLEO_CONFIG_HOME");
+/**
+* Get the absolute path to CLEO's global data directory.
+*
+* Equivalent to `getCleoPlatformPaths().data` — exposed as a stable named
+* helper because `getCleoHome()` is the most common consumer call.
+*
+* @public
+*/
+function getCleoHome() {
+	return cleoResolver.getPlatformPaths().data;
+}
+/**
+* Synchronously find the git root for a given directory.
+* Returns `null` if the directory is not inside a git repo.
+*/
+function _findGitRootSync(fromPath) {
+	try {
+		return resolve(execFileSync("git", ["rev-parse", "--show-toplevel"], {
+			cwd: resolve(fromPath),
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim());
+	} catch {
+		return null;
+	}
+}
+/**
+* Synchronously find the primary git remote URL (origin fetch URL).
+* Returns `null` when there are no remotes or git is unavailable.
+*/
+function _findGitRemoteUrlSync(fromPath) {
+	try {
+		return execFileSync("git", [
+			"remote",
+			"get-url",
+			"origin"
+		], {
+			cwd: resolve(fromPath),
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim() || null;
+	} catch {
+		return null;
+	}
+}
+/**
+* Read the project name from `.cleo/project-info.json` (if present).
+* Non-fatal on any I/O or parse error.
+*/
+function _readProjectInfoName(repoRoot) {
+	try {
+		const raw = readFileSync(join(repoRoot, ".cleo", "project-info.json"), "utf-8");
+		const parsed = JSON.parse(raw);
+		return typeof parsed.name === "string" ? parsed.name : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Canonicalize a filesystem path across operating systems — resolve symlinks
+* and mount/alias divergence (macOS `/var` → `/private/var`, Windows
+* drive-letter case + 8.3 short names, Linux bind-mounts) via
+* {@link realpathSync}.
+*
+* Falls back to the lexically-resolved absolute path when the target does not
+* exist on disk, so identity/root computations never throw for a moved,
+* deleted, or not-yet-created project path.
+*
+* **SSoT:** this is the single path-canonicalization entry point for the CLEO
+* SDK. Never call `realpathSync` ad-hoc for path identity — route through here
+* so the OS-specific normalization stays consistent across every consumer and
+* test (notably the macOS `/var` vs `/private/var` split).
+*
+* @param p - A relative or absolute filesystem path.
+* @returns The realpath-canonicalized absolute path, or the lexically-resolved
+*   absolute path when the target does not exist.
+*
+* @public
+* @task T11023
+*/
+function canonicalizePath(p) {
+	const resolved = resolve(p);
+	try {
+		return realpathSync(resolved);
+	} catch {
+		return resolved;
+	}
+}
+/**
+* Compute the canonical project ID for a given repository path (T9149/T11023).
+*
+* Algorithm:
+*   1. Resolve `repoPath` to its `realpath` (resolves symlinks, normalises mounts).
+*   2. Detect the git root via `git rev-parse --show-toplevel` (falls back to realpath).
+*   3. Read `.cleo/project-info.json` name (optional).
+*   4. Read `git remote get-url origin` (optional).
+*   5. SHA-256 of `<gitRoot>|<projectName>|<remoteUrl>`, first 12 hex chars.
+*
+* This ensures `/mnt/projects/X` and `/workspace/X` (same git root,
+* same remote) produce the same ID.
+*
+* @param repoPath - Absolute path to the project root.
+* @returns The 12-hex-char canonical project ID.
+*
+* @task T11023
+* @task T9149
+*/
+function computeCanonicalProjectId(repoPath) {
+	const realRepoPath = canonicalizePath(repoPath);
+	const gitRoot = _findGitRootSync(realRepoPath);
+	const effectiveRoot = gitRoot ?? realRepoPath;
+	const remoteUrl = gitRoot ? _findGitRemoteUrlSync(gitRoot) : null;
+	const fingerprint = [
+		effectiveRoot,
+		_readProjectInfoName(effectiveRoot) ?? "",
+		remoteUrl ?? ""
+	].join("|");
+	return createHash("sha256").update(fingerprint).digest("hex").substring(0, 12);
+}
+/**
+* Walk up from `cwd` (or `process.cwd()`) looking for `.cleo/project-info.json`
+* and return the project identity if found.
+*
+* The project-info file acts as the local sentinel and supplies `legacyUUID`.
+* The returned `projectId` is the derived canonical runtime ID, not the raw
+* project-local UUID stored in the file.
+*
+* **Cross-mount divergence (T11023):** Uses `realpathSync` to normalize
+* bind-mounts and symlinks so the same repo at `/mnt/projects/X` and
+* `/workspace/X` resolves to the same `projectRoot`. The `projectId` is
+* the T9149 canonical 12-hex-char SHA-256 fingerprint of git-root + name
+* + remote URL, which is also mount-invariant.
+*
+* @param cwd - Optional working directory to start the ancestor walk from.
+*   Defaults to `process.cwd()`.
+* @returns The resolved project identity, or `null` if no CLEO project is
+*   found anywhere in the ancestor chain.
+*
+* @example
+* ```typescript
+* const project = resolveProjectByCwd('/repo/packages/core');
+* // { projectId: 'a1b2c3d4e5f6', projectRoot: '/repo' }
+*
+* const notFound = resolveProjectByCwd('/tmp/empty');
+* // null
+* ```
+*
+* @public
+* @task T11008
+* @task T11023
+*/
+function resolveProjectByCwd(cwd) {
+	let current = resolve(process.cwd());
+	while (true) {
+		const infoPath = join(current, ".cleo", "project-info.json");
+		if (existsSync(infoPath)) try {
+			const raw = readFileSync(infoPath, "utf-8");
+			const data = JSON.parse(raw);
+			if (typeof data.projectId === "string" && data.projectId.length > 0) {
+				const realRoot = canonicalizePath(current);
+				return {
+					projectId: computeCanonicalProjectId(realRoot),
+					projectRoot: realRoot,
+					legacyUUID: data.projectId
+				};
+			}
+		} catch {}
+		const parent = dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return null;
+}
+/**
+* Resolve the canonical `.cleo` directory for a project given its `projectId`.
+*
+* Looks up the project in the consolidated GLOBAL `cleo.db` registry
+* (`nexus_project_registry` table) to find the project's root path, then returns
+* the `.cleo/` directory under that root.
+*
+* **Post-E6 consolidation (T11569):** The cross-project registry moved from the
+* standalone `<cleoHome>/nexus.db` into the consolidated dual-scope
+* `<cleoHome>/cleo.db` (SG-DB-SUBSTRATE-V2 · E6-L4, T11524). On a fresh post-E6
+* install `nexus.db` is never created, so opening it here returned `null` and
+* the core wrapper threw `E_PROJECT_NOT_FOUND` even for registered projects (the
+* read path had diverged from the write path — same class as #909/T11562). This
+* resolver opens `cleo.db`.
+*
+* **COMPLETE-CUTOVER (T11578 · AC3):** The live runtime registry table is now the
+* PREFIXED consolidated `nexus_project_registry` (the consolidated cleo-global
+* migration owns it; the bare `project_registry` runtime shape is retired). The
+* runtime writers and this read path both target the prefixed table — the read
+* path no longer diverges from the write path.
+*
+* **Legacy ID support (T11023 AC4):** If the `projectId` is not found in
+* `nexus_project_registry`, also checks the `nexus_project_id_aliases` table for a
+* legacy→canonical mapping before returning `null`. The path-derived canonical
+* 12-hex id is recorded as an alias of the immutable registry id (T11281), so a
+* canonical id supplied by `resolveProjectByCwd` resolves through this fallback.
+*
+* This enables cross-project lookups: given a stable project ID, resolve where
+* that project lives on disk without walking from a working directory.
+*
+* @param projectId - The project ID to look up. Can be a canonical 12-hex-char
+*   ID, a legacy UUID, or a legacy base64url(path) ID.
+* @returns Absolute path to the `.cleo/` directory, or `null` if the
+*   projectId is not found in the consolidated registry (or its alias table).
+*
+* @task T11008
+* @task T11023
+* @task T11569
+*/
+function resolveCanonicalCleoDir(projectId) {
+	const globalDbPath = join(getCleoHome(), "cleo.db");
+	if (!existsSync(globalDbPath)) return null;
+	let db;
+	try {
+		db = new (getDatabaseSyncCtor())(globalDbPath, { readOnly: true });
+		const directStmt = db.prepare("SELECT project_path FROM nexus_project_registry WHERE project_id = ? LIMIT 1");
+		const directRow = directStmt.get(projectId);
+		if (directRow && typeof directRow.project_path === "string" && directRow.project_path.length > 0) return join(directRow.project_path, ".cleo");
+		try {
+			const aliasRow = db.prepare("SELECT canonical_id FROM nexus_project_id_aliases WHERE legacy_id = ? LIMIT 1").get(projectId);
+			if (aliasRow && typeof aliasRow.canonical_id === "string" && aliasRow.canonical_id.length > 0) {
+				const canonicalRow = directStmt.get(aliasRow.canonical_id);
+				if (canonicalRow && typeof canonicalRow.project_path === "string" && canonicalRow.project_path.length > 0) return join(canonicalRow.project_path, ".cleo");
+			}
+		} catch {}
+		return null;
+	} catch {
+		return null;
+	} finally {
+		try {
+			db?.close();
+		} catch {}
+	}
+}
+//#endregion
 //#region ../brain/dist/src/cleo-home.js
 /**
 * CLEO home + project DB path resolution for `@cleocode/brain`.
@@ -1058,4 +1475,4 @@ function getAllSubstrates(options = {}) {
 }
 
 export { getAgentRegistryDb as a, getNexusDb as b, getConduitDb as c, getTasksDb as d, getBrainDb as e, getAllSubstrates as g };
-//# sourceMappingURL=src-BUqGet2c.js.map
+//# sourceMappingURL=src-D2rW9bIF.js.map

package/studio-dist/server/chunks/{stores-5DmdjPCH.js → stores-BZdYTyl7.js}

@@ -1,6 +1,6 @@
-import { h as getContext } from './dev-BNpEUZI3.js';
+import { g as getContext } from './dev-Br5zieNA.js';
 import 'node:module';
-import './client-CgX38JBu.js';
+import './client-D71MZ7Vi.js';
 
 //#region ../../node_modules/.pnpm/@sveltejs+kit@2.57.1_@opentelemetry+api@1.9.0_@sveltejs+vite-plugin-svelte@5.1.1_svelte_e94e6db60b0c5f7146157d0facbe8042/node_modules/@sveltejs/kit/src/runtime/app/stores.js
 /**
@@ -30,4 +30,4 @@ var page = { subscribe(fn) {
 } };
 
 export { page as p };
-//# sourceMappingURL=stores-5DmdjPCH.js.map
+//# sourceMappingURL=stores-BZdYTyl7.js.map