syncorejs 0.2.1 → 0.2.3

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,16 +13,22 @@ 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
-const COMBINED_DEV_COMMAND = "concurrently --kill-others-on-fail --names syncore,app --prefix-colors yellow,cyan \"bun run syncorejs:dev\" \"bun run dev:app\"";
+function templateUsesConnectedClients(template) {
+	return template === "react-web" || template === "svelte" || template === "expo" || template === "next";
+}
+const loadedTypeScriptModules = /* @__PURE__ */ new Map();
+const COMBINED_DEV_COMMAND = "concurrently --kill-others-on-fail --names syncore,app --prefix-colors yellow,cyan \"npm run syncorejs:dev\" \"npm 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",
 	"node",
 	"react-web",
+	"svelte",
 	"expo",
 	"electron",
 	"next"
@@ -123,8 +130,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 hasNonEmptyComponentsManifest(componentsManifestPath);
 	const files = await listTypeScriptFiles(functionsDir);
 	const functionEntries = [];
 	for (const file of files) {
@@ -148,6 +157,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 +185,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 +198,72 @@ 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 runtimeSource = [
+		`/**`,
+		` * Generated local runtime bundle for Syncore CLI and Node adapters.`,
+		` *`,
+		` * THIS CODE IS AUTOMATICALLY GENERATED.`,
+		` *`,
+		` * To regenerate, run \`npx syncorejs dev\` or \`npx syncorejs codegen\`.`,
+		` * @module`,
+		` */`,
+		``,
+		`import schema from "./schema${functionImportExtension}";`,
+		`import { functions } from "./functions${functionImportExtension}";`,
+		...hasComponentsManifest ? [`import { resolvedComponents } from "./components${functionImportExtension}";`] : [`const resolvedComponents = [] as const;`],
+		``,
+		`export { functions, schema };`,
+		`export const components = resolvedComponents;`,
 		``
 	].join("\n");
 	const serverSource = [
@@ -213,7 +290,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 +317,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 +334,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,27 +351,28 @@ 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, "functions.ts"), functionsSource);
-	await writeFile(path.join(generatedDir, "server.ts"), serverSource);
+	await writeGeneratedFile(path.join(generatedDir, "api.ts"), apiSource);
+	await writeGeneratedFile(path.join(generatedDir, "components.ts"), componentsSource);
+	await writeGeneratedFile(path.join(generatedDir, "functions.ts"), functionsSource);
+	await writeGeneratedFile(path.join(generatedDir, "runtime.ts"), runtimeSource);
+	await writeGeneratedFile(path.join(generatedDir, "schema.ts"), schemaSource);
+	await writeGeneratedFile(path.join(generatedDir, "server.ts"), serverSource);
+}
+async function writeGeneratedFile(filePath, source) {
+	try {
+		if (await readFile(filePath, "utf8") === source) return;
+	} catch {}
+	await writeFile(filePath, source);
 }
 async function scaffoldProject(cwd, options) {
 	const files = buildTemplateFiles(options.template);
@@ -345,19 +407,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 +435,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,15 +449,13 @@ 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 { functions } from "../syncore/_generated/functions";
 
 void createBrowserWorkerRuntime({
   endpoint: self,
   schema,
-  functions,
-  databaseName: "syncore-app",
-  persistenceMode: "opfs"
+  functions
 });
 `
 			}, {
@@ -410,14 +477,12 @@ 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 { functions } from "../syncore/_generated/functions";
 
 export const syncore = createExpoSyncoreBootstrap({
   schema,
-  functions,
-  databaseName: "syncore-app.db",
-  storageDirectoryName: "syncore-app-storage"
+  functions
 });
 `
 			});
@@ -428,17 +493,13 @@ export const syncore = createExpoSyncoreBootstrap({
 				content: `/* eslint-disable */
 
 import { createBrowserWorkerRuntime } from "syncorejs/browser";
-import schema from "../syncore/schema";
+import schema from "../syncore/_generated/schema";
 import { functions } from "../syncore/_generated/functions";
 
 void createBrowserWorkerRuntime({
   endpoint: self,
   schema,
-  functions,
-  databaseName: "syncore-app",
-  persistenceDatabaseName: "syncore-app",
-  locateFile: () => "/sql-wasm.wasm",
-  platform: "browser-worker"
+  functions
 });
 `
 			}, {
@@ -469,7 +530,7 @@ 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 { functions } from "./syncore/_generated/functions.ts";
 
 await withNodeSyncoreClient(
@@ -493,7 +554,7 @@ 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 { functions } from "../syncore/_generated/functions.js";
 
 export function createAppSyncoreRuntime() {
@@ -506,6 +567,50 @@ export function createAppSyncoreRuntime() {
     platform: "electron-main"
   });
 }
+`
+			});
+			break;
+		case "svelte":
+			files.push({
+				path: path.join("src", "syncore.worker.ts"),
+				content: `/// <reference lib="webworker" />
+
+import { createBrowserWorkerRuntime } from "syncorejs/browser";
+import schema from "../syncore/_generated/schema";
+import { functions } from "../syncore/_generated/functions";
+
+void createBrowserWorkerRuntime({
+  endpoint: self,
+  schema,
+  functions
+});
+`
+			}, {
+				path: path.join("src", "SyncoreProvider.svelte"),
+				content: `<script lang="ts">
+  import { onDestroy } from "svelte";
+  import type { Snippet } from "svelte";
+  import { createBrowserWorkerClient } from "syncorejs/browser";
+  import { setSyncoreClient } from "syncorejs/svelte";
+
+  interface Props {
+    children?: Snippet;
+  }
+
+  const { children }: Props = $props();
+
+  const managed = createBrowserWorkerClient({
+    workerUrl: new URL("./syncore.worker.ts", import.meta.url)
+  });
+
+  setSyncoreClient(managed.client);
+
+  onDestroy(() => {
+    void managed.dispose();
+  });
+<\/script>
+
+{@render children?.()}
 `
 			});
 			break;
@@ -554,7 +659,8 @@ async function detectProjectTemplate(cwd) {
 	if ("expo" in dependencies || "react-native" in dependencies) return "expo";
 	if ("electron" in dependencies) return "electron";
 	if ("next" in dependencies) return "next";
-	if ("vite" in dependencies || "@vitejs/plugin-react" in dependencies || await fileExists(path.join(cwd, "src", "main.tsx")) && "react" in dependencies) return "react-web";
+	if ("svelte" in dependencies || "@sveltejs/vite-plugin-svelte" in dependencies || "@sveltejs/kit" in dependencies || await fileExists(path.join(cwd, "src", "SyncoreProvider.svelte"))) return "svelte";
+	if ("vite" in dependencies || "@vitejs/plugin-react" in dependencies || await fileExists(path.join(cwd, "src", "syncore.worker.ts")) || await fileExists(path.join(cwd, "src", "syncore-provider.tsx")) || await fileExists(path.join(cwd, "src", "main.tsx")) && "react" in dependencies) return "react-web";
 	if (packageJson) return "node";
 	return "minimal";
 }
@@ -569,7 +675,16 @@ async function readPackageJson(cwd) {
 }
 async function ensurePackageScripts(cwd, template) {
 	const packageJsonPath = path.join(cwd, "package.json");
-	if (!await fileExists(packageJsonPath)) return;
+	if (!await fileExists(packageJsonPath)) {
+		await writeFile(packageJsonPath, `${JSON.stringify({
+			type: "module",
+			scripts: {
+				"syncorejs:dev": "syncorejs dev",
+				"syncorejs:codegen": "syncorejs codegen"
+			}
+		}, null, 2)}\n`);
+		return;
+	}
 	const packageJson = await readPackageJson(cwd);
 	if (!packageJson) return;
 	const nextPackageJson = {
@@ -602,7 +717,7 @@ function maybeAddManagedDevScripts(packageJson, template) {
 	scripts.dev = combinedDevCommand();
 }
 function supportsManagedCombinedDev(template) {
-	return template === "next" || template === "react-web" || template === "electron";
+	return template === "next" || template === "react-web" || template === "svelte" || template === "electron";
 }
 function combinedDevCommand() {
 	return COMBINED_DEV_COMMAND;
@@ -651,7 +766,7 @@ async function importJsonlIntoProject(cwd, tableName, sourcePath) {
 			try {
 				parsed = JSON.parse(line);
 			} catch (error) {
-				throw new Error(`Invalid JSON on line ${lineNumber} of ${sourcePath}: ${formatError(error)}`);
+				throw new Error(`Invalid JSON on line ${lineNumber} of ${sourcePath}: ${formatError(error)}`, { cause: error });
 			}
 			if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) throw new Error(`Line ${lineNumber} of ${sourcePath} must contain a JSON object.`);
 			const payload = { ...parsed };
@@ -768,12 +883,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,15 +953,28 @@ 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;
-	const loaded = await tsImport(moduleUrl, { parentURL: import.meta.url });
+	const loaded = await loadTypeScriptModule(filePath);
 	if (!("default" in loaded)) throw new Error(`File ${path.relative(process.cwd(), filePath)} must have a default export.`);
 	const resolvedDefault = unwrapDefaultExport(loaded.default);
 	if (resolvedDefault === void 0) throw new Error(`File ${path.relative(process.cwd(), filePath)} exported undefined.`);
@@ -847,24 +982,94 @@ async function loadDefaultExport(filePath) {
 }
 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 loaded = await loadTypeScriptModule(filePath);
 	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 hasNonEmptyComponentsManifest(filePath) {
+	if (!await fileExists(filePath)) return false;
+	const source = await readFile(filePath, "utf8");
+	return !/defineComponents\s*\(\s*\{\s*\}\s*\)/.test(source);
+}
+async function loadTypeScriptModule(filePath) {
+	const fileStat = await stat(filePath);
+	const cached = loadedTypeScriptModules.get(filePath);
+	if (cached && cached.mtimeMs === fileStat.mtimeMs) return await cached.loaded;
+	const moduleUrl = pathToFileURL(filePath).href;
+	const loaded = tsImport(moduleUrl, { parentURL: import.meta.url });
+	loadedTypeScriptModules.set(filePath, {
+		mtimeMs: fileStat.mtimeMs,
+		loaded
+	});
+	return await loaded;
+}
 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 componentsManifestPath = path.join(cwd, "syncore", "components.ts");
+	if (await fileExists(componentsManifestPath)) {
+		const source = await readFile(componentsManifestPath, "utf8");
+		if (/defineComponents\s*\(\s*\{\s*\}\s*\)/.test(source)) return [];
+	}
+	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;
+}
+async function loadProjectRuntime(cwd) {
+	const filePath = path.join(cwd, "syncore", "_generated", "runtime.ts");
+	if (!await fileExists(filePath)) await runCodegen(cwd);
+	const loaded = await loadTypeScriptModule(filePath);
+	const schema = unwrapDefaultExport(loaded.schema);
+	const functions = unwrapDefaultExport(loaded.functions);
+	const components = unwrapDefaultExport(loaded.components);
+	if (!schema || typeof schema !== "object" || typeof schema.tableNames !== "function") throw new Error("syncore/_generated/runtime.ts must export a composed Syncore schema.");
+	if (!functions || typeof functions !== "object") throw new Error("syncore/_generated/runtime.ts must export a functions registry.");
+	if (!Array.isArray(components)) throw new Error("syncore/_generated/runtime.ts must export resolved components.");
+	return {
+		schema,
+		functions,
+		components
+	};
+}
+var HubExternalChangeSignal = class {
+	publishToHub;
+	listeners = /* @__PURE__ */ new Set();
+	constructor(publishToHub) {
+		this.publishToHub = publishToHub;
+	}
+	subscribe(listener) {
+		this.listeners.add(listener);
+		return () => {
+			this.listeners.delete(listener);
+		};
+	}
+	publish(event) {
+		return this.publishToHub(event);
+	}
+	receive(event) {
+		for (const listener of this.listeners) listener(event);
+	}
+	close() {
+		this.listeners.clear();
+	}
+};
 var HubSqliteDriver = class {
+	databasePath;
 	database;
 	transactionDepth = 0;
-	constructor(filename) {
-		this.database = new DatabaseSync(filename);
+	constructor(databasePath) {
+		this.databasePath = databasePath;
+		this.database = new DatabaseSync(databasePath);
 		this.database.exec("PRAGMA foreign_keys = ON;");
 		this.database.exec("PRAGMA journal_mode = WAL;");
 	}
@@ -917,6 +1122,7 @@ var HubSqliteDriver = class {
 	}
 };
 var HubFileStorageAdapter = class {
+	directory;
 	constructor(directory) {
 		this.directory = directory;
 	}
@@ -1030,11 +1236,10 @@ const hubDevtoolsSqlSupport = {
 		}
 	}
 };
-async function createProjectTargetBackend(cwd) {
+async function createProjectTargetBackend(cwd, externalChangeSignal) {
 	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 loadProjectRuntime(cwd);
 	const databasePath = path.resolve(cwd, projectTarget.databasePath);
 	const storageDirectory = path.resolve(cwd, projectTarget.storageDirectory);
 	await mkdir(path.dirname(databasePath), { recursive: true });
@@ -1043,35 +1248,42 @@ async function createProjectTargetBackend(cwd) {
 	const runtime = new SyncoreRuntime({
 		schema,
 		functions,
+		components,
 		driver,
 		storage: new HubFileStorageAdapter(storageDirectory),
-		platform: "project"
+		platform: "project",
+		...externalChangeSignal ? { externalChangeSignal } : {}
 	});
-	await runtime.prepareForDirectAccess();
+	await runtime.start();
 	const commandHandler = createDevtoolsCommandHandler({
 		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",
 			targetKind: "project",
+			runtimeRole: "project-target",
 			storageProtocol: "file",
 			databaseLabel: path.basename(databasePath),
-			storageIdentity: `file::${databasePath}`
+			storageIdentity: `file::${databasePath}`,
+			capabilities: createProjectDevtoolsCapabilities()
 		},
 		handleCommand: commandHandler,
 		subscribe(subscriptionId, payload, listener) {
@@ -1086,6 +1298,24 @@ async function createProjectTargetBackend(cwd) {
 		}
 	};
 }
+function createProjectDevtoolsCapabilities() {
+	return {
+		sql: {
+			read: true,
+			write: true,
+			live: true
+		},
+		data: {
+			browse: true,
+			mutate: true,
+			importExport: true
+		},
+		scheduler: {
+			read: true,
+			edit: true
+		}
+	};
+}
 function normalizeStorageInput(input) {
 	if (typeof input === "string") return Buffer.from(input);
 	if (input instanceof Uint8Array) return input;
@@ -1208,16 +1438,24 @@ function formatError(error) {
 }
 async function isLocalPortInUse(port) {
 	return await new Promise((resolve) => {
+		let settled = false;
 		const socket = connect({
 			host: "127.0.0.1",
 			port
 		});
+		const finish = (inUse) => {
+			if (settled) return;
+			settled = true;
+			clearTimeout(timeout);
+			socket.destroy();
+			resolve(inUse);
+		};
+		const timeout = setTimeout(() => finish(false), 100);
 		socket.once("connect", () => {
-			socket.end();
-			resolve(true);
+			finish(true);
 		});
 		socket.once("error", () => {
-			resolve(false);
+			finish(false);
 		});
 	});
 }
@@ -1239,22 +1477,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;
-	}
-	let projectTargetBackend = null;
-	try {
-		projectTargetBackend = await createProjectTargetBackend(options.cwd);
-	} catch (error) {
-		console.warn(`Project target fallback unavailable: ${formatError(error)}`);
+		return await readDevtoolsSessionState(options.cwd) ?? sessionState;
 	}
+	await writeDevtoolsSessionState(options.cwd, sessionState);
 	const httpServer = createServer((_request, response) => {
 		response.writeHead(200, { "content-type": "application/json" });
 		response.end(JSON.stringify({
@@ -1269,8 +1511,19 @@ async function startDevHub(options) {
 	const socketRuntimeIds = /* @__PURE__ */ new Map();
 	const dashboardSockets = /* @__PURE__ */ new Set();
 	const dashboardSubscriptions = /* @__PURE__ */ new Map();
+	let relayExternalChange = () => {};
+	const projectTargetExternalChangeSignal = new HubExternalChangeSignal((event) => relayExternalChange(PROJECT_TARGET_RUNTIME_ID, runtimeHellos.get(PROJECT_TARGET_RUNTIME_ID)?.storageIdentity ?? "", event));
+	let projectTargetBackend = null;
+	try {
+		projectTargetBackend = await createProjectTargetBackend(options.cwd, projectTargetExternalChangeSignal);
+	} catch (error) {
+		console.warn(`Project target fallback unavailable: ${formatError(error)}`);
+	}
 	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"
 	};
@@ -1278,12 +1531,30 @@ async function startDevHub(options) {
 		runtimeHellos.set(PROJECT_TARGET_RUNTIME_ID, projectTargetBackend.hello);
 		runtimeEvents.set(PROJECT_TARGET_RUNTIME_ID, []);
 	}
+	relayExternalChange = (sourceRuntimeId, storageIdentity, event) => {
+		if (!storageIdentity) return;
+		const message = {
+			type: "external.change",
+			runtimeId: sourceRuntimeId,
+			storageIdentity,
+			event
+		};
+		for (const [runtimeId, runtimeHello] of runtimeHellos) {
+			if (runtimeId === sourceRuntimeId || runtimeHello.storageIdentity !== storageIdentity) continue;
+			if (runtimeId === PROJECT_TARGET_RUNTIME_ID) {
+				projectTargetExternalChangeSignal.receive(event);
+				continue;
+			}
+			const targetSocket = runtimeSockets.get(runtimeId);
+			if (targetSocket?.readyState === WebSocket.OPEN) targetSocket.send(JSON.stringify(message));
+		}
+	};
 	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 clientRuntimeIds = [...runtimeHellos.values()].filter((hello) => hello.runtimeId !== "syncore-dev-hub").map((hello) => hello.runtimeId).sort();
+		const clientTargetKeys = [...runtimeHellos.values()].filter((hello) => hello.runtimeId !== "syncore-dev-hub").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 targetId = event.runtimeId === "syncore-dev-hub" ? "all" : 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;
@@ -1300,7 +1571,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 +1600,20 @@ 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 === "external.change") {
+				const storageIdentity = runtimeHellos.get(message.runtimeId)?.storageIdentity ?? message.storageIdentity;
+				if (storageIdentity && storageIdentity === message.storageIdentity) relayExternalChange(message.runtimeId, storageIdentity, message.event);
+				return;
+			}
 			if (message.type === "command") {
+				if (!isAuthorizedDashboardClient) return;
 				const targetRuntimeId = message.targetRuntimeId;
 				if (!targetRuntimeId) return;
 				if (targetRuntimeId === PROJECT_TARGET_RUNTIME_ID && projectTargetBackend) {
@@ -1342,6 +1634,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 +1668,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;
@@ -1419,8 +1713,8 @@ async function startDevHub(options) {
 			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));
+				history.push(message.event);
+				runtimeEvents.set(message.event.runtimeId, history.slice(-200));
 				if (message.event.type === "runtime.disconnected") runtimeEvents.delete(message.event.runtimeId);
 				appendHubLog(message.event);
 			} else if (message.type === "event") appendHubLog(message.event);
@@ -1481,25 +1775,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 +1806,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 +1879,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 +1969,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, loadProjectRuntime, loadProjectSchema, logScaffoldResult, readPackageJson, readStoredSnapshot, resolveDefaultSeedFile, resolvePortFromEnv, resolveProjectTargetConfig, resolveRequestedTemplate, runCodegen, runDevProjectBootstrap, runSyncoreCli, scaffoldProject, slugify, startDevHub, templateUsesConnectedClients, writeStoredSnapshot };
 
 //# sourceMappingURL=cli.mjs.map