camox 0.58.1 → 0.60.2

package/dist/features/vite/definitionsSync.js

@@ -1,32 +1,14 @@
 import { createServerApiClient } from "../../lib/api-client-server.js";
-import { DEVELOPMENT_DRAFT } from "@camox/api-contract/drafts";
 import { isRunnableDevEnvironment } from "vite-plus";
 
 //#region src/features/vite/definitionsSync.ts
 const SYNC_DEBOUNCE_DELAY_MS = 100;
-/**
-* The client definitions sync with. A release (deploy token) syncs Live's definitions; dev mode
-* sends the developer's session and syncs their development draft, which its first sync
-* creates (ADR 0006).
-*/
-function createSyncClient(options) {
-	const draftId = options.deployToken ? void 0 : DEVELOPMENT_DRAFT;
-	return createServerApiClient(options.apiUrl, options.authToken, draftId);
-}
 function throwIfSyncAuthError(error) {
 	if (error instanceof Error && error.name === "ORPCError" && error.message.toLowerCase().includes("unauthorized")) throw new Error("[camox] Definition sync failed: invalid or missing credentials.");
 }
 function isNotFoundError(error) {
 	return error instanceof Error && error.name === "ORPCError" && error.message.toLowerCase().includes("not found");
 }
-/**
-* A sync that may not create the development draft finds nothing to write to: a release names a
-* project that doesn't exist, or dev mode has no development draft yet (ADR 0006).
-*/
-function throwSyncTargetNotFoundError(projectUuid, deployToken) {
-	if (deployToken) throw new Error(`[camox] No project has the Project ID "${projectUuid}". Check the camox() projectId.`);
-	throw new Error(`[camox] You have no development draft in the project with Project ID "${projectUuid}" yet. Run the dev server while authenticated to create it first.`);
-}
 /** `count` of `noun`, pluralized: "1 block", "2 blocks". */
 function counted(count, noun) {
 	return `${count} ${noun}${count === 1 ? "" : "s"}`;
@@ -36,26 +18,25 @@ function quoted(names) {
 	return names.map((name) => `"${name}"`).join(", ");
 }
 /**
-* Send a Definition Set to the API: Live's for a release, the development draft's in dev mode.
-* It goes in one `definitions.sync` call, which either fully applies it or changes nothing.
+* Release a Definition Set to Live with the Deploy Token, adding the content it declares that
+* Live lacks. It goes in one `definitions.sync` call, which either fully applies it or changes
+* nothing.
 */
 async function syncDefinitionsToApi(options) {
-	const { definitionSet, projectUuid, autoCreate, deployToken, logger } = options;
-	const client = createSyncClient(options);
+	const { definitionSet, projectUuid, apiUrl, deployToken, logger } = options;
+	const client = createServerApiClient(apiUrl);
 	let result;
 	try {
 		result = await client.definitions.sync({
 			projectUuid,
 			deployToken,
-			autoCreate,
 			definitionSet
 		});
 	} catch (error) {
 		throwIfSyncAuthError(error);
-		if (!autoCreate && isNotFoundError(error)) throwSyncTargetNotFoundError(projectUuid, deployToken);
+		if (isNotFoundError(error)) throw new Error(`[camox] No project has the Project ID "${projectUuid}". Check the camox() projectId.`);
 		throw error;
 	}
-	if (result.draftCreated) logger.info("[camox] Created your development draft", { timestamp: true });
 	const definitionCount = result.blocks.count + result.collections.count + (result.layouts?.count ?? 0);
 	logger.info(`[camox] Synced ${counted(definitionCount, "Camox definition")}`, { timestamp: true });
 	const { deletedDefinitionTypes } = result.blocks;
@@ -130,53 +111,29 @@ function isAppDependency(server, file) {
 function isScriptFile(file) {
 	return /\.[cm]?[jt]sx?$/.test(file) && !file.endsWith(".d.ts");
 }
-/** Whether a project's Live has no pages, as on a fresh database. */
-async function liveHasNoPages(apiUrl, projectUuid) {
-	const { pages } = await createServerApiClient(apiUrl).pages.listBySlug({ projectUuid });
-	return pages.length === 0;
-}
 /**
-* Sync the app's whole Definition Set to the development draft now, then again whenever a module
-* the app depends on changes (debounced), skipping a sync when the set equals the last one sent
-* (ADR 0006). Resolves once the initial sync settles: `synced` if definitions reached the API,
-* and `releasedToLive` if it first released them to an empty Live (`releaseToEmptyLive`).
+* Release the app's whole Definition Set to Live now, then again whenever a module the app depends
+* on changes (debounced), skipping a release when the set equals the last one sent (ADR 0027).
+* Resolves once the initial release settles: `synced` if definitions reached the API.
 */
 async function syncDefinitions(server, options) {
-	const { projectUuid, apiUrl, autoCreate, authToken, deployToken, releaseToEmptyLive } = options;
 	const logger = server.config.logger;
-	/** What the development draft last received, so an unchanged set isn't sent again. */
+	/** What Live last received, so an unchanged set isn't sent again. */
 	let lastSynced;
-	let releasedToLive = false;
-	async function sync({ initial = false } = {}) {
+	async function sync() {
 		const definitionSet = await loadDefinitionSet(server);
 		const serialized = serializeDefinitionSet(definitionSet);
 		if (serialized === lastSynced) return;
-		if (initial && releaseToEmptyLive && await liveHasNoPages(apiUrl, projectUuid)) {
-			logger.info("[camox] Live is empty: releasing your definitions to it", { timestamp: true });
-			await syncDefinitionsToApi({
-				definitionSet,
-				projectUuid,
-				apiUrl,
-				autoCreate: false,
-				deployToken: releaseToEmptyLive,
-				logger
-			});
-			releasedToLive = true;
-		}
 		await syncDefinitionsToApi({
+			...options,
 			definitionSet,
-			projectUuid,
-			apiUrl,
-			autoCreate,
-			authToken,
-			deployToken,
 			logger
 		});
 		lastSynced = serialized;
 	}
 	let synced = false;
 	try {
-		await sync({ initial: true });
+		await sync();
 		synced = true;
 	} catch (error) {
 		logger.error(`[camox] Failed to sync Camox definitions: ${String(error)}`, { timestamp: true });
@@ -200,10 +157,7 @@ async function syncDefinitions(server, options) {
 	server.watcher.on("unlink", (file) => {
 		if (isScriptFile(file) || isAppDependency(server, file)) scheduleSync();
 	});
-	return {
-		synced,
-		releasedToLive
-	};
+	return { synced };
 }
 
 //#endregion

package/dist/features/vite/devSignIn.js

@@ -58,7 +58,7 @@ function installDevSignInLink(server, options) {
 			}
 		}
 		if (controller.signal.aborted) return;
-		server.config.logger.warn("Camox sign-in link unavailable. Use the normal local URL to sign in, or run camox preview for a fresh link.");
+		server.config.logger.warn("Camox sign-in link unavailable. Use the normal local URL to sign in, or restart the dev server for a fresh link.");
 	}
 	async function openSignInLink(url) {
 		let warned = false;

package/dist/features/vite/hostedChecks.js

@@ -6,7 +6,7 @@ import { Visitor, parseSync } from "vite-plus";
 //#region src/features/vite/hostedChecks.ts
 /**
 * Set by Camox's revision and release sandboxes: a hosted project's build checks the code an
-* agent may have written (ADR 0021). `apps/landing` and dev mode never set it.
+* agent may have written (ADR 0021). Dev mode never sets it.
 */
 const HOSTED_BUILD_ENV = "CAMOX_INTERNAL_HOSTED";
 const sdkRoot = resolve(dirname(fileURLToPath(import.meta.url)), "../../..");

package/dist/features/vite/runtimeDev.js

@@ -73,7 +73,8 @@ function resolveCamoxSourceImport(id) {
 		"camox/_internal/rendererClient": resolve(sdkRoot, "src/features/runtime/rendererClient.tsx"),
 		"camox/_internal/studioServer": resolve(sdkRoot, "src/features/runtime/studioServer.tsx"),
 		"camox/_internal/runtime": resolve(sdkRoot, "src/features/runtime/runtime.ts"),
-		"camox/worker": resolve(sdkRoot, "src/features/runtime/worker.ts")
+		"camox/worker": resolve(sdkRoot, "src/features/runtime/worker.ts"),
+		"camox/_internal/workerRuntime": resolve(sdkRoot, "src/features/runtime/workerRuntime.ts")
 	}[id];
 	if (!sourceImport || !existsSync(sourceImport)) return;
 	return sourceImport;
@@ -231,7 +232,6 @@ const options = {
   pageClientEntryUrl,
   studioClientEntryUrl,
   rendererClientEntryUrl,
-  developmentDraft: __CAMOX_DEVELOPMENT_DRAFT__,
   getCamoxApp: async () => camoxApp,
   getDocument: async () => camoxDocument,
   // Loaded by the first page image, so the stylesheet stays out of the Worker's main chunk.

package/dist/features/vite/sdkBundleBuild.js

@@ -0,0 +1,74 @@
+import { sdkBundleEntryFile } from "../sdkBundle/specifiers.js";
+import { SDK_BUNDLE_BUILD_MANIFEST, sdkBundlePath } from "../sdkBundle/sdkBundleName.js";
+import { SDK_BUNDLE_MANIFEST } from "../sdkBundle/buildSdkBundle.js";
+import { buildsAgainstSdkBundle, ensureLocalSdkBundle } from "../sdkBundle/localSdkBundle.js";
+import { createRequire } from "node:module";
+import { readFileSync, readdirSync } from "node:fs";
+import { dirname, join, posix, resolve } from "node:path";
+
+//#region src/features/vite/sdkBundleBuild.ts
+/**
+* The SDK Bundle a build builds against, from the local cache, or undefined when the switch is
+* off and the build is whole-app.
+*/
+async function sdkBundleBuildState({ root, settings, mayBuild }) {
+	if (!buildsAgainstSdkBundle()) return;
+	let built = false;
+	const bundle = await ensureLocalSdkBundle({
+		root,
+		settings,
+		mayBuild,
+		onBuild: () => {
+			built = true;
+		}
+	});
+	const names = {
+		browser: bundle.browser.name,
+		workerd: bundle.workerd.name
+	};
+	const stylesheet = readdirSync(bundle.browser.dir).find((file) => /^camox-studio-.*\.css$/.test(file));
+	if (!stylesheet) throw new Error(`Camox: the SDK Bundle ${names.browser} has no Studio stylesheet.`);
+	const websiteRequire = createRequire(join(root, "package.json"));
+	/** What each target holds: its entry files by specifier, and by the file a path specifier names. */
+	const held = (dir) => {
+		const { entries } = JSON.parse(readFileSync(join(dir, SDK_BUNDLE_MANIFEST), "utf8"));
+		const byFile = /* @__PURE__ */ new Map();
+		for (const specifier of Object.keys(entries)) if (/\.[cm]?js$/.test(specifier)) byFile.set(websiteRequire.resolve(specifier), sdkBundleEntryFile(specifier));
+		return {
+			entries,
+			byFile
+		};
+	};
+	const holds = {
+		browser: held(bundle.browser.dir),
+		workerd: held(bundle.workerd.dir)
+	};
+	return {
+		names,
+		built,
+		studioStylesheetUrl: sdkBundlePath(names.browser) + stylesheet,
+		manifest: {
+			fileName: SDK_BUNDLE_BUILD_MANIFEST,
+			source: `${JSON.stringify(names)}\n`
+		},
+		resolve(id, importer, consumer) {
+			const target = consumer === "client" ? "browser" : "workerd";
+			const { entries, byFile } = holds[target];
+			const file = Object.hasOwn(entries, id) ? entries[id] : id.startsWith(".") && importer ? byFile.get(resolve(dirname(importer), id)) : void 0;
+			if (!file) return;
+			return {
+				id: sdkBundlePath(names[target]) + file,
+				external: "absolute"
+			};
+		},
+		relativizeWorkerImports(code, fileName) {
+			const prefix = sdkBundlePath(names.workerd);
+			if (!code.includes(prefix)) return;
+			const toRoot = posix.relative(posix.dirname(fileName), "") || ".";
+			return code.replaceAll(new RegExp(`(["'\`])${prefix.replaceAll("/", "\\/")}`, "g"), `$1${toRoot}${prefix}`);
+		}
+	};
+}
+
+//#endregion
+export { sdkBundleBuildState };

package/dist/features/vite/staticAssetHeaders.js

@@ -5,17 +5,20 @@ import { join, relative } from "node:path";
 /** Where the client build puts the files it names by their content's hash. */
 const HASHED_DIRS = ["assets", "_chunks"];
 const IMMUTABLE = "public, max-age=31536000, immutable";
+/** Where a build against an SDK Bundle serves its files, under the bundle's name (ADR 0029). */
+const SDK_BUNDLE_DIR = "_camox/sdk";
 /** Workers Static Assets reads at most this many rules. */
 const MAX_RULES = 100;
 /**
 * The `_headers` file Workers Static Assets serves the client build with. Files under
 * `/assets/` and `/_chunks/` are named by their content's hash, so browsers keep them for good;
 * the files there named otherwise, the entry chunks pages load by a fixed name and whatever the
-* app's public directory puts there, keep the default, which revalidates. The app's own
-* `_headers` comes first, as it wrote it.
+* app's public directory puts there, keep the default, which revalidates. A build against an
+* SDK Bundle has its files under `/_camox/sdk/<name>/`, which never change under a name either.
+* The app's own `_headers` comes first, as it wrote it.
 */
-function staticAssetHeaders({ ownHeaders, unhashedFiles }) {
-	const rules = [...HASHED_DIRS.map((dir) => `/${dir}/*\n  Cache-Control: ${IMMUTABLE}`), ...[...unhashedFiles].sort().map((file) => `/${file}\n  ! Cache-Control`)];
+function staticAssetHeaders({ ownHeaders, unhashedFiles, sdkBundle = false }) {
+	const rules = [...(sdkBundle ? [...HASHED_DIRS, SDK_BUNDLE_DIR] : HASHED_DIRS).map((dir) => `/${dir}/*\n  Cache-Control: ${IMMUTABLE}`), ...[...unhashedFiles].sort().map((file) => `/${file}\n  ! Cache-Control`)];
 	const own = ownHeaders?.trimEnd();
 	const ownRules = own ? own.split("\n").filter((line) => /^\S/.test(line) && !line.startsWith("#")) : [];
 	if (ownRules.length + rules.length > MAX_RULES) throw new Error(`Camox: _headers would hold ${ownRules.length + rules.length} rules, past Workers Static Assets' ${MAX_RULES}. Move the public directory's files out of /assets/ and /_chunks/, or drop rules from public/_headers.`);

package/dist/features/vite/vite.d.ts

@@ -3,7 +3,11 @@ import { Logger, Plugin } from "vite-plus";
 //#region src/features/vite/vite.d.ts
 /** What `_internal.afterSync` receives: an API client authenticated as the dev user. */
 export interface CamoxAfterSyncContext {
-  /** Sends the dev session and reads and writes the developer's development draft. */
+  /**
+   * Sends the dev session. Its first content write starts a regular draft, as an edit in the
+   * studio does, and it reads and writes that draft from then on. Until then it reads Live, so
+   * seeding that finds its content starts nothing.
+   */
   client: ServerApiClient;
   /** The project's Project ID, which API inputs name `projectUuid`. */
   projectUuid: string;
@@ -25,8 +29,6 @@ export interface CamoxPluginOptions {
     apiUrl?: string;
     /** URL of the Camox authentication backend (default: https://app.camox.ai) */
     authenticationUrl?: string;
-    /** Show Tanstack query devtools (default: false) */
-    enableTanstackDevtools?: boolean;
     /** Enable experimental features (default: false). */
     enableExperimentalFeatures?: boolean;
     /** Disable automatic code generation (route and layout files) (default: false) */
@@ -45,11 +47,10 @@ export interface CamoxPluginOptions {
      */
     afterSync?: (context: CamoxAfterSyncContext) => void | Promise<void>;
     /**
-     * Dev-only: a deploy token for seeding Live. When Live has no pages yet, the first sync
-     * releases the local definitions to Live, and the development draft is published after
-     * `afterSync`, so seeded content becomes Live instead of the draft's changes.
+     * Dev-only: the local API's Deploy Token. Dev mode runs only against a local API with it,
+     * and releases the app's definitions to local Live on every save (ADR 0027).
      */
-    seedLiveDeployToken?: string;
+    localDeployToken?: string;
   };
 }
 export declare const CAMOX_OPTIMIZED_DEPS: string[];

package/dist/features/vite/vite.js

@@ -10,14 +10,13 @@ import { installDevSignInLink } from "./devSignIn.js";
 import { HOSTED_BUILD_ENV, forbiddenImport, misnamedBlock, readHostedProject } from "./hostedChecks.js";
 import { generateIconTypes } from "./iconGeneration.js";
 import { generateLayoutFiles, watchLayoutFiles } from "./layoutGeneration.js";
+import { sdkBundleBuildState } from "./sdkBundleBuild.js";
 import { publicFilesInHashedDirs, readOwnHeaders, staticAssetHeaders, unhashedEntries } from "./staticAssetHeaders.js";
 import { buildClientThenWorker } from "./workerBuild.js";
 import { VIRTUAL_CAMOX_APP, syncDefinitions, syncDefinitionsToApi } from "./definitionsSync.js";
-import { publishSeededContent } from "./publishSeededContent.js";
 import { cleanupGeneratedRouteFiles } from "./routeGeneration.js";
 import { RESOLVED_VIRTUAL_DEV_HTML, createRuntimeRegistryPlugin, loadRuntimeDevModule, resolveRuntimeDevId } from "./runtimeDev.js";
-import { projectIdSchema } from "@camox/api-contract/ids";
-import { DEVELOPMENT_DRAFT } from "@camox/api-contract/drafts";
+import { generateUuidv7, projectIdSchema } from "@camox/api-contract/ids";
 import { createHash, randomUUID } from "node:crypto";
 import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, posix, resolve } from "node:path";
@@ -62,8 +61,7 @@ function findClientOnLog(config) {
 * CLI can pick up the same Project ID / apiUrl / authenticationUrl the
 * plugin actually used. The CLI treats the vite config as the source of
 * truth for those values — there is no other reliable way to recover them
-* from outside vite. No draft is written here: the CLI always works in the
-* developer's development draft (ADR 0010).
+* from outside vite.
 */
 function writeRuntimeSidecar(root, data) {
 	const dir = join(root, "node_modules", ".camox");
@@ -170,11 +168,24 @@ function projectIdOf(options) {
 	if (!projectIdSchema.safeParse(options.projectId).success) throw new Error(`Camox: ${JSON.stringify(options.projectId)} is not a Project ID. Copy your project's Project ID, a lowercase UUIDv7, from the Camox dashboard into your camox() config.`);
 	return options.projectId;
 }
+/** Whether an API URL is on this machine, as each checkout's own local API is. */
+function isLocalApi(apiUrl) {
+	const { hostname } = new URL(apiUrl);
+	return hostname === "localhost" || hostname.endsWith(".localhost") || hostname === "127.0.0.1" || hostname === "[::1]";
+}
+/**
+* The Deploy Token dev mode releases with, refused when it's missing or the API isn't local:
+* dev mode exists for Camox contributors, and a hosted project's code never comes from a machine.
+*/
+function localDeployTokenOf(apiUrl, options) {
+	const token = options._internal?.localDeployToken;
+	if (token && isLocalApi(apiUrl)) return token;
+	throw new Error("Camox: dev mode only runs against a local Camox API, with its internal Deploy Token. A hosted project's code reaches Camox through drafts and Upgrades.");
+}
 function camox(options) {
 	const projectUuid = projectIdOf(options);
 	const apiUrl = options._internal?.apiUrl ?? PRODUCTION_API_URL;
 	const authenticationUrl = options._internal?.authenticationUrl ?? DEFAULT_AUTHENTICATION_URL;
-	const enableTanstackDevtools = options._internal?.enableTanstackDevtools ?? false;
 	const disableCodeGen = options._internal?.disableCodeGen ?? false;
 	const runtimeBasePath = options._internal?.runtimeBasePath;
 	let isBuild = false;
@@ -185,8 +196,12 @@ function camox(options) {
 	let hostedProject;
 	let resolvedConfig;
 	let localAuth = null;
+	/** Set in dev mode, which releases to local Live with it. */
+	let localDeployToken;
 	let blockChunks = {};
 	let devServer;
+	/** Set when the build builds against an SDK Bundle. */
+	let sdkBundle;
 	return {
 		name: "camox",
 		enforce: "pre",
@@ -196,6 +211,10 @@ function camox(options) {
 				const forbidden = forbiddenImport(hostedProject, id, importer);
 				if (forbidden) this.error(forbidden);
 			}
+			if (sdkBundle) {
+				const external = sdkBundle.resolve(id, importer, this.environment.config.consumer);
+				if (external) return external;
+			}
 			const runtimeId = resolveRuntimeDevId(id, importer);
 			if (runtimeId) return runtimeId;
 			if (id === VIRTUAL_STUDIO_CSS) return RESOLVED_VIRTUAL_STUDIO_CSS;
@@ -203,6 +222,7 @@ function camox(options) {
 		},
 		async load(id, loadOptions) {
 			const stylesDir = resolve(sdkRoot, !isBuild && isSdkSource ? ".dev" : "dist");
+			if (id === RESOLVED_VIRTUAL_STUDIO_CSS && sdkBundle) return `export default ${JSON.stringify(sdkBundle.studioStylesheetUrl)};`;
 			if (id === RESOLVED_VIRTUAL_STUDIO_CSS) {
 				const cssPath = resolve(stylesDir, "studio.css");
 				if (isBuild) {
@@ -244,7 +264,19 @@ function camox(options) {
 			}
 			return transformArtifactRuntime(code, id);
 		},
+		renderChunk(code, chunk) {
+			if (!sdkBundle || this.environment.config.consumer !== "server") return;
+			const relative = sdkBundle.relativizeWorkerImports(code, chunk.fileName);
+			return relative === void 0 ? void 0 : {
+				code: relative,
+				map: null
+			};
+		},
 		generateBundle(_outputOptions, bundle) {
+			if (sdkBundle && this.environment.config.consumer === "server") this.emitFile({
+				type: "asset",
+				...sdkBundle.manifest
+			});
 			if (this.environment.name !== "client") return;
 			blockChunks = collectBlockChunks(bundle, resolvedConfig.root);
 			if (!isBuild) return;
@@ -254,7 +286,8 @@ function camox(options) {
 				fileName: "_headers",
 				source: staticAssetHeaders({
 					ownHeaders: readOwnHeaders(publicDir),
-					unhashedFiles: [...unhashedEntries(bundle), ...publicFilesInHashedDirs(publicDir)]
+					unhashedFiles: [...unhashedEntries(bundle), ...publicFilesInHashedDirs(publicDir)],
+					sdkBundle: sdkBundle !== void 0
 				})
 			});
 		},
@@ -264,10 +297,18 @@ function camox(options) {
 			const release = process.env.CAMOX_INTERNAL_RELEASE;
 			isRelease = isBuild && (release === "1" || release === "dry-run");
 			isDryRun = isRelease && release === "dry-run";
-			if (!isRelease) {
-				localAuth = readAuthTokenForUrl(authenticationUrl);
-				if (isBuild && !localAuth) throw new Error("Camox: not authenticated. Run `npx camox login` before building the site.");
-			}
+			if (env.command === "serve" && !env.isPreview) localDeployToken = localDeployTokenOf(apiUrl, options);
+			if (!isBuild) localAuth = readAuthTokenForUrl(authenticationUrl);
+			if (isBuild) sdkBundle = await sdkBundleBuildState({
+				root: resolve(_config.root ?? process.cwd()),
+				settings: {
+					iconIds,
+					telemetryDisabled: !!options.disableTelemetry,
+					experimentalFeatures: options._internal?.enableExperimentalFeatures ?? false,
+					apiUrl
+				},
+				mayBuild: !(isRelease && process.env["CAMOX_INTERNAL_HOSTED"] === "1")
+			});
 			return {
 				...isBuild && {
 					base: "./",
@@ -277,14 +318,15 @@ function camox(options) {
 						return { runtime: serverAssetUrl(filename) };
 					} }
 				},
-				build: { emitAssets: true },
+				build: {
+					emitAssets: true,
+					rolldownOptions: { experimental: { lazyBarrel: true } }
+				},
 				..._config.builder?.buildApp ? {} : { builder: { buildApp: buildClientThenWorker } },
 				define: {
 					__CAMOX_ICON_IDS__: JSON.stringify(iconIds),
 					__CAMOX_TELEMETRY_DISABLED__: JSON.stringify(!!options.disableTelemetry),
-					__ENABLE_TANSTACK_DEVTOOLS__: JSON.stringify(enableTanstackDevtools),
 					__CAMOX_ENABLE_EXPERIMENTAL_FEATURES__: JSON.stringify(options._internal?.enableExperimentalFeatures ?? false),
-					__CAMOX_DEVELOPMENT_DRAFT__: JSON.stringify(!isRelease),
 					__CAMOX_API_URL__: JSON.stringify(apiUrl),
 					__CAMOX_AUTHENTICATION_URL__: JSON.stringify(authenticationUrl),
 					__CAMOX_PROJECT_ID__: JSON.stringify(projectUuid),
@@ -342,11 +384,13 @@ function camox(options) {
 			}
 			if (disableCodeGen) config.logger.warn("⚠️  Code generation is disabled (_internal.disableCodeGen). This option is only meant for momentary debugging — do not deploy or commit your app with it enabled.", { timestamp: true });
 			const mode = config.command === "serve" ? "Running" : "Building";
-			let target = "your development draft";
+			let target = "Live, not released";
 			if (isDryRun) target = "Live, dry run";
 			else if (isRelease) target = "Live";
-			else if (!localAuth) target = "authentication required";
+			else if (localDeployToken) target = "local Live";
+			else if (!isBuild && !localAuth) target = "authentication required";
 			config.logger.info(`${mode} Camox app (${target})`, { timestamp: true });
+			if (sdkBundle?.built) config.logger.info(`Built the SDK Bundle ${sdkBundle.names.browser} (browser) and ${sdkBundle.names.workerd} (workerd) into its cache`, { timestamp: true });
 		},
 		configureServer(server) {
 			devServer = server;
@@ -369,28 +413,24 @@ function camox(options) {
 				watchNewBlockFiles(server);
 			}
 			server.httpServer?.once("listening", () => {
-				if (!localAuth) return;
-				const authToken = localAuth.token;
+				if (!localDeployToken) return;
 				syncDefinitions(server, {
 					projectUuid,
 					apiUrl,
-					autoCreate: true,
-					authToken,
-					releaseToEmptyLive: options._internal?.seedLiveDeployToken
-				}).then(async ({ synced, releasedToLive }) => {
-					if (!synced) return;
+					deployToken: localDeployToken
+				}).then(async ({ synced }) => {
+					const afterSync = options._internal?.afterSync;
+					if (!synced || !afterSync || !localAuth) return;
 					const context = {
-						client: createServerApiClient(apiUrl, authToken, DEVELOPMENT_DRAFT),
+						client: createServerApiClient(apiUrl, localAuth.token, generateUuidv7()),
 						projectUuid,
 						logger: server.config.logger
 					};
-					const afterSync = options._internal?.afterSync;
-					if (afterSync) try {
+					try {
 						await afterSync(context);
 					} catch (error) {
 						context.logger.warn(`[camox] afterSync failed: ${String(error)}`, { timestamp: true });
 					}
-					if (releasedToLive) await publishSeededContent(context);
 				});
 			});
 		},
@@ -414,7 +454,6 @@ function camox(options) {
 					definitionSet: await camoxModule.camoxApp.getDefinitionSet(),
 					projectUuid,
 					apiUrl,
-					autoCreate: false,
 					deployToken,
 					logger: resolvedConfig.logger
 				});

package/dist/lib/api-client-server.js

@@ -1,19 +1,36 @@
-import { DRAFT_HEADER } from "@camox/api-contract/drafts";
+import { DRAFT_CREATE_HEADER, DRAFT_HEADER, isContentWrite } from "@camox/api-contract/drafts";
 import { createORPCClient } from "@orpc/client";
 import { RPCLink } from "@orpc/client/fetch";
 
 //#region src/lib/api-client-server.ts
 /**
-* An API client for the plugin's own requests. `draftId` names the draft they read and write:
-* dev mode sends `development`, and a release names none, so it writes Live.
+* An API client for the plugin's own requests. A release names no draft, so it writes Live. With
+* `startsDraft`, its first content write starts that draft, as the studio's first write on Live
+* does: reads see Live until a write has started it, and the draft from then on.
 */
-function createServerApiClient(apiUrl, authToken, draftId) {
-	const headers = {};
-	if (authToken) headers.Authorization = `Bearer ${authToken}`;
-	if (draftId) headers[DRAFT_HEADER] = draftId;
+function createServerApiClient(apiUrl, authToken, startsDraft) {
+	const base = {};
+	if (authToken) base.Authorization = `Bearer ${authToken}`;
+	let started = false;
 	const link = new RPCLink({
 		url: `${apiUrl}/rpc`,
-		headers
+		headers: (_options, path) => {
+			if (!startsDraft) return base;
+			if (isContentWrite(path)) return {
+				...base,
+				[DRAFT_HEADER]: startsDraft,
+				[DRAFT_CREATE_HEADER]: "1"
+			};
+			return started ? {
+				...base,
+				[DRAFT_HEADER]: startsDraft
+			} : base;
+		},
+		fetch: async (request, init, _options, path) => {
+			const response = await fetch(request, init);
+			if (response.ok && isContentWrite(path)) started = true;
+			return response;
+		}
 	});
 	return createORPCClient(link);
 }

package/dist/lib/api-client.js

@@ -1,5 +1,5 @@
-import { getAuthCookieHeader, getAuthRequestCredentials } from "./auth.js";
 import { localeHeaders } from "./locale-path.js";
+import { getAuthCookieHeader, getAuthRequestCredentials } from "./auth.js";
 import { DRAFT_HEADER, isContentWrite } from "@camox/api-contract/drafts";
 import { createORPCClient } from "@orpc/client";
 import { RPCLink } from "@orpc/client/fetch";
@@ -61,10 +61,6 @@ function createStudioClient(apiUrl, draftHeaders) {
 	});
 	return createORPCClient(link);
 }
-function getApiClient() {
-	if (!_client) throw new Error("API client not initialized — call initApiClient first");
-	return _client;
-}
 function getOrpc() {
 	if (!_orpc) throw new Error("API client not initialized — call initApiClient first");
 	return _orpc;
@@ -83,4 +79,4 @@ function getContentWriteHeaders() {
 }
 
 //#endregion
-export { getApiClient, getApiUrl, getContentWriteHeaders, getDraftReadClient, getOrpc, initApiClient };
+export { getApiUrl, getContentWriteHeaders, getDraftReadClient, getOrpc, initApiClient };