@rebasepro/cli 0.10.1-canary.d8d45b2 → 0.10.1-canary.ed78a2c

package/dist/index.es.js

@@ -1695,6 +1695,29 @@ function mayUseAmbientKey(target, cwd) {
 		return false;
 	}
 }
+/**
+* The base URL to show in the printed usage example.
+*
+* `rebase dev` binds a port derived from the project path, not 3001, and writes
+* the one it actually got to `.rebase/state.json`. Printing a hardcoded
+* `localhost:3001` sent people to a port nothing was listening on — or, with
+* several projects on one machine, to a different project's backend. Prefer the
+* port this project last ran on; fall back to the literal only when the project
+* has never been started.
+*/
+function resolveExampleBaseUrl(cwd) {
+	const projectRoot = findProjectRoot(cwd) ?? cwd;
+	try {
+		const state = JSON.parse(fs.readFileSync(path.join(projectRoot, ".rebase", "state.json"), "utf-8"));
+		if (typeof state.baseUrl === "string" && state.baseUrl) return state.baseUrl;
+		if (typeof state.port === "number") return `http://localhost:${state.port}`;
+	} catch {}
+	return "http://localhost:3001";
+}
+/** Whether a slug can be written as `rebase.data.<slug>` rather than a lookup. */
+function isIdentifierLike(slug) {
+	return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(slug);
+}
 /** Resolve `--from` into a base URL, following the link file when asked. */
 function resolveSchemaSource(from, cwd) {
 	if (from !== "link") {
@@ -1790,16 +1813,20 @@ export const GENERATED_AT = ${JSON.stringify((/* @__PURE__ */ new Date()).toISOS
 	console.log("");
 	console.log(chalk.green.bold("  ✓ SDK generated successfully!"));
 	console.log("");
+	const typesImport = `./${path.relative(cwd, path.join(resolvedOutput, "database.types"))}`;
+	const exampleSlug = collections[0]?.slug || "my_collection";
 	console.log(chalk.gray("  Usage:"));
 	console.log(chalk.gray("    import { createRebaseClient } from '@rebasepro/client';"));
-	console.log(chalk.gray(`    import type { Database } from './${path.relative(cwd, path.join(resolvedOutput, "database.types"))}';`));
+	console.log(chalk.gray(`    import { collectionsDictionary, type Database } from '${typesImport}';`));
 	console.log("");
 	console.log(chalk.gray("    const rebase = createRebaseClient<Database>({"));
-	console.log(chalk.gray("        baseUrl: 'http://localhost:3001',"));
+	console.log(chalk.gray(`        baseUrl: '${resolveExampleBaseUrl(cwd)}',`));
+	console.log(chalk.gray("        collections: collectionsDictionary,"));
 	console.log(chalk.gray("        // token: 'your-jwt-token',"));
 	console.log(chalk.gray("    });"));
 	console.log("");
-	console.log(chalk.gray(`    const { data } = await rebase.collection('${collections[0]?.slug || "my_collection"}').find();`));
+	console.log(chalk.gray(`    const { data } = await rebase.data.collection('${exampleSlug}').find();`));
+	if (isIdentifierLike(exampleSlug)) console.log(chalk.gray(`    // …or in property style: rebase.data.${exampleSlug}.find()`));
 	console.log("");
 }
 //#endregion
@@ -3288,6 +3315,30 @@ async function regenerateSchema(projectRoot, configDir, options) {
 	}
 }
 /**
+* A hand-written server entrypoint that a bundle does not use.
+*
+* `rebase dev` runs `backend/src/index.ts` whenever a project has one, so for
+* the whole of local development that file *is* the server and every route
+* written in it works. A bundle has no entrypoint of its own: the runtime boots
+* the bundle and mounts what the manifest points at — the config package,
+* functions, crons and the schema. The file is not compiled, not shipped, and
+* never imported.
+*
+* Nothing said so. A project with custom routes in its entrypoint built clean,
+* deployed green, and answered 404 on every one of them, with the file still
+* sitting in the repository looking exactly like the server.
+*
+* A project that means to keep its own entrypoint declares the app as
+* `"type": "custom"`, which builds the repository's Dockerfile instead — which
+* is what {@link synthesizeManifest} already infers for a manifest-less repo
+* carrying one. The warning names that route rather than implying the file is
+* a mistake.
+*/
+function findUnusedServerEntry(projectRoot, functionsDir) {
+	const found = [path.join("backend", "src", "index.ts"), path.join(path.dirname(functionsDir), "src", "index.ts")].find((candidate) => fs.existsSync(path.join(projectRoot, candidate)));
+	return found ? found.split(path.sep).join("/") : void 0;
+}
+/**
 * Compile and assemble a bundle.
 */
 async function buildBundle(options) {
@@ -3304,6 +3355,19 @@ async function buildBundle(options) {
 	if (fs.existsSync(path.join(projectRoot, paths.schema))) includes.push(paths.schema);
 	if (includes.length === 0) throw new Error(`Nothing to build for app "${appName}". Expected a config directory at "${paths.config}" or functions at "${paths.functions}".`);
 	if (paths.mode === "cms" && options.skipSchema !== true) await regenerateSchema(projectRoot, paths.config, options);
+	const unusedEntry = findUnusedServerEntry(projectRoot, paths.functions);
+	if (unusedEntry) {
+		const parts = [
+			...paths.mode === "cms" ? [`${paths.config}/`] : [],
+			`${paths.functions}/`,
+			"the schema"
+		];
+		const compiled = `${parts.slice(0, -1).join(", ")} and ${parts[parts.length - 1]}`;
+		console.log(chalk.yellow(`  ⚠ ${unusedEntry} is not the bundle's entry point — it is not compiled or shipped.`));
+		console.log(chalk.dim(`      The runtime boots the bundle itself and mounts ${compiled}.`));
+		console.log(chalk.dim(`      Routes defined there will not exist once deployed: move them to ${paths.functions}/,`));
+		console.log(chalk.dim(`      or declare this app as "type": "custom" in rebase.json to keep your own entrypoint.`));
+	}
 	log(options, chalk.dim(`  compiling ${includes.length} source group(s) → ${path.relative(projectRoot, outDir)}/`));
 	cleanOutDir(projectRoot, outDir);
 	const tsconfigPath = await writeBundleTsconfig(projectRoot, outDir, includes, options.skipTypeCheck === true);
@@ -3395,6 +3459,59 @@ async function buildBundle(options) {
 * manifest — no compilation, no dependency closure (a static bundle installs
 * nothing at boot).
 */
+/**
+* Fold a built static app into a backend bundle, so one runtime serves both.
+*
+* ## Why this exists
+*
+* A managed tenant runs one pod, and `bootFromBundle` on the backend path already
+* knows how to serve a SPA — it looks for `entry.static` and mounts `serveSPA`
+* last, behind `REBASE_SERVE_STATIC`. What was missing was anything putting the
+* assets there.
+*
+* The consequence was not subtle. A project whose custom image served its website
+* at `/` and its API at `/api` — the shape the scaffolded template produces — lost
+* the website the moment it moved to the managed runtime: the API answered
+* perfectly and every page 404'd. Managed could not be a drop-in replacement for
+* custom while the frontend simply vanished.
+*
+* Folding restores parity with the container it replaces, which is the only
+* honest baseline. It is deliberately the FIRST implementation and not the last:
+* a static app on its own bucket behind a CDN is better for cache behaviour and
+* lets the frontend deploy independently. But that needs infrastructure that does
+* not exist yet, and "your site is gone" is not an acceptable state to leave a
+* project in while it gets built.
+*
+* The trade it makes, stated plainly: frontend and backend now deploy together
+* and the bundle carries the built assets. For a project that was shipping both
+* in one image already, that is exactly what it had.
+*/
+function foldStaticIntoBundle(options) {
+	const { bundleDir, assetsDir } = options;
+	const manifestPath = path.join(bundleDir, "manifest.json");
+	if (!fs.existsSync(manifestPath)) throw new Error(`No manifest at ${manifestPath} — build the backend bundle first.`);
+	if (!fs.existsSync(assetsDir)) throw new Error(`No built assets at ${assetsDir}.`);
+	const staticOut = path.join(bundleDir, "static");
+	fs.rmSync(staticOut, {
+		recursive: true,
+		force: true
+	});
+	fs.mkdirSync(staticOut, { recursive: true });
+	fs.cpSync(assetsDir, staticOut, { recursive: true });
+	let fileCount = 0;
+	const count = (dir) => {
+		for (const entry of fs.readdirSync(dir, { withFileTypes: true })) if (entry.isDirectory()) count(path.join(dir, entry.name));
+		else fileCount++;
+	};
+	count(staticOut);
+	const manifest = JSON.parse(fs.readFileSync(manifestPath, "utf8"));
+	manifest.entry = {
+		...manifest.entry,
+		static: "static"
+	};
+	fs.writeFileSync(manifestPath, `${JSON.stringify(manifest, null, 2)}\n`, "utf8");
+	return { fileCount };
+}
 function buildStaticBundle(options) {
 	const { projectRoot, appName, assetsDir, outDir, runtimeRange } = options;
 	cleanOutDir(projectRoot, outDir);
@@ -3517,6 +3634,76 @@ function resolveCliVersion() {
 	return "unknown";
 }
 //#endregion
+//#region src/fold-static.ts
+/**
+* Folding a project's frontend into its backend bundle.
+*
+* Shared by `rebase build` and `rebase cloud deploy` deliberately. It lived in
+* the build *command* first, and `deploy` rebuilds the bundle itself — so a
+* deploy silently produced a bundle without the frontend, packed 164 KB where
+* 39 MB was expected, and the site 404'd on the managed runtime exactly as if
+* folding had never been written. Two callers building the same artefact must
+* share the step that completes it.
+*
+* Why fold at all: `bootFromBundle` already serves a SPA from `entry.static`
+* behind `REBASE_SERVE_STATIC` (default on). A managed tenant runs one pod, so
+* putting the built site in the bundle gives it the shape a custom container
+* already had — site at `/`, API at `/api` — which is the only honest baseline
+* for calling the managed runtime a drop-in replacement.
+*/
+/**
+* Which static app, if any, should be served by the backend.
+*
+* Exactly one `static` app is folded. With several, folding would have to choose,
+* and silently picking one of two websites is worse than doing nothing — so it
+* declines and names what it saw. Pure, so the decision is testable without a
+* filesystem.
+*/
+function selectFoldableApp(manifest) {
+	const statics = Object.entries(manifest.apps ?? {}).filter(([, app]) => app?.type === "static").map(([name, app]) => ({
+		name,
+		build: app?.build,
+		output: app?.output
+	}));
+	if (statics.length === 0) return {};
+	if (statics.length > 1) return { reason: `${statics.length} static apps (${statics.map((s) => s.name).join(", ")}) — none folded in. Pick one to serve from the backend, or host them separately.` };
+	const only = statics[0];
+	if (!only.output) return { reason: `"${only.name}" declares no output directory — not folded in.` };
+	return { app: only };
+}
+/**
+* Build the project's frontend and fold it into the backend bundle.
+*
+* Throws rather than exiting, so the caller decides whether a missing frontend
+* should fail its command — a `build` may reasonably want to stop, and so should
+* a deploy, but that is not this function's call to make.
+*/
+async function foldFrontendIntoBundle(options) {
+	const { projectRoot, manifest, bundleDir, skipBuild } = options;
+	const log = options.log ?? ((m) => console.log(m));
+	const { app, reason } = selectFoldableApp(manifest);
+	if (reason) {
+		log(chalk.yellow(`    ⚠ ${reason}`));
+		return null;
+	}
+	if (!app) return null;
+	if (app.build && !skipBuild) await execa(app.build, {
+		cwd: projectRoot,
+		stdio: "inherit",
+		shell: true
+	});
+	const assetsDir = path.join(projectRoot, app.output);
+	if (!fs.existsSync(assetsDir)) throw new Error(`"${app.name}" declared output "${app.output}" does not exist after building — the bundle would ship without a frontend.`);
+	const { fileCount } = foldStaticIntoBundle({
+		bundleDir,
+		assetsDir
+	});
+	return {
+		appName: app.name,
+		fileCount
+	};
+}
+//#endregion
 //#region src/commands/build.ts
 /**
 * CLI command: rebase build [app...]
@@ -3557,6 +3744,8 @@ async function buildCommand(rawArgs = []) {
 		"--out": String,
 		"--skip-type-check": Boolean,
 		"--skip-schema": Boolean,
+		"--no-static": Boolean,
+		"--skip-static-build": Boolean,
 		"--legacy": Boolean,
 		"--help": Boolean,
 		"-h": "--help"
@@ -3627,6 +3816,19 @@ async function buildCommand(rawArgs = []) {
 				console.log(chalk.yellow(`    ⚠ native dependencies detected: ${names}`));
 				console.log(chalk.dim("      These cannot run on the managed runtime. See `rebase doctor`."));
 			}
+			if (!args["--no-static"]) {
+				const folded = await foldFrontendIntoBundle({
+					projectRoot,
+					manifest,
+					bundleDir: result.outDir,
+					skipBuild: args["--skip-static-build"] === true,
+					log: (m) => console.log(m)
+				}).catch((err) => {
+					console.error(chalk.red(`    ✗ ${err instanceof Error ? err.message : String(err)}`));
+					process.exit(1);
+				});
+				if (folded) console.log(chalk.green(`    ✓ ${folded.appName} folded in`) + chalk.dim(` (${folded.fileCount} file(s) → served at /)`));
+			}
 		} else if (app.type === "static" || app.type === "admin") await buildAssetApp(projectRoot, name, app, manifest.runtime, args["--out"]);
 		else if (app.type === "custom") console.log(chalk.dim("  custom container — built at deploy time from its Dockerfile"));
 		console.log("");
@@ -5124,9 +5326,28 @@ function bundleDeployBody(input) {
 		app: input.app ?? input.manifest.app ?? "backend",
 		client: "cli",
 		frameworkVersion: input.manifest.runtime?.builtAgainst,
+		...input.declaredApps?.length ? { declaredApps: input.declaredApps } : {},
 		...input.message ? { message: input.message } : {}
 	};
 }
+/**
+* The apps a project manifest declares.
+*
+* A deploy only ever ships ONE app's bundle, so the trigger alone could never
+* tell the platform that the repository also contains a web frontend and an
+* admin panel — and the Apps page, whose whole job is to show the set, listed a
+* single entry called "backend". Sending the declared set fixes that without
+* pretending the others are deployed: the platform registers them, and their
+* status says what is actually true.
+*/
+function declaredAppsFrom(manifest) {
+	const apps = manifest?.apps;
+	if (!apps || typeof apps !== "object") return [];
+	return Object.entries(apps).filter(([name]) => name.trim().length > 0).map(([name, value]) => ({
+		name,
+		type: String(value?.type ?? "custom")
+	}));
+}
 /** Upload a bundle archive; returns the control-plane bundle id. */
 async function uploadBundle(url, token, projectId, tarPath) {
 	const bytes = fs.readFileSync(tarPath);
@@ -5154,6 +5375,12 @@ async function uploadBundle(url, token, projectId, tarPath) {
 * `deploy` triggers the control-plane `deploy` function, then tails the build
 * logs from the deployment record until it succeeds or fails. `logs` shows the
 * latest build log, or runtime logs with `--runtime`.
+*
+* There are three deploys behind the one verb, and which one runs depends on the
+* flags: `--bundle` builds and uploads a managed bundle, `--source .` uploads
+* this directory as a build context, and the bare form uploads nothing and asks
+* the control plane to rebuild what it already holds. That last one is the
+* dangerous one — see `planBareDeploy`.
 */
 var POLL_INTERVAL_MS = 1500;
 var POLL_TIMEOUT_MS = 900 * 1e3;
@@ -5276,8 +5503,20 @@ async function deployBundle(opts) {
 			appName: backend.name,
 			app: backend.app,
 			runtimeRange: loaded.manifest.runtime,
+			skipTypeCheck: opts.skipTypeCheck,
 			log: (m) => console.log(chalk.gray(m))
 		})).outDir;
+		try {
+			const folded = await foldFrontendIntoBundle({
+				projectRoot,
+				manifest: loaded.manifest,
+				bundleDir,
+				log: (m) => console.log(m)
+			});
+			if (folded) console.log(chalk.gray(`  folded ${folded.appName} in (${folded.fileCount} file(s), served at /)`));
+		} catch (err) {
+			fail(err instanceof Error ? err.message : String(err), "Fix the frontend build, or pass --no-static to deploy the API alone.");
+		}
 	}
 	const manifest = readBundleManifest(bundleDir);
 	if (manifest.hooks?.native) {
@@ -5301,11 +5540,16 @@ async function deployBundle(opts) {
 	}
 	console.log("");
 	console.log(`  🚀 Triggering managed deployment for ${chalk.bold(projectRef)} (schema ${manifest.schemaVersion})...`);
+	let declaredApps = [];
+	try {
+		declaredApps = declaredAppsFrom(loadManifest(process.cwd()).manifest);
+	} catch {}
 	const body = bundleDeployBody({
 		projectId,
 		bundleId,
 		manifest,
-		message: opts.message
+		message: opts.message,
+		declaredApps
 	});
 	try {
 		const res = await client.functions.invoke("deploy", body);
@@ -5323,6 +5567,89 @@ async function deployBundle(opts) {
 		reportError(e, "Managed deploy failed to start");
 	}
 }
+function pick(row, ...keys) {
+	for (const key of keys) {
+		const raw = row?.[key];
+		if (typeof raw === "string" && raw.trim() !== "") return raw.trim();
+	}
+}
+/** Rough age of a timestamp, for "…uploaded 6d ago". Undefined if unreadable. */
+function timeAgo(value, now) {
+	if (value === void 0) return void 0;
+	const then = value instanceof Date ? value.getTime() : new Date(value).getTime();
+	if (Number.isNaN(then)) return void 0;
+	const ms = now.getTime() - then;
+	if (ms < 0) return void 0;
+	const minutes = Math.floor(ms / 6e4);
+	if (minutes < 1) return "just now";
+	if (minutes < 60) return `${minutes}m ago`;
+	const hours = Math.floor(minutes / 60);
+	if (hours < 24) return `${hours}h ago`;
+	return `${Math.floor(hours / 24)}d ago`;
+}
+/**
+* Whether this project runs on the managed runtime.
+*
+* `runtimeMode` on the project row is the authority — the control plane writes
+* it. The bundle-id fallback covers a control plane that does not return the
+* field: a successful deploy that served a bundle only happens on the managed
+* path.
+*/
+function isManagedProject(project, latest) {
+	if (pick(project, "runtimeMode", "runtime_mode") === "managed") return true;
+	return latest?.status === "success" && pick(latest, "bundleId", "bundle_id") !== void 0;
+}
+/** What a `deploy` with nothing attached will build, in the words to print. */
+function planBareDeploy(project, latest, now) {
+	const projectRow = project;
+	const deploymentRow = latest;
+	const managed = isManagedProject(project, latest);
+	const repo = pick(projectRow, "gitRepoUrl", "git_repo_url");
+	if (repo) {
+		const branch = pick(projectRow, "gitBranch", "git_branch");
+		return {
+			managed,
+			source: "git",
+			lines: [`Building from git: ${repo}${branch ? ` (${branch})` : ""}.`]
+		};
+	}
+	if (pick(deploymentRow, "sourceRef", "source_ref")) {
+		const age = timeAgo(latest?.createdAt ?? latest?.created_at, now);
+		return {
+			managed,
+			source: "snapshot",
+			lines: [`Rebuilding the stored source archive${latest?.id !== void 0 ? ` from deployment ${latest.id}` : ""}${age ? `, uploaded ${age}` : ""}.`, "This directory is NOT uploaded — pass `--source .` to build what is on disk."]
+		};
+	}
+	return {
+		managed,
+		source: "none",
+		lines: ["This project has no git repository configured and no stored source archive to rebuild.", "Upload this directory with `--source .`, or set a repository URL in the project settings."]
+	};
+}
+/** The one sentence that says a source build undoes `runtimeMode: managed`. */
+function ejectWarning(projectRef) {
+	return `⚠ ${projectRef} runs on the managed runtime — a source build ejects it to a custom container.`;
+}
+/**
+* Read the two rows the preflight needs.
+*
+* Best effort by construction: a preflight that cannot read is a preflight that
+* says nothing, never a deploy that fails. The managed refusal rides on the same
+* read, so an unreadable project falls through to the old behaviour rather than
+* blocking a deploy on a lookup.
+*/
+async function readDeployContext(client, projectId) {
+	try {
+		const [project, latest] = await Promise.all([client.data.collection("projects").findById(projectId), latestDeployment(client, projectId)]);
+		return {
+			project,
+			latest
+		};
+	} catch {
+		return {};
+	}
+}
 async function deployCommand(rawArgs, projectRef) {
 	const args = arg({
 		"--no-follow": Boolean,
@@ -5330,6 +5657,8 @@ async function deployCommand(rawArgs, projectRef) {
 		"--message": String,
 		"--bundle": Boolean,
 		"--bundle-dir": String,
+		"--skip-type-check": Boolean,
+		"--force": Boolean,
 		"-m": "--message"
 	}, {
 		argv: rawArgs.slice(2),
@@ -5345,10 +5674,25 @@ async function deployCommand(rawArgs, projectRef) {
 			projectId,
 			projectRef,
 			bundleDir: args["--bundle-dir"],
-			message: args["--message"]
+			message: args["--message"],
+			skipTypeCheck: args["--skip-type-check"] === true
 		});
 		return;
 	}
+	const { project, latest } = await readDeployContext(client, projectId);
+	const plan = planBareDeploy(project, latest, /* @__PURE__ */ new Date());
+	if (!args["--source"]) {
+		if (plan.managed && args["--force"] !== true) fail(`${projectRef} runs on the managed runtime, and a plain \`rebase cloud deploy\` builds a container image instead — ejecting it from managed, from source the control plane already holds rather than this directory.`, "Redeploy it with `rebase cloud deploy --bundle`. To eject on purpose, pass `--source .` to build this directory, or `--force` to build what the control plane holds.", "managed_project");
+		if (!isJsonMode()) {
+			console.log("");
+			if (plan.managed) console.log(chalk.yellow(`  ${ejectWarning(projectRef)}`));
+			for (const line of plan.lines) console.log(chalk.gray(`  ${line}`));
+		}
+	} else if (plan.managed && !isJsonMode()) {
+		console.log("");
+		console.log(chalk.yellow(`  ${ejectWarning(projectRef)}`));
+		console.log(chalk.gray("    Use `rebase cloud deploy --bundle` to stay on managed."));
+	}
 	let source;
 	if (args["--source"]) {
 		const tarPath = await createSourceTarball(args["--source"]);
@@ -8560,7 +8904,7 @@ ${chalk.green.bold("Projects")}
   ${chalk.blue.bold("projects delete")} ${chalk.gray("[id]")}    Delete a project
 
 ${chalk.green.bold("Deploy & observe")}
-  ${chalk.blue.bold("deploy")} ${chalk.gray("[--source .] [-m msg]")}  Deploy the linked project + stream build logs
+  ${chalk.blue.bold("deploy")} ${chalk.gray("[--bundle|--source .]")}   Deploy the linked project + stream build logs
   ${chalk.blue.bold("logs")} ${chalk.gray("[--runtime] [-f]")}   Show build (or runtime) logs
   ${chalk.blue.bold("deployments list")} ${chalk.gray("[--limit N|--all]")}  Deployment history ${chalk.gray("(status, duration, trigger)")}
   ${chalk.blue.bold("rollback")} ${chalk.gray("[id] [-y]")}       Roll back to a successful deploy
@@ -8966,6 +9310,6 @@ ${chalk.gray("Documentation: https://rebase.pro/docs")}
 `);
 }
 //#endregion
-export { CURRENT_RUNTIME_RANGE, DEFAULT_BUNDLE_DIR, DEFAULT_CONFIG_DIR, DEFAULT_CRONS_DIR, DEFAULT_FUNCTIONS_DIR, DEFAULT_SCHEMA_FILE, MANIFEST_FILENAME, ManifestError, appsCommand, assessManagedCompatibility, authCommand, buildBundle, buildCommand, buildInitQuestions, buildStaticBundle, buildableApps, cloudCommand, collectDeclaredDependencies, configureEnvFile, createRebaseApp, dbCommand, detectNativeDependencies, detectPackageManager, detectStorageAuthorize, devCommand, doctorCommand, entry, findBackendApp, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, formatCdTarget, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isPnpmAvailable, loadManifest, manifestExists, manifestPath, normalizeEsmSpecifiers, pnpmAvailabilityFromProbe, printInitHelp, requireBackendDir, requireProjectRoot, resetPnpmAvailabilityCache, resolveBackendPaths, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, synthesizeManifest, validateManifest, validateProjectName, validateTsxInstallation, writeManifest };
+export { CURRENT_RUNTIME_RANGE, DEFAULT_BUNDLE_DIR, DEFAULT_CONFIG_DIR, DEFAULT_CRONS_DIR, DEFAULT_FUNCTIONS_DIR, DEFAULT_SCHEMA_FILE, MANIFEST_FILENAME, ManifestError, appsCommand, assessManagedCompatibility, authCommand, buildBundle, buildCommand, buildInitQuestions, buildStaticBundle, buildableApps, cloudCommand, collectDeclaredDependencies, configureEnvFile, createRebaseApp, dbCommand, detectNativeDependencies, detectPackageManager, detectStorageAuthorize, devCommand, doctorCommand, entry, findBackendApp, findBackendDir, findEnvFile, findFrontendDir, findProjectRoot, findUnusedServerEntry, foldStaticIntoBundle, formatCdTarget, generateSdkCommand, getActiveBackendPlugin, getPMCommands, isIdentifierLike, isPnpmAvailable, loadManifest, manifestExists, manifestPath, normalizeEsmSpecifiers, pnpmAvailabilityFromProbe, printInitHelp, requireBackendDir, requireProjectRoot, resetPnpmAvailabilityCache, resolveBackendPaths, resolveExampleBaseUrl, resolveLocalBin, resolvePluginCliScript, resolveTsx, schemaCommand, startCommand, synthesizeManifest, validateManifest, validateProjectName, validateTsxInstallation, writeManifest };
 
 //# sourceMappingURL=index.es.js.map