@keystrokehq/cli 0.0.165 → 0.0.166

package/README.md

@@ -106,6 +106,17 @@ keystroke build
 keystroke build --dir ./my-app
 ```
 
+### `deploy`
+
+Build, upload, and promote a project artifact on the platform. Requires `keystroke auth login` and `--project <slug>`.
+
+```bash
+keystroke deploy
+keystroke deploy --filter workflows/ping --filter agents/world
+```
+
+`--filter` matches exact build entry keys (`agents/foo`, `workflows/bar`, …). Repeat the flag for multiple modules. Targeted deploy downloads the active artifact, overlays rebuilt module files, merges `route-manifest.json`, and uploads a full tarball — the first deploy for a project must be a full deploy without `--filter`. Config and bundled assets are carried forward from the active artifact; skill/asset drift is not validated in v1.
+
 ### `dev`
 
 Watch `src/`, rebuild `dist/` on change, and restart the API. **Not true hot reload** — each change reruns tsdown and boots a fresh server process so discovery picks up new agents/workflows/triggers.

package/dist/dist-BMPry9tj.mjs

@@ -0,0 +1,577 @@
+#!/usr/bin/env node
+import { cn as object, in as array, ln as string } from "./dist-D_0UmqFb.mjs";
+import { L as entryIdFromFile, R as readKeystrokeIgnoreDirective, a as buildStoredRouteManifestForProject, z as shouldSkipKeystrokeModuleFile } from "./dist-WoxxHzM6.mjs";
+import { isBuiltin } from "node:module";
+import { basename, dirname, join, relative, resolve, sep } from "node:path";
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import "node:fs/promises";
+import { createHash } from "node:crypto";
+import { build, mergeConfig } from "tsdown";
+//#region ../../packages/build/dist/walk-project-eZ95LOUW.mjs
+function toPosix$1(path) {
+	return path.split(sep).join("/");
+}
+function projectRelativePath(root, filePath) {
+	return toPosix$1(relative(root, normalizeBuildFilePath(filePath)));
+}
+/** Normalize paths so /var and /private/var compare equal on macOS. */
+function normalizeBuildFilePath(filePath) {
+	const absolute = resolve(filePath);
+	try {
+		return realpathSync.native(absolute);
+	} catch {
+		return absolute;
+	}
+}
+function normalizeModuleId(id, root) {
+	if (id.startsWith("\0")) return null;
+	const normalized = normalizeBuildFilePath(id.startsWith("file://") ? fileURLToPath(id) : id);
+	if (!normalized.startsWith(normalizeBuildFilePath(root))) return null;
+	return normalized;
+}
+function formatImportGuardError(root, ignoredPath, importer) {
+	const ignored = projectRelativePath(root, ignoredPath);
+	if (importer) return `Cannot import "${ignored}" (@keystroke ignore) from "${projectRelativePath(root, importer)}". Remove the directive or stop importing it from a shipped module.`;
+	return `Cannot import "${ignored}" (@keystroke ignore). Remove the directive or stop importing it from a shipped module.`;
+}
+/** Throw when a built module imports a `@keystroke ignore` source file. */
+function keystrokeIgnoreGuardPlugin(options) {
+	const root = normalizeBuildFilePath(options.root);
+	const ignoredFiles = new Set(options.ignoredFiles.map((filePath) => normalizeBuildFilePath(filePath)));
+	function assertNotIgnored(filePath, importer) {
+		const normalized = normalizeBuildFilePath(filePath);
+		if (!ignoredFiles.has(normalized)) return;
+		throw new Error(formatImportGuardError(root, normalized, importer));
+	}
+	return {
+		name: "keystroke-ignore-guard",
+		async resolveId(source, importer, resolveOptions) {
+			if (resolveOptions?.isEntry || !importer) return null;
+			const resolved = await this.resolve(source, importer, {
+				...resolveOptions,
+				skipSelf: true
+			});
+			if (!resolved) return null;
+			assertNotIgnored(typeof resolved === "string" ? resolved : resolved.id, importer);
+			return null;
+		},
+		load(id) {
+			const normalized = normalizeModuleId(id, root);
+			if (!normalized) return null;
+			assertNotIgnored(normalized);
+			return null;
+		}
+	};
+}
+const IGNORED_DIRS = new Set([
+	"node_modules",
+	"dist",
+	".git",
+	".turbo",
+	"build",
+	"coverage",
+	".keystroke",
+	".cache",
+	"tmp"
+]);
+const IGNORED_ENV_FILE = /\.env/;
+const IGNORED_LOG_FILE = /\.log$/;
+function isIgnoredFile(name) {
+	return IGNORED_ENV_FILE.test(name) || IGNORED_LOG_FILE.test(name);
+}
+function toPosix$2(path) {
+	return path.split(sep).join("/");
+}
+function isProbablyBinary(buffer) {
+	const sampleLength = Math.min(buffer.length, 8e3);
+	for (let index = 0; index < sampleLength; index += 1) if (buffer[index] === 0) return true;
+	return false;
+}
+function classifyBuildEntry(root, srcRoot, filePath) {
+	const relativePath = toPosix$2(relative(root, filePath));
+	const agentsPrefix = `${toPosix$2(relative(root, join(srcRoot, "agents")))}/`;
+	const workflowsPrefix = `${toPosix$2(relative(root, join(srcRoot, "workflows")))}/`;
+	const triggersPrefix = `${toPosix$2(relative(root, join(srcRoot, "triggers")))}/`;
+	if (relativePath.startsWith(agentsPrefix) && /\.(ts|mts)$/.test(relativePath) && !/\.(int\.)?test\.(ts|mts)$/.test(relativePath)) {
+		const id = entryIdFromFile(join(srcRoot, "agents"), filePath, { nestedEntry: "agent" });
+		return id ? {
+			entryKey: `agents/${id}`,
+			entryPath: filePath
+		} : null;
+	}
+	if (relativePath.startsWith(workflowsPrefix) && /\.(ts|mts)$/.test(relativePath) && !/\.(int\.)?test\.(ts|mts)$/.test(relativePath)) {
+		const id = entryIdFromFile(join(srcRoot, "workflows"), filePath, { nestedEntry: "workflow" });
+		return id ? {
+			entryKey: `workflows/${id}`,
+			entryPath: filePath
+		} : null;
+	}
+	if (relativePath.startsWith(triggersPrefix) && /\.(ts|mts)$/.test(relativePath) && !/\.(int\.)?test\.(ts|mts)$/.test(relativePath)) {
+		const id = entryIdFromFile(join(srcRoot, "triggers"), filePath, { nestedEntry: "trigger" });
+		return id ? {
+			entryKey: `triggers/${id}`,
+			entryPath: filePath
+		} : null;
+	}
+	return null;
+}
+function shouldSkipIgnoredModule(filePath, phase) {
+	return shouldSkipKeystrokeModuleFile(readKeystrokeIgnoreDirective(filePath), phase);
+}
+function isSrcTypeScriptFile(srcRoot, filePath) {
+	const relativePath = toPosix$2(relative(srcRoot, filePath));
+	if (relativePath.startsWith("..")) return false;
+	return /\.(ts|mts)$/.test(relativePath);
+}
+function walkTree(root, dir, srcRoot, phase, collectSources, sourceFiles, buildEntries, ignoredFiles, totals) {
+	for (const name of readdirSync(dir).sort()) {
+		if (collectSources && (sourceFiles.length >= 2e3 || totals.bytes >= 8388608)) return;
+		const absolute = join(dir, name);
+		const stats = statSync(absolute);
+		if (stats.isDirectory()) {
+			if (IGNORED_DIRS.has(name)) continue;
+			walkTree(root, absolute, srcRoot, phase, collectSources, sourceFiles, buildEntries, ignoredFiles, totals);
+			continue;
+		}
+		if (!stats.isFile()) continue;
+		const isUnderSrc = isSrcTypeScriptFile(srcRoot, absolute);
+		const skipIgnored = isUnderSrc ? shouldSkipIgnoredModule(absolute, phase) : false;
+		if (isUnderSrc && skipIgnored) ignoredFiles.push(normalizeBuildFilePath(absolute));
+		const buildEntry = classifyBuildEntry(root, srcRoot, absolute);
+		if (buildEntry && !skipIgnored) buildEntries[buildEntry.entryKey] = buildEntry.entryPath;
+		if (!collectSources) continue;
+		if (stats.size > 262144 || isIgnoredFile(name)) continue;
+		const buffer = readFileSync(absolute);
+		if (isProbablyBinary(buffer)) continue;
+		totals.bytes += buffer.byteLength;
+		sourceFiles.push({
+			path: toPosix$2(relative(root, absolute)),
+			contents: buffer.toString("utf8"),
+			hash: createHash("sha256").update(buffer).digest("hex")
+		});
+	}
+}
+/**
+* One full-tree walk of the project: classifies tsdown entries and optionally
+* collects deploy source files (path + contents + hash) under snapshot limits.
+*/
+function walkProject(root, srcDirOrOptions = "src", maybeOptions) {
+	const srcDir = typeof srcDirOrOptions === "string" ? srcDirOrOptions : srcDirOrOptions.srcDir ?? "src";
+	const options = typeof srcDirOrOptions === "string" ? maybeOptions ?? {} : srcDirOrOptions;
+	const collectSources = options.collectSources ?? false;
+	const phase = options.phase ?? "build";
+	const sourceFiles = [];
+	const buildEntries = {};
+	const ignoredFiles = [];
+	walkTree(root, root, join(root, srcDir), phase, collectSources, sourceFiles, buildEntries, ignoredFiles, { bytes: 0 });
+	return {
+		sourceFiles,
+		buildEntries,
+		ignoredFiles
+	};
+}
+//#endregion
+//#region ../../packages/sandbox/dist/files-B0H9_dP4.mjs
+const SandboxFileContentSchema = object({
+	path: string(),
+	file: string()
+});
+/** Destination path under `/workspace`. For `dir`, used as a prefix. */
+const SandboxFileSchema = object({
+	path: string(),
+	/** Single file body — typically from a build-time import (`import doc from "./doc.md"`). */
+	file: string().optional(),
+	/** Directory contents — each path is relative to `path`. */
+	dir: array(SandboxFileContentSchema).optional()
+});
+object({
+	key: string().optional(),
+	files: array(SandboxFileSchema).optional()
+});
+const SKIP_DIRS$1 = new Set([".git", "node_modules"]);
+/** Recursively read a host file or directory into sandbox-relative `{ path, file }` entries. */
+function packDirFromDisk(rootPath) {
+	const stat = statSync(rootPath);
+	if (stat.isFile()) return [{
+		path: basename(rootPath),
+		file: readFileSync(rootPath, "utf8")
+	}];
+	if (!stat.isDirectory()) throw new Error(`Expected a file or directory at ${rootPath}`);
+	const files = [];
+	walkDir(rootPath, rootPath, files);
+	return files;
+}
+function walkDir(rootPath, currentPath, files) {
+	for (const name of readdirSync(currentPath)) {
+		if (SKIP_DIRS$1.has(name)) continue;
+		const entryPath = join(currentPath, name);
+		const stat = statSync(entryPath);
+		if (stat.isDirectory()) {
+			walkDir(rootPath, entryPath, files);
+			continue;
+		}
+		if (!stat.isFile()) continue;
+		files.push({
+			path: relative(rootPath, entryPath),
+			file: readFileSync(entryPath, "utf8")
+		});
+	}
+}
+const SKIP_DIRS = new Set([".git", "node_modules"]);
+/** Pack every subdir under `src/skills/` and `src/files/` into an asset manifest. */
+function packAssetDirs(appRoot, srcDir = "src") {
+	return {
+		skills: packAssetRoot(join(appRoot, srcDir, "skills")),
+		files: packAssetRoot(join(appRoot, srcDir, "files"))
+	};
+}
+function packAssetRoot(rootPath) {
+	if (!statSync(rootPath, { throwIfNoEntry: false })?.isDirectory()) return {};
+	const manifest = {};
+	for (const name of readdirSync(rootPath)) {
+		if (SKIP_DIRS.has(name)) continue;
+		const entryPath = join(rootPath, name);
+		if (!statSync(entryPath).isDirectory()) continue;
+		manifest[name] = packDirFromDisk(entryPath);
+	}
+	return manifest;
+}
+//#endregion
+//#region ../../packages/tsdown-config/deps.js
+/** Native addons kept external — resolved from the CLI runtime at app start. */
+const NATIVE_RUNTIME_DEPS = [
+	"pg",
+	"better-sqlite3",
+	"@parcel/watcher"
+];
+/** Kept external so .d.ts emission does not inline internal/inferred types. */
+const LIBRARY_EXTERNAL_DEPS = [
+	"better-auth",
+	/^@better-auth\//,
+	/^better-auth\//
+];
+/** Kept external when bundling published entry points (cli, keystroke, platform). */
+const BUNDLED_ENTRY_EXTERNAL_DEPS = [...[
+	...NATIVE_RUNTIME_DEPS,
+	"dockerode",
+	"ssh2",
+	"cpu-features",
+	"microsandbox",
+	/^@aws-sdk\//,
+	/^@napi-rs\//,
+	"hono",
+	/^@hono\//,
+	"undici"
+], ...LIBRARY_EXTERNAL_DEPS];
+/** Bundle into CLI — device login uses Better Auth client only. */
+const BETTER_AUTH_CLIENT_BUNDLE_PATTERNS = [/^better-auth\/client$/, /^better-auth\/client\//];
+function isNativeRuntimeDep(id) {
+	return NATIVE_RUNTIME_DEPS.some((dep) => id === dep || id.startsWith(`${dep}/`));
+}
+function packageName(id) {
+	if (id.startsWith("@")) {
+		const [scope, name] = id.split("/");
+		return name ? `${scope}/${name}` : id;
+	}
+	return id.split("/")[0] ?? id;
+}
+function isRuntimeExternal(id) {
+	const name = packageName(id);
+	if (isNativeRuntimeDep(name)) return true;
+	if (name.startsWith("@keystrokehq/")) return true;
+	if (name === "better-auth" || name.startsWith("@better-auth/")) return true;
+	return false;
+}
+/** Library packages resolve npm deps from node_modules at runtime. */
+function libraryBuildDepsConfig() {
+	return {
+		alwaysBundle: (_id) => null,
+		neverBundle: [
+			...NATIVE_RUNTIME_DEPS,
+			/^@keystrokehq\//,
+			...LIBRARY_EXTERNAL_DEPS
+		],
+		onlyBundle: false
+	};
+}
+/** Bundle npm deps into dist; resolve @keystrokehq/* and natives from the runtime. */
+function userAppBuildDepsConfig() {
+	return {
+		alwaysBundle: (id, _importer) => {
+			if (id.startsWith(".") || id.startsWith("/") || isBuiltin(id)) return null;
+			return isRuntimeExternal(id) ? null : true;
+		},
+		neverBundle: [
+			...NATIVE_RUNTIME_DEPS,
+			/^@keystrokehq\//,
+			...LIBRARY_EXTERNAL_DEPS
+		],
+		onlyBundle: false
+	};
+}
+/**
+* Published entry packages (cli, keystroke, platform): declare bundled @keystrokehq/*
+* in dependencies (changesets release graph ignores devDependencies). Inlining is
+* driven by alwaysBundle below, not by dep kind. Runtime npm deps stay external.
+*/
+function bundledEntryDepsConfig() {
+	return {
+		alwaysBundle: [/^@keystrokehq\//],
+		neverBundle: [...BUNDLED_ENTRY_EXTERNAL_DEPS],
+		onlyBundle: false
+	};
+}
+[...BETTER_AUTH_CLIENT_BUNDLE_PATTERNS];
+//#endregion
+//#region ../../packages/tsdown-config/index.js
+const baseTsdownConfig = {
+	format: ["esm", "cjs"],
+	dts: true,
+	clean: true,
+	sourcemap: true,
+	target: "node20",
+	deps: libraryBuildDepsConfig()
+};
+bundledEntryDepsConfig();
+//#endregion
+//#region ../../packages/build/dist/index.mjs
+function packageRoot(nodeModules, scope, name) {
+	const direct = scope ? join(nodeModules, scope, name) : join(nodeModules, name);
+	if (existsSync(join(direct, "package.json"))) return direct;
+	const pnpmDir = join(nodeModules, ".pnpm");
+	if (!existsSync(pnpmDir)) return null;
+	for (const entry of readdirSync(pnpmDir)) {
+		const candidate = scope ? join(pnpmDir, entry, "node_modules", scope, name) : join(pnpmDir, entry, "node_modules", name);
+		if (existsSync(join(candidate, "package.json"))) return candidate;
+	}
+	return null;
+}
+/** Resolve a file shipped with `@keystrokehq/build` inside the CLI runtime. */
+function resolveRuntimeBuildArtifact(runtimeNodeModules, relativePath) {
+	const pkgRoot = packageRoot(runtimeNodeModules, "@keystrokehq", "build");
+	if (!pkgRoot) throw new Error("Keystroke runtime is missing @keystrokehq/build");
+	const artifact = join(pkgRoot, relativePath);
+	if (!existsSync(artifact)) throw new Error(`Keystroke runtime artifact not found: ${relativePath}`);
+	return artifact;
+}
+/** Resolve exact build-entry keys for a filtered deploy build. */
+function resolveBuildFilter(filter, buildEntries) {
+	if (filter.length === 0) throw new Error("At least one --filter entry is required");
+	const matched = {};
+	for (const key of [...new Set(filter)]) {
+		const entryPath = buildEntries[key];
+		if (!entryPath) throw new Error(`Unknown build entry "${key}". Use keys like agents/foo or workflows/bar from walkProject.`);
+		matched[key] = entryPath;
+	}
+	return matched;
+}
+function toPosix(path) {
+	return path.replace(/\\/g, "/");
+}
+function distRelativePath(entryKey) {
+	return `${entryKey}.mjs`;
+}
+async function buildSingleEntry(root, entryKey, entryPath, ignoredFiles) {
+	mkdirSync(join(root, ".keystroke"), { recursive: true });
+	const scratchRoot = mkdtempSync(join(root, ".keystroke", "filter-build-"));
+	const outDir = join(scratchRoot, "dist");
+	const relativePath = distRelativePath(entryKey);
+	await build(mergeConfig(baseTsdownConfig, {
+		entry: { [entryKey]: entryPath },
+		format: ["esm"],
+		outDir,
+		clean: true,
+		dts: false,
+		loader: { ".md": "text" },
+		deps: userAppBuildDepsConfig(),
+		plugins: [keystrokeIgnoreGuardPlugin({
+			root,
+			ignoredFiles
+		})]
+	}));
+	return {
+		scratchRoot,
+		relativePath
+	};
+}
+async function manifestEntriesForBuiltModule(root, entryPath, relativePath, contents, sourceMap) {
+	const moduleFile = toPosix(relative(root, entryPath));
+	const distPath = join(root, "dist", relativePath);
+	const distMapPath = `${distPath}.map`;
+	const previousDist = existsSync(distPath) ? readFileSync(distPath) : void 0;
+	const hadMap = existsSync(distMapPath);
+	const previousMap = hadMap ? readFileSync(distMapPath) : void 0;
+	mkdirSync(dirname(distPath), { recursive: true });
+	writeFileSync(distPath, contents);
+	if (sourceMap) writeFileSync(distMapPath, sourceMap);
+	try {
+		return (await buildStoredRouteManifestForProject(root, { reloadModules: true })).entries.filter((entry) => "moduleFile" in entry && entry.moduleFile === moduleFile);
+	} finally {
+		if (previousDist) writeFileSync(distPath, previousDist);
+		else rmSync(distPath, { force: true });
+		if (previousMap) writeFileSync(distMapPath, previousMap);
+		else if (sourceMap || hadMap) rmSync(distMapPath, { force: true });
+	}
+}
+/** Build selected modules in isolation for a filtered deploy merge. */
+async function buildFilteredApp(options) {
+	const root = options.root ?? process.cwd();
+	const srcDir = options.srcDir ?? "src";
+	const phase = options.phase ?? "deploy";
+	const collectSources = options.collectSources ?? false;
+	const previous = process.cwd();
+	const walked = walkProject(root, {
+		srcDir,
+		collectSources,
+		phase
+	});
+	const matched = resolveBuildFilter(options.filter, walked.buildEntries);
+	const files = [];
+	const manifestEntries = [];
+	try {
+		process.chdir(root);
+		for (const [entryKey, entryPath] of Object.entries(matched)) {
+			const { scratchRoot, relativePath } = await buildSingleEntry(root, entryKey, entryPath, walked.ignoredFiles);
+			try {
+				const builtPath = join(scratchRoot, "dist", relativePath);
+				const mapPath = `${builtPath}.map`;
+				const contents = readFileSync(builtPath);
+				const sourceMap = existsSync(mapPath) ? readFileSync(mapPath) : void 0;
+				files.push({
+					entryKey,
+					relativePath,
+					contents,
+					sourceMap
+				});
+				manifestEntries.push(...await manifestEntriesForBuiltModule(root, entryPath, relativePath, contents, sourceMap));
+			} finally {
+				rmSync(scratchRoot, {
+					recursive: true,
+					force: true
+				});
+			}
+		}
+	} finally {
+		process.chdir(previous);
+	}
+	return {
+		files,
+		manifestEntries,
+		sourceFiles: walked.sourceFiles
+	};
+}
+const ASSETS_MODULE = "@keystrokehq/assets";
+const VIRTUAL_PREFIX = `\0${ASSETS_MODULE}:`;
+function renderAssetModule(manifest) {
+	return `export default ${JSON.stringify(manifest)};\n`;
+}
+/** Rolldown plugin: pack src/skills + src/files and expose `@keystrokehq/assets`. */
+function agentAssetsPlugin(options) {
+	const srcDir = options.srcDir ?? "src";
+	let manifest = null;
+	return {
+		name: "keystroke-assets",
+		buildStart() {
+			manifest = packAssetDirs(options.root, srcDir);
+		},
+		resolveId(source) {
+			if (source !== ASSETS_MODULE) return null;
+			return `${VIRTUAL_PREFIX}manifest`;
+		},
+		load(id) {
+			if (id !== `${VIRTUAL_PREFIX}manifest` || !manifest) return null;
+			return renderAssetModule(manifest);
+		},
+		buildEnd() {
+			if (!manifest) return;
+			const outDir = join(options.root, options.outDir ?? "dist", ".keystroke");
+			mkdirSync(outDir, { recursive: true });
+			writeFileSync(join(outDir, "assets.mjs"), renderAssetModule(manifest));
+		}
+	};
+}
+/** Full tsdown config for user keystroke apps (config + discovered modules only). */
+function createAppBuildConfig(options = {}, walked) {
+	const root = options.root ?? process.cwd();
+	const srcDir = options.srcDir ?? "src";
+	const outDir = options.outDir ?? "dist";
+	const configEntry = existsSync(join(root, "keystroke.config.ts")) ? join(root, "keystroke.config.ts") : void 0;
+	const walkedResult = walked ?? walkProject(root, {
+		srcDir,
+		phase: options.phase
+	});
+	const discovered = walkedResult.buildEntries;
+	const ignoredFiles = walkedResult.ignoredFiles;
+	const entries = {
+		...configEntry ? { config: configEntry } : {},
+		...discovered
+	};
+	if (Object.keys(entries).length === 0) throw new Error("Nothing to build — add keystroke.config.ts or modules under src/");
+	return mergeConfig(baseTsdownConfig, {
+		entry: entries,
+		format: ["esm"],
+		outDir: join(root, outDir),
+		clean: options.clean ?? true,
+		dts: false,
+		loader: { ".md": "text" },
+		deps: userAppBuildDepsConfig(),
+		plugins: [keystrokeIgnoreGuardPlugin({
+			root,
+			ignoredFiles
+		}), agentAssetsPlugin({
+			root,
+			srcDir,
+			outDir
+		})]
+	});
+}
+/** Build user agents, workflows, triggers, and config to `dist/`. */
+async function buildApp(options = {}) {
+	const root = options.root ?? process.cwd();
+	const srcDir = options.srcDir ?? "src";
+	const emitManifest = options.emitManifest ?? true;
+	const collectSources = options.collectSources ?? false;
+	const phase = options.phase ?? "build";
+	const previous = process.cwd();
+	const walked = walkProject(root, {
+		srcDir,
+		collectSources,
+		phase
+	});
+	try {
+		process.chdir(root);
+		await build(createAppBuildConfig({
+			...options,
+			root
+		}, {
+			buildEntries: walked.buildEntries,
+			ignoredFiles: walked.ignoredFiles
+		}));
+		if (emitManifest) {
+			const { emitStoredRouteManifestForProject } = await import("./dist-CegYAHE0.mjs");
+			await emitStoredRouteManifestForProject(root);
+		}
+	} finally {
+		process.chdir(previous);
+	}
+	return { sourceFiles: walked.sourceFiles };
+}
+/**
+* Watch `src/` and rebuild `dist/` on change.
+*
+* NOT true hot reload — each change runs a full tsdown rebuild. Callers should
+* restart the API server in `onRebuild` so discovery picks up new/changed modules.
+*/
+async function watchApp(options = {}) {
+	const { runWatchApp } = await import("./watch-app-DTIeKrbl-CSpsNzVG.mjs");
+	await runWatchApp((watchOptions) => buildApp({
+		...watchOptions,
+		emitManifest: false,
+		collectSources: false
+	}), options);
+}
+//#endregion
+export { buildApp, buildFilteredApp, resolveRuntimeBuildArtifact, watchApp };
+
+//# sourceMappingURL=dist-BMPry9tj.mjs.map