syncorejs 0.1.0 → 0.2.0

package/dist/_vendor/core/cli.mjs

@@ -1,7 +1,9 @@
 #!/usr/bin/env node
 import { generateId } from "./runtime/id.mjs";
+import { SyncoreRuntime } from "./runtime/runtime.mjs";
+import { createDevtoolsCommandHandler, createDevtoolsSubscriptionHost } from "./runtime/devtools.mjs";
 import { src_exports } from "./index.mjs";
-import { mkdir, readFile, readdir, stat, writeFile } from "node:fs/promises";
+import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { connect } from "node:net";
 import path from "node:path";
@@ -10,12 +12,13 @@ import { DatabaseSync } from "node:sqlite";
 import { Command } from "commander";
 import { tsImport } from "tsx/esm/api";
 import WebSocket, { WebSocketServer } from "ws";
+import { createPublicRuntimeId, createPublicTargetId } from "../devtools-protocol/index.js";
 //#region src/cli.ts
 const COMBINED_DEV_COMMAND = "concurrently --kill-others-on-fail --names syncore,app --prefix-colors yellow,cyan \"bun run syncorejs:dev\" \"bun run dev:app\"";
 const program = new Command();
 const CORE_PACKAGE_ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
-const migrationSnapshotFileName = "_schema_snapshot.json";
-const validTemplates = [
+const SYNCORE_MIGRATION_SNAPSHOT_FILE_NAME = "_schema_snapshot.json";
+const VALID_SYNCORE_TEMPLATES = [
 	"minimal",
 	"node",
 	"react-web",
@@ -25,8 +28,9 @@ const validTemplates = [
 ];
 let pendingDevBootstrap;
 let devBootstrapInFlight = false;
+const PROJECT_TARGET_RUNTIME_ID = "syncore-project-target";
 program.name("syncorejs").description("Syncore local-first toolkit CLI").version("0.1.0");
-program.command("init").description("Scaffold Syncore in the current directory").option("--template <template>", `Template to scaffold (${validTemplates.join(", ")}, or auto)`, "auto").option("--force", "Overwrite Syncore-managed files when they already exist").action(async (options) => {
+program.command("init").description("Scaffold Syncore in the current directory").option("--template <template>", `Template to scaffold (${VALID_SYNCORE_TEMPLATES.join(", ")}, or auto)`, "auto").option("--force", "Overwrite Syncore-managed files when they already exist").action(async (options) => {
 	const cwd = process.cwd();
 	const result = await scaffoldProject(cwd, {
 		template: await resolveRequestedTemplate(cwd, options.template),
@@ -105,7 +109,7 @@ program.command("migrate:apply").description("Apply SQL migrations from syncore/
 	const appliedCount = await applyProjectMigrations(process.cwd());
 	console.log(`Applied ${appliedCount} migration(s).`);
 });
-program.command("dev").description("Start the Syncore dev loop and devtools hub").option("--template <template>", `Template to scaffold when Syncore is missing (${validTemplates.join(", ")}, or auto)`, "auto").action(async (options) => {
+program.command("dev").description("Start the Syncore dev loop and devtools hub").option("--template <template>", `Template to scaffold when Syncore is missing (${VALID_SYNCORE_TEMPLATES.join(", ")}, or auto)`, "auto").action(async (options) => {
 	const cwd = process.cwd();
 	await startDevHub({
 		cwd,
@@ -337,11 +341,7 @@ function buildTemplateFiles(template) {
 	const files = [
 		{
 			path: "syncore.config.ts",
-			content: `export default {
-  databasePath: ".syncore/syncore.db",
-  storageDirectory: ".syncore/storage"
-};
-`
+			content: renderSyncoreConfigTemplate(template)
 		},
 		{
 			path: path.join("syncore", "schema.ts"),
@@ -513,6 +513,17 @@ export function createAppSyncoreRuntime() {
 	}
 	return files;
 }
+function renderSyncoreConfigTemplate(template) {
+	if (template === "node" || template === "electron") return `export default {
+  projectTarget: {
+    databasePath: ".syncore/syncore.db",
+    storageDirectory: ".syncore/storage"
+  }
+};
+`;
+	return `export default {};
+`;
+}
 function logScaffoldResult(result, heading) {
 	console.log(heading);
 	console.log(`Using template: ${result.template}`);
@@ -529,7 +540,7 @@ async function hasSyncoreProject(cwd) {
 }
 async function resolveRequestedTemplate(cwd, requestedTemplate) {
 	if (requestedTemplate !== "auto") {
-		if (!validTemplates.includes(requestedTemplate)) throw new Error(`Unknown template ${JSON.stringify(requestedTemplate)}. Expected one of ${validTemplates.join(", ")} or auto.`);
+		if (!VALID_SYNCORE_TEMPLATES.includes(requestedTemplate)) throw new Error(`Unknown template ${JSON.stringify(requestedTemplate)}. Expected one of ${VALID_SYNCORE_TEMPLATES.join(", ")} or auto.`);
 		return requestedTemplate;
 	}
 	return detectProjectTemplate(cwd);
@@ -622,9 +633,9 @@ async function writeManagedFile(filePath, content, force = false) {
 async function importJsonlIntoProject(cwd, tableName, sourcePath) {
 	const schema = await loadProjectSchema(cwd);
 	const table = schema.getTable(tableName);
-	const config = await loadProjectConfig(cwd);
-	const databasePath = path.resolve(cwd, config.databasePath);
-	const storageDirectory = path.resolve(cwd, config.storageDirectory);
+	const projectTarget = requireProjectTargetConfig(await loadProjectConfig(cwd));
+	const databasePath = path.resolve(cwd, projectTarget.databasePath);
+	const storageDirectory = path.resolve(cwd, projectTarget.storageDirectory);
 	const sourceFilePath = path.resolve(cwd, sourcePath);
 	await mkdir(path.dirname(databasePath), { recursive: true });
 	await mkdir(storageDirectory, { recursive: true });
@@ -798,10 +809,27 @@ function renderFunctionTypeImports(functionEntries, extension) {
 function renderFunctionImportName(entry) {
 	return [...entry.pathParts.map((segment) => segment.replace(/[^a-zA-Z0-9_$]/g, "_")), entry.exportName].join("__");
 }
+function resolveProjectTargetConfig(config) {
+	if (config.projectTarget && typeof config.projectTarget === "object" && typeof config.projectTarget.databasePath === "string" && typeof config.projectTarget.storageDirectory === "string") return config.projectTarget;
+	if (typeof config.databasePath === "string" && typeof config.storageDirectory === "string") return {
+		databasePath: config.databasePath,
+		storageDirectory: config.storageDirectory
+	};
+	return null;
+}
 async function loadProjectConfig(cwd) {
 	const config = await loadDefaultExport(path.join(cwd, "syncore.config.ts"));
-	if (!config || typeof config !== "object" || typeof config.databasePath !== "string" || typeof config.storageDirectory !== "string") throw new Error("syncore.config.ts must export { databasePath, storageDirectory }.");
-	return config;
+	if (!config || typeof config !== "object") throw new Error("syncore.config.ts must default export a Syncore config object.");
+	const projectTarget = resolveProjectTargetConfig(config);
+	return projectTarget ? {
+		...config,
+		projectTarget
+	} : config;
+}
+function requireProjectTargetConfig(config) {
+	const projectTarget = resolveProjectTargetConfig(config);
+	if (!projectTarget) throw new Error("This Syncore project does not define a projectTarget. Use a connected client target instead.");
+	return projectTarget;
 }
 async function loadProjectSchema(cwd) {
 	const schema = await loadDefaultExport(path.join(cwd, "syncore", "schema.ts"));
@@ -817,15 +845,267 @@ async function loadDefaultExport(filePath) {
 	if (resolvedDefault === void 0) throw new Error(`File ${path.relative(process.cwd(), filePath)} exported undefined.`);
 	return resolvedDefault;
 }
+async function loadNamedExport(filePath, exportName) {
+	if (!await fileExists(filePath)) throw new Error(`Missing file: ${path.relative(process.cwd(), filePath)}`);
+	const moduleUrl = pathToFileURL(filePath).href;
+	const loaded = await tsImport(moduleUrl, { parentURL: import.meta.url });
+	const defaultExport = loaded.default && typeof loaded.default === "object" && exportName in loaded.default ? loaded.default[exportName] : void 0;
+	if (!(exportName in loaded) && defaultExport === void 0) throw new Error(`File ${path.relative(process.cwd(), filePath)} must export ${exportName}.`);
+	const resolvedValue = unwrapDefaultExport(loaded[exportName] ?? defaultExport);
+	if (resolvedValue === void 0) throw new Error(`File ${path.relative(process.cwd(), filePath)} exported undefined for ${exportName}.`);
+	return resolvedValue;
+}
+async function loadProjectFunctions(cwd) {
+	const functions = await loadNamedExport(path.join(cwd, "syncore", "_generated", "functions.ts"), "functions");
+	if (!functions || typeof functions !== "object") throw new Error("syncore/_generated/functions.ts must export a functions registry.");
+	return functions;
+}
+var HubSqliteDriver = class {
+	database;
+	transactionDepth = 0;
+	constructor(filename) {
+		this.database = new DatabaseSync(filename);
+		this.database.exec("PRAGMA foreign_keys = ON;");
+		this.database.exec("PRAGMA journal_mode = WAL;");
+	}
+	async exec(sql) {
+		this.database.exec(sql);
+	}
+	async run(sql, params = []) {
+		const result = this.database.prepare(sql).run(...toSqlParameters(params));
+		return {
+			changes: Number(result.changes ?? 0),
+			lastInsertRowid: typeof result.lastInsertRowid === "bigint" ? Number(result.lastInsertRowid) : result.lastInsertRowid
+		};
+	}
+	async get(sql, params = []) {
+		return this.database.prepare(sql).get(...toSqlParameters(params));
+	}
+	async all(sql, params = []) {
+		return this.database.prepare(sql).all(...toSqlParameters(params));
+	}
+	async withTransaction(callback) {
+		if (this.transactionDepth > 0) return this.withSavepoint(`nested_${this.transactionDepth}`, callback);
+		this.transactionDepth += 1;
+		this.database.exec("BEGIN");
+		try {
+			const result = await callback();
+			this.database.exec("COMMIT");
+			return result;
+		} catch (error) {
+			this.database.exec("ROLLBACK");
+			throw error;
+		} finally {
+			this.transactionDepth -= 1;
+		}
+	}
+	async withSavepoint(name, callback) {
+		const safeName = name.replaceAll(/[^a-zA-Z0-9_]/g, "_");
+		this.database.exec(`SAVEPOINT ${safeName}`);
+		try {
+			const result = await callback();
+			this.database.exec(`RELEASE SAVEPOINT ${safeName}`);
+			return result;
+		} catch (error) {
+			this.database.exec(`ROLLBACK TO SAVEPOINT ${safeName}`);
+			this.database.exec(`RELEASE SAVEPOINT ${safeName}`);
+			throw error;
+		}
+	}
+	async close() {
+		this.database.close();
+	}
+};
+var HubFileStorageAdapter = class {
+	constructor(directory) {
+		this.directory = directory;
+	}
+	filePath(id) {
+		return path.join(this.directory, id);
+	}
+	async put(id, input) {
+		await mkdir(this.directory, { recursive: true });
+		const filePath = this.filePath(id);
+		const bytes = normalizeStorageInput(input.data);
+		await writeFile(filePath, bytes);
+		return {
+			id,
+			path: filePath,
+			size: bytes.byteLength,
+			contentType: input.contentType ?? null
+		};
+	}
+	async get(id) {
+		const filePath = this.filePath(id);
+		try {
+			return {
+				id,
+				path: filePath,
+				size: (await stat(filePath)).size,
+				contentType: null
+			};
+		} catch {
+			return null;
+		}
+	}
+	async read(id) {
+		try {
+			return await readFile(this.filePath(id));
+		} catch {
+			return null;
+		}
+	}
+	async delete(id) {
+		await rm(this.filePath(id), { force: true });
+	}
+	async list() {
+		try {
+			const entries = await readdir(this.directory, { withFileTypes: true });
+			return Promise.all(entries.filter((entry) => entry.isFile()).map(async (entry) => {
+				const filePath = this.filePath(entry.name);
+				const info = await stat(filePath);
+				return {
+					id: entry.name,
+					path: filePath,
+					size: info.size,
+					contentType: null
+				};
+			}));
+		} catch {
+			return [];
+		}
+	}
+};
+const hubDevtoolsSqlSupport = {
+	analyzeSqlStatement(query) {
+		const firstKeyword = query.trim().replace(/^\(+/, "").toUpperCase().split(/\s+/, 1)[0] ?? "";
+		if (firstKeyword === "SELECT" || firstKeyword === "WITH" || firstKeyword === "PRAGMA" || firstKeyword === "EXPLAIN") return {
+			mode: "read",
+			readTables: [],
+			writeTables: [],
+			schemaChanged: false,
+			observedScopes: ["all"]
+		};
+		if (firstKeyword === "INSERT" || firstKeyword === "UPDATE" || firstKeyword === "DELETE" || firstKeyword === "REPLACE") return {
+			mode: "write",
+			readTables: [],
+			writeTables: [],
+			schemaChanged: false,
+			observedScopes: ["all"]
+		};
+		if (firstKeyword === "CREATE" || firstKeyword === "DROP" || firstKeyword === "ALTER") return {
+			mode: "ddl",
+			readTables: [],
+			writeTables: [],
+			schemaChanged: true,
+			observedScopes: ["all", "schema.tables"]
+		};
+		throw new Error(`Unsupported SQL statement type: ${firstKeyword || "unknown"}`);
+	},
+	ensureSqlMode(analysis, expected) {
+		if (expected === "watch") {
+			if (analysis.mode !== "read") throw new Error("Live mode supports read-only SQL only.");
+			return;
+		}
+		if (analysis.mode !== expected) {
+			if (expected === "read") throw new Error("Use SQL Write for mutating statements.");
+			throw new Error("Use SQL Read or SQL Live for read-only statements.");
+		}
+	},
+	runReadonlyQuery(databasePath, query) {
+		const analysis = this.analyzeSqlStatement(query);
+		this.ensureSqlMode(analysis, "read");
+		const database = new DatabaseSync(databasePath, { readOnly: true });
+		try {
+			const statement = database.prepare(query);
+			const rows = statement.all();
+			const columns = statement.columns().map((column) => column.name);
+			return {
+				columns,
+				rows: rows.map((row) => columns.map((column) => row[column])),
+				observedTables: []
+			};
+		} finally {
+			database.close();
+		}
+	}
+};
+async function createProjectTargetBackend(cwd) {
+	const projectTarget = resolveProjectTargetConfig(await loadProjectConfig(cwd));
+	if (!projectTarget) return null;
+	const schema = await loadProjectSchema(cwd);
+	const functions = await loadProjectFunctions(cwd);
+	const databasePath = path.resolve(cwd, projectTarget.databasePath);
+	const storageDirectory = path.resolve(cwd, projectTarget.storageDirectory);
+	await mkdir(path.dirname(databasePath), { recursive: true });
+	await mkdir(storageDirectory, { recursive: true });
+	const driver = new HubSqliteDriver(databasePath);
+	const runtime = new SyncoreRuntime({
+		schema,
+		functions,
+		driver,
+		storage: new HubFileStorageAdapter(storageDirectory),
+		platform: "project"
+	});
+	await runtime.prepareForDirectAccess();
+	const commandHandler = createDevtoolsCommandHandler({
+		driver,
+		schema,
+		functions,
+		runtime,
+		sql: hubDevtoolsSqlSupport
+	});
+	const subscriptionHost = createDevtoolsSubscriptionHost({
+		driver,
+		schema,
+		functions,
+		runtime,
+		sql: hubDevtoolsSqlSupport
+	});
+	return {
+		hello: {
+			type: "hello",
+			runtimeId: PROJECT_TARGET_RUNTIME_ID,
+			platform: "project",
+			sessionLabel: "Project Target",
+			targetKind: "project",
+			storageProtocol: "file",
+			databaseLabel: path.basename(databasePath),
+			storageIdentity: `file::${databasePath}`
+		},
+		handleCommand: commandHandler,
+		subscribe(subscriptionId, payload, listener) {
+			return subscriptionHost.subscribe(subscriptionId, payload, listener);
+		},
+		unsubscribe(subscriptionId) {
+			subscriptionHost.unsubscribe(subscriptionId);
+		},
+		async dispose() {
+			subscriptionHost.dispose();
+			await runtime.stop();
+		}
+	};
+}
+function normalizeStorageInput(input) {
+	if (typeof input === "string") return Buffer.from(input);
+	if (input instanceof Uint8Array) return input;
+	return new Uint8Array(input);
+}
+function toSqlParameters(params) {
+	return params.map((value) => {
+		if (value instanceof Uint8Array) return Buffer.from(value);
+		return value;
+	});
+}
 async function readStoredSnapshot(cwd) {
-	const snapshotPath = path.join(cwd, "syncore", "migrations", migrationSnapshotFileName);
+	const snapshotPath = path.join(cwd, "syncore", "migrations", SYNCORE_MIGRATION_SNAPSHOT_FILE_NAME);
 	if (!await fileExists(snapshotPath)) return null;
 	return (0, src_exports.parseSchemaSnapshot)(await readFile(snapshotPath, "utf8"));
 }
 async function writeStoredSnapshot(cwd, snapshot) {
 	const migrationsDirectory = path.join(cwd, "syncore", "migrations");
 	await mkdir(migrationsDirectory, { recursive: true });
-	await writeFile(path.join(migrationsDirectory, migrationSnapshotFileName), `${JSON.stringify(snapshot, null, 2)}\n`);
+	await writeFile(path.join(migrationsDirectory, SYNCORE_MIGRATION_SNAPSHOT_FILE_NAME), `${JSON.stringify(snapshot, null, 2)}\n`);
 }
 async function getNextMigrationNumber(directory) {
 	if (!await fileExists(directory)) return 1;
@@ -834,25 +1114,20 @@ async function getNextMigrationNumber(directory) {
 	return Math.max(...migrationNumbers) + 1;
 }
 async function applyProjectMigrations(cwd) {
-	const config = await loadProjectConfig(cwd);
-	const databasePath = path.resolve(cwd, config.databasePath);
-	const storageDirectory = path.resolve(cwd, config.storageDirectory);
+	const projectTarget = requireProjectTargetConfig(await loadProjectConfig(cwd));
+	const databasePath = path.resolve(cwd, projectTarget.databasePath);
+	const storageDirectory = path.resolve(cwd, projectTarget.storageDirectory);
 	await mkdir(path.dirname(databasePath), { recursive: true });
 	await mkdir(storageDirectory, { recursive: true });
 	const database = new DatabaseSync(databasePath);
-	database.exec(`
-    CREATE TABLE IF NOT EXISTS "_syncore_migrations" (
-      name TEXT PRIMARY KEY,
-      applied_at TEXT NOT NULL
-    );
-  `);
+	ensureCliMigrationTrackingTable(database);
 	const migrationsDirectory = path.join(cwd, "syncore", "migrations");
 	if (!await fileExists(migrationsDirectory)) {
 		database.close();
 		return 0;
 	}
-	const appliedRows = database.prepare(`SELECT name FROM "_syncore_migrations" ORDER BY name ASC`).all();
-	const appliedNames = new Set(appliedRows.map((row) => row.name));
+	const appliedRows = database.prepare(`SELECT id FROM "_syncore_migrations" ORDER BY id ASC`).all();
+	const appliedNames = new Set(appliedRows.map((row) => row.id));
 	const migrationFiles = (await readdir(migrationsDirectory)).filter((name) => /\.sql$/i.test(name)).sort((left, right) => left.localeCompare(right));
 	let appliedCount = 0;
 	for (const fileName of migrationFiles) {
@@ -861,7 +1136,7 @@ async function applyProjectMigrations(cwd) {
 		database.exec("BEGIN");
 		try {
 			applyMigrationSql(database, sql, fileName);
-			database.prepare(`INSERT INTO "_syncore_migrations" (name, applied_at) VALUES (?, ?)`).run(fileName, (/* @__PURE__ */ new Date()).toISOString());
+			database.prepare(`INSERT OR REPLACE INTO "_syncore_migrations" (id, applied_at, sql) VALUES (?, ?, ?)`).run(fileName, Date.now(), sql);
 			database.exec("COMMIT");
 			appliedCount += 1;
 		} catch (error) {
@@ -873,6 +1148,41 @@ async function applyProjectMigrations(cwd) {
 	database.close();
 	return appliedCount;
 }
+function ensureCliMigrationTrackingTable(database) {
+	if (!(database.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = '_syncore_migrations'`).get()?.name === "_syncore_migrations")) {
+		database.exec(`
+      CREATE TABLE "_syncore_migrations" (
+        id TEXT PRIMARY KEY,
+        applied_at INTEGER NOT NULL,
+        sql TEXT NOT NULL
+      );
+    `);
+		return;
+	}
+	const columns = database.prepare(`PRAGMA table_info("_syncore_migrations")`).all();
+	const columnNames = new Set(columns.map((column) => column.name));
+	if (columnNames.has("id") && columnNames.has("applied_at") && columnNames.has("sql")) return;
+	database.exec(`
+    ALTER TABLE "_syncore_migrations" RENAME TO "_syncore_migrations_legacy";
+    CREATE TABLE "_syncore_migrations" (
+      id TEXT PRIMARY KEY,
+      applied_at INTEGER NOT NULL,
+      sql TEXT NOT NULL
+    );
+  `);
+	if (columnNames.has("name")) database.exec(`
+      INSERT INTO "_syncore_migrations" (id, applied_at, sql)
+      SELECT
+        name,
+        CASE
+          WHEN typeof(applied_at) = 'integer' THEN applied_at
+          ELSE CAST(strftime('%s', applied_at) AS INTEGER) * 1000
+        END,
+        ''
+      FROM "_syncore_migrations_legacy";
+    `);
+	database.exec(`DROP TABLE "_syncore_migrations_legacy";`);
+}
 async function fileExists(filePath) {
 	try {
 		await stat(filePath);
@@ -882,15 +1192,14 @@ async function fileExists(filePath) {
 	}
 }
 async function resolveFunctionImportExtension(cwd) {
-	const candidateConfigFiles = (await readdir(cwd, { withFileTypes: true })).filter((entry) => entry.isFile() && /^tsconfig.*\.json$/i.test(entry.name)).map((entry) => path.join(cwd, entry.name)).sort((left, right) => left.localeCompare(right));
-	for (const filePath of candidateConfigFiles) try {
-		const rawConfig = JSON.parse(await readFile(filePath, "utf8"));
-		const moduleResolution = rawConfig.compilerOptions?.moduleResolution?.toLowerCase();
-		const moduleTarget = rawConfig.compilerOptions?.module?.toLowerCase();
-		if (moduleResolution === "nodenext" || moduleTarget === "nodenext") return ".js";
-	} catch {
-		continue;
-	}
+	const tsconfigFiles = (await readdir(cwd, { withFileTypes: true })).filter((entry) => entry.isFile() && /^tsconfig(\..+)?\.json$/u.test(entry.name)).map((entry) => path.join(cwd, entry.name)).sort();
+	for (const configPath of tsconfigFiles) try {
+		const source = await readFile(configPath, "utf8");
+		const parsed = JSON.parse(source);
+		const moduleResolution = parsed.compilerOptions?.moduleResolution?.toLowerCase();
+		const moduleKind = parsed.compilerOptions?.module?.toLowerCase();
+		if (moduleResolution === "nodenext" || moduleResolution === "node16" || moduleKind === "nodenext" || moduleKind === "node16") return ".js";
+	} catch {}
 	return "";
 }
 function formatError(error) {
@@ -930,12 +1239,22 @@ function applyMigrationSql(database, sql, fileName) {
 async function startDevHub(options) {
 	const dashboardPort = resolvePortFromEnv("SYNCORE_DASHBOARD_PORT", 4310);
 	const devtoolsPort = resolvePortFromEnv("SYNCORE_DEVTOOLS_PORT", 4311);
+	const logsDirectory = path.join(options.cwd, ".syncore", "logs");
+	const logFilePath = path.join(logsDirectory, "runtime.jsonl");
+	await mkdir(logsDirectory, { recursive: true });
+	await writeFile(logFilePath, "");
 	await runDevProjectBootstrap(options.cwd, options.template);
 	await setupDevProjectWatch(options.cwd, options.template);
 	if (await isLocalPortInUse(devtoolsPort)) {
-		console.log(`Syncore devtools hub already running at ws://127.0.0.1:${devtoolsPort}. Reusing existing hub/dashboard.`);
+		console.log(`Syncore devtools hub already running at ws://localhost:${devtoolsPort}. Reusing existing hub/dashboard.`);
 		return;
 	}
+	let projectTargetBackend = null;
+	try {
+		projectTargetBackend = await createProjectTargetBackend(options.cwd);
+	} catch (error) {
+		console.warn(`Project target fallback unavailable: ${formatError(error)}`);
+	}
 	const httpServer = createServer((_request, response) => {
 		response.writeHead(200, { "content-type": "application/json" });
 		response.end(JSON.stringify({
@@ -944,19 +1263,56 @@ async function startDevHub(options) {
 		}));
 	});
 	const websocketServer = new WebSocketServer({ server: httpServer });
-	const latestSnapshots = /* @__PURE__ */ new Map();
 	const runtimeSockets = /* @__PURE__ */ new Map();
+	const runtimeHellos = /* @__PURE__ */ new Map();
+	const runtimeEvents = /* @__PURE__ */ new Map();
 	const socketRuntimeIds = /* @__PURE__ */ new Map();
 	const dashboardSockets = /* @__PURE__ */ new Set();
+	const dashboardSubscriptions = /* @__PURE__ */ new Map();
 	const hello = {
 		type: "hello",
 		runtimeId: "syncore-dev-hub",
 		platform: "dev"
 	};
+	if (projectTargetBackend) {
+		runtimeHellos.set(PROJECT_TARGET_RUNTIME_ID, projectTargetBackend.hello);
+		runtimeEvents.set(PROJECT_TARGET_RUNTIME_ID, []);
+	}
+	const appendHubLog = async (event) => {
+		const runtimeHello = runtimeHellos.get(event.runtimeId);
+		const clientRuntimeIds = [...runtimeHellos.values()].filter((hello) => hello.runtimeId !== "syncore-dev-hub" && hello.targetKind !== "project").map((hello) => hello.runtimeId).sort();
+		const clientTargetKeys = [...runtimeHellos.values()].filter((hello) => hello.runtimeId !== "syncore-dev-hub" && hello.targetKind !== "project").map((hello) => hello.storageIdentity ?? `runtime::${hello.runtimeId}`).sort();
+		const targetIdentity = runtimeHello?.storageIdentity ?? `runtime::${event.runtimeId}`;
+		const targetId = event.runtimeId === "syncore-dev-hub" ? "all" : runtimeHello?.targetKind === "project" ? "project" : createPublicTargetId(targetIdentity, clientTargetKeys);
+		const publicRuntimeId = event.runtimeId === "syncore-dev-hub" ? void 0 : createPublicRuntimeId(event.runtimeId, clientRuntimeIds);
+		const category = event.type === "query.executed" ? "query" : event.type === "mutation.committed" ? "mutation" : event.type === "action.completed" ? "action" : "system";
+		const message = event.type === "log" ? event.message : event.type === "query.executed" || event.type === "mutation.committed" || event.type === "action.completed" ? event.functionName : event.type;
+		await appendFile(logFilePath, `${JSON.stringify({
+			version: 2,
+			timestamp: event.timestamp,
+			runtimeId: event.runtimeId,
+			targetId,
+			...publicRuntimeId ? { publicRuntimeId } : {},
+			...runtimeHello?.platform ? { platform: runtimeHello.platform } : {},
+			eventType: event.type,
+			category,
+			message,
+			event
+		})}\n`);
+	};
 	websocketServer.on("connection", (socket) => {
 		dashboardSockets.add(socket);
 		socket.send(JSON.stringify(hello));
-		for (const snapshot of latestSnapshots.values()) socket.send(JSON.stringify(snapshot));
+		for (const runtimeHello of runtimeHellos.values()) socket.send(JSON.stringify(runtimeHello));
+		for (const [runtimeId, history] of runtimeEvents) {
+			if (!runtimeHellos.has(runtimeId)) continue;
+			if (history.length === 0) continue;
+			socket.send(JSON.stringify({
+				type: "event.batch",
+				runtimeId,
+				events: [...history]
+			}));
+		}
 		socket.on("message", (payload) => {
 			const rawPayload = decodeWebSocketPayload(payload);
 			if (rawPayload.length === 0) return;
@@ -965,32 +1321,110 @@ async function startDevHub(options) {
 				socket.send(JSON.stringify({ type: "pong" }));
 				return;
 			}
-			if (message.type === "request") {
+			if (message.type === "command") {
+				const targetRuntimeId = message.targetRuntimeId;
+				if (!targetRuntimeId) return;
+				if (targetRuntimeId === PROJECT_TARGET_RUNTIME_ID && projectTargetBackend) {
+					(async () => {
+						const payload = await projectTargetBackend.handleCommand(message.payload);
+						if (socket.readyState !== WebSocket.OPEN) return;
+						socket.send(JSON.stringify({
+							type: "command.result",
+							commandId: message.commandId,
+							runtimeId: PROJECT_TARGET_RUNTIME_ID,
+							payload
+						}));
+					})();
+					return;
+				}
+				const target = runtimeSockets.get(targetRuntimeId);
+				if (target && target.readyState === WebSocket.OPEN) target.send(JSON.stringify(message));
+				return;
+			}
+			if (message.type === "subscribe") {
 				const targetRuntimeId = message.targetRuntimeId;
 				if (!targetRuntimeId) return;
+				const subscriptions = dashboardSubscriptions.get(socket) ?? /* @__PURE__ */ new Map();
+				subscriptions.set(message.subscriptionId, {
+					runtimeId: targetRuntimeId,
+					payload: message
+				});
+				dashboardSubscriptions.set(socket, subscriptions);
+				if (targetRuntimeId === PROJECT_TARGET_RUNTIME_ID && projectTargetBackend) {
+					projectTargetBackend.subscribe(message.subscriptionId, message.payload, (payload) => {
+						if (socket.readyState !== WebSocket.OPEN) return;
+						socket.send(JSON.stringify({
+							type: "subscription.data",
+							subscriptionId: message.subscriptionId,
+							runtimeId: PROJECT_TARGET_RUNTIME_ID,
+							payload
+						}));
+					}).catch((error) => {
+						if (socket.readyState !== WebSocket.OPEN) return;
+						socket.send(JSON.stringify({
+							type: "subscription.error",
+							subscriptionId: message.subscriptionId,
+							runtimeId: PROJECT_TARGET_RUNTIME_ID,
+							error: formatError(error)
+						}));
+					});
+					return;
+				}
 				const target = runtimeSockets.get(targetRuntimeId);
 				if (target && target.readyState === WebSocket.OPEN) target.send(JSON.stringify(message));
 				return;
 			}
+			if (message.type === "unsubscribe") {
+				const subscriptions = dashboardSubscriptions.get(socket);
+				const subscription = subscriptions?.get(message.subscriptionId);
+				if (!subscription) return;
+				if (subscription.runtimeId === PROJECT_TARGET_RUNTIME_ID && projectTargetBackend) {
+					projectTargetBackend.unsubscribe(message.subscriptionId);
+					subscriptions?.delete(message.subscriptionId);
+					if (subscriptions && subscriptions.size === 0) dashboardSubscriptions.delete(socket);
+					return;
+				}
+				const target = runtimeSockets.get(subscription.runtimeId);
+				if (target && target.readyState === WebSocket.OPEN) {
+					const runtimeMessage = {
+						type: "unsubscribe",
+						subscriptionId: message.subscriptionId,
+						targetRuntimeId: subscription.runtimeId
+					};
+					target.send(JSON.stringify(runtimeMessage));
+				}
+				subscriptions?.delete(message.subscriptionId);
+				if (subscriptions && subscriptions.size === 0) dashboardSubscriptions.delete(socket);
+				return;
+			}
 			if (message.type === "hello") {
 				dashboardSockets.delete(socket);
 				runtimeSockets.set(message.runtimeId, socket);
+				runtimeHellos.set(message.runtimeId, message);
+				runtimeEvents.set(message.runtimeId, []);
 				const runtimeIds = socketRuntimeIds.get(socket) ?? /* @__PURE__ */ new Set();
 				runtimeIds.add(message.runtimeId);
 				socketRuntimeIds.set(socket, runtimeIds);
+				for (const [dashboardSocket, subscriptions] of dashboardSubscriptions) {
+					if (dashboardSocket.readyState !== WebSocket.OPEN) continue;
+					for (const subscription of subscriptions.values()) {
+						if (subscription.runtimeId !== message.runtimeId) continue;
+						socket.send(JSON.stringify(subscription.payload));
+					}
+				}
 				for (const client of dashboardSockets) if (client.readyState === WebSocket.OPEN) client.send(JSON.stringify(message));
 				return;
 			}
-			if (message.type === "snapshot") {
-				latestSnapshots.set(message.snapshot.runtimeId, message);
-				dashboardSockets.delete(socket);
-				runtimeSockets.set(message.snapshot.runtimeId, socket);
-				const runtimeIds = socketRuntimeIds.get(socket) ?? /* @__PURE__ */ new Set();
-				runtimeIds.add(message.snapshot.runtimeId);
-				socketRuntimeIds.set(socket, runtimeIds);
-			}
 			const encoded = JSON.stringify(message);
-			if (message.type === "response") {
+			if (message.type === "event" && message.event.type === "runtime.disconnected") runtimeHellos.delete(message.event.runtimeId);
+			if (message.type === "event" && message.event.runtimeId !== "syncore-dev-hub") {
+				const history = runtimeEvents.get(message.event.runtimeId) ?? [];
+				history.unshift(message.event);
+				runtimeEvents.set(message.event.runtimeId, history.slice(0, 200));
+				if (message.event.type === "runtime.disconnected") runtimeEvents.delete(message.event.runtimeId);
+				appendHubLog(message.event);
+			} else if (message.type === "event") appendHubLog(message.event);
+			if (message.type === "command.result" || message.type === "subscription.data" || message.type === "subscription.error") {
 				for (const client of dashboardSockets) if (client.readyState === WebSocket.OPEN) client.send(encoded);
 				return;
 			}
@@ -1001,38 +1435,57 @@ async function startDevHub(options) {
 		});
 		socket.on("close", () => {
 			dashboardSockets.delete(socket);
+			const subscriptions = dashboardSubscriptions.get(socket);
+			if (subscriptions) {
+				for (const [subscriptionId, subscription] of subscriptions) {
+					if (subscription.runtimeId === PROJECT_TARGET_RUNTIME_ID && projectTargetBackend) {
+						projectTargetBackend.unsubscribe(subscriptionId);
+						continue;
+					}
+					const target = runtimeSockets.get(subscription.runtimeId);
+					if (target && target.readyState === WebSocket.OPEN) {
+						const message = {
+							type: "unsubscribe",
+							subscriptionId,
+							targetRuntimeId: subscription.runtimeId
+						};
+						target.send(JSON.stringify(message));
+					}
+				}
+				dashboardSubscriptions.delete(socket);
+			}
 			const runtimeIds = socketRuntimeIds.get(socket);
 			if (!runtimeIds) return;
-			for (const runtimeId of runtimeIds) {
-				latestSnapshots.delete(runtimeId);
-				if (runtimeSockets.get(runtimeId) === socket) runtimeSockets.delete(runtimeId);
+			for (const runtimeId of runtimeIds) if (runtimeSockets.get(runtimeId) === socket) {
+				if (runtimeHellos.has(runtimeId)) {
+					const disconnectedEvent = {
+						type: "event",
+						event: {
+							type: "runtime.disconnected",
+							runtimeId,
+							timestamp: Date.now()
+						}
+					};
+					const payload = JSON.stringify(disconnectedEvent);
+					appendHubLog(disconnectedEvent.event);
+					for (const client of dashboardSockets) if (client.readyState === WebSocket.OPEN) client.send(payload);
+				}
+				runtimeSockets.delete(runtimeId);
+				runtimeHellos.delete(runtimeId);
+				runtimeEvents.delete(runtimeId);
 			}
 			socketRuntimeIds.delete(socket);
 		});
 	});
-	const heartbeat = setInterval(() => {
-		const event = {
-			type: "event",
-			event: {
-				type: "log",
-				runtimeId: "syncore-dev-hub",
-				level: "info",
-				message: "Syncore devtools hub is alive.",
-				timestamp: Date.now()
-			}
-		};
-		const payload = JSON.stringify(event);
-		for (const client of websocketServer.clients) client.send(payload);
-	}, 4e3);
 	httpServer.on("error", (error) => {
 		console.error(`Syncore devtools hub failed: ${formatError(error)}`);
 		process.exit(1);
 	});
 	httpServer.listen(devtoolsPort, "127.0.0.1", () => {
 		(async () => {
-			console.log(`Syncore devtools hub: ws://127.0.0.1:${devtoolsPort}`);
-			console.log(`Electron/Node runtimes: set devtoolsUrl to ws://127.0.0.1:${devtoolsPort}.`);
-			console.log(`Web/Next apps: connect the dashboard or worker bridge to ws://127.0.0.1:${devtoolsPort}.`);
+			console.log(`Syncore devtools hub: ws://localhost:${devtoolsPort}`);
+			console.log(`Electron/Node runtimes: set devtoolsUrl to ws://localhost:${devtoolsPort}.`);
+			console.log(`Web/Next apps: connect the dashboard or worker bridge to ws://localhost:${devtoolsPort}.`);
 			console.log("Expo apps: use the same hub URL through LAN or adb reverse while developing.");
 			const dashboardRoot = path.resolve(CORE_PACKAGE_ROOT, "..", "..", "apps", "dashboard");
 			if (await fileExists(path.join(dashboardRoot, "vite.config.ts"))) try {
@@ -1041,14 +1494,14 @@ async function startDevHub(options) {
 					root: dashboardRoot,
 					server: { port: dashboardPort }
 				})).listen();
-				console.log(`Dashboard shell: http://127.0.0.1:${dashboardPort}`);
+				console.log(`Dashboard shell: http://localhost:${dashboardPort}`);
 			} catch (error) {
 				console.log(`Dashboard source not started automatically: ${formatError(error)}`);
 			}
 		})();
 	});
 	const close = () => {
-		clearInterval(heartbeat);
+		projectTargetBackend?.dispose();
 		websocketServer.close();
 		httpServer.close();
 		process.exit(0);
@@ -1191,6 +1644,6 @@ function toSearchValue(value) {
 	return stableStringify(value);
 }
 //#endregion
-export { runSyncoreCli };
+export { SYNCORE_MIGRATION_SNAPSHOT_FILE_NAME, VALID_SYNCORE_TEMPLATES, applyProjectMigrations, detectProjectTemplate, fileExists, formatError, getNextMigrationNumber, hasSyncoreProject, importJsonlIntoProject, isLocalPortInUse, loadProjectConfig, loadProjectFunctions, loadProjectSchema, logScaffoldResult, readPackageJson, readStoredSnapshot, resolveDefaultSeedFile, resolvePortFromEnv, resolveProjectTargetConfig, resolveRequestedTemplate, runCodegen, runDevProjectBootstrap, runSyncoreCli, scaffoldProject, slugify, startDevHub, writeStoredSnapshot };
 
 //# sourceMappingURL=cli.mjs.map