syncorejs 0.1.0 → 0.2.0

package/dist/_vendor/cli/project.mjs

@@ -0,0 +1,583 @@
+import { mkdir, mkdtemp, readFile, readdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { VALID_SYNCORE_TEMPLATES, detectProjectTemplate, fileExists, importJsonlIntoProject, isLocalPortInUse, loadProjectConfig, loadProjectFunctions, loadProjectSchema, resolvePortFromEnv, resolveProjectTargetConfig, runCodegen } from "../core/cli.mjs";
+import os from "node:os";
+import { pathToFileURL } from "node:url";
+import AdmZip from "adm-zip";
+import { createPublicRuntimeId, createPublicTargetId } from "../devtools-protocol/index.js";
+import { NodeSqliteDriver, createManagedNodeSyncoreClient } from "../platform-node/index.mjs";
+import WebSocket from "ws";
+//#region src/project.ts
+const PROJECT_TARGET_CAPABILITIES = [
+	"run",
+	"readData",
+	"writeData",
+	"exportData"
+];
+const CLIENT_TARGET_CAPABILITIES = [
+	"run",
+	"readData",
+	"writeData",
+	"exportData",
+	"streamLogs"
+];
+function createPublicRuntimeId$1(runtimeId, runtimeIds) {
+	return createPublicRuntimeId(runtimeId, runtimeIds);
+}
+function getClientRuntimeLabel(input) {
+	return input.sessionLabel ?? input.appName ?? input.platform;
+}
+function buildRuntimeLookup(targets) {
+	const lookup = /* @__PURE__ */ new Map();
+	for (const target of targets) {
+		if (target.kind !== "client") continue;
+		for (const runtime of target.runtimes) lookup.set(runtime.runtimeId, {
+			...runtime,
+			targetId: target.id,
+			targetLabel: target.label
+		});
+	}
+	return lookup;
+}
+async function resolveProjectPaths(cwd) {
+	if (!await fileExists(path.join(cwd, "syncore.config.ts"))) return null;
+	const projectTarget = resolveProjectTargetConfig(await loadProjectConfig(cwd));
+	if (!projectTarget) return null;
+	return {
+		databasePath: path.resolve(cwd, projectTarget.databasePath),
+		storageDirectory: path.resolve(cwd, projectTarget.storageDirectory)
+	};
+}
+async function requireProjectPaths(cwd) {
+	const paths = await resolveProjectPaths(cwd);
+	if (!paths) throw new Error("This Syncore project does not define a projectTarget. Use a connected client target instead.");
+	return paths;
+}
+async function resolveProjectTargetDescriptor(cwd) {
+	const paths = await resolveProjectPaths(cwd);
+	if (!paths) return null;
+	return {
+		id: "project",
+		kind: "project",
+		label: `project (${path.basename(paths.databasePath)})`,
+		databasePath: paths.databasePath,
+		storageDirectory: paths.storageDirectory,
+		online: true,
+		capabilities: [...PROJECT_TARGET_CAPABILITIES]
+	};
+}
+async function createManagedProjectClient(cwd) {
+	const [paths, schema, functions] = await Promise.all([
+		requireProjectPaths(cwd),
+		loadProjectSchema(cwd),
+		loadRuntimeProjectFunctions(cwd)
+	]);
+	return await createManagedNodeSyncoreClient({
+		databasePath: paths.databasePath,
+		storageDirectory: paths.storageDirectory,
+		schema,
+		functions,
+		devtools: false,
+		platform: "cli"
+	});
+}
+async function resolveProjectFunction(cwd, requestedName) {
+	const functions = await loadRuntimeProjectFunctions(cwd);
+	const normalizedName = normalizeFunctionName(requestedName, functions);
+	const definition = functions[normalizedName];
+	if (!definition) {
+		const available = Object.keys(functions).sort((left, right) => left.localeCompare(right));
+		const suggestions = suggestFunctionNames(requestedName, available);
+		throw new Error(`Unknown function ${JSON.stringify(requestedName)}.${suggestions.length > 0 ? ` Did you mean: ${suggestions.join(", ")}?` : ""} Available functions: ${available.join(", ")}`);
+	}
+	return {
+		name: normalizedName,
+		definition,
+		reference: {
+			kind: definition.kind,
+			name: normalizedName
+		}
+	};
+}
+function suggestFunctionNames(requestedName, available) {
+	const normalized = requestedName.trim().replace(/^api\./, "").replaceAll(".", "/").replaceAll(":", "/").toLowerCase();
+	return available.map((name) => ({
+		name,
+		score: (name.toLowerCase() === normalized ? 100 : 0) + (name.toLowerCase().startsWith(normalized) ? 30 : 0) + (name.toLowerCase().includes(normalized) ? 20 : 0) + sharedSegmentsScore(normalized, name.toLowerCase())
+	})).filter((entry) => entry.score > 0).sort((left, right) => right.score - left.score || left.name.localeCompare(right.name)).slice(0, 5).map((entry) => entry.name);
+}
+function sharedSegmentsScore(left, right) {
+	const leftSegments = left.split("/").filter(Boolean);
+	const rightSegments = right.split("/").filter(Boolean);
+	let score = 0;
+	for (const segment of leftSegments) if (rightSegments.includes(segment)) score += 10;
+	return score;
+}
+function normalizeFunctionName(requestedName, functions) {
+	const trimmed = requestedName.trim();
+	const candidates = [
+		trimmed,
+		trimmed.replace(/^api\./, "").replaceAll(".", "/"),
+		trimmed.replace(/^api\./, "").replaceAll(".", "/").replaceAll(":", "/"),
+		trimmed.replaceAll(":", "/"),
+		trimmed.replaceAll(".", "/")
+	];
+	for (const candidate of candidates) if (functions[candidate]) return candidate;
+	return trimmed.replace(/^api\./, "").replaceAll(".", "/").replaceAll(":", "/");
+}
+async function listProjectTables(cwd) {
+	const [paths, schema] = await Promise.all([requireProjectPaths(cwd), loadProjectSchema(cwd)]);
+	await mkdir(path.dirname(paths.databasePath), { recursive: true });
+	const driver = new NodeSqliteDriver(paths.databasePath);
+	try {
+		const results = [];
+		for (const tableName of schema.tableNames()) {
+			const row = await driver.get(`SELECT COUNT(*) AS count FROM ${quoteIdentifier(tableName)}`);
+			results.push({
+				name: tableName,
+				documentCount: Number(row?.count ?? 0)
+			});
+		}
+		return results;
+	} finally {
+		await driver.close();
+	}
+}
+async function readProjectTable(cwd, tableName, options) {
+	const driver = new NodeSqliteDriver((await requireProjectPaths(cwd)).databasePath);
+	try {
+		return {
+			table: tableName,
+			rows: (await driver.all(`SELECT _id, _creationTime, _json FROM ${quoteIdentifier(tableName)} ORDER BY _creationTime ${options.order.toUpperCase()} LIMIT ?`, [options.limit])).map((row) => ({
+				_id: row._id,
+				_creationTime: row._creationTime,
+				...JSON.parse(row._json)
+			}))
+		};
+	} finally {
+		await driver.close();
+	}
+}
+async function exportProjectData(cwd, outputPath, options = {}) {
+	const resolvedOutput = path.resolve(cwd, outputPath);
+	const tables = options.table ? [options.table] : (await listProjectTables(cwd)).map((table) => table.name);
+	if (tables.length === 0) throw new Error("No tables are available to export.");
+	return await writeExportData(resolvedOutput, await Promise.all(tables.map(async (table) => ({
+		table,
+		rows: (await readProjectTable(cwd, table, {
+			limit: Number.MAX_SAFE_INTEGER,
+			order: "asc"
+		})).rows
+	}))));
+}
+async function writeExportData(resolvedOutput, payloads) {
+	const tables = payloads.map((payload) => payload.table);
+	if (tables.length === 0) throw new Error("No tables are available to export.");
+	const extension = path.extname(resolvedOutput).toLowerCase();
+	if (extension === ".json" || extension === ".jsonl") {
+		if (tables.length !== 1) throw new Error(`Single-file exports require --table. Available tables: ${tables.join(", ")}`);
+		const payload = payloads[0];
+		await mkdir(path.dirname(resolvedOutput), { recursive: true });
+		await writeFile(resolvedOutput, extension === ".json" ? `${JSON.stringify(payload.rows, null, 2)}\n` : `${payload.rows.map((row) => JSON.stringify(row)).join("\n")}\n`);
+		return {
+			path: resolvedOutput,
+			tables: [payload.table],
+			format: extension === ".json" ? "json" : "jsonl"
+		};
+	}
+	if (extension === ".zip") {
+		const zip = new AdmZip();
+		for (const payload of payloads) zip.addFile(`${payload.table}.jsonl`, Buffer.from(`${payload.rows.map((row) => JSON.stringify(row)).join("\n")}\n`));
+		await mkdir(path.dirname(resolvedOutput), { recursive: true });
+		zip.writeZip(resolvedOutput);
+		return {
+			path: resolvedOutput,
+			tables,
+			format: "zip"
+		};
+	}
+	await mkdir(resolvedOutput, { recursive: true });
+	for (const payload of payloads) await writeFile(path.join(resolvedOutput, `${payload.table}.jsonl`), `${payload.rows.map((row) => JSON.stringify(row)).join("\n")}\n`);
+	return {
+		path: resolvedOutput,
+		tables,
+		format: "directory"
+	};
+}
+async function importProjectData(cwd, sourcePath, options = {}) {
+	const resolvedSource = path.resolve(cwd, sourcePath);
+	const extension = path.extname(resolvedSource).toLowerCase();
+	const cleanupDirectories = [];
+	try {
+		const sources = extension === ".zip" ? await extractImportSourcesFromZip(resolvedSource, cleanupDirectories) : await resolveImportSources(resolvedSource, options.table, cleanupDirectories);
+		const imported = [];
+		for (const source of sources) {
+			const importedCount = await importJsonlIntoProject(cwd, source.table, source.filePath);
+			imported.push({
+				table: source.table,
+				importedCount
+			});
+		}
+		return imported;
+	} finally {
+		for (const directory of cleanupDirectories) await rm(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function loadImportDocumentBatches(cwd, sourcePath, options = {}) {
+	const resolvedSource = path.resolve(cwd, sourcePath);
+	const extension = path.extname(resolvedSource).toLowerCase();
+	const cleanupDirectories = [];
+	try {
+		const sources = extension === ".zip" ? await extractImportSourcesFromZip(resolvedSource, cleanupDirectories) : await resolveImportSources(resolvedSource, options.table, cleanupDirectories);
+		return await Promise.all(sources.map(async (source) => ({
+			table: source.table,
+			rows: await readJsonlRows(source.filePath)
+		})));
+	} finally {
+		for (const directory of cleanupDirectories) await rm(directory, {
+			recursive: true,
+			force: true
+		});
+	}
+}
+async function findWorkspaceSyncoreProjects(cwd) {
+	const packageJsonPath = path.join(cwd, "package.json");
+	if (!await fileExists(packageJsonPath)) return [];
+	let workspaces = [];
+	try {
+		workspaces = JSON.parse(await readFile(packageJsonPath, "utf8")).workspaces ?? [];
+	} catch {
+		return [];
+	}
+	const directories = /* @__PURE__ */ new Set();
+	for (const workspace of workspaces) {
+		const prefix = workspace.replace(/\/\*+$/, "");
+		const fullPrefix = path.join(cwd, prefix);
+		if (!await fileExists(fullPrefix)) continue;
+		const entries = await readdir(fullPrefix, { withFileTypes: true });
+		for (const entry of entries) if (entry.isDirectory()) directories.add(path.join(fullPrefix, entry.name));
+	}
+	const matches = [];
+	for (const directory of directories) {
+		if (!await fileExists(path.join(directory, "syncore.config.ts"))) continue;
+		matches.push({
+			path: directory,
+			relativePath: path.relative(cwd, directory).replaceAll("\\", "/"),
+			template: await detectProjectTemplate(directory)
+		});
+	}
+	return matches.sort((left, right) => left.relativePath.localeCompare(right.relativePath));
+}
+async function resolveDocsTarget(cwd) {
+	const template = await detectProjectTemplate(cwd);
+	const docsFile = template === "react-web" ? path.join("docs", "quickstarts", "react-web.md") : template === "next" ? path.join("docs", "quickstarts", "next-pwa.md") : template === "expo" ? path.join("docs", "quickstarts", "expo.md") : template === "electron" ? path.join("docs", "quickstarts", "electron.md") : template === "node" ? path.join("docs", "quickstarts", "node-script.md") : path.join("README.md");
+	return pathToFileURL(path.resolve(import.meta.dirname, "..", "..", "..", docsFile)).href;
+}
+function resolveDashboardUrl() {
+	return `http://localhost:${resolvePortFromEnv("SYNCORE_DASHBOARD_PORT", 4310)}`;
+}
+function resolveDevtoolsUrl() {
+	return `ws://127.0.0.1:${resolvePortFromEnv("SYNCORE_DEVTOOLS_PORT", 4311)}`;
+}
+async function listConnectedClientTargets(devtoolsUrl = resolveDevtoolsUrl()) {
+	const port = Number.parseInt(new URL(devtoolsUrl).port, 10);
+	if (!Number.isFinite(port) || !await isLocalPortInUse(port)) return [];
+	let hub;
+	try {
+		hub = await connectToDevtoolsHub(devtoolsUrl);
+	} catch {
+		return [];
+	}
+	try {
+		return buildClientTargets((await hub.collectSnapshot()).hellos);
+	} finally {
+		await hub.dispose();
+	}
+}
+async function listAvailableTargets(cwd) {
+	const [projectTarget, clientTargets] = await Promise.all([resolveProjectTargetDescriptor(cwd), listConnectedClientTargets()]);
+	return [...projectTarget ? [projectTarget] : [], ...clientTargets];
+}
+async function connectToProjectHub(devtoolsUrl = resolveDevtoolsUrl()) {
+	const port = Number.parseInt(new URL(devtoolsUrl).port, 10);
+	if (!Number.isFinite(port) || !await isLocalPortInUse(port)) return null;
+	try {
+		return await connectToDevtoolsHub(devtoolsUrl);
+	} catch {
+		return null;
+	}
+}
+function isKnownTemplate(value) {
+	return VALID_SYNCORE_TEMPLATES.includes(value);
+}
+async function loadRuntimeProjectFunctions(cwd) {
+	try {
+		return await loadProjectFunctions(cwd);
+	} catch (error) {
+		if (!await fileExists(path.join(cwd, "syncore", "functions"))) throw error;
+		await runCodegen(cwd);
+		return await loadProjectFunctions(cwd);
+	}
+}
+function quoteIdentifier(value) {
+	return `"${value.replaceAll("\"", "\"\"")}"`;
+}
+async function resolveImportSources(sourcePath, explicitTable, cleanupDirectories) {
+	const extension = path.extname(sourcePath).toLowerCase();
+	if (extension === ".jsonl") {
+		if (!explicitTable) throw new Error("`syncorejs import` requires --table when importing a .jsonl file.");
+		return [{
+			table: explicitTable,
+			filePath: sourcePath
+		}];
+	}
+	if (extension === ".json") {
+		if (!explicitTable) throw new Error("`syncorejs import` requires --table when importing a .json file.");
+		const rows = JSON.parse(await readFile(sourcePath, "utf8"));
+		if (!Array.isArray(rows)) throw new Error(`${sourcePath} must contain a JSON array.`);
+		const { directory, filePath } = await writeRowsToTempJsonl(rows);
+		cleanupDirectories.push(directory);
+		return [{
+			table: explicitTable,
+			filePath
+		}];
+	}
+	if (await isDirectory(sourcePath)) {
+		const entries = await readdir(sourcePath, { withFileTypes: true });
+		const sources = [];
+		for (const entry of entries) {
+			const fullPath = path.join(sourcePath, entry.name);
+			if (entry.isFile() && entry.name.endsWith(".jsonl")) sources.push({
+				table: entry.name.replace(/\.jsonl$/i, ""),
+				filePath: fullPath
+			});
+			if (entry.isDirectory()) {
+				const nestedPath = path.join(fullPath, "documents.jsonl");
+				if (await fileExists(nestedPath)) sources.push({
+					table: entry.name,
+					filePath: nestedPath
+				});
+			}
+		}
+		if (sources.length === 0) throw new Error(`No importable JSONL files were found in ${sourcePath}.`);
+		return sources.sort((left, right) => left.table.localeCompare(right.table));
+	}
+	throw new Error(`Unsupported import source: ${sourcePath}`);
+}
+async function extractImportSourcesFromZip(sourcePath, cleanupDirectories) {
+	const tempDirectory = await mkdtemp(path.join(os.tmpdir(), "syncore-cli-import-"));
+	cleanupDirectories.push(tempDirectory);
+	new AdmZip(sourcePath).extractAllTo(tempDirectory, true);
+	return await resolveImportSources(tempDirectory, void 0, cleanupDirectories);
+}
+async function writeRowsToTempJsonl(rows) {
+	const tempDirectory = await mkdtemp(path.join(os.tmpdir(), "syncore-cli-json-"));
+	const tempFile = path.join(tempDirectory, "rows.jsonl");
+	await writeFile(tempFile, `${rows.map((row) => JSON.stringify(row)).join("\n")}\n`);
+	return {
+		directory: tempDirectory,
+		filePath: tempFile
+	};
+}
+async function readJsonlRows(filePath) {
+	const source = await readFile(filePath, "utf8");
+	const rows = [];
+	let lineNumber = 0;
+	for (const line of source.split(/\r?\n/)) {
+		const trimmed = line.trim();
+		if (!trimmed) continue;
+		lineNumber += 1;
+		const parsed = JSON.parse(trimmed);
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Line ${lineNumber} of ${filePath} must contain a JSON object.`);
+		rows.push(parsed);
+	}
+	return rows;
+}
+async function isDirectory(filePath) {
+	try {
+		const entries = await readdir(filePath);
+		return Array.isArray(entries);
+	} catch {
+		return false;
+	}
+}
+async function connectToDevtoolsHub(url) {
+	const socket = new WebSocket(url);
+	socket.on("error", () => {});
+	const hellos = /* @__PURE__ */ new Map();
+	const events = [];
+	const eventListeners = /* @__PURE__ */ new Set();
+	const commandResolvers = /* @__PURE__ */ new Map();
+	const subscriptionHandlers = /* @__PURE__ */ new Map();
+	await new Promise((resolve, reject) => {
+		socket.once("open", () => resolve());
+		socket.once("error", (error) => reject(error));
+	});
+	socket.on("message", (rawPayload) => {
+		const payload = typeof rawPayload === "string" ? rawPayload : rawPayload instanceof Buffer ? rawPayload.toString("utf8") : Array.isArray(rawPayload) ? Buffer.concat(rawPayload).toString("utf8") : rawPayload instanceof ArrayBuffer ? Buffer.from(rawPayload).toString("utf8") : Buffer.from(rawPayload.buffer, rawPayload.byteOffset, rawPayload.byteLength).toString("utf8");
+		if (payload.length === 0) return;
+		const message = JSON.parse(payload);
+		if (message.type === "hello") {
+			hellos.set(message.runtimeId, message);
+			return;
+		}
+		if (message.type === "event") {
+			events.unshift(message.event);
+			events.splice(200);
+			if (message.event.type === "runtime.disconnected") hellos.delete(message.event.runtimeId);
+			for (const listener of eventListeners) listener(message.event);
+			return;
+		}
+		if (message.type === "command.result") {
+			const resolver = commandResolvers.get(message.commandId);
+			if (!resolver) return;
+			commandResolvers.delete(message.commandId);
+			resolver.resolve(message.payload);
+			return;
+		}
+		if (message.type === "subscription.data") {
+			subscriptionHandlers.get(message.subscriptionId)?.onData(message.payload);
+			return;
+		}
+		if (message.type === "subscription.error") subscriptionHandlers.get(message.subscriptionId)?.onError?.(message.error);
+	});
+	const dispose = async () => {
+		for (const [commandId, resolver] of commandResolvers) {
+			commandResolvers.delete(commandId);
+			resolver.reject(/* @__PURE__ */ new Error("Syncore devtools hub disconnected."));
+		}
+		subscriptionHandlers.clear();
+		if (socket.readyState === WebSocket.CLOSED) return;
+		await new Promise((resolve) => {
+			socket.once("close", () => resolve());
+			socket.close();
+		});
+	};
+	return {
+		async collectSnapshot(timeoutMs = 120) {
+			await new Promise((resolve) => setTimeout(resolve, timeoutMs));
+			return {
+				hellos: [...hellos.values()],
+				events: [...events]
+			};
+		},
+		listRuntimeHellos() {
+			return [...hellos.values()];
+		},
+		onEvent(listener) {
+			eventListeners.add(listener);
+			return () => {
+				eventListeners.delete(listener);
+			};
+		},
+		async sendCommand(runtimeId, payload) {
+			const commandId = createHubRequestId("command");
+			return await new Promise((resolve, reject) => {
+				commandResolvers.set(commandId, {
+					resolve,
+					reject
+				});
+				socket.send(JSON.stringify({
+					type: "command",
+					commandId,
+					targetRuntimeId: runtimeId,
+					payload
+				}));
+			});
+		},
+		subscribe(runtimeId, payload, handlers) {
+			const subscriptionId = createHubRequestId("subscription");
+			subscriptionHandlers.set(subscriptionId, handlers);
+			socket.send(JSON.stringify({
+				type: "subscribe",
+				subscriptionId,
+				targetRuntimeId: runtimeId,
+				payload
+			}));
+			return () => {
+				if (!subscriptionHandlers.has(subscriptionId)) return;
+				subscriptionHandlers.delete(subscriptionId);
+				socket.send(JSON.stringify({
+					type: "unsubscribe",
+					subscriptionId,
+					targetRuntimeId: runtimeId
+				}));
+			};
+		},
+		dispose
+	};
+}
+function buildClientTargets(hellos) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const hello of hellos) {
+		if (hello.runtimeId === "syncore-dev-hub") continue;
+		const key = hello.storageIdentity ?? `runtime::${hello.runtimeId}`;
+		const group = groups.get(key) ?? {
+			key,
+			runtimes: []
+		};
+		group.runtimes.push(hello);
+		groups.set(key, group);
+	}
+	const allRuntimeIds = hellos.filter((hello) => hello.runtimeId !== "syncore-dev-hub").map((hello) => hello.runtimeId).sort();
+	return [...groups.values()].map(({ key, runtimes }) => {
+		const sortedRuntimes = [...runtimes].sort((left, right) => left.runtimeId.localeCompare(right.runtimeId));
+		const primary = sortedRuntimes[0];
+		const sessionLabels = Array.from(new Set(sortedRuntimes.map((entry) => entry.sessionLabel).filter((value) => typeof value === "string")));
+		const runtimeIds = sortedRuntimes.map((entry) => entry.runtimeId);
+		const runtimeDescriptors = sortedRuntimes.map((entry, index) => ({
+			id: createPublicRuntimeId$1(entry.runtimeId, allRuntimeIds),
+			runtimeId: entry.runtimeId,
+			label: getClientRuntimeLabel({
+				...entry.sessionLabel ? { sessionLabel: entry.sessionLabel } : {},
+				...entry.appName ? { appName: entry.appName } : {},
+				platform: entry.platform
+			}),
+			platform: entry.platform,
+			...entry.appName ? { appName: entry.appName } : {},
+			...entry.origin ? { origin: entry.origin } : {},
+			...entry.sessionLabel ? { sessionLabel: entry.sessionLabel } : {},
+			...entry.storageIdentity ? { storageIdentity: entry.storageIdentity } : {},
+			online: true,
+			primary: index === 0
+		}));
+		return {
+			id: createPublicClientTargetId(key, groups),
+			kind: "client",
+			label: renderClientTargetLabel(primary, runtimes.length),
+			runtimeId: primary.runtimeId,
+			runtimeIds,
+			runtimes: runtimeDescriptors,
+			platform: primary.platform,
+			...primary.appName ? { appName: primary.appName } : {},
+			...primary.origin ? { origin: primary.origin } : {},
+			sessionLabels,
+			...primary.storageProtocol ? { storageProtocol: primary.storageProtocol } : {},
+			...primary.databaseLabel ? { databaseLabel: primary.databaseLabel } : {},
+			...primary.storageIdentity ? { storageIdentity: primary.storageIdentity } : {},
+			connectedSessions: runtimes.length,
+			online: true,
+			capabilities: [...CLIENT_TARGET_CAPABILITIES]
+		};
+	}).sort((left, right) => left.label.localeCompare(right.label));
+}
+function createPublicClientTargetId(key, groupsOrKeys) {
+	return createPublicTargetId(key, groupsOrKeys instanceof Map ? [...groupsOrKeys.keys()] : [...groupsOrKeys]);
+}
+function targetSupportsCapability(target, capability) {
+	return target.capabilities.includes(capability);
+}
+function renderClientTargetLabel(hello, connectedSessions) {
+	const base = hello.appName ?? hello.databaseLabel ?? hello.origin ?? `${hello.platform} client`;
+	return connectedSessions > 1 ? `${base} (${connectedSessions} sessions)` : base;
+}
+function createHubRequestId(prefix) {
+	return `syncore-cli-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 10)}`;
+}
+//#endregion
+export { buildRuntimeLookup, connectToProjectHub, createManagedProjectClient, createPublicRuntimeId$1 as createPublicRuntimeId, exportProjectData, findWorkspaceSyncoreProjects, importProjectData, isKnownTemplate, listAvailableTargets, listConnectedClientTargets, listProjectTables, loadImportDocumentBatches, readProjectTable, resolveDashboardUrl, resolveDevtoolsUrl, resolveDocsTarget, resolveProjectFunction, resolveProjectTargetDescriptor, targetSupportsCapability, writeExportData };
+
+//# sourceMappingURL=project.mjs.map