@velajs/cli 1.22.1 → 1.24.0

package/README.md

@@ -14,6 +14,9 @@ pnpm add -D @velajs/cli
 
 | Command | What it does |
 | --- | --- |
+| `vela new my-api` | Create a minimal Workers project with a module, controller, injected service, and a working local development setup. |
+| `vela doctor` | Explain config resolution without importing it; `--app` opts into application graph snapshots and teardown. Supports `--json`. |
+| `vela deploy check` | Check an explicit Wrangler config/environment against a saved entrypoint snapshot without bootstrapping, building or deploying. See the [deployment guide](../../docs/deployment.md). |
 | `vela db seed` | Build the app and run all `@Seeder()` classes in order. |
 | `vela route list` | HTTP route table: framework-composed controller routes (`Controller#handler`, full paths incl. prefix/version) plus `(mounted)` extras (CRUD/contributed, doc UIs). |
 | `vela module graph` | Module graph: imports tree with `global`/`lazy` flags and provider counts (`--json` for the raw graph). |
@@ -21,8 +24,37 @@ pnpm add -D @velajs/cli
 | `vela openapi dump` | Emit the OpenAPI document (needs `rootModule` in the config; `--out`, `--title`, `--api-version`, `--global-prefix`). |
 | `vela client generate` | Generate an `AppType` for `hc` from the app or `--input openapi.json`; `--out`, `--strict`, and CI `--check`. |
 | `vela mcp serve` | Run a Model Context Protocol stdio server exposing the introspection above as read-only tools (`route_list`, `module_graph`, `entrypoint_list`, `openapi_dump`, `token_describe`) plus a `vela://openapi` resource — for AI agents. |
+| `vela studio` | Serve the optional Studio UI through a local host, proxying the app selected by `--url`. |
 
-All introspection commands take `--config <path>`; the four listing/dump commands also take `--json`.
+All introspection commands take `--config <path>`; the listing commands also take `--json`.
+
+### Create a project
+
+Requires Node.js 24+ and pnpm 11.11.0:
+
+```sh
+pnpm dlx @velajs/cli@latest new my-api
+cd my-api
+pnpm install
+pnpm typecheck
+pnpm build
+pnpm dev
+```
+
+Request `http://localhost:8787` to receive `{"message":"Hello from Vela!"}`.
+The greeting comes from a constructor-injected service. SWC emits decorator
+metadata, and Wrangler rebuilds source changes during local development.
+The generated application uses published npm dependencies and requires no
+Cloudflare login, authentication integration, D1, Studio, or live queries.
+
+With an installed CLI, use `vela new my-api`. Names start with a lowercase letter
+and contain lowercase letters, digits, or single hyphens (at most 63 characters).
+Paths and reserved device names are rejected. Existing empty directories are
+accepted; nonempty directories, files, and symbolic links are rejected without
+overwriting them. Creation does not install dependencies or initialize Git.
+
+See the [project creation guide](https://github.com/velajs/vela/blob/main/docs/getting-started.md).
+Module, controller, service, and resource generators are not included yet.
 
 ### MCP server
 
@@ -47,25 +79,74 @@ the client disconnects, then disposes the app.
 ## Configure
 
 Create a `vela.config.{js,mjs,ts}` at your project root that builds your app.
-Wire your runtime bindings here (e.g. via miniflare for Cloudflare, or a Node
-adapter):
+Import compiled application JavaScript, including its decorator metadata. The
+starter's SWC build produces these files in `dist/`; run `pnpm build` first.
+This minimal config uses the portable factory in Node:
 
-```ts
-// vela.config.ts
+```js
+// vela.config.mjs
 import { defineVelaConfig } from '@velajs/cli/config';
-import { AppModule } from './src/app.module';
+import { VelaFactory } from '@velajs/vela';
+import { AppModule } from './dist/app.module.js';
 
 export default defineVelaConfig({
   rootModule: AppModule, // needed by `vela openapi dump` and `vela client generate`
-  async createApp() {
-    const { createCloudflareApp } = await import('@velajs/cloudflare');
-    return createCloudflareApp(AppModule);
-  },
+  createApp: () => VelaFactory.create(AppModule),
 });
 ```
 
-> `.ts` configs require a runtime that strips types (Node 22+
-> `--experimental-strip-types`, or `tsx`). `.js`/`.mjs` load directly.
+Supply local runtime bindings inside `createApp` if the application needs them.
+Do not import the Worker entrypoint into Node when it uses native
+`cloudflare:workers` APIs. A plain default-exported object or named `config`
+export also works; `defineVelaConfig` preserves the inferred app subtype and
+custom fields. The loader validates `createApp` and optional `rootModule` before
+commands use them. Command teardown awaits application disposal even when work
+fails, and cleanup warnings do not replace the command's exit result.
+
+Node 24 can strip erasable types in a `.ts` config, but it does not transform
+legacy decorators, emit constructor metadata, or resolve `tsconfig` path
+aliases. A `.ts` config should therefore also import the compiled `.js` graph
+with explicit extensions. Use SWC's `legacyDecorator` and `decoratorMetadata`
+settings from the starter, or a compiler with equivalent output. The CLI adds
+no compiler hooks. See [Node's TypeScript documentation](https://nodejs.org/docs/latest-v24.x/api/typescript.html#typescript-features).
+
+The loader checks `vela.config.js`, then `.mjs`, then `.ts` in the current
+directory; it does not search parents. `--config` selects exactly that path,
+relative to the current directory or absolute, with no fallback to another file.
+`resolveConfig()` from `@velajs/cli/config` returns the selected absolute path,
+the `explicit`/`discovered` source and the candidates actually checked, without
+importing user code.
+
+### Diagnose configuration
+
+```sh
+vela doctor --json
+pnpm build
+vela doctor --app --config vela.config.mjs --json
+```
+
+The default only resolves the config file. `--app` imports it and runs normal
+application bootstrap and shutdown hooks, which may perform application-defined
+work. It then reads existing module, route and entrypoint descriptions without
+resolving providers or materializing lazy modules for inspection. Reports omit
+provider values, environment values and arbitrary entrypoint metadata, and show
+only entrypoints belonging to that app. `--json` uses `schemaVersion: 1`; missing
+configs, bootstrap/snapshot errors or cleanup warnings return exit code 1.
+Send application startup logs to stderr when consuming JSON output.
+
+For breakpoints and source maps, see the [debugging guide](../../docs/debugging.md).
+
+### Studio
+
+```sh
+vela studio --url http://127.0.0.1:8787 --port 4000
+```
+
+The optional `@velajs/studio-host` and `@velajs/studio-ui` packages provide the
+host and UI. `--port` accepts a decimal integer from 0 to 65535 (0 asks the OS
+for an available port). Tokens come from `--token` or `VELA_STUDIO_TOKEN` and are
+injected by the host. The CLI config and client-generation entrypoints remain
+usable without Studio installed.
 
 ## Commands
 
@@ -74,9 +155,14 @@ export default defineVelaConfig({
 vela db seed
 vela db seed --config ./config/vela.config.js
 vela db seed --continue-on-error
+# Inspect registration owners without running seeders:
+vela db seed --list --json
 ```
 
 Exit code is `0` when all seeders run and `1` if any fail.
+Seeders registered in multiple modules run once per owner, including async
+providers. Invocations finish their managed deferred work and dispose request
+resources before the next seeder starts. See [seeding](../../docs/seeding.md).
 
 ## Typed HTTP clients
 

package/dist/config.d.ts

@@ -6,13 +6,13 @@ import { Type, VelaApplication } from "@velajs/vela";
  * Cloudflare Worker, or a plain Node adapter — and return a built app.
  *
  * ```ts
- * // vela.config.ts
+ * // vela.config.mjs — run `pnpm build` before using app-aware commands.
  * import { defineVelaConfig } from '@velajs/cli/config';
+ * import { VelaFactory } from '@velajs/vela';
+ * import { AppModule } from './dist/app.module.js';
  * export default defineVelaConfig({
- *   async createApp() {
- *     const { createCloudflareApp } = await import('@velajs/cloudflare');
- *     return createCloudflareApp(AppModule);
- *   },
+ *   rootModule: AppModule,
+ *   createApp: () => VelaFactory.create(AppModule),
  * });
  * ```
  */
@@ -25,12 +25,21 @@ export interface VelaConfig {
   rootModule?: Type;
 }
 /** Identity helper for type-safe config files. */
-export declare function defineVelaConfig(config: VelaConfig): VelaConfig;
+export declare function defineVelaConfig<const Config extends VelaConfig>(config: Config): Config;
 /**
- * Locate + import the vela config. `.ts` requires a runtime that strips types
- * (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load
- * directly.
+ * Locate and import a config using Node's loader. Node 24 can strip erasable
+ * types in `.ts` configs, but does not emit legacy decorators or DI metadata.
+ * Import compiled application `.js` from the config (e.g. the SWC build used
+ * by Wrangler). This loader does not install compiler or path-alias hooks.
  */
 export declare function loadConfig(cwd?: string, explicitPath?: string): Promise<VelaConfig>;
+export interface ConfigResolution {
+  readonly path: string;
+  readonly source: 'explicit' | 'discovered';
+  /** Absolute paths checked in order, ending at the selected file. */
+  readonly candidates: readonly string[];
+}
+/** Resolve provenance without importing application code or walking parent directories. */
+export declare function resolveConfig(cwd?: string, explicitPath?: string): Promise<ConfigResolution>;
 //#endregion
 //# sourceMappingURL=config.d.ts.map

package/dist/config.js

@@ -1,5 +1,5 @@
-import { access } from "node:fs/promises";
-import { isAbsolute, join, resolve } from "node:path";
+import { stat } from "node:fs/promises";
+import { join, resolve } from "node:path";
 import { pathToFileURL } from "node:url";
 //#region src/config.ts
 /** Identity helper for type-safe config files. */
@@ -12,28 +12,59 @@ const CANDIDATES = [
 	"vela.config.ts"
 ];
 /**
-* Locate + import the vela config. `.ts` requires a runtime that strips types
-* (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load
-* directly.
+* Locate and import a config using Node's loader. Node 24 can strip erasable
+* types in `.ts` configs, but does not emit legacy decorators or DI metadata.
+* Import compiled application `.js` from the config (e.g. the SWC build used
+* by Wrangler). This loader does not install compiler or path-alias hooks.
 */
 async function loadConfig(cwd = process.cwd(), explicitPath) {
-	const path = explicitPath ? isAbsolute(explicitPath) ? explicitPath : resolve(cwd, explicitPath) : await findConfig(cwd);
-	if (!path) throw new Error(`No vela config found. Create one of: ${CANDIDATES.join(", ")} (or pass --config <path>).`);
-	const mod = await import(pathToFileURL(path).href);
-	const config = mod.default ?? mod.config;
-	if (!config || typeof config.createApp !== "function") throw new Error(`Config at ${path} must export { createApp(): Promise<VelaApplication> } (default export or a named 'config').`);
+	const { path } = await resolveConfig(cwd, explicitPath);
+	let mod;
+	try {
+		mod = await import(pathToFileURL(path).href);
+	} catch (cause) {
+		throw new Error(`Could not import config at ${path}: ${cause instanceof Error ? cause.message : String(cause)}\nConfigs run in Node. Compile decorated application source with SWC (legacyDecorator + decoratorMetadata) or an equivalent metadata-emitting compiler, then import its compiled .js files with explicit extensions. Run your application build first; native TypeScript stripping does not transform decorators or tsconfig paths.`, { cause });
+	}
+	const config = isRecord(mod) ? mod.default ?? mod.config : void 0;
+	if (!isVelaConfig(config)) throw new Error(`Config at ${path} must export an object with createApp(): VelaApplication | Promise<VelaApplication> (default export or a named 'config'); rootModule, when provided, must be a constructor.`);
 	return config;
 }
-async function findConfig(cwd) {
-	for (const name of CANDIDATES) {
-		const candidate = join(cwd, name);
+/** Resolve provenance without importing application code or walking parent directories. */
+async function resolveConfig(cwd = process.cwd(), explicitPath) {
+	if (explicitPath !== void 0 && explicitPath.trim() === "") throw new Error("--config must name a file.");
+	const candidates = explicitPath === void 0 ? CANDIDATES.map((name) => join(resolve(cwd), name)) : [resolve(cwd, explicitPath)];
+	const checked = [];
+	for (const candidate of candidates) {
+		checked.push(candidate);
 		try {
-			await access(candidate);
-			return candidate;
-		} catch {}
+			if (!(await stat(candidate)).isFile()) throw new Error(`Config at ${candidate} must be a file.`);
+			return {
+				path: candidate,
+				source: explicitPath === void 0 ? "discovered" : "explicit",
+				candidates: checked
+			};
+		} catch (error) {
+			if (!isRecord(error) || error.code !== "ENOENT") throw error;
+		}
 	}
+	throw new Error(`No vela config found. Checked: ${checked.join(", ")}. Create one of: ${CANDIDATES.join(", ")} (or pass --config <path>).`);
+}
+function isRecord(value) {
+	return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function isConstructor(value) {
+	if (typeof value !== "function") return false;
+	try {
+		Reflect.construct(Object, [], value);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function isVelaConfig(value) {
+	return isRecord(value) && typeof value.createApp === "function" && (value.rootModule === void 0 || isConstructor(value.rootModule));
 }
 //#endregion
-export { defineVelaConfig, loadConfig };
+export { defineVelaConfig, loadConfig, resolveConfig };
 
 //# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -1 +1 @@
-{"version":3,"file":"config.js","names":[],"sources":["../src/config.ts"],"sourcesContent":["import { access } from 'node:fs/promises';\nimport { isAbsolute, join, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type { Type, VelaApplication } from '@velajs/vela';\n\n/**\n * A `vela.config.{js,mjs,ts}` default-exports (or exports `config`) this shape.\n * You wire your runtime bindings inside `createApp` — e.g. via miniflare for a\n * Cloudflare Worker, or a plain Node adapter — and return a built app.\n *\n * ```ts\n * // vela.config.ts\n * import { defineVelaConfig } from '@velajs/cli/config';\n * export default defineVelaConfig({\n *   async createApp() {\n *     const { createCloudflareApp } = await import('@velajs/cloudflare');\n *     return createCloudflareApp(AppModule);\n *   },\n * });\n * ```\n */\nexport interface VelaConfig {\n  createApp(): Promise<VelaApplication> | VelaApplication;\n  /**\n   * The app's root module class — needed only by commands that work from\n   * module metadata rather than the built app (`vela openapi dump`, `vela client generate`).\n   */\n  rootModule?: Type;\n}\n\n/** Identity helper for type-safe config files. */\nexport function defineVelaConfig(config: VelaConfig): VelaConfig {\n  return config;\n}\n\nconst CANDIDATES = ['vela.config.js', 'vela.config.mjs', 'vela.config.ts'];\n\n/**\n * Locate + import the vela config. `.ts` requires a runtime that strips types\n * (Node 22+ `--experimental-strip-types`, or tsx/ts-node); `.js`/`.mjs` load\n * directly.\n */\nexport async function loadConfig(\n  cwd: string = process.cwd(),\n  explicitPath?: string,\n): Promise<VelaConfig> {\n  const path = explicitPath\n    ? isAbsolute(explicitPath)\n      ? explicitPath\n      : resolve(cwd, explicitPath)\n    : await findConfig(cwd);\n\n  if (!path) {\n    throw new Error(\n      `No vela config found. Create one of: ${CANDIDATES.join(', ')} (or pass --config <path>).`,\n    );\n  }\n\n  const mod = (await import(pathToFileURL(path).href)) as {\n    default?: VelaConfig;\n    config?: VelaConfig;\n  };\n  const config = mod.default ?? mod.config;\n  if (!config || typeof config.createApp !== 'function') {\n    throw new Error(\n      `Config at ${path} must export { createApp(): Promise<VelaApplication> } (default export or a named 'config').`,\n    );\n  }\n  return config;\n}\n\nasync function findConfig(cwd: string): Promise<string | undefined> {\n  for (const name of CANDIDATES) {\n    const candidate = join(cwd, name);\n    try {\n      await access(candidate);\n      return candidate;\n    } catch {\n      // try next\n    }\n  }\n  return undefined;\n}\n"],"mappings":";;;;;AA+BA,SAAgB,iBAAiB,QAAgC;CAC/D,OAAO;AACT;AAEA,MAAM,aAAa;CAAC;CAAkB;CAAmB;AAAgB;;;;;;AAOzE,eAAsB,WACpB,MAAc,QAAQ,IAAI,GAC1B,cACqB;CACrB,MAAM,OAAO,eACT,WAAW,YAAY,IACrB,eACA,QAAQ,KAAK,YAAY,IAC3B,MAAM,WAAW,GAAG;CAExB,IAAI,CAAC,MACH,MAAM,IAAI,MACR,wCAAwC,WAAW,KAAK,IAAI,EAAE,4BAChE;CAGF,MAAM,MAAO,MAAM,OAAO,cAAc,IAAI,CAAC,CAAC;CAI9C,MAAM,SAAS,IAAI,WAAW,IAAI;CAClC,IAAI,CAAC,UAAU,OAAO,OAAO,cAAc,YACzC,MAAM,IAAI,MACR,aAAa,KAAK,6FACpB;CAEF,OAAO;AACT;AAEA,eAAe,WAAW,KAA0C;CAClE,KAAK,MAAM,QAAQ,YAAY;EAC7B,MAAM,YAAY,KAAK,KAAK,IAAI;EAChC,IAAI;GACF,MAAM,OAAO,SAAS;GACtB,OAAO;EACT,QAAQ,CAER;CACF;AAEF"}
+{"version":3,"file":"config.js","names":[],"sources":["../src/config.ts"],"sourcesContent":["import { stat } from 'node:fs/promises';\nimport { join, resolve } from 'node:path';\nimport { pathToFileURL } from 'node:url';\nimport type { Type, VelaApplication } from '@velajs/vela';\n\n/**\n * A `vela.config.{js,mjs,ts}` default-exports (or exports `config`) this shape.\n * You wire your runtime bindings inside `createApp` — e.g. via miniflare for a\n * Cloudflare Worker, or a plain Node adapter — and return a built app.\n *\n * ```ts\n * // vela.config.mjs — run `pnpm build` before using app-aware commands.\n * import { defineVelaConfig } from '@velajs/cli/config';\n * import { VelaFactory } from '@velajs/vela';\n * import { AppModule } from './dist/app.module.js';\n * export default defineVelaConfig({\n *   rootModule: AppModule,\n *   createApp: () => VelaFactory.create(AppModule),\n * });\n * ```\n */\nexport interface VelaConfig {\n  createApp(): Promise<VelaApplication> | VelaApplication;\n  /**\n   * The app's root module class — needed only by commands that work from\n   * module metadata rather than the built app (`vela openapi dump`, `vela client generate`).\n   */\n  rootModule?: Type;\n}\n\n/** Identity helper for type-safe config files. */\nexport function defineVelaConfig<const Config extends VelaConfig>(config: Config): Config {\n  return config;\n}\n\nconst CANDIDATES = ['vela.config.js', 'vela.config.mjs', 'vela.config.ts'];\n\n/**\n * Locate and import a config using Node's loader. Node 24 can strip erasable\n * types in `.ts` configs, but does not emit legacy decorators or DI metadata.\n * Import compiled application `.js` from the config (e.g. the SWC build used\n * by Wrangler). This loader does not install compiler or path-alias hooks.\n */\nexport async function loadConfig(\n  cwd: string = process.cwd(),\n  explicitPath?: string,\n): Promise<VelaConfig> {\n  const { path } = await resolveConfig(cwd, explicitPath);\n  let mod: unknown;\n  try {\n    mod = await import(pathToFileURL(path).href);\n  } catch (cause) {\n    throw new Error(\n      `Could not import config at ${path}: ${cause instanceof Error ? cause.message : String(cause)}\\n` +\n        'Configs run in Node. Compile decorated application source with SWC (legacyDecorator + decoratorMetadata) ' +\n        'or an equivalent metadata-emitting compiler, then import its compiled .js files with explicit extensions. ' +\n        'Run your application build first; native TypeScript stripping does not transform decorators or tsconfig paths.',\n      { cause },\n    );\n  }\n  const config = isRecord(mod) ? (mod.default ?? mod.config) : undefined;\n  if (!isVelaConfig(config)) {\n    throw new Error(\n      `Config at ${path} must export an object with createApp(): VelaApplication | Promise<VelaApplication> ` +\n        \"(default export or a named 'config'); rootModule, when provided, must be a constructor.\",\n    );\n  }\n  return config;\n}\n\nexport interface ConfigResolution {\n  readonly path: string;\n  readonly source: 'explicit' | 'discovered';\n  /** Absolute paths checked in order, ending at the selected file. */\n  readonly candidates: readonly string[];\n}\n\n/** Resolve provenance without importing application code or walking parent directories. */\nexport async function resolveConfig(\n  cwd: string = process.cwd(),\n  explicitPath?: string,\n): Promise<ConfigResolution> {\n  if (explicitPath !== undefined && explicitPath.trim() === '') {\n    throw new Error('--config must name a file.');\n  }\n  const candidates =\n    explicitPath === undefined\n      ? CANDIDATES.map((name) => join(resolve(cwd), name))\n      : [resolve(cwd, explicitPath)];\n  const checked: string[] = [];\n  for (const candidate of candidates) {\n    checked.push(candidate);\n    try {\n      if (!(await stat(candidate)).isFile()) {\n        throw new Error(`Config at ${candidate} must be a file.`);\n      }\n      return {\n        path: candidate,\n        source: explicitPath === undefined ? 'discovered' : 'explicit',\n        candidates: checked,\n      };\n    } catch (error) {\n      if (!isRecord(error) || error.code !== 'ENOENT') throw error;\n    }\n  }\n  throw new Error(\n    `No vela config found. Checked: ${checked.join(', ')}. Create one of: ${CANDIDATES.join(', ')} (or pass --config <path>).`,\n  );\n}\n\nfunction isRecord(value: unknown): value is Record<string, unknown> {\n  return value !== null && typeof value === 'object' && !Array.isArray(value);\n}\n\nfunction isConstructor(value: unknown): value is Type {\n  if (typeof value !== 'function') return false;\n  try {\n    // Validate constructability without invoking the user's constructor.\n    Reflect.construct(Object, [], value);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction isVelaConfig(value: unknown): value is VelaConfig {\n  return (\n    isRecord(value) &&\n    typeof value.createApp === 'function' &&\n    (value.rootModule === undefined || isConstructor(value.rootModule))\n  );\n}\n"],"mappings":";;;;;AA+BA,SAAgB,iBAAkD,QAAwB;CACxF,OAAO;AACT;AAEA,MAAM,aAAa;CAAC;CAAkB;CAAmB;AAAgB;;;;;;;AAQzE,eAAsB,WACpB,MAAc,QAAQ,IAAI,GAC1B,cACqB;CACrB,MAAM,EAAE,SAAS,MAAM,cAAc,KAAK,YAAY;CACtD,IAAI;CACJ,IAAI;EACF,MAAM,MAAM,OAAO,cAAc,IAAI,CAAC,CAAC;CACzC,SAAS,OAAO;EACd,MAAM,IAAI,MACR,8BAA8B,KAAK,IAAI,iBAAiB,QAAQ,MAAM,UAAU,OAAO,KAAK,EAAE,sUAI9F,EAAE,MAAM,CACV;CACF;CACA,MAAM,SAAS,SAAS,GAAG,IAAK,IAAI,WAAW,IAAI,SAAU,KAAA;CAC7D,IAAI,CAAC,aAAa,MAAM,GACtB,MAAM,IAAI,MACR,aAAa,KAAK,4KAEpB;CAEF,OAAO;AACT;;AAUA,eAAsB,cACpB,MAAc,QAAQ,IAAI,GAC1B,cAC2B;CAC3B,IAAI,iBAAiB,KAAA,KAAa,aAAa,KAAK,MAAM,IACxD,MAAM,IAAI,MAAM,4BAA4B;CAE9C,MAAM,aACJ,iBAAiB,KAAA,IACb,WAAW,KAAK,SAAS,KAAK,QAAQ,GAAG,GAAG,IAAI,CAAC,IACjD,CAAC,QAAQ,KAAK,YAAY,CAAC;CACjC,MAAM,UAAoB,CAAC;CAC3B,KAAK,MAAM,aAAa,YAAY;EAClC,QAAQ,KAAK,SAAS;EACtB,IAAI;GACF,IAAI,EAAE,MAAM,KAAK,SAAS,EAAA,CAAG,OAAO,GAClC,MAAM,IAAI,MAAM,aAAa,UAAU,iBAAiB;GAE1D,OAAO;IACL,MAAM;IACN,QAAQ,iBAAiB,KAAA,IAAY,eAAe;IACpD,YAAY;GACd;EACF,SAAS,OAAO;GACd,IAAI,CAAC,SAAS,KAAK,KAAK,MAAM,SAAS,UAAU,MAAM;EACzD;CACF;CACA,MAAM,IAAI,MACR,kCAAkC,QAAQ,KAAK,IAAI,EAAE,mBAAmB,WAAW,KAAK,IAAI,EAAE,4BAChG;AACF;AAEA,SAAS,SAAS,OAAkD;CAClE,OAAO,UAAU,QAAQ,OAAO,UAAU,YAAY,CAAC,MAAM,QAAQ,KAAK;AAC5E;AAEA,SAAS,cAAc,OAA+B;CACpD,IAAI,OAAO,UAAU,YAAY,OAAO;CACxC,IAAI;EAEF,QAAQ,UAAU,QAAQ,CAAC,GAAG,KAAK;EACnC,OAAO;CACT,QAAQ;EACN,OAAO;CACT;AACF;AAEA,SAAS,aAAa,OAAqC;CACzD,OACE,SAAS,KAAK,KACd,OAAO,MAAM,cAAc,eAC1B,MAAM,eAAe,KAAA,KAAa,cAAc,MAAM,UAAU;AAErE"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 import { GeneratedClientContract, generateClientContract } from "./client-contract.js";
-import { VelaConfig, defineVelaConfig, loadConfig } from "./config.js";
+import { ConfigResolution, VelaConfig, defineVelaConfig, loadConfig, resolveConfig } from "./config.js";
 import { Command } from "clipanion";
 import { ModuleDescription, VelaApplication } from "@velajs/vela";
 import { SeederResult } from "@velajs/vela/seeder";
@@ -10,6 +10,16 @@ export declare class SeedCommand extends Command {
   static usage: import("clipanion").Usage;
   config: string | undefined;
   continueOnError: boolean;
+  list: boolean;
+  json: boolean;
+  execute(): Promise<number>;
+}
+//#endregion
+//#region src/commands/new.command.d.ts
+export declare class NewCommand extends Command {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  name: string;
   execute(): Promise<number>;
 }
 //#endregion
@@ -58,10 +68,8 @@ export declare class OpenApiDumpCommand extends Command {
  * introspection as the `route`/`module`/`entrypoint`/`openapi` commands, so an
  * AI agent can query a Vela app's shape over the Model Context Protocol.
  *
- * Deliberately does NOT extend `AppCommand`: that base disposes the app in its
- * `finally` the moment `run()` returns, but an MCP server must stay alive until
- * the transport closes. stdout is reserved for JSON-RPC framing; every human
- * message goes to stderr.
+ * The application lifetime includes the transport's close promise. stdout is
+ * reserved for JSON-RPC framing; every human message goes to stderr.
  */
 export declare class McpServeCommand extends Command {
   static paths: string[][];
@@ -93,6 +101,7 @@ export declare class StudioCommand extends Command {
 //#endregion
 //#region src/commands/client.command.d.ts
 export declare class ClientGenerateCommand extends Command {
+  #private;
   static paths: string[][];
   static usage: import("clipanion").Usage;
   config: string | undefined;
@@ -101,8 +110,28 @@ export declare class ClientGenerateCommand extends Command {
   check: boolean;
   strict: boolean;
   execute(): Promise<number>;
-  private readDocument;
-  private fromApp;
+}
+//#endregion
+//#region src/commands/doctor.command.d.ts
+export declare class DoctorCommand extends Command {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  config: string | undefined;
+  app: boolean;
+  json: boolean;
+  execute(): Promise<number>;
+}
+//#endregion
+//#region src/commands/deploy-check.command.d.ts
+/** Static application deployment preflight; never invokes Wrangler or application code. */
+export declare class DeployCheckCommand extends Command {
+  static paths: string[][];
+  static usage: import("clipanion").Usage;
+  config: string;
+  environment: string;
+  entrypoints: string;
+  json: boolean;
+  execute(): Promise<number>;
 }
 //#endregion
 //#region src/introspect.d.ts
@@ -146,5 +175,5 @@ export declare function formatSeedResults(results: SeederResult[], log?: (messag
 /** Aligned plain-text table. Pure; returns lines. */
 export declare function renderTable(headers: string[], rows: string[][]): string[];
 //#endregion
-export { type EntrypointRow, type GeneratedClientContract, type RouteRow, type VelaConfig, defineVelaConfig, generateClientContract, loadConfig };
+export { type ConfigResolution, type EntrypointRow, type GeneratedClientContract, type RouteRow, type VelaConfig, defineVelaConfig, generateClientContract, loadConfig, resolveConfig };
 //# sourceMappingURL=index.d.ts.map