@zerotal/core 1.6.2 → 1.6.3

package/CHANGELOG.md

@@ -8,6 +8,31 @@ follows the Zerotal monorepo's unified versioning.
 
 ## [Unreleased]
 
+## [1.6.3] — 2026-08-15
+
+### Added
+
+- **`serve --dev` says when the framework on disk is no longer the framework running.** A
+  running dev server holds the code it imported at boot: `bun add zerotal@latest` in another
+  terminal rewrites `node_modules` and nothing else, and a save restarts only the _worker_,
+  which re-executes your app against that same in-memory framework. So an upgrade taken
+  mid-session appears to do nothing — the fix is installed, the symptom persists, and the
+  reasonable conclusion is that the fix does not work.
+
+  The supervisor now compares the version it booted with against the one installed, on each
+  restart, and says which is which:
+
+  ```text
+  [zerotal:dev] ⚠  framework upgraded on disk: running v1.6.2, installed v1.6.3
+  [zerotal:dev]    restart the dev server to pick it up (a save will not).
+  ```
+
+  Once per version, so a long session is not nagged, and silent where there is nothing to read
+  — a workspace checkout or a hoisted layout is not a finding.
+
+- **The dev banner carries the version** — `Zerotal v1.6.3 › dev`. There was previously
+  nothing on screen naming the framework a running server was actually executing.
+
 ## [1.6.2] — 2026-08-15
 
 ### Fixed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zerotal/core",
-  "version": "1.6.2",
+  "version": "1.6.3",
   "license": "MIT",
   "maturity": "stable",
   "private": false,

package/src/command/builtin/ServeCommand.ts

@@ -24,6 +24,7 @@ import {
   type PortOwner,
 } from "../../support/port.ts";
 import { localNetworkAddress } from "../../support/network.ts";
+import { ZEROTAL_VERSION } from "../../support/version.ts";
 import { createInterface } from "node:readline";
 
 /**
@@ -319,7 +320,11 @@ export class ServeCommand extends Command {
     const network = localNetworkAddress();
 
     this.newLine();
-    this.line(`  Zerotal  ›  ${mode}`);
+    // The version is here because a running server holds the framework it booted
+    // with: an upgrade installed in another terminal is invisible until a full
+    // restart, and without this line there is nothing on screen to tell you which
+    // one you are looking at.
+    this.line(`  Zerotal v${ZEROTAL_VERSION}  ›  ${mode}`);
     this.newLine();
     this._route("Local", `http://localhost:${port}`);
     this._route(

package/src/dev/DevOrchestrator.ts

@@ -6,6 +6,7 @@ import { watch } from "node:fs";
 import type { BuildHookFn } from "./DevBuildHook.ts";
 import { DEV_WORKER_ENV_VAR } from "../support/env.ts";
 import { requestGracefulStop } from "./devShutdown.ts";
+import { ZEROTAL_VERSION, installedCoreVersion } from "../support/version.ts";
 
 /**
  * How the orchestrator reports to whatever is presenting dev mode.
@@ -81,6 +82,8 @@ export class DevOrchestrator {
    * queues a single follow-up instead of running in parallel.
    */
   private _restartInFlight: Promise<void> | null = null;
+  /** The installed version already warned about, so one upgrade warns once. */
+  private _warnedVersion: string | null = null;
   private _restartQueued = false;
 
   /**
@@ -282,11 +285,37 @@ export class DevOrchestrator {
     // browser refetches the updated CSS.
     await this._runBuild();
 
+    this._warnIfFrameworkUpgradedUnderneath();
+
     // Stop before spawning, always: the old server owns the port until it exits.
     await this._stopChild();
     await this._spawnServerWithRetry();
   }
 
+  /**
+   * Say so when the framework on disk is no longer the framework running.
+   *
+   * A `bun add zerotal@latest` in another terminal changes `node_modules` and
+   * nothing else: this process holds the code it imported at boot, and a restart
+   * only re-executes the *app* against that same in-memory framework. So the
+   * upgrade appears to have no effect — the fix is installed, the symptom
+   * persists, and the obvious conclusion is that the fix does not work.
+   *
+   * Checked on restart rather than at boot, because that is when it can have
+   * become true, and warned once per version so a long session is not nagged.
+   */
+  private _warnIfFrameworkUpgradedUnderneath(): void {
+    const onDisk = installedCoreVersion(this._cwd);
+    if (onDisk === null || onDisk === ZEROTAL_VERSION || onDisk === this._warnedVersion) return;
+
+    this._warnedVersion = onDisk;
+    this._say(
+      `  [zerotal:dev] ⚠  framework upgraded on disk: running v${ZEROTAL_VERSION}, installed v${onDisk}`,
+      "warn",
+    );
+    this._say("  [zerotal:dev]    restart the dev server to pick it up (a save will not).", "warn");
+  }
+
   /** Stop the running server and wait for it to actually exit, releasing the port. */
   private async _stopChild(): Promise<void> {
     const child = this._child;

package/src/support/version.ts

@@ -0,0 +1,39 @@
+/**
+ * The framework version this build of `@zerotal/core` is.
+ *
+ * Read from the manifest rather than written down, for the reason `@zerotal/monitor`
+ * already learned: a hardcoded version is correct until the next release, and three
+ * separate literals across the monorepo once claimed a version that had never been
+ * published. The monorepo releases in lockstep, so this package's manifest carries
+ * the framework version, and it ships inside the tarball.
+ *
+ * @module
+ */
+import { readFileSync } from "node:fs";
+
+const pkg: { version: string } = JSON.parse(
+  readFileSync(new URL("../../package.json", import.meta.url), "utf8"),
+) as { version: string };
+
+/** Full version of the running framework, e.g. `1.6.2`. */
+export const ZEROTAL_VERSION: string = pkg.version;
+
+/**
+ * The version of `@zerotal/core` currently installed in a project, which is not
+ * necessarily {@link ZEROTAL_VERSION} — a long-running process holds the code it
+ * booted with, so an upgrade lands on disk without reaching it.
+ *
+ * @param cwd - Project root to look under.
+ * @returns The installed version, or `null` when there is nothing to read — a
+ *   workspace checkout, a hoisted layout, a partial install. Absence is not a
+ *   finding, so callers stay quiet on `null` rather than guessing.
+ */
+export function installedCoreVersion(cwd: string): string | null {
+  try {
+    const raw = readFileSync(`${cwd}/node_modules/@zerotal/core/package.json`, "utf8");
+    const { version } = JSON.parse(raw) as { version?: string };
+    return version ?? null;
+  } catch {
+    return null;
+  }
+}