syncorejs 0.2.0 → 0.2.2

package/dist/_vendor/core/cli.mjs

@@ -3,6 +3,7 @@ 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 { generateDevtoolsToken, isAllowedDashboardOrigin, isAuthorizedDashboardRequest, sanitizeDevtoolsToken } from "./devtools-auth.mjs";
 import { appendFile, mkdir, readFile, readdir, rm, stat, writeFile } from "node:fs/promises";
 import { createServer } from "node:http";
 import { connect } from "node:net";
@@ -12,11 +13,15 @@ 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";
+import { SYNCORE_DEVTOOLS_MAX_SUPPORTED_PROTOCOL_VERSION, SYNCORE_DEVTOOLS_MIN_SUPPORTED_PROTOCOL_VERSION, SYNCORE_DEVTOOLS_PROTOCOL_VERSION, createPublicRuntimeId, createPublicTargetId } from "../devtools-protocol/index.js";
 //#region src/cli.ts
+function templateUsesConnectedClients(template) {
+	return template === "react-web" || template === "expo" || template === "next";
+}
 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 DEVTOOLS_SESSION_FILE = path.join(".syncore", "devtools-session.json");
 const SYNCORE_MIGRATION_SNAPSHOT_FILE_NAME = "_schema_snapshot.json";
 const VALID_SYNCORE_TEMPLATES = [
 	"minimal",
@@ -123,8 +128,10 @@ if (isCliEntryPoint()) await runSyncoreCli();
 async function runCodegen(cwd) {
 	const functionsDir = path.join(cwd, "syncore", "functions");
 	const generatedDir = path.join(cwd, "syncore", "_generated");
+	const componentsManifestPath = path.join(cwd, "syncore", "components.ts");
 	await mkdir(generatedDir, { recursive: true });
 	const functionImportExtension = await resolveFunctionImportExtension(cwd);
+	const hasComponentsManifest = await fileExists(componentsManifestPath);
 	const files = await listTypeScriptFiles(functionsDir);
 	const functionEntries = [];
 	for (const file of files) {
@@ -148,6 +155,8 @@ async function runCodegen(cwd) {
 		``,
 		`import { createFunctionReferenceFor } from "syncorejs";`,
 		`import type { FunctionReferenceFor } from "syncorejs";`,
+		`export { components } from "./components${functionImportExtension}";`,
+		``,
 		...renderFunctionTypeImports(functionEntries, functionImportExtension),
 		``,
 		...renderGeneratedApiInterfaces(functionEntries),
@@ -174,9 +183,12 @@ async function runCodegen(cwd) {
 		` */`,
 		``,
 		`import type { SyncoreFunctionRegistry } from "syncorejs";`,
-		``,
+		`import { composeProjectFunctionRegistry } from "syncorejs";`,
+		...renderGeneratedManifestImportLines(hasComponentsManifest, functionImportExtension),
 		...renderFunctionImports(functionEntries, functionImportExtension),
 		``,
+		...renderGeneratedManifestDeclarationLines(hasComponentsManifest),
+		``,
 		...renderGeneratedFunctionsInterface(functionEntries),
 		``,
 		`/**`,
@@ -184,9 +196,54 @@ async function runCodegen(cwd) {
 		` *`,
 		` * Most application code should import from \`./api\` instead of using this map directly.`,
 		` */`,
-		`export const functions: SyncoreFunctionsRegistry = {`,
+		`const rootFunctions: SyncoreRootFunctionsRegistry = {`,
 		...functionEntries.map((entry) => `  ${JSON.stringify(`${entry.pathParts.join("/")}/${entry.exportName}`)}: ${renderFunctionImportName(entry)},`),
 		`} as const;`,
+		``,
+		`export const functions: SyncoreFunctionRegistry = composeProjectFunctionRegistry(rootFunctions, componentsManifest);`,
+		``
+	].join("\n");
+	const schemaSource = [
+		`/**`,
+		` * Generated composed Syncore schema including installed components.`,
+		` *`,
+		` * THIS CODE IS AUTOMATICALLY GENERATED.`,
+		` *`,
+		` * To regenerate, run \`npx syncorejs dev\` or \`npx syncorejs codegen\`.`,
+		` * @module`,
+		` */`,
+		``,
+		`import { composeProjectSchema } from "syncorejs";`,
+		`import rootSchema from "../schema${functionImportExtension}";`,
+		...renderGeneratedManifestImportLines(hasComponentsManifest, functionImportExtension),
+		``,
+		...renderGeneratedManifestDeclarationLines(hasComponentsManifest),
+		``,
+		`const schema = composeProjectSchema(rootSchema, componentsManifest);`,
+		``,
+		`export default schema;`,
+		``
+	].join("\n");
+	const componentsSource = [
+		`/**`,
+		` * Generated installed-component helpers for this Syncore app.`,
+		` *`,
+		` * THIS CODE IS AUTOMATICALLY GENERATED.`,
+		` *`,
+		` * To regenerate, run \`npx syncorejs dev\` or \`npx syncorejs codegen\`.`,
+		` * @module`,
+		` */`,
+		``,
+		`import { createInstalledComponentsApi, resolveComponentsManifest } from "syncorejs";`,
+		...renderGeneratedManifestImportLines(hasComponentsManifest, functionImportExtension),
+		``,
+		...renderGeneratedManifestDeclarationLines(hasComponentsManifest),
+		``,
+		`export const components = createInstalledComponentsApi(componentsManifest);`,
+		``,
+		`export const resolvedComponents = resolveComponentsManifest(componentsManifest);`,
+		``,
+		`export default resolvedComponents;`,
 		``
 	].join("\n");
 	const serverSource = [
@@ -213,7 +270,7 @@ async function runCodegen(cwd) {
 		`  ValidatorMap`,
 		`} from "syncorejs";`,
 		``,
-		`export { createFunctionReference, createFunctionReferenceFor, v } from "syncorejs";`,
+		`export { createFunctionReference, createFunctionReferenceFor, s } from "syncorejs";`,
 		``,
 		`/**`,
 		` * The context object available inside Syncore query handlers in this app.`,
@@ -240,22 +297,14 @@ async function runCodegen(cwd) {
 		` * @param config - The query definition, including args and a handler.`,
 		` * @returns The wrapped query. Export it from \`syncore/functions\` to add it to the generated API.`,
 		` */`,
-		`export function query<TValidator extends Validator<unknown>, TResult>(`,
-		`  config: FunctionConfig<QueryCtx, Infer<TValidator>, TResult> & { args: TValidator }`,
-		`): SyncoreFunctionDefinition<"query", QueryCtx, Infer<TValidator>, TResult>;`,
-		`export function query<TArgsShape extends ValidatorMap, TResult>(`,
-		`  config: FunctionConfig<QueryCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
-		`): SyncoreFunctionDefinition<"query", QueryCtx, InferArgs<TArgsShape>, TResult>;`,
-		`export function query<TArgsShape extends Validator<unknown> | ValidatorMap, TResult>(`,
-		`  config: FunctionConfig<QueryCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
-		`) {`,
-		`  return baseQuery(config as never) as SyncoreFunctionDefinition<`,
-		`    "query",`,
-		`    QueryCtx,`,
-		`    InferArgs<TArgsShape>,`,
-		`    TResult`,
-		`  >;`,
-		`}`,
+		`export const query = baseQuery as {`,
+		`  <TValidator extends Validator<unknown, unknown, string>, TResult>(`,
+		`    config: FunctionConfig<QueryCtx, Infer<TValidator>, TResult> & { args: TValidator }`,
+		`  ): SyncoreFunctionDefinition<"query", QueryCtx, Infer<TValidator>, TResult>;`,
+		`  <TArgsShape extends ValidatorMap, TResult>(`,
+		`    config: FunctionConfig<QueryCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
+		`  ): SyncoreFunctionDefinition<"query", QueryCtx, InferArgs<TArgsShape>, TResult>;`,
+		`};`,
 		``,
 		`/**`,
 		` * Define a mutation in this Syncore app's public API.`,
@@ -265,22 +314,14 @@ async function runCodegen(cwd) {
 		` * @param config - The mutation definition, including args and a handler.`,
 		` * @returns The wrapped mutation. Export it from \`syncore/functions\` to add it to the generated API.`,
 		` */`,
-		`export function mutation<TValidator extends Validator<unknown>, TResult>(`,
-		`  config: FunctionConfig<MutationCtx, Infer<TValidator>, TResult> & { args: TValidator }`,
-		`): SyncoreFunctionDefinition<"mutation", MutationCtx, Infer<TValidator>, TResult>;`,
-		`export function mutation<TArgsShape extends ValidatorMap, TResult>(`,
-		`  config: FunctionConfig<MutationCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
-		`): SyncoreFunctionDefinition<"mutation", MutationCtx, InferArgs<TArgsShape>, TResult>;`,
-		`export function mutation<TArgsShape extends Validator<unknown> | ValidatorMap, TResult>(`,
-		`  config: FunctionConfig<MutationCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
-		`) {`,
-		`  return baseMutation(config as never) as SyncoreFunctionDefinition<`,
-		`    "mutation",`,
-		`    MutationCtx,`,
-		`    InferArgs<TArgsShape>,`,
-		`    TResult`,
-		`  >;`,
-		`}`,
+		`export const mutation = baseMutation as {`,
+		`  <TValidator extends Validator<unknown, unknown, string>, TResult>(`,
+		`    config: FunctionConfig<MutationCtx, Infer<TValidator>, TResult> & { args: TValidator }`,
+		`  ): SyncoreFunctionDefinition<"mutation", MutationCtx, Infer<TValidator>, TResult>;`,
+		`  <TArgsShape extends ValidatorMap, TResult>(`,
+		`    config: FunctionConfig<MutationCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
+		`  ): SyncoreFunctionDefinition<"mutation", MutationCtx, InferArgs<TArgsShape>, TResult>;`,
+		`};`,
 		``,
 		`/**`,
 		` * Define an action in this Syncore app's public API.`,
@@ -290,26 +331,20 @@ async function runCodegen(cwd) {
 		` * @param config - The action definition, including args and a handler.`,
 		` * @returns The wrapped action. Export it from \`syncore/functions\` to add it to the generated API.`,
 		` */`,
-		`export function action<TValidator extends Validator<unknown>, TResult>(`,
-		`  config: FunctionConfig<ActionCtx, Infer<TValidator>, TResult> & { args: TValidator }`,
-		`): SyncoreFunctionDefinition<"action", ActionCtx, Infer<TValidator>, TResult>;`,
-		`export function action<TArgsShape extends ValidatorMap, TResult>(`,
-		`  config: FunctionConfig<ActionCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
-		`): SyncoreFunctionDefinition<"action", ActionCtx, InferArgs<TArgsShape>, TResult>;`,
-		`export function action<TArgsShape extends Validator<unknown> | ValidatorMap, TResult>(`,
-		`  config: FunctionConfig<ActionCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
-		`) {`,
-		`  return baseAction(config as never) as SyncoreFunctionDefinition<`,
-		`    "action",`,
-		`    ActionCtx,`,
-		`    InferArgs<TArgsShape>,`,
-		`    TResult`,
-		`  >;`,
-		`}`,
+		`export const action = baseAction as {`,
+		`  <TValidator extends Validator<unknown, unknown, string>, TResult>(`,
+		`    config: FunctionConfig<ActionCtx, Infer<TValidator>, TResult> & { args: TValidator }`,
+		`  ): SyncoreFunctionDefinition<"action", ActionCtx, Infer<TValidator>, TResult>;`,
+		`  <TArgsShape extends ValidatorMap, TResult>(`,
+		`    config: FunctionConfig<ActionCtx, InferArgs<TArgsShape>, TResult> & { args: TArgsShape }`,
+		`  ): SyncoreFunctionDefinition<"action", ActionCtx, InferArgs<TArgsShape>, TResult>;`,
+		`};`,
 		``
 	].join("\n");
 	await writeFile(path.join(generatedDir, "api.ts"), apiSource);
+	await writeFile(path.join(generatedDir, "components.ts"), componentsSource);
 	await writeFile(path.join(generatedDir, "functions.ts"), functionsSource);
+	await writeFile(path.join(generatedDir, "schema.ts"), schemaSource);
 	await writeFile(path.join(generatedDir, "server.ts"), serverSource);
 }
 async function scaffoldProject(cwd, options) {
@@ -345,19 +380,26 @@ function buildTemplateFiles(template) {
 		},
 		{
 			path: path.join("syncore", "schema.ts"),
-			content: `import { defineSchema, defineTable, v } from "syncorejs";
+			content: `import { defineSchema, defineTable, s } from "syncorejs";
 
 export default defineSchema({
   tasks: defineTable({
-    text: v.string(),
-    done: v.boolean()
+    text: s.string(),
+    done: s.boolean()
   }).index("by_done", ["done"])
 });
+`
+		},
+		{
+			path: path.join("syncore", "components.ts"),
+			content: `import { defineComponents } from "syncorejs";
+
+export default defineComponents({});
 `
 		},
 		{
 			path: path.join("syncore", "functions", "tasks.ts"),
-			content: `import { mutation, query, v } from "../_generated/server";
+			content: `import { mutation, query, s } from "../_generated/server";
 
 export const list = query({
   args: {},
@@ -366,7 +408,7 @@ export const list = query({
 });
 
 export const create = mutation({
-  args: { text: v.string() },
+  args: { text: s.string() },
   handler: async (ctx, args) =>
     ctx.db.insert("tasks", { text: args.text, done: false })
 });
@@ -380,13 +422,15 @@ export const create = mutation({
 				content: `/// <reference lib="webworker" />
 
 import { createBrowserWorkerRuntime } from "syncorejs/browser";
-import schema from "../syncore/schema";
+import schema from "../syncore/_generated/schema";
+import { resolvedComponents } from "../syncore/_generated/components";
 import { functions } from "../syncore/_generated/functions";
 
 void createBrowserWorkerRuntime({
   endpoint: self,
   schema,
   functions,
+  components: resolvedComponents,
   databaseName: "syncore-app",
   persistenceMode: "opfs"
 });
@@ -410,12 +454,14 @@ export function AppSyncoreProvider({ children }: { children: ReactNode }) {
 			files.push({
 				path: path.join("lib", "syncore.ts"),
 				content: `import { createExpoSyncoreBootstrap } from "syncorejs/expo";
-import schema from "../syncore/schema";
+import schema from "../syncore/_generated/schema";
+import { resolvedComponents } from "../syncore/_generated/components";
 import { functions } from "../syncore/_generated/functions";
 
 export const syncore = createExpoSyncoreBootstrap({
   schema,
   functions,
+  components: resolvedComponents,
   databaseName: "syncore-app.db",
   storageDirectoryName: "syncore-app-storage"
 });
@@ -428,13 +474,15 @@ export const syncore = createExpoSyncoreBootstrap({
 				content: `/* eslint-disable */
 
 import { createBrowserWorkerRuntime } from "syncorejs/browser";
-import schema from "../syncore/schema";
+import schema from "../syncore/_generated/schema";
+import { resolvedComponents } from "../syncore/_generated/components";
 import { functions } from "../syncore/_generated/functions";
 
 void createBrowserWorkerRuntime({
   endpoint: self,
   schema,
   functions,
+  components: resolvedComponents,
   databaseName: "syncore-app",
   persistenceDatabaseName: "syncore-app",
   locateFile: () => "/sql-wasm.wasm",
@@ -469,7 +517,8 @@ export function AppSyncoreProvider({ children }: { children: ReactNode }) {
 				content: `import path from "node:path";
 import { withNodeSyncoreClient } from "syncorejs/node";
 import { api } from "./syncore/_generated/api.ts";
-import schema from "./syncore/schema.ts";
+import schema from "./syncore/_generated/schema.ts";
+import { resolvedComponents } from "./syncore/_generated/components.ts";
 import { functions } from "./syncore/_generated/functions.ts";
 
 await withNodeSyncoreClient(
@@ -477,7 +526,8 @@ await withNodeSyncoreClient(
     databasePath: path.join(process.cwd(), ".syncore", "syncore.db"),
     storageDirectory: path.join(process.cwd(), ".syncore", "storage"),
     schema,
-    functions
+    functions,
+    components: resolvedComponents
   },
   async (client) => {
     await client.mutation(api.tasks.create, { text: "Run locally" });
@@ -493,7 +543,8 @@ await withNodeSyncoreClient(
 				content: `import path from "node:path";
 import { app } from "electron";
 import { createNodeSyncoreRuntime } from "syncorejs/node";
-import schema from "../syncore/schema.js";
+import schema from "../syncore/_generated/schema.js";
+import { resolvedComponents } from "../syncore/_generated/components.js";
 import { functions } from "../syncore/_generated/functions.js";
 
 export function createAppSyncoreRuntime() {
@@ -503,6 +554,7 @@ export function createAppSyncoreRuntime() {
     storageDirectory: path.join(userDataDirectory, "storage"),
     schema,
     functions,
+    components: resolvedComponents,
     platform: "electron-main"
   });
 }
@@ -768,12 +820,19 @@ function renderGeneratedFunctionsInterface(functionEntries) {
 		`/**`,
 		` * Type-safe runtime definitions for every function exported from \`syncore/functions\`.`,
 		` */`,
-		`export interface SyncoreFunctionsRegistry extends SyncoreFunctionRegistry {`
+		`export interface SyncoreRootFunctionsRegistry extends SyncoreFunctionRegistry {`
 	];
 	for (const entry of functionEntries.slice().sort((left, right) => `${left.pathParts.join("/")}/${left.exportName}`.localeCompare(`${right.pathParts.join("/")}/${right.exportName}`))) lines.push(`  /**`, `   * Runtime definition for the public Syncore ${entry.kind} \`${entry.pathParts.join("/")}/${entry.exportName}\`.`, `   */`, `  readonly ${JSON.stringify(`${entry.pathParts.join("/")}/${entry.exportName}`)}: typeof ${renderFunctionImportName(entry)};`);
 	lines.push(`}`);
 	return [lines.join("\n")];
 }
+function renderGeneratedManifestImportLines(hasComponentsManifest, extension) {
+	if (!hasComponentsManifest) return [];
+	return [`import componentsManifest from "../components${extension}";`];
+}
+function renderGeneratedManifestDeclarationLines(hasComponentsManifest) {
+	return hasComponentsManifest ? [] : [`const componentsManifest = {} as const;`];
+}
 function renderApiInterfaceName(node) {
 	if (node.pathParts.length === 0) return "SyncoreApi";
 	return `SyncoreApi__${node.pathParts.map(toTypeNamePart).join("__")}`;
@@ -831,11 +890,25 @@ function requireProjectTargetConfig(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) {
+async function loadProjectRootSchema(cwd) {
 	const schema = await loadDefaultExport(path.join(cwd, "syncore", "schema.ts"));
 	if (!schema || typeof schema !== "object" || typeof schema.tableNames !== "function") throw new Error("syncore/schema.ts must default export defineSchema(...).");
 	return schema;
 }
+async function loadProjectComponentsManifest(cwd) {
+	const filePath = path.join(cwd, "syncore", "components.ts");
+	if (!await fileExists(filePath)) return {};
+	const manifest = await loadDefaultExport(filePath);
+	if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) throw new Error("syncore/components.ts must default export defineComponents({...}).");
+	return manifest;
+}
+async function loadProjectSchema(cwd) {
+	const filePath = path.join(cwd, "syncore", "_generated", "schema.ts");
+	if (!await fileExists(filePath)) await runCodegen(cwd);
+	const schema = await loadDefaultExport(filePath);
+	if (!schema || typeof schema !== "object" || typeof schema.tableNames !== "function") throw new Error("syncore/_generated/schema.ts must default export a composed Syncore schema.");
+	return schema;
+}
 async function loadDefaultExport(filePath) {
 	if (!await fileExists(filePath)) throw new Error(`Missing file: ${path.relative(process.cwd(), filePath)}`);
 	const moduleUrl = pathToFileURL(filePath).href;
@@ -856,10 +929,19 @@ async function loadNamedExport(filePath, exportName) {
 	return resolvedValue;
 }
 async function loadProjectFunctions(cwd) {
-	const functions = await loadNamedExport(path.join(cwd, "syncore", "_generated", "functions.ts"), "functions");
+	const filePath = path.join(cwd, "syncore", "_generated", "functions.ts");
+	if (!await fileExists(filePath)) await runCodegen(cwd);
+	const functions = await loadNamedExport(filePath, "functions");
 	if (!functions || typeof functions !== "object") throw new Error("syncore/_generated/functions.ts must export a functions registry.");
 	return functions;
 }
+async function loadProjectResolvedComponents(cwd) {
+	const filePath = path.join(cwd, "syncore", "_generated", "components.ts");
+	if (!await fileExists(filePath)) await runCodegen(cwd);
+	const components = await loadNamedExport(filePath, "resolvedComponents");
+	if (!Array.isArray(components)) throw new Error("syncore/_generated/components.ts must export resolvedComponents.");
+	return components;
+}
 var HubSqliteDriver = class {
 	database;
 	transactionDepth = 0;
@@ -1033,8 +1115,11 @@ const hubDevtoolsSqlSupport = {
 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 [schema, functions, components] = await Promise.all([
+		loadProjectSchema(cwd),
+		loadProjectFunctions(cwd),
+		loadProjectResolvedComponents(cwd)
+	]);
 	const databasePath = path.resolve(cwd, projectTarget.databasePath);
 	const storageDirectory = path.resolve(cwd, projectTarget.storageDirectory);
 	await mkdir(path.dirname(databasePath), { recursive: true });
@@ -1043,6 +1128,7 @@ async function createProjectTargetBackend(cwd) {
 	const runtime = new SyncoreRuntime({
 		schema,
 		functions,
+		components,
 		driver,
 		storage: new HubFileStorageAdapter(storageDirectory),
 		platform: "project"
@@ -1052,19 +1138,22 @@ async function createProjectTargetBackend(cwd) {
 		driver,
 		schema,
 		functions,
-		runtime,
+		admin: runtime.getAdmin(),
 		sql: hubDevtoolsSqlSupport
 	});
 	const subscriptionHost = createDevtoolsSubscriptionHost({
 		driver,
 		schema,
 		functions,
-		runtime,
+		admin: runtime.getAdmin(),
 		sql: hubDevtoolsSqlSupport
 	});
 	return {
 		hello: {
 			type: "hello",
+			protocolVersion: SYNCORE_DEVTOOLS_PROTOCOL_VERSION,
+			minSupportedProtocolVersion: SYNCORE_DEVTOOLS_MIN_SUPPORTED_PROTOCOL_VERSION,
+			maxSupportedProtocolVersion: SYNCORE_DEVTOOLS_MAX_SUPPORTED_PROTOCOL_VERSION,
 			runtimeId: PROJECT_TARGET_RUNTIME_ID,
 			platform: "project",
 			sessionLabel: "Project Target",
@@ -1239,16 +1328,26 @@ function applyMigrationSql(database, sql, fileName) {
 async function startDevHub(options) {
 	const dashboardPort = resolvePortFromEnv("SYNCORE_DASHBOARD_PORT", 4310);
 	const devtoolsPort = resolvePortFromEnv("SYNCORE_DEVTOOLS_PORT", 4311);
+	const dashboardUrl = `http://localhost:${dashboardPort}`;
+	const devtoolsUrl = `ws://127.0.0.1:${devtoolsPort}`;
 	const logsDirectory = path.join(options.cwd, ".syncore", "logs");
 	const logFilePath = path.join(logsDirectory, "runtime.jsonl");
+	const hubAccessToken = sanitizeDevtoolsToken(process.env.SYNCORE_DEVTOOLS_TOKEN) ?? generateDevtoolsToken();
+	const sessionState = {
+		dashboardUrl,
+		authenticatedDashboardUrl: `${dashboardUrl}/?token=${hubAccessToken}`,
+		devtoolsUrl,
+		token: hubAccessToken
+	};
 	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://localhost:${devtoolsPort}. Reusing existing hub/dashboard.`);
-		return;
+		return await readDevtoolsSessionState(options.cwd) ?? sessionState;
 	}
+	await writeDevtoolsSessionState(options.cwd, sessionState);
 	let projectTargetBackend = null;
 	try {
 		projectTargetBackend = await createProjectTargetBackend(options.cwd);
@@ -1271,6 +1370,9 @@ async function startDevHub(options) {
 	const dashboardSubscriptions = /* @__PURE__ */ new Map();
 	const hello = {
 		type: "hello",
+		protocolVersion: SYNCORE_DEVTOOLS_PROTOCOL_VERSION,
+		minSupportedProtocolVersion: SYNCORE_DEVTOOLS_MIN_SUPPORTED_PROTOCOL_VERSION,
+		maxSupportedProtocolVersion: SYNCORE_DEVTOOLS_MAX_SUPPORTED_PROTOCOL_VERSION,
 		runtimeId: "syncore-dev-hub",
 		platform: "dev"
 	};
@@ -1300,7 +1402,18 @@ async function startDevHub(options) {
 			event
 		})}\n`);
 	};
-	websocketServer.on("connection", (socket) => {
+	websocketServer.on("connection", (socket, request) => {
+		const isBrowserDashboardClient = isAllowedDashboardOrigin(request.headers.origin, dashboardPort);
+		const isAuthorizedDashboardClient = !isBrowserDashboardClient || isAuthorizedDashboardRequest({
+			requestUrl: request.url,
+			originHeader: request.headers.origin,
+			dashboardPort,
+			expectedToken: hubAccessToken
+		});
+		if (isBrowserDashboardClient && !isAuthorizedDashboardClient) {
+			socket.close(1008, "Unauthorized devtools client");
+			return;
+		}
 		dashboardSockets.add(socket);
 		socket.send(JSON.stringify(hello));
 		for (const runtimeHello of runtimeHellos.values()) socket.send(JSON.stringify(runtimeHello));
@@ -1318,10 +1431,15 @@ async function startDevHub(options) {
 			if (rawPayload.length === 0) return;
 			const message = JSON.parse(rawPayload);
 			if (message.type === "ping") {
+				if (!isAuthorizedDashboardClient) {
+					socket.close(1008, "Unauthorized devtools client");
+					return;
+				}
 				socket.send(JSON.stringify({ type: "pong" }));
 				return;
 			}
 			if (message.type === "command") {
+				if (!isAuthorizedDashboardClient) return;
 				const targetRuntimeId = message.targetRuntimeId;
 				if (!targetRuntimeId) return;
 				if (targetRuntimeId === PROJECT_TARGET_RUNTIME_ID && projectTargetBackend) {
@@ -1342,6 +1460,7 @@ async function startDevHub(options) {
 				return;
 			}
 			if (message.type === "subscribe") {
+				if (!isAuthorizedDashboardClient) return;
 				const targetRuntimeId = message.targetRuntimeId;
 				if (!targetRuntimeId) return;
 				const subscriptions = dashboardSubscriptions.get(socket) ?? /* @__PURE__ */ new Map();
@@ -1375,6 +1494,7 @@ async function startDevHub(options) {
 				return;
 			}
 			if (message.type === "unsubscribe") {
+				if (!isAuthorizedDashboardClient) return;
 				const subscriptions = dashboardSubscriptions.get(socket);
 				const subscription = subscriptions?.get(message.subscriptionId);
 				if (!subscription) return;
@@ -1481,25 +1601,29 @@ async function startDevHub(options) {
 		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://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 {
-				await (await (await import("vite")).createServer({
-					configFile: path.join(dashboardRoot, "vite.config.ts"),
-					root: dashboardRoot,
-					server: { port: dashboardPort }
-				})).listen();
-				console.log(`Dashboard shell: http://localhost:${dashboardPort}`);
-			} catch (error) {
-				console.log(`Dashboard source not started automatically: ${formatError(error)}`);
-			}
-		})();
+	await new Promise((resolve, reject) => {
+		httpServer.once("error", reject);
+		httpServer.listen(devtoolsPort, "127.0.0.1", () => {
+			httpServer.off("error", reject);
+			resolve();
+		});
 	});
+	console.log(`Syncore devtools hub: ws://localhost:${devtoolsPort}`);
+	console.log(`Devtools dashboard token: ${hubAccessToken}`);
+	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 {
+		await (await (await import("vite")).createServer({
+			configFile: path.join(dashboardRoot, "vite.config.ts"),
+			root: dashboardRoot,
+			server: { port: dashboardPort }
+		})).listen();
+		console.log(`Dashboard shell: ${sessionState.authenticatedDashboardUrl}`);
+	} catch (error) {
+		console.log(`Dashboard source not started automatically: ${formatError(error)}`);
+	}
 	const close = () => {
 		projectTargetBackend?.dispose();
 		websocketServer.close();
@@ -1508,6 +1632,29 @@ async function startDevHub(options) {
 	};
 	process.on("SIGINT", close);
 	process.on("SIGTERM", close);
+	return sessionState;
+}
+async function writeDevtoolsSessionState(cwd, state) {
+	const sessionPath = path.join(cwd, DEVTOOLS_SESSION_FILE);
+	await mkdir(path.dirname(sessionPath), { recursive: true });
+	await writeFile(sessionPath, `${JSON.stringify(state, null, 2)}\n`);
+}
+async function readDevtoolsSessionState(cwd) {
+	const sessionPath = path.join(cwd, DEVTOOLS_SESSION_FILE);
+	if (!await fileExists(sessionPath)) return null;
+	try {
+		const source = await readFile(sessionPath, "utf8");
+		const parsed = JSON.parse(source);
+		if (typeof parsed.dashboardUrl !== "string" || typeof parsed.authenticatedDashboardUrl !== "string" || typeof parsed.devtoolsUrl !== "string" || typeof parsed.token !== "string") return null;
+		return {
+			dashboardUrl: parsed.dashboardUrl,
+			authenticatedDashboardUrl: parsed.authenticatedDashboardUrl,
+			devtoolsUrl: parsed.devtoolsUrl,
+			token: parsed.token
+		};
+	} catch {
+		return null;
+	}
 }
 async function setupDevProjectWatch(cwd, template) {
 	const snapshot = await createDevWatchSnapshot(cwd);
@@ -1558,6 +1705,10 @@ async function runDevProjectBootstrap(cwd, template) {
 			else console.log("Schema snapshot updated.");
 		}
 		for (const warning of plan.warnings) console.warn(`Syncore dev warning: ${warning}`);
+		if (templateUsesConnectedClients(template)) {
+			console.log("Syncore dev is ready. Codegen refreshed; waiting for a connected client runtime to apply schema locally.");
+			return;
+		}
 		const appliedCount = await applyProjectMigrations(cwd);
 		console.log(`Syncore dev is ready. Codegen refreshed; ${appliedCount} migration(s) applied.`);
 	} catch (error) {
@@ -1644,6 +1795,6 @@ function toSearchValue(value) {
 	return stableStringify(value);
 }
 //#endregion
-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 };
+export { SYNCORE_MIGRATION_SNAPSHOT_FILE_NAME, VALID_SYNCORE_TEMPLATES, applyProjectMigrations, detectProjectTemplate, fileExists, formatError, getNextMigrationNumber, hasSyncoreProject, importJsonlIntoProject, isLocalPortInUse, loadProjectComponentsManifest, loadProjectConfig, loadProjectFunctions, loadProjectResolvedComponents, loadProjectRootSchema, loadProjectSchema, logScaffoldResult, readPackageJson, readStoredSnapshot, resolveDefaultSeedFile, resolvePortFromEnv, resolveProjectTargetConfig, resolveRequestedTemplate, runCodegen, runDevProjectBootstrap, runSyncoreCli, scaffoldProject, slugify, startDevHub, templateUsesConnectedClients, writeStoredSnapshot };
 
 //# sourceMappingURL=cli.mjs.map