heximon 0.10.0 → 0.11.0

package/README.md

@@ -8,12 +8,14 @@ after your last `pnpm build`.
 
 ## Why you want it
 
-- **One binary for the whole surface.** `create`, `check`, `routes`, `graph`, `doctor`, `deploy`,
-  `provision`, `migrations`, `task`, and `workflows` are one command each.
+- **One binary for the whole surface.** `create`, `check`, `routes`, `graph`, `doctor`, `freshness`,
+  `deploy`, `provision`, `migrations`, `task`, and `workflows` are one command each.
 - **`heximon check` catches a dependency-injection error before `tsgo` does.** It compiles your app
   headlessly and reports every compile error with its position and a fix.
 - **`heximon doctor` finds a package installed twice.** Class identity is the only dependency-injection
   token, so two copies of one package bind two different sets of classes. `doctor` names both directories.
+- **`heximon freshness` finds the packages that need a new `vp pack`.** It runs from any folder of a
+  workspace, lists every package that has a pack record, and names the file that made a package stale.
 - **`heximon deploy` ships with the platform's own tool.** It builds your app, then runs `wrangler`,
   `vercel`, `netlify`, or `deployctl` for you, with the right flags for your environment.
 - **Agents and CI read one JSON document.** Every command takes `--json`: stdout gets one document with
@@ -58,6 +60,7 @@ const main = defineCommand({
     routes: routesCommand,
     graph: graphCommand,
     doctor: doctorCommand,
+    freshness: freshnessCommand,
     provision: provisionCommand,
     migrations: migrationsCommand,
     workflows: workflowsCommand,
@@ -76,6 +79,7 @@ const main = defineCommand({
 | `heximon routes` | Prints one table for every path the app answers — routes, SSE streams, and WebSocket upgrades — read from the compiler, with no boot required. |
 | `heximon graph` | Prints the resolved module dependency graph: modules, providers, and dependencies. |
 | `heximon doctor` | Reports a package installed twice, an untraced deploy target, and a stale published module. |
+| `heximon freshness` | Lists every workspace package that has a pack record (`dist/heximon.manifest.json` or `dist/heximon.inputs.json`), with its status and the input that made it stale. It finds the workspace root from any folder (`pnpm-workspace.yaml`, or a `workspaces` field in `package.json`), compiles nothing, and exits `1` when a package is stale or its check failed. A record file that exists but cannot be read is a failed check, not a missing record. `--stale` lists only those packages. |
 | `heximon deploy` | Builds the app, then ships it with the target platform's own command-line tool. |
 | `heximon provision` | Creates a resource your build needs an identifier for, before the build runs. |
 | `heximon migrations` | Runs `generate`, `migrate`, `status`, or `push` against your database, with no hand-written `drizzle-kit` config. |
@@ -114,6 +118,7 @@ The document types are exported as types from the package root:
 | `routes` | `RoutesJsonDocument` | `RoutesDiagnosticCode` |
 | `graph` | `GraphJsonDocument` | `GraphDiagnosticCode` |
 | `doctor` | `DoctorJsonDocument` | `DoctorDiagnosticCode` |
+| `freshness` | `FreshnessJsonDocument` | `FreshnessDiagnosticCode` |
 | `skills add`, `skills sync` | `SkillsAddJsonDocument`, `SkillsSyncJsonDocument` | `SkillsDiagnosticCode` |
 | `task run` | `TaskRunJsonDocument` | `TaskDiagnosticCode` |
 | `migrations generate`, `migrate`, `push`, `status` | `MigrationsGenerateJsonDocument`, `MigrationsMigrateJsonDocument`, `MigrationsPushJsonDocument`, `MigrationsStatusJsonDocument` | `MigrationsDiagnosticCode` |

package/dist/bin.mjs

@@ -4,15 +4,16 @@ import { createRequire, register } from "node:module";
 import { cancel, confirm, intro, isCancel, log, outro, select, spinner } from "@clack/prompts";
 import process from "node:process";
 import { defineCommand } from "citty";
-import { existsSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
+import { existsSync, globSync, mkdirSync, mkdtempSync, readFileSync, realpathSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { AstNodeType, CompileEnvironment, CompileMode, DeployPlatform, DiagnosticCode, DiagnosticRenderMode, DiagnosticRenderer, DiagnosticSeverity, ImportKind, ReexportIndex, RuntimeConfigFile, RuntimeSingletons, TerminalStyle, UpgradeBaselineFile } from "@heximon/compiler";
 import { spawn } from "node:child_process";
 import { basename, dirname, isAbsolute, join, relative, resolve } from "pathe";
 import tab from "@bomb.sh/tab/citty";
-import { ConfigLoader, LibraryEmitter, LibraryFactoryPreflight, LibraryFreshness, ProjectCompiler, RuntimeConfigLoader, SourceModuleResolution, SourceParser, WorkspaceTopologyReader } from "@heximon/compiler/project";
+import { ConfigLoader, LibraryEmitter, LibraryFactoryPreflight, LibraryFreshness, LibraryFreshnessStatus, PnpmWorkspaceManifest, ProjectCompiler, RuntimeConfigLoader, SourceModuleResolution, SourceParser, WorkspaceTopologyReader } from "@heximon/compiler/project";
 import { NodeCompileSeam } from "@heximon/node/compiler";
 import { TransactionCensus, TransactionCensusPolicy } from "@heximon/cqrs/compiler";
 import { BoundaryProvenanceAuditor, BoundaryProvenanceStatus, CredentialSelection, DatabaseConfigDetector, DeployDiagnosticSeverity, DeployLedger, DeployManifestStore, DeployRunner, DeployStrategyUnavailableError, DeployTargetResolver, DeployableServiceReader, DotenvCascade, DrizzleKitRunner, EnvFileReader, EnvFileUnreadableError, HostManagedDeployUnsupportedError, ImportScanner, MigrationInspector, MigrationTargetComposer, PackageCopyAuditor, PeerClosureAuditor, PlatformTracingAuditor, PlatformTracingStatus, SecretMask, WorkspaceConsumerLocator } from "@heximon/deploy";
+import { matchesGlob } from "node:path";
 import { RouteCensus, RouteScopeGap } from "@heximon/http/compiler";
 import { pathToFileURL } from "node:url";
 import { homedir } from "node:os";
@@ -1677,7 +1678,7 @@ var DoctorAudit = class DoctorAudit {
 			const hasConsumers = (result.workspaceConsumers?.consumers.length ?? 0) > 0;
 			parts.push(hasConsumers ? "Forked against a workspace consumer — equalize the two packages' installed peer contexts (a one-sided cover can flip the fork, not remove it) and reinstall." : "Forked within this package's own resolution (no workspace consumers found to compare against) — align the versions its own dependency tree resolves and reinstall.");
 		}
-		if (result.selfReport === null) parts.push("This directory is not a packed Heximon library (no dist/heximon.manifest.json) — the peer-closure and copy census above still ran; run `vp pack` to enable the staleness check too.");
+		if (result.selfReport === null) parts.push("This directory is not a packed Heximon library (no dist/heximon.manifest.json and no dist/heximon.inputs.json) — the peer-closure and copy census above still ran; run `vp pack` to enable the staleness check too.");
 		else if (result.selfReport.status === BoundaryProvenanceStatus.Stale || !forked) parts.push(DoctorAudit.selfProvenanceSummary(result.selfReport));
 		return parts.join(" ");
 	}
@@ -1707,7 +1708,7 @@ var DoctorAudit = class DoctorAudit {
 	*/
 	static selfProvenanceSummary(report) {
 		switch (report.status) {
-			case BoundaryProvenanceStatus.Fresh: return "This package's dist is current with its src/.";
+			case BoundaryProvenanceStatus.Fresh: return report.manifestSourceHash === void 0 ? "This package's dist is current with its build inputs." : "This package's dist is current with its src/.";
 			case BoundaryProvenanceStatus.NoProvenance: return "Its packed manifest predates the provenance stamp, so nothing was compared — repack (`vp pack`) to enable the staleness check.";
 			case BoundaryProvenanceStatus.NoSource: return "It ships no local src/, so its packed manifest was not compared with anything.";
 			case BoundaryProvenanceStatus.Stale: return "Your dist is STALE — repack (`vp pack`) before publishing or consuming this package.";
@@ -1890,61 +1891,113 @@ var DoctorJsonReport = class DoctorJsonReport {
 	/** One staleness entry. `self` marks the package that `--self` audits. */
 	static staleness(report, self) {
 		const freshness = report;
-		const repack = `cd ${DoctorJsonReport.shellWord(report.packageDirectory)} && vp pack`;
-		const details = {
+		const repack = DoctorJsonReport.repackCommand(report.packageDirectory);
+		const verdict = DoctorJsonReport.verdictOf(report.status, self ? "Repack (`vp pack`) before publishing or consuming it." : `Rebuild it (\`vp pack\` in ${report.packageDirectory}) before trusting this app's build.`, repack);
+		return {
+			name: report.specifier,
+			status: verdict.status,
+			reason: DoctorJsonReport.reasonOf(freshness),
+			...verdict.hint === void 0 ? {} : { hint: verdict.hint },
+			...verdict.fix === void 0 ? {} : { fix: verdict.fix },
+			failing: verdict.failing,
 			self,
 			...report.packageVersion === void 0 ? {} : { version: report.packageVersion },
 			directory: report.packageDirectory,
-			...report.manifestSourceHash === void 0 ? {} : { manifestSourceHash: report.manifestSourceHash },
-			...report.recomputedSourceHash === void 0 ? {} : { recomputedSourceHash: report.recomputedSourceHash },
-			...report.missingSource === void 0 ? {} : { missingSource: report.missingSource },
-			...freshness.currentSource === void 0 ? {} : { currentSource: freshness.currentSource },
-			...report.manifestBundleInputHash === void 0 ? {} : { manifestBundleInputHash: report.manifestBundleInputHash },
-			...report.recomputedBundleInputHash === void 0 ? {} : { recomputedBundleInputHash: report.recomputedBundleInputHash },
-			...report.missingBundleInputs === void 0 ? {} : { missingBundleInputs: report.missingBundleInputs }
+			...DoctorJsonReport.freshnessDetails(freshness)
 		};
-		switch (report.status) {
-			case BoundaryProvenanceStatus.Fresh: return {
-				name: report.specifier,
+	}
+	/**
+	* The status, the hint, the fix and whether it fails the run, for a verdict: a stale package fails and is
+	* repacked, a package with no provenance is repacked, and the others need nothing.
+	*
+	* @param status - The status of a {@link LibraryFreshness} verdict.
+	* @param staleHint - The hint of a stale package.
+	* @param repack - The command that repacks the package.
+	* @returns The fields.
+	*/
+	static verdictOf(status, staleHint, repack) {
+		switch (status) {
+			case LibraryFreshnessStatus.Fresh: return {
 				status: DoctorPackageStatus.Fresh,
-				reason: `The packed manifest matches the local source (${String(report.manifestSourceHash)}).`,
-				failing: false,
-				...details
+				failing: false
 			};
-			case BoundaryProvenanceStatus.Stale: return {
-				name: report.specifier,
+			case LibraryFreshnessStatus.Stale: return {
 				status: DoctorPackageStatus.Stale,
-				reason: DoctorJsonReport.staleReason(freshness),
-				hint: self ? "Repack (`vp pack`) before publishing or consuming it." : `Rebuild it (\`vp pack\` in ${report.packageDirectory}) before trusting this app's build.`,
+				hint: staleHint,
 				fix: repack,
-				failing: true,
-				...details
+				failing: true
 			};
-			case BoundaryProvenanceStatus.NoProvenance: return {
-				name: report.specifier,
+			case LibraryFreshnessStatus.NoProvenance: return {
 				status: DoctorPackageStatus.NoProvenance,
-				reason: "The packed manifest predates the provenance stamp, so nothing was compared.",
 				hint: "Repack (`vp pack`) to enable the staleness check.",
 				fix: repack,
-				failing: false,
-				...details
+				failing: false
 			};
-			case BoundaryProvenanceStatus.NoSource: return {
-				name: report.specifier,
+			case LibraryFreshnessStatus.NoSource: return {
 				status: DoctorPackageStatus.NoSource,
-				reason: "A published package with no local src/, so its provenance is display-only.",
-				failing: false,
-				...details
+				failing: false
 			};
 		}
 	}
+	/**
+	* The fields of a verdict that the JSON documents print beside its status: the hashes, the missing and the
+	* current source, and the stale build entries. A field the verdict does not have is left out.
+	*
+	* @param report - A {@link LibraryFreshness} verdict.
+	* @returns The fields.
+	*/
+	static freshnessDetails(report) {
+		return {
+			...report.manifestSourceHash === void 0 ? {} : { manifestSourceHash: report.manifestSourceHash },
+			...report.recomputedSourceHash === void 0 ? {} : { recomputedSourceHash: report.recomputedSourceHash },
+			...report.missingSource === void 0 ? {} : { missingSource: report.missingSource },
+			...report.currentSource === void 0 ? {} : { currentSource: report.currentSource },
+			...report.manifestBundleInputHash === void 0 ? {} : { manifestBundleInputHash: report.manifestBundleInputHash },
+			...report.recomputedBundleInputHash === void 0 ? {} : { recomputedBundleInputHash: report.recomputedBundleInputHash },
+			...report.missingBundleInputs === void 0 ? {} : { missingBundleInputs: report.missingBundleInputs },
+			...report.staleBuildEntries === void 0 ? {} : { staleBuildEntries: report.staleBuildEntries }
+		};
+	}
+	/**
+	* Why a package has the status of its verdict, as one sentence.
+	*
+	* @param report - A {@link LibraryFreshness} verdict.
+	* @returns The reason.
+	*/
+	static reasonOf(report) {
+		switch (report.status) {
+			case LibraryFreshnessStatus.Fresh: return report.manifestSourceHash === void 0 ? "The pack inputs file matches the local build inputs." : `The packed manifest matches the local source (${report.manifestSourceHash}).`;
+			case LibraryFreshnessStatus.Stale: return DoctorJsonReport.staleReason(report);
+			case LibraryFreshnessStatus.NoProvenance: return "The packed manifest predates the provenance stamp, so nothing was compared.";
+			case LibraryFreshnessStatus.NoSource: return "A published package with no local src/, so its provenance is display-only.";
+		}
+	}
+	/**
+	* The shell command that repacks a package.
+	*
+	* @param packageDirectory - The package root.
+	* @returns `cd <directory> && vp pack`, with the directory quoted when it needs quotes.
+	*/
+	static repackCommand(packageDirectory) {
+		return `cd ${DoctorJsonReport.shellWord(packageDirectory)} && vp pack`;
+	}
 	/** Why a stale report is stale, in the words and the order of the text report. */
 	static staleReason(report) {
-		if (report.currentSource !== void 0) return `The source folders it was packed from (${(report.missingSource ?? []).join(", ")}) no longer exist, and its source is now in ${report.currentSource}.`;
-		if (report.missingBundleInputs !== void 0) return `Files its bundle read outside its source (${report.missingBundleInputs.join(", ")}) are no longer on disk.`;
-		if (report.recomputedBundleInputHash !== void 0) return `A file its bundle read outside its source changed: the bundle inputs (${report.recomputedBundleInputHash}) no longer match the packed manifest (${String(report.manifestBundleInputHash)}).`;
-		if (report.missingSource !== void 0 && report.missingSource.length > 0) return `The source it was packed from (${report.missingSource.join(", ")}) is no longer on disk.`;
-		return `Its src/ (${String(report.recomputedSourceHash)}) no longer matches the packed manifest (${String(report.manifestSourceHash)}).`;
+		const entries = LibraryFreshness.staleBuildEntriesClause(report);
+		if (report.currentSource !== void 0) return `The source folders it was packed from (${(report.missingSource ?? []).join(", ")}) no longer exist, and its source is now in ${report.currentSource}${entries}.`;
+		if (report.missingSource !== void 0 && report.missingSource.length > 0) return `The source it was packed from (${report.missingSource.join(", ")}) is no longer on disk${entries}.`;
+		if (report.recomputedSourceHash !== void 0 && report.manifestSourceHash !== void 0 && report.recomputedSourceHash !== report.manifestSourceHash) return DoctorJsonReport.sourceChangedReason(report);
+		if (report.staleBuildEntries !== void 0 && report.staleBuildEntries.length > 0) {
+			const reason = LibraryFreshness.staleBuildEntriesReason(report.staleBuildEntries);
+			return `${reason.charAt(0).toUpperCase()}${reason.slice(1)}.`;
+		}
+		if (report.missingBundleInputs !== void 0) return `Files its build read outside its source (${report.missingBundleInputs.join(", ")}) are no longer on disk.`;
+		if (report.recomputedBundleInputHash !== void 0) return `A file its build read outside its source changed: the build inputs (${report.recomputedBundleInputHash}) no longer match the packed manifest (${String(report.manifestBundleInputHash)}).`;
+		return DoctorJsonReport.sourceChangedReason(report);
+	}
+	/** The reason for a source fingerprint that no longer matches the manifest. */
+	static sourceChangedReason(report) {
+		return `Its src/ (${String(report.recomputedSourceHash)}) no longer matches the packed manifest (${String(report.manifestSourceHash)})${LibraryFreshness.staleBuildEntriesClause(report)}.`;
 	}
 	/** The registry diagnostic, when the probe failed. */
 	static registryDiagnostics(result) {
@@ -2032,8 +2085,10 @@ var DoctorReport = class DoctorReport {
 		const name = self ? `${report.specifier} (this package)` : report.specifier;
 		const version = report.packageVersion === void 0 ? "" : ` v${report.packageVersion}`;
 		switch (report.status) {
-			case BoundaryProvenanceStatus.Fresh: return self ? `✔ ${name}${version} — dist is current with src/ (${report.manifestSourceHash})` : `✔ ${name}${version} — up to date (${report.manifestSourceHash})`;
-			case BoundaryProvenanceStatus.Stale: return self && report.missingSource === void 0 && !LibraryFreshness.isBundleStale(report) ? `✖ ${name}${version} — STALE: your src/ (${report.recomputedSourceHash}) no longer matches your own dist manifest (${report.manifestSourceHash}). Repack (\`vp pack\`) before publishing or consuming it.` : LibraryFreshness.staleLine(self ? name : report.specifier, report);
+			case BoundaryProvenanceStatus.Fresh:
+				if (report.manifestSourceHash === void 0) return `✔ ${name}${version} — dist is current with its build inputs`;
+				return self ? `✔ ${name}${version} — dist is current with src/ (${report.manifestSourceHash})` : `✔ ${name}${version} — up to date (${report.manifestSourceHash})`;
+			case BoundaryProvenanceStatus.Stale: return self && report.missingSource === void 0 && !LibraryFreshness.isBundleStale(report) ? `✖ ${name}${version} — STALE: your src/ (${report.recomputedSourceHash}) no longer matches your own dist manifest (${report.manifestSourceHash})${LibraryFreshness.staleBuildEntriesClause(report)}. Repack (\`vp pack\`) before publishing or consuming it.` : LibraryFreshness.staleLine(self ? name : report.specifier, report);
 			case BoundaryProvenanceStatus.NoProvenance: return `● ${name}${version} — manifest predates the provenance stamp; repack to enable the check.`;
 			case BoundaryProvenanceStatus.NoSource: return `● ${name}${version} — published package (no local src/); provenance is display-only.`;
 		}
@@ -2192,6 +2247,411 @@ const doctorCommand = defineCommand({
 	}
 });
 //#endregion
+//#region src/freshness-json-document.ts
+/**
+* The verdict on one workspace package in a {@link FreshnessJsonDocument}. The first four are the staleness
+* values of `DoctorPackageStatus`.
+*/
+const FreshnessPackageStatus = {
+	/** Every recorded input of the package matches the files on disk. */
+	Fresh: "fresh",
+	/** The source or another recorded input changed since the last pack, or is gone. */
+	Stale: "stale",
+	/** The packed manifest has no provenance stamp, so nothing was compared. */
+	NoProvenance: "no-provenance",
+	/** None of the recorded source is on disk, so nothing was compared. */
+	NoSource: "no-source",
+	/** The check of the package failed, for example because its `heximon.config.ts` threw. */
+	Error: "error"
+};
+/** The stable codes of the `heximon freshness` diagnostics. */
+const FreshnessDiagnosticCode = {
+	/** A workspace package changed since its last pack. Error. */
+	StalePackage: "freshness.stale-package",
+	/** The check of one package failed; the message has the error. Error. */
+	CheckFailed: "freshness.check-failed",
+	/** The `pnpm-workspace.yaml` or the root `package.json` cannot be read or parsed. Error. */
+	WorkspaceUnreadable: "freshness.workspace-unreadable"
+};
+//#endregion
+//#region src/workspace-packages.ts
+/** Where the member list of a {@link Workspace} comes from. */
+const WorkspaceKind = {
+	/** The `packages:` list of a `pnpm-workspace.yaml`. */
+	Pnpm: "pnpm",
+	/** The `workspaces` field of a root `package.json` (npm, Yarn, Bun). */
+	PackageJson: "package-json",
+	/** No workspace file: the nearest package is the only member. */
+	SinglePackage: "single-package",
+	/** No workspace file and no `package.json` from the start directory up. */
+	None: "none"
+};
+/**
+* Finds the workspace that holds a directory and lists its packages. It walks up to the nearest directory with a
+* `pnpm-workspace.yaml`, or with a `package.json` that has a `workspaces` field (an array, or Yarn's
+* `{ packages }` form). With neither, the nearest package is a one-package workspace. The root package is a
+* member when it has a `package.json`. A `!` pattern removes the members it matches, and `node_modules` is never
+* searched. A folder that two paths reach (a symlink) is one member, under the path that sorts first.
+*/
+var WorkspacePackages = class WorkspacePackages {
+	/** The package manifest file name. */
+	static packageJsonFileName = "package.json";
+	/** The folder name the member search never enters. */
+	static installedDirectoryName = "node_modules";
+	/**
+	* Find the workspace of a directory.
+	*
+	* @param startDirectory - The directory to start the walk from.
+	* @returns The workspace and its member packages.
+	* @throws When a `pnpm-workspace.yaml` or a root `package.json` on the walk cannot be read or parsed.
+	*/
+	static locate(startDirectory) {
+		const start = resolve(startDirectory);
+		let nearestPackage;
+		let current = start;
+		while (true) {
+			if (existsSync(join(current, PnpmWorkspaceManifest.fileName))) {
+				const manifestPath = join(current, PnpmWorkspaceManifest.fileName);
+				const patterns = PnpmWorkspaceManifest.parsePackagePatterns(readFileSync(manifestPath, "utf8"), manifestPath);
+				return WorkspacePackages.workspaceOf(current, WorkspaceKind.Pnpm, patterns);
+			}
+			const packageJsonPath = join(current, WorkspacePackages.packageJsonFileName);
+			if (existsSync(packageJsonPath)) {
+				nearestPackage ??= current;
+				const patterns = WorkspacePackages.workspacePatternsOf(packageJsonPath);
+				if (patterns !== void 0) return WorkspacePackages.workspaceOf(current, WorkspaceKind.PackageJson, patterns);
+			}
+			const parent = dirname(current);
+			if (parent === current) break;
+			current = parent;
+		}
+		return nearestPackage === void 0 ? {
+			root: start,
+			kind: WorkspaceKind.None,
+			members: []
+		} : {
+			root: nearestPackage,
+			kind: WorkspaceKind.SinglePackage,
+			members: [{
+				directory: WorkspacePackages.realPathOf(nearestPackage),
+				path: "."
+			}]
+		};
+	}
+	/**
+	* The `workspaces` patterns of a `package.json`.
+	*
+	* @returns The patterns, or `undefined` when the file has no `workspaces` field in a known form.
+	* @throws When the file is not valid JSON.
+	*/
+	static workspacePatternsOf(packageJsonPath) {
+		let parsed;
+		try {
+			parsed = JSON.parse(readFileSync(packageJsonPath, "utf8"));
+		} catch (cause) {
+			const reason = cause instanceof Error ? cause.message : String(cause);
+			throw new Error(`${packageJsonPath} could not be parsed as JSON: ${reason}`, { cause });
+		}
+		if (typeof parsed !== "object" || parsed === null || !("workspaces" in parsed)) return;
+		const workspaces = parsed.workspaces;
+		const patterns = typeof workspaces === "object" && workspaces !== null && "packages" in workspaces ? workspaces.packages : workspaces;
+		return Array.isArray(patterns) ? patterns.filter((pattern) => typeof pattern === "string") : void 0;
+	}
+	/** The workspace at a root: the root package, then every directory the patterns name that has a package. */
+	static workspaceOf(root, kind, patterns) {
+		const includes = patterns.filter((pattern) => !pattern.trim().startsWith("!")).map((pattern) => WorkspacePackages.normalizedPattern(pattern)).filter((pattern) => pattern !== "");
+		const excludes = patterns.filter((pattern) => pattern.trim().startsWith("!")).map((pattern) => WorkspacePackages.normalizedPattern(pattern.trim().slice(1))).filter((pattern) => pattern !== "");
+		const members = (includes.length === 0 ? [] : globSync(includes, {
+			cwd: root,
+			exclude: (entry) => basename(String(entry)) === WorkspacePackages.installedDirectoryName
+		})).map((match) => relative(root, resolve(root, match))).filter((path) => !WorkspacePackages.isExcluded(path, excludes)).sort();
+		const workspaceMembers = [];
+		const seen = /* @__PURE__ */ new Set();
+		for (const memberPath of ["", ...members]) {
+			const directory = resolve(root, memberPath);
+			if (!WorkspacePackages.isPackageDirectory(directory)) continue;
+			const realDirectory = WorkspacePackages.realPathOf(directory);
+			if (!seen.has(realDirectory)) {
+				seen.add(realDirectory);
+				workspaceMembers.push({
+					directory: realDirectory,
+					path: memberPath || "."
+				});
+			}
+		}
+		return {
+			root,
+			kind,
+			members: workspaceMembers
+		};
+	}
+	/** A pattern without a leading `./` and a trailing `/`, so it matches the paths the glob returns. */
+	static normalizedPattern(pattern) {
+		return pattern.trim().replace(/^(?:\.\/)+/, "").replace(/\/+$/, "");
+	}
+	/** Whether a `!` pattern removes a member path. A pattern that ends in a globstar also removes its folder. */
+	static isExcluded(memberPath, excludes) {
+		return excludes.some((pattern) => matchesGlob(memberPath, pattern) || matchesGlob(`${memberPath}/`, pattern));
+	}
+	/** Whether a path is a directory that holds a `package.json`. */
+	static isPackageDirectory(directory) {
+		try {
+			return statSync(directory).isDirectory() && existsSync(join(directory, WorkspacePackages.packageJsonFileName));
+		} catch {
+			return false;
+		}
+	}
+	/** The real path of a directory, or the path itself when it cannot be resolved. */
+	static realPathOf(directory) {
+		try {
+			return realpathSync(directory);
+		} catch {
+			return directory;
+		}
+	}
+};
+//#endregion
+//#region src/workspace-freshness.ts
+/**
+* Judges every package of a workspace with {@link LibraryFreshness}: each package that has a Heximon manifest or
+* a `dist/heximon.inputs.json`. It compiles nothing and runs no other audit, so it only stats and hashes files.
+* A package whose check throws (a `heximon.config.ts` that fails to load) gets an `error` verdict.
+*/
+var WorkspaceFreshness = class WorkspaceFreshness {
+	/** The fix hint of a package whose check failed. */
+	static checkFailedHint = "Fix the error, for example in the package's heximon.config.ts, then run heximon freshness again.";
+	/**
+	* Find the workspace of a directory and judge each of its packages.
+	*
+	* @param startDirectory - Any directory inside the workspace.
+	* @returns The verdicts.
+	* @throws CommandFailure with {@link FreshnessDiagnosticCode.WorkspaceUnreadable} when the workspace file
+	*   cannot be read.
+	*/
+	static async run(startDirectory) {
+		const workspace = WorkspaceFreshness.locate(startDirectory);
+		const freshness = new LibraryFreshness();
+		const packages = [];
+		for (const member of workspace.members) {
+			const identity = WorkspaceFreshness.identityOf(member);
+			const recordProblem = LibraryFreshness.recordProblemOf(member.directory);
+			if (recordProblem !== void 0) {
+				packages.push({
+					...identity,
+					error: recordProblem,
+					recordUnreadable: true
+				});
+				continue;
+			}
+			try {
+				const report = await freshness.inspect(member.directory);
+				if (report !== null) packages.push({
+					...identity,
+					report
+				});
+			} catch (error) {
+				packages.push({
+					...identity,
+					error: error instanceof Error ? error.message : String(error)
+				});
+			}
+		}
+		return {
+			workspace,
+			packages,
+			skippedPackages: workspace.members.length - packages.length
+		};
+	}
+	/** Whether a verdict fails the run: a stale package, or one whose check failed. */
+	static isFailing(verdict) {
+		return verdict.error !== void 0 || verdict.report?.status === LibraryFreshnessStatus.Stale;
+	}
+	/** Whether the run exits 1. */
+	static isFailure(result) {
+		return result.packages.some((verdict) => WorkspaceFreshness.isFailing(verdict));
+	}
+	/** The status of a verdict. */
+	static statusOf(verdict) {
+		return verdict.report === void 0 ? FreshnessPackageStatus.Error : verdict.report.status;
+	}
+	/**
+	* The text line of one package: its name, version and path, its status, and for a stale package the
+	* {@link LibraryFreshness.staleLine} that names the changed and missing inputs.
+	*
+	* @param verdict - The verdict.
+	* @returns The line.
+	*/
+	static lineOf(verdict) {
+		const version = verdict.version === void 0 ? "" : ` v${verdict.version}`;
+		const label = `${verdict.name}${version} (${verdict.path})`;
+		const report = verdict.report;
+		if (report === void 0) return `✖ ${label} — ERROR: ${String(verdict.error)}`;
+		switch (report.status) {
+			case LibraryFreshnessStatus.Fresh: return `✔ ${label} — fresh`;
+			case LibraryFreshnessStatus.Stale: return LibraryFreshness.staleLine(label, {
+				...report,
+				packageVersion: void 0
+			}, { forApp: false });
+			case LibraryFreshnessStatus.NoProvenance: return `● ${label} — no provenance: the manifest predates the provenance stamp. Repack to enable the check.`;
+			case LibraryFreshnessStatus.NoSource: return `● ${label} — no source: none of its recorded source is on disk, so nothing was compared.`;
+		}
+	}
+	/** The closing sentence of the run. */
+	static summary(result) {
+		const skipped = result.skippedPackages === 0 ? "" : ` ${String(result.skippedPackages)} package(s) without a record were skipped.`;
+		if (result.packages.length === 0) return result.workspace.members.length === 0 ? `No package found from ${result.workspace.root}.` : `No workspace package has a freshness record.${skipped}`;
+		const count = (status) => result.packages.filter((verdict) => WorkspaceFreshness.statusOf(verdict) === status).length;
+		const parts = [`${String(count(FreshnessPackageStatus.Stale))} stale`, `${String(count(FreshnessPackageStatus.Fresh))} fresh`];
+		const notCompared = count(FreshnessPackageStatus.NoProvenance) + count(FreshnessPackageStatus.NoSource);
+		if (notCompared > 0) parts.push(`${String(notCompared)} not compared`);
+		if (count(FreshnessPackageStatus.Error) > 0) parts.push(`${String(count(FreshnessPackageStatus.Error))} failed`);
+		return `${String(result.packages.length)} package(s) with a record: ${parts.join(", ")}.${skipped}`;
+	}
+	/**
+	* Build the `--json` document of one run.
+	*
+	* @param result - The verdicts.
+	* @param staleOnly - List only the entries that fail the run.
+	* @returns The document. Its `ok` is `false` exactly when {@link isFailure} is `true`.
+	*/
+	static toJson(result, staleOnly) {
+		const packages = result.packages.map((verdict) => WorkspaceFreshness.entryOf(verdict));
+		return {
+			ok: !WorkspaceFreshness.isFailure(result),
+			diagnostics: packages.flatMap((entry) => WorkspaceFreshness.diagnosticsOf(entry)),
+			workspaceRoot: result.workspace.root,
+			workspaceKind: result.workspace.kind,
+			packages: staleOnly ? packages.filter((entry) => entry.failing) : packages,
+			skippedPackages: result.skippedPackages,
+			summary: WorkspaceFreshness.summary(result)
+		};
+	}
+	/** The workspace of a directory, with a file that cannot be read as the command's failure. */
+	static locate(startDirectory) {
+		try {
+			return WorkspacePackages.locate(startDirectory);
+		} catch (error) {
+			throw new CommandFailure([CliDiagnostics.error(FreshnessDiagnosticCode.WorkspaceUnreadable, error instanceof Error ? error.message : String(error), { hint: "Fix the workspace file, then run heximon freshness again." })]);
+		}
+	}
+	/** One JSON package entry. */
+	static entryOf(verdict) {
+		const location = {
+			...verdict.version === void 0 ? {} : { version: verdict.version },
+			path: verdict.path,
+			directory: verdict.directory
+		};
+		if (verdict.report === void 0) return {
+			name: verdict.name,
+			status: FreshnessPackageStatus.Error,
+			reason: String(verdict.error),
+			...verdict.recordUnreadable === true ? {
+				hint: `Repack it (\`vp pack\` in ${verdict.directory}) to write the record again.`,
+				fix: DoctorJsonReport.repackCommand(verdict.directory)
+			} : { hint: WorkspaceFreshness.checkFailedHint },
+			failing: true,
+			...location
+		};
+		const fields = DoctorJsonReport.verdictOf(verdict.report.status, `Rebuild it (\`vp pack\` in ${verdict.directory}).`, DoctorJsonReport.repackCommand(verdict.directory));
+		return {
+			name: verdict.name,
+			status: verdict.report.status,
+			reason: DoctorJsonReport.reasonOf(verdict.report),
+			...fields.hint === void 0 ? {} : { hint: fields.hint },
+			...fields.fix === void 0 ? {} : { fix: fields.fix },
+			failing: fields.failing,
+			...location,
+			...DoctorJsonReport.freshnessDetails(verdict.report)
+		};
+	}
+	/** The error diagnostic of an entry that fails the run. */
+	static diagnosticsOf(entry) {
+		if (!entry.failing) return [];
+		return [CliDiagnostics.error(entry.status === FreshnessPackageStatus.Error ? FreshnessDiagnosticCode.CheckFailed : FreshnessDiagnosticCode.StalePackage, `${entry.name} (${entry.path}): ${entry.reason}`, entry.hint === void 0 ? {} : { hint: entry.hint })];
+	}
+	/** The name, version and paths of a package, from its `package.json`. */
+	static identityOf(member) {
+		const directory = member.directory;
+		let name;
+		let version;
+		try {
+			const parsed = JSON.parse(readFileSync(join(directory, "package.json"), "utf8"));
+			if (typeof parsed === "object" && parsed !== null) {
+				const fields = parsed;
+				name = typeof fields.name === "string" ? fields.name : void 0;
+				version = typeof fields.version === "string" ? fields.version : void 0;
+			}
+		} catch {}
+		return {
+			name: name ?? basename(directory),
+			...version === void 0 ? {} : { version },
+			path: member.path,
+			directory
+		};
+	}
+};
+//#endregion
+//#region src/freshness-command.ts
+/** The text renderer behind {@link freshnessCommand}: one clack line per package, then the summary. */
+var FreshnessReport = class {
+	/**
+	* Print the report of one run.
+	*
+	* @param result - The verdicts.
+	* @param staleOnly - Print only the packages that fail the run.
+	*/
+	static render(result, staleOnly) {
+		for (const verdict of result.packages) {
+			const failing = WorkspaceFreshness.isFailing(verdict);
+			if (staleOnly && !failing) continue;
+			const line = WorkspaceFreshness.lineOf(verdict);
+			if (failing) log.error(line);
+			else if (verdict.report?.status === LibraryFreshnessStatus.Fresh) log.success(line);
+			else log.info(line);
+		}
+		outro(WorkspaceFreshness.summary(result));
+	}
+};
+/**
+* `heximon freshness` — lists every package of the workspace that has a freshness record, with its status. It
+* finds the workspace root from any directory inside it, judges each package with the rule of `heximon doctor`
+* ({@link LibraryFreshness}), and exits 1 when a package is stale or its check failed. It compiles nothing and
+* runs no other audit.
+*/
+const freshnessCommand = defineCommand({
+	meta: {
+		name: "freshness",
+		description: "List every workspace package with a freshness record (a Heximon manifest or dist/heximon.inputs.json), its status, and the input that made it stale. Works from any directory of the workspace. Exits 1 when a package is stale."
+	},
+	args: {
+		cwd: {
+			type: "string",
+			description: "A directory inside the workspace; the command walks up to the workspace root.",
+			default: "."
+		},
+		json: CommandOutput.jsonFlag,
+		stale: {
+			type: "boolean",
+			description: "List only the packages that fail the run: the stale ones, and the ones whose check failed.",
+			default: false
+		}
+	},
+	async run({ args }) {
+		const commandOutput = CommandOutput.resolve("freshness", args);
+		await commandOutput.run(async () => {
+			const startDirectory = ProjectRoot.resolve(args.cwd);
+			const result = await WorkspaceFreshness.run(startDirectory);
+			const staleOnly = args.stale === true;
+			if (WorkspaceFreshness.isFailure(result)) process.exitCode = 1;
+			if (commandOutput.isJson()) commandOutput.emit(WorkspaceFreshness.toJson(result, staleOnly));
+			else {
+				intro(`heximon freshness — ${basename(result.workspace.root)}`);
+				FreshnessReport.render(result, staleOnly);
+			}
+		});
+	}
+});
+//#endregion
 //#region src/graph-json-document.ts
 /** The stable codes of the failures `heximon graph` raises itself. */
 const GraphDiagnosticCode = {
@@ -5927,6 +6387,7 @@ const main = defineCommand({
 		routes: routesCommand,
 		graph: graphCommand,
 		doctor: doctorCommand,
+		freshness: freshnessCommand,
 		provision: provisionCommand,
 		migrations: migrationsCommand,
 		workflows: workflowsCommand,

package/dist/index.d.mts

@@ -827,11 +827,45 @@ interface DoctorPackageCopy {
   /** Who resolves to this copy (`the app`, `this package`, or a package name). */
   readonly origins: readonly string[];
 }
+/** One build entry of a package whose recorded inputs no longer match the files on disk. */
+interface DoctorStaleBuildEntry {
+  /** The key of the build entry: its output folder, its entry file-name patterns and its format. */
+  readonly entry: string;
+  /** The package-relative inputs whose digest changed. */
+  readonly changedInputs: readonly string[];
+  /** The package-relative inputs that are no longer on disk. */
+  readonly missingInputs: readonly string[];
+}
+/**
+ * The fields of a staleness verdict, as `heximon doctor --json` and `heximon freshness --json` both print them.
+ * Each field is present only when the verdict has it.
+ */
+interface DoctorFreshnessDetails {
+  /** The source fingerprint the packed manifest recorded. */
+  readonly manifestSourceHash?: string;
+  /** The source fingerprint computed from the local source now. */
+  readonly recomputedSourceHash?: string;
+  /** The recorded source folders and files that are no longer on disk. */
+  readonly missingSource?: readonly string[];
+  /** The current source directory, when the source moved since the pack. */
+  readonly currentSource?: string;
+  /** The hash of the files the bundle read outside the source, as the packed manifest recorded it. */
+  readonly manifestBundleInputHash?: string;
+  /** That hash recomputed from the files now, when the source matched and every file is on disk. */
+  readonly recomputedBundleInputHash?: string;
+  /** The recorded bundle inputs (package-relative) that are no longer on disk. */
+  readonly missingBundleInputs?: readonly string[];
+  /**
+   * The build entries of the package's `dist/heximon.inputs.json` whose inputs changed or are gone: each entry's
+   * key and its changed and missing inputs (package-relative).
+   */
+  readonly staleBuildEntries?: readonly DoctorStaleBuildEntry[];
+}
 /**
  * One audited package. A staleness verdict and a fork are separate entries, so a stale library that also forks
  * appears twice: once with its staleness status and once with `fork`.
  */
-interface DoctorPackageResult {
+interface DoctorPackageResult extends DoctorFreshnessDetails {
   /** The package name, or the bare specifier the app imports a consumed library under. */
   readonly name: string;
   /** The verdict. */
@@ -850,20 +884,6 @@ interface DoctorPackageResult {
   readonly version?: string;
   /** The real package directory, for a staleness entry. */
   readonly directory?: string;
-  /** The source fingerprint the packed manifest recorded. */
-  readonly manifestSourceHash?: string;
-  /** The source fingerprint computed from the local source now. */
-  readonly recomputedSourceHash?: string;
-  /** The recorded source folders and files that are no longer on disk. */
-  readonly missingSource?: readonly string[];
-  /** The current source directory, when the source moved since the pack. */
-  readonly currentSource?: string;
-  /** The hash of the files the bundle read outside the source, as the packed manifest recorded it. */
-  readonly manifestBundleInputHash?: string;
-  /** That hash recomputed from the files now, when the source matched and every file is on disk. */
-  readonly recomputedBundleInputHash?: string;
-  /** The recorded bundle inputs (package-relative) that are no longer on disk. */
-  readonly missingBundleInputs?: readonly string[];
   /** Every physical copy, for a `fork` entry. */
   readonly copies?: readonly DoctorPackageCopy[];
 }
@@ -935,6 +955,86 @@ interface DoctorJsonDocument extends CliJsonDocument {
   readonly summary: string;
 }
 //#endregion
+//#region src/workspace-packages.d.ts
+/** Where the member list of a {@link Workspace} comes from. */
+declare const WorkspaceKind: {
+  /** The `packages:` list of a `pnpm-workspace.yaml`. */
+  readonly Pnpm: "pnpm";
+  /** The `workspaces` field of a root `package.json` (npm, Yarn, Bun). */
+  readonly PackageJson: "package-json";
+  /** No workspace file: the nearest package is the only member. */
+  readonly SinglePackage: "single-package";
+  /** No workspace file and no `package.json` from the start directory up. */
+  readonly None: "none";
+};
+/** One of the {@link WorkspaceKind} values. */
+type WorkspaceKind = (typeof WorkspaceKind)[keyof typeof WorkspaceKind];
+//#endregion
+//#region src/freshness-json-document.d.ts
+/**
+ * The verdict on one workspace package in a {@link FreshnessJsonDocument}. The first four are the staleness
+ * values of `DoctorPackageStatus`.
+ */
+declare const FreshnessPackageStatus: {
+  /** Every recorded input of the package matches the files on disk. */
+  readonly Fresh: "fresh";
+  /** The source or another recorded input changed since the last pack, or is gone. */
+  readonly Stale: "stale";
+  /** The packed manifest has no provenance stamp, so nothing was compared. */
+  readonly NoProvenance: "no-provenance";
+  /** None of the recorded source is on disk, so nothing was compared. */
+  readonly NoSource: "no-source";
+  /** The check of the package failed, for example because its `heximon.config.ts` threw. */
+  readonly Error: "error";
+};
+/** One of the {@link FreshnessPackageStatus} values. */
+type FreshnessPackageStatus = (typeof FreshnessPackageStatus)[keyof typeof FreshnessPackageStatus];
+/** The stable codes of the `heximon freshness` diagnostics. */
+declare const FreshnessDiagnosticCode: {
+  /** A workspace package changed since its last pack. Error. */
+  readonly StalePackage: "freshness.stale-package";
+  /** The check of one package failed; the message has the error. Error. */
+  readonly CheckFailed: "freshness.check-failed";
+  /** The `pnpm-workspace.yaml` or the root `package.json` cannot be read or parsed. Error. */
+  readonly WorkspaceUnreadable: "freshness.workspace-unreadable";
+};
+/** One of the {@link FreshnessDiagnosticCode} values. */
+type FreshnessDiagnosticCode = (typeof FreshnessDiagnosticCode)[keyof typeof FreshnessDiagnosticCode];
+/** One workspace package that has a record: a Heximon manifest, or a `dist/heximon.inputs.json`. */
+interface FreshnessPackageResult extends DoctorFreshnessDetails {
+  /** The `name` of the package's `package.json`, else its folder name. */
+  readonly name: string;
+  /** The verdict. */
+  readonly status: FreshnessPackageStatus;
+  /** Why the package has this status. For `error`, the error message. */
+  readonly reason: string;
+  /** How to fix the package, as text. Absent when there is nothing to fix. */
+  readonly hint?: string;
+  /** The shell command that fixes the package. Absent when no single command fixes it. */
+  readonly fix?: string;
+  /** Whether this entry fails the run: `stale` and `error` do. */
+  readonly failing: boolean;
+  /** The `version` of the package's `package.json`, when it has one. */
+  readonly version?: string;
+  /** The package folder, relative to the workspace root (`.` for the root package). */
+  readonly path: string;
+  /** The absolute package folder. */
+  readonly directory: string;
+}
+/** The `heximon freshness --json` document. `ok` is `false` exactly when the run exits 1. */
+interface FreshnessJsonDocument extends CliJsonDocument {
+  /** The absolute workspace root. */
+  readonly workspaceRoot: string;
+  /** Where the member list came from. */
+  readonly workspaceKind: WorkspaceKind;
+  /** Each workspace package that has a record. With `--stale`, only the entries that fail the run. */
+  readonly packages: readonly FreshnessPackageResult[];
+  /** How many workspace packages have no record, so they were not checked. */
+  readonly skippedPackages: number;
+  /** The closing sentence of the text report. */
+  readonly summary: string;
+}
+//#endregion
 //#region src/module-graph-report.d.ts
 /** A cross-package boundary node summarized for the graph report — its factory plus its `requires`/`exports` tokens. */
 interface BoundarySummary {
@@ -1395,4 +1495,4 @@ interface WorkflowsJsonDocument extends CliJsonDocument {
   };
 }
 //#endregion
-export type { BoundarySummary, CheckDiagnosticCode, CheckJsonDocument, CheckUpgradeBaselineResult, CliDiagnostic, CliDiagnosticCode, CliFailureDocument, CliJsonDocument, CreateDiagnosticCode, CreateJsonDocument, DeployAction, DeployDiagnosticCode, DeployJsonCredential, DeployJsonDestroy, DeployJsonDocument, DeployJsonMigration, DeployJsonResources, DeployJsonShip, DeployJsonShipResult, DeployJsonTarget, DoctorCopyCensusResult, DoctorCopyCensusStatus, DoctorDiagnosticCode, DoctorJsonDocument, DoctorMode, DoctorPackageCopy, DoctorPackageResult, DoctorPackageStatus, DoctorPeerClosureResult, DoctorPeerPivot, DoctorPlatformTracingResult, DoctorRegistryResult, GraphDiagnosticCode, GraphJsonDocument, InstalledSkill, MigrationsDatabaseView, MigrationsDiagnosticCode, MigrationsDrizzleKitResult, MigrationsGenerateEntry, MigrationsGenerateJsonDocument, MigrationsMigrateJsonDocument, MigrationsPushJsonDocument, MigrationsStatusEntry, MigrationsStatusJsonDocument, MigrationsStepEntry, MigrationsStepStatus, PreparedTarget, ProcessRunResult, ProcessRunner, Prompter, ProvisionDiagnosticCode, ProvisionJsonDocument, ProvisionJsonResource, ProvisionJsonResult, RegistryAccessReport, RoutesDiagnosticCode, RoutesJsonDocument, ScaffoldRequest, ScaffoldResult, SkillJsonEntry, SkillSourceJsonEntry, SkillSourceRecording, SkillsAddJsonDocument, SkillsDiagnosticCode, SkillsSyncJsonDocument, StartersScaffoldRequest, TaskDiagnosticCode, TaskRunError, TaskRunJsonDocument, TemplateSelection, TemplateSource, WorkflowBaselineState, WorkflowInstanceInventory, WorkflowInstanceView, WorkflowStatusEntry, WorkflowStatusJsonEntry, WorkflowsDiagnosticCode, WorkflowsJsonDocument };
+export type { BoundarySummary, CheckDiagnosticCode, CheckJsonDocument, CheckUpgradeBaselineResult, CliDiagnostic, CliDiagnosticCode, CliFailureDocument, CliJsonDocument, CreateDiagnosticCode, CreateJsonDocument, DeployAction, DeployDiagnosticCode, DeployJsonCredential, DeployJsonDestroy, DeployJsonDocument, DeployJsonMigration, DeployJsonResources, DeployJsonShip, DeployJsonShipResult, DeployJsonTarget, DoctorCopyCensusResult, DoctorCopyCensusStatus, DoctorDiagnosticCode, DoctorFreshnessDetails, DoctorJsonDocument, DoctorMode, DoctorPackageCopy, DoctorPackageResult, DoctorPackageStatus, DoctorPeerClosureResult, DoctorPeerPivot, DoctorPlatformTracingResult, DoctorRegistryResult, DoctorStaleBuildEntry, FreshnessDiagnosticCode, FreshnessJsonDocument, FreshnessPackageResult, FreshnessPackageStatus, GraphDiagnosticCode, GraphJsonDocument, InstalledSkill, MigrationsDatabaseView, MigrationsDiagnosticCode, MigrationsDrizzleKitResult, MigrationsGenerateEntry, MigrationsGenerateJsonDocument, MigrationsMigrateJsonDocument, MigrationsPushJsonDocument, MigrationsStatusEntry, MigrationsStatusJsonDocument, MigrationsStepEntry, MigrationsStepStatus, PreparedTarget, ProcessRunResult, ProcessRunner, Prompter, ProvisionDiagnosticCode, ProvisionJsonDocument, ProvisionJsonResource, ProvisionJsonResult, RegistryAccessReport, RoutesDiagnosticCode, RoutesJsonDocument, ScaffoldRequest, ScaffoldResult, SkillJsonEntry, SkillSourceJsonEntry, SkillSourceRecording, SkillsAddJsonDocument, SkillsDiagnosticCode, SkillsSyncJsonDocument, StartersScaffoldRequest, TaskDiagnosticCode, TaskRunError, TaskRunJsonDocument, TemplateSelection, TemplateSource, WorkflowBaselineState, WorkflowInstanceInventory, WorkflowInstanceView, WorkflowStatusEntry, WorkflowStatusJsonEntry, WorkflowsDiagnosticCode, WorkflowsJsonDocument, WorkspaceKind };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "heximon",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "description": "The Heximon CLI: create, develop, build, migrate, and deploy Heximon apps.",
   "keywords": [
     "cli",
@@ -38,26 +38,26 @@
   "dependencies": {
     "@bomb.sh/tab": "^0.0.22",
     "@clack/prompts": "^1.8.1",
-    "@heximon/compiler": "0.10.0",
-    "@heximon/cqrs": "0.10.0",
-    "@heximon/deploy": "0.10.0",
-    "@heximon/http": "0.10.0",
-    "@heximon/node": "0.10.0",
-    "@heximon/runtime": "0.10.0",
-    "@heximon/testing": "0.10.0",
+    "@heximon/compiler": "0.11.0",
+    "@heximon/cqrs": "0.11.0",
+    "@heximon/deploy": "0.11.0",
+    "@heximon/http": "0.11.0",
+    "@heximon/node": "0.11.0",
+    "@heximon/runtime": "0.11.0",
+    "@heximon/testing": "0.11.0",
     "citty": "^0.2.2",
     "giget": "^3.3.1",
     "pathe": "^2.0.3"
   },
   "devDependencies": {
-    "@heximon/cloudflare": "0.10.0",
-    "@heximon/durable": "0.10.0",
-    "@heximon/integration": "0.10.0",
-    "@heximon/library": "0.10.0",
-    "@heximon/nitro": "0.10.0",
-    "@heximon/queue": "0.10.0",
-    "@heximon/schedule": "0.10.0",
-    "@heximon/schema": "0.10.0",
+    "@heximon/cloudflare": "0.11.0",
+    "@heximon/durable": "0.11.0",
+    "@heximon/integration": "0.11.0",
+    "@heximon/library": "0.11.0",
+    "@heximon/nitro": "0.11.0",
+    "@heximon/queue": "0.11.0",
+    "@heximon/schedule": "0.11.0",
+    "@heximon/schema": "0.11.0",
     "@heximon/test-support": "0.0.1",
     "@types/node": "^24.19.0",
     "@typescript/native-preview": "^7.0.0-dev.20260707.2",