@heroiclands/package-build 3.0.0 → 3.1.0

package/CHANGELOG.md

@@ -1,5 +1,86 @@
 # @heroiclands/package-build
 
+## 3.1.0
+
+### Minor Changes
+
+- 40386b1: Build a pack from JSON that is already built, and declare the system per pack.
+  
+  The compile is two stages — content notes to `build/packs-json/<pack>/`, then
+  that directory to LevelDB — but only the first could feed the second. A package
+  whose packs are already Foundry JSON had no way in: generation runs first and
+  refuses an empty content tree, so a package with no `assets/content` threw
+  before the compile loop, and staging the files by hand did not survive
+  `generatePack`'s `rmSync` of its destination.
+  
+  `packs[].prebuilt` names the directory a pack's per-document JSON already lives
+  in. Generation is skipped for it and the compile reads from there, so
+  `cleanPackEntry` and the Scene/Level integrity check still run — which is the
+  reason to route through this toolchain rather than call `compilePack` directly.
+  When every selected pack is prebuilt the content walk is skipped altogether.
+  
+  `prebuilt` may not be combined with `folders`, `companions` or `default`, and
+  may not be declared on a companion. Each of those describes a generation pass,
+  and a prebuilt pack has none; refusing is better than ignoring a folder file
+  that can never be read.
+  
+  Separately, `stats.systemId` is now optional and `packs[].system` declares it
+  per pack, falling back to the package-wide value and omitted from the manifest
+  when neither is set. Every pack used to be emitted with one system id, which no
+  package needing two could express. Foundry requires `system` on ActiveEffect,
+  Actor and Item packs and on no others, and an Adventure pack that declares one
+  is hidden from every other system.
+- de6dc40: Let packages share one Foundry container, and so one signed licence.
+  
+  The container name was derived from the package id, and `--hostname` set to
+  match. The hostname part is right — Foundry binds a signed licence to it, and a
+  stable one is exactly what makes the signature survive a `recreate`. What was
+  wrong is that the value could not be shared: `sohl` got `sohl-foundry-test` and
+  `hm3` got `hm3-foundry-test`, so a `Config/license.json` signed for the first
+  would not verify for the second, and one maintainer with one dev licence needed
+  one per package.
+  
+  Neither fallback rescues it. Passing `FOUNDRYVTT_<STAGE>_LICENSE_KEY` makes the
+  felddy image write the key **unsigned**, and Foundry v13+ refuses to start with
+  `Software license requires signature`; omitting it makes the image fetch a key
+  from the account, unsigned, same refusal. Signing is a one-time interactive step
+  per host, so a second package's container could not come up without a second
+  licence — or a re-signing that then broke the first.
+  
+  The rest of the shared-instance model already worked. `requireIsolatedDataRoot`
+  refuses only the dev/qa/prod roots, so a shared **test** root was already
+  allowed, and `resolveE2EWorld` already derives a distinct world id per package,
+  so one data root already holds both systems and both worlds with `FOUNDRY_WORLD`
+  choosing which launches. The container identity was the last package-scoped
+  piece.
+  
+  So `packageBuild.container.name` declares it:
+  
+  ```yaml
+  packageBuild:
+    container:
+      # Shared with the other HeroicLands packages so one signed Foundry
+      # licence covers them all.
+      name: heroiclands-foundry
+  ```
+  
+  The stage is still appended — this declares `heroiclands-foundry-test`, not
+  `heroiclands-foundry`. Sharing is meant to cross packages, not stages: two
+  stages are two containers over two data roots, and docker names are unique, so a
+  name used whole would have `container dev` find the `test` container already
+  there, start it, and serve the test data root on the dev port. Nothing is
+  declared by default, and the name stays `<packageId>-foundry-<stage>`.
+
+## 3.0.1
+
+### Patch Changes
+
+- 73a7e60: Correct the release the merge is dated to: 3.0.0, not 2.0.0.
+  
+  The merge commit set `version` by hand _and_ carried a major changeset, so
+  changesets bumped it a second time. `MIGRATING.md` was the live defect — it told
+  a consumer to install `^2.0.0`, which resolves nowhere.
+
 ## 3.0.0
 
 ### Major Changes

package/CONTENT.md

@@ -86,6 +86,23 @@ packs:
     companions:
       - { name: adventures, type: Adventure }
 
+  # A pack whose per-document JSON is already built — checked in rather than
+  # generated. `prebuilt` names where it lives, generation is skipped for it,
+  # and `cleanPackEntry` and the Scene/Level integrity check still run. It may
+  # not carry `folders`, `companions` or `default`, and may not be a companion:
+  # each of those describes a generation pass a prebuilt pack does not have.
+  # When every configured pack is prebuilt the content walk is skipped
+  # entirely, so a package with no `assets/content` builds.
+  - name: adventures
+    type: Adventure
+    prebuilt: assets/packs/adventure
+    # Foundry requires `system` on ActiveEffect, Actor and Item packs and on no
+    # others, so it is declared per pack. Unset falls back to `stats.systemId`
+    # — itself optional — and with neither the manifest omits the key. An
+    # Adventure or Scene pack that names a system is hidden from every other
+    # one, which is rarely what a package that declined to name one meant.
+    system: null
+
 # How this repository frames the pages `content-build docs` generates. The
 # tables come from the itemBuilders registry and are the same everywhere; the
 # heading, the filing and what a reader is told first are this repository's.

package/MIGRATING.md

@@ -1,7 +1,7 @@
-# Migrating to `@heroiclands/package-build` 2.0.0
+# Migrating to `@heroiclands/package-build` 3.0.0
 
 `@heroiclands/content-build` and `@heroiclands/package-build` are one package.
-The content half now ships inside `@heroiclands/package-build` at 2.0.0;
+The content half now ships inside `@heroiclands/package-build` at 3.0.0;
 `@heroiclands/content-build` is deprecated and receives no further releases.
 
 Nothing about how a build _works_ changed. This is a packaging change: the same
@@ -22,13 +22,13 @@ that touched a single idea.
 
 ## 1. Dependencies
 
-Drop `@heroiclands/content-build` and move to 2.0.0:
+Drop `@heroiclands/content-build` and move to 3.0.0:
 
 ```diff
  "devDependencies": {
 -  "@heroiclands/content-build": "^1.8.2",
 -  "@heroiclands/package-build": "^0.6.1"
-+  "@heroiclands/package-build": "^2.0.0"
++  "@heroiclands/package-build": "^3.0.0"
  }
 ```
 

package/README.md

@@ -14,7 +14,7 @@ The content half is documented separately in **[CONTENT.md](CONTENT.md)** — th
 note format, the pack pipeline, and the configuration contract a content tree
 declares itself with.
 
-> **This package was two.** Until 2.0.0 the content half shipped as
+> **This package was two.** Until 3.0.0 the content half shipped as
 > `@heroiclands/content-build`. No consumer ever installed one without the
 > other, and the packaging half depended on the content half besides, so the
 > boundary bought nothing and cost a configuration file with two owners and a
@@ -189,6 +189,13 @@ packageBuild:
   # `FOUNDRYVTT_<STAGE>_DATA`, the same variable `deploy` writes into, and their
   # ports are conventional. Declare a stage only when it is genuinely yours.
   container:
+    # Optional. The container name, minus the stage, which is always appended:
+    # this declares `heroiclands-foundry-test`, not `sohl-foundry-test`.
+    # Foundry binds a signed licence to the container hostname, so packages that
+    # declare the same name are one instance covered by one signature. Defaults
+    # to the package id, which keeps every package in its own container.
+    name: heroiclands-foundry
+
     stages:
       # SoHL keeps the previous, pre-TypeScript system on an older Foundry.
       # An empty `world` declares "never auto-launch" — it is managed by hand.

package/config.mjs

@@ -29,7 +29,7 @@
  * loader checks that the section is a mapping and hands it back frozen;
  * everything inside it is validated here.
  *
- * **That section used to be a reservation.** Until 2.0.0 these were two
+ * **That section used to be a reservation.** Until 3.0.0 these were two
  * packages, and `packageBuild:` was a block `@heroiclands/content-build`
  * carried on behalf of a toolchain it knew nothing about. One package now owns
  * the whole file, so it is an ordinary section — but the validation split is
@@ -114,7 +114,16 @@ const LANG_KEYS = [
 ];
 const DEPLOY_KEYS = ["envPrefix"];
 const RELEASE_KEYS = ["artifact"];
-const CONTAINER_KEYS = ["image", "stages"];
+const CONTAINER_KEYS = ["image", "name", "stages"];
+
+/**
+ * What docker accepts as the head of a container name.
+ *
+ * Checked here rather than left to `docker run`, because the stage is appended
+ * to it: a rejected name surfaces as a failure to create a container whose name
+ * the repository never wrote down.
+ */
+const CONTAINER_NAME = /^[a-zA-Z0-9][a-zA-Z0-9_.-]*$/;
 const CONTAINER_STAGE_KEYS = ["port", "world", "version"];
 const E2E_KEYS = ["stage", "suite", "build", "world", "gm", "documents"];
 const E2E_SUITE_KEYS = ["run", "open"];
@@ -265,6 +274,30 @@ function normalizeGlobs(value, fallback, where) {
     );
 }
 
+/**
+ * A container name several packages may share.
+ *
+ * Foundry binds a signed licence to the container hostname, and the hostname
+ * follows the name. Declaring the same one in two repositories is how they come
+ * to be one instance covered by one signature — so this is a name that must
+ * survive being retyped elsewhere, and the stage is still appended to it.
+ *
+ * @param {unknown} value - The declared name.
+ * @returns {string} The name, minus the stage.
+ */
+function requireContainerName(value) {
+    const where = "packageBuild.container.name";
+    const name = requireNonEmptyString(value, where);
+    if (!CONTAINER_NAME.test(name)) {
+        fail(
+            where,
+            "must be a container name docker accepts — a letter or digit, " +
+                "then letters, digits, underscores, periods or hyphens",
+        );
+    }
+    return name;
+}
+
 /**
  * A container stage a repository runs beyond the conventional four.
  *
@@ -477,6 +510,9 @@ function normalizeExceptions(value, field, where) {
  * @property {string|null} systemVersion  That system's version, when the shared
  *   configuration stamps one.
  * @property {string|null} containerImage  Image override for every stage.
+ * @property {string|null} containerName  Container name, minus the stage,
+ *   shared with the packages that declare the same one so a single signed
+ *   Foundry licence covers them all. `null` names it after the package.
  * @property {Readonly<Record<string, Readonly<{port: number|null, world: string|null, version: string|null}>>>} containerStages
  *   Container stages beyond the conventional four.
  * @property {string} e2eStage       Which stage the suite runs against.
@@ -575,6 +611,10 @@ export function resolvePackageBuildConfig(shared) {
         "packageBuild.container.",
     );
     const containerInput = /** @type {Record<string, unknown>} */ (container);
+    const containerName =
+        containerInput.name === undefined ?
+            null
+        :   requireContainerName(containerInput.name);
     const declaredStages = containerInput.stages ?? {};
     if (!isMapping(declaredStages)) {
         fail("packageBuild.container.stages", "must be a mapping");
@@ -765,6 +805,7 @@ export function resolvePackageBuildConfig(shared) {
                     containerInput.image,
                     "packageBuild.container.image",
                 ),
+        containerName,
         containerStages,
         e2eStage:
             e2eInput.stage === undefined ?

package/container.mjs

@@ -110,16 +110,27 @@ export function dataEnvVar(stage) {
 /**
  * The container name for a package's stage.
  *
- * Named after the package so two HeroicLands packages can run their own
- * containers side by side, and stable so Foundry's signed licence — which is
- * bound to the container hostname — survives a recreate.
+ * Stable, so Foundry's signed licence — which is bound to the container
+ * hostname — survives a recreate. Named after the package by default, so two
+ * HeroicLands packages run their own containers side by side.
+ *
+ * A declared `base` replaces the package-scoped half, which is what lets
+ * several packages share one container and so one signed licence: a signature
+ * is issued for a hostname, not for a package, and a package that cannot name
+ * the host cannot be pointed at a signature that already exists.
+ *
+ * The stage stays in the name either way. Two stages are two containers over
+ * two data roots, and docker names are unique: were a declared name used
+ * whole, `container dev` would find the `test` container already there, start
+ * it, and serve the test data root on the dev port.
  *
  * @param {string} packageId - The Foundry package id.
  * @param {string} stage - The stage name.
+ * @param {string|null} [base] - Declared name, shareable between packages.
  * @returns {string} The container name.
  */
-export function containerName(packageId, stage) {
-    return `${packageId}-foundry-${stage}`;
+export function containerName(packageId, stage, base = null) {
+    return `${base ?? `${packageId}-foundry`}-${stage}`;
 }
 
 /**
@@ -522,7 +533,7 @@ export function resolveContainer({ stage, config, env = process.env }) {
     const port = resolveStagePort(stage, { env, stages });
     return {
         stage,
-        name: containerName(config.packageId, stage),
+        name: containerName(config.packageId, stage, config.containerName),
         port,
         image: resolveImage({
             env,

package/content-config.mjs

@@ -181,6 +181,14 @@ export const DEFAULT_ADDRESS_SCHEME = Object.freeze({
  * @property {string|null} [folders]    The pack's folder-hierarchy file, relative
  *                                      to `paths.content`. Default `null` — no
  *                                      folder documents are emitted.
+ * @property {string} [prebuilt]        Directory holding this pack's per-document
+ *                                     JSON, already built. Declaring it skips
+ *                                     generation for the pack and compiles from
+ *                                     there instead.
+ * @property {string} [system]          The system this pack depends on, written
+ *                                     to the manifest. Defaults to
+ *                                     `stats.systemId`; omitted when neither is
+ *                                     set.
  * @property {PackSpec[]} [companions]  Packs written by this pack's own compiler
  *                                      pass rather than a pass of their own (the
  *                                      scenes pass also emits the adventures
@@ -208,6 +216,8 @@ export const DEFAULT_ADDRESS_SCHEME = Object.freeze({
  * @property {string} label
  * @property {boolean} private
  * @property {string|null} folders
+ * @property {string|null} prebuilt
+ * @property {string|null} system
  * @property {readonly Readonly<ResolvedPackSpec>[]} companions
  * @property {boolean} mayBeEmpty
  * @property {boolean} default
@@ -546,6 +556,8 @@ const PACK_KEYS = [
     "companions",
     "mayBeEmpty",
     "default",
+    "prebuilt",
+    "system",
 ];
 const PATH_KEYS = Object.keys(DEFAULT_PATHS);
 const STATS_KEYS = ["systemId", "systemVersion", "lastModifiedBy"];
@@ -673,6 +685,54 @@ function normalizePack(value, where, nested = false) {
         normalizePack(companion, `${where}.companions[${index}]`, true),
     );
 
+    // A prebuilt pack's per-document JSON already exists, so it has no
+    // generation pass. Every key below describes one, which is why none of them
+    // may accompany it: silently ignoring a `folders` file that can never be
+    // read is worse than refusing the configuration that declares it.
+    const prebuilt =
+        pack.prebuilt === undefined || pack.prebuilt === null ?
+            null
+        :   requireNonEmptyString(pack.prebuilt, `${where}.prebuilt`);
+    if (prebuilt !== null) {
+        if (nested) {
+            fail(
+                `${where}.prebuilt`,
+                "may not be declared on a companion: a companion is written by " +
+                    "another pack's pass, and a prebuilt pack has no pass",
+            );
+        }
+        if (pack.folders !== undefined && pack.folders !== null) {
+            fail(
+                `${where}.folders`,
+                "may not accompany `prebuilt`: the folder hierarchy is built " +
+                    "during generation, which a prebuilt pack skips",
+            );
+        }
+        if (Array.isArray(companionsInput) && companionsInput.length) {
+            fail(
+                `${where}.companions`,
+                "may not accompany `prebuilt`: a companion is written by this " +
+                    "pack's pass, and a prebuilt pack has none",
+            );
+        }
+        if (pack.default === true) {
+            fail(
+                `${where}.default`,
+                "may not accompany `prebuilt`: the default pack receives notes " +
+                    "declaring no `pack:`, and no note is routed into a prebuilt one",
+            );
+        }
+    }
+
+    // Foundry requires `system` on ActiveEffect, Actor and Item packs and on no
+    // others (CONST.SYSTEM_SPECIFIC_COMPENDIUM_TYPES), so a package may need a
+    // different answer per pack. Unset here falls back to `stats.systemId`, and
+    // unset in both omits the key from the manifest.
+    const system =
+        pack.system === undefined || pack.system === null ?
+            null
+        :   requireNonEmptyString(pack.system, `${where}.system`);
+
     /** @type {ResolvedPackSpec} */
     const normalized = {
         name,
@@ -695,6 +755,8 @@ function normalizePack(value, where, nested = false) {
         // Which pack of a type receives a note that declares none. Validated
         // across the whole list in `defineConfig` — at most one per type.
         default: optionalBoolean(pack.default, `${where}.default`, false),
+        prebuilt,
+        system,
     };
     return Object.freeze(normalized);
 }
@@ -747,7 +809,13 @@ function normalizeStats(value) {
     rejectUnknownKeys(input, STATS_KEYS, "stats.");
 
     return Object.freeze({
-        systemId: requireNonEmptyString(input.systemId, "stats.systemId"),
+        // Optional: a package whose packs are not all for one system declares
+        // the system per pack instead (`packs[].system`), and a package that
+        // ships only system-agnostic documents declares none at all.
+        systemId:
+            input.systemId === undefined || input.systemId === null ?
+                null
+            :   requireNonEmptyString(input.systemId, "stats.systemId"),
         systemVersion: requireNonEmptyString(
             input.systemVersion,
             "stats.systemVersion",

package/engine/compendiums.mjs

@@ -91,21 +91,41 @@ export async function compilePacks({
         (name) => !packName || name === packName,
     );
 
+    // A prebuilt pack's JSON is checked in rather than generated, so it is
+    // compiled from where it lives. Anything else comes from the build-only
+    // intermediate the generation pass writes.
+    const prebuiltDirs = new Map(
+        config.packs
+            .filter((pack) => pack.prebuilt)
+            .map((pack) => [pack.name, pack.prebuilt]),
+    );
+    const needsGeneration = packNames.some((name) => !prebuiltDirs.has(name));
+
     // Generate the per-entry JSON from the content tree into the build-only
     // JSON intermediate. The package-id guard runs first, inside this call,
     // before any pack is written.
-    const errors = await generatePacksJson({ only: packName, config });
-    if (errors > 0) {
-        throw new Error(
-            `Pack JSON generation reported ${errors} error(s); refusing to ` +
-                `compile packs from incomplete output.`,
-        );
+    //
+    // Skipped when every selected pack is prebuilt: generation refuses an empty
+    // content tree, and a package that ships only prebuilt packs has none at
+    // all — so running it would fail the build over a tree nothing reads.
+    if (needsGeneration) {
+        const errors = await generatePacksJson({ only: packName, config });
+        if (errors > 0) {
+            throw new Error(
+                `Pack JSON generation reported ${errors} error(s); refusing to ` +
+                    `compile packs from incomplete output.`,
+            );
+        }
     }
 
     for (const name of packNames) {
-        const source = packJsonDir(name, config);
+        const source = prebuiltDirs.get(name) ?? packJsonDir(name, config);
         if (!fs.existsSync(source)) {
-            log.error(`Pack ${name}: generated JSON not found at ${source}.`);
+            log.error(
+                prebuiltDirs.has(name) ?
+                    `Pack ${name}: prebuilt JSON not found at ${source}.`
+                :   `Pack ${name}: generated JSON not found at ${source}.`,
+            );
             continue;
         }
 

package/engine/pack-config.mjs

@@ -94,7 +94,7 @@ export const CONFIG_BASENAME = "package-build.config";
  * reach for them: YAML first, `.mjs` last.
  *
  * The `content-build.config.*` stem this package read before the two toolchains
- * merged is **not** resolved. 2.0.0 renames the file rather than accepting both:
+ * merged is **not** resolved. 3.0.0 renames the file rather than accepting both:
  * a deprecation window here would mean a repository could sit indefinitely on a
  * name for a package that no longer exists, and the upgrade already requires
  * touching the consumer's manifest and imports.

package/manifest.mjs

@@ -178,14 +178,23 @@ export function manifestPacks(config) {
         pack,
         ...(pack.companions ?? []).flatMap(flatten),
     ];
-    return config.packs.flatMap(flatten).map((pack) => ({
-        label: pack.label,
-        type: pack.type,
-        name: pack.name,
-        system: config.stats.systemId,
-        path: `packs/${pack.name}`,
-        private: pack.private,
-    }));
+    return config.packs.flatMap(flatten).map((pack) => {
+        // Foundry requires `system` on ActiveEffect, Actor and Item packs and
+        // on no others, so the value is per pack: its own declaration first,
+        // then the package-wide one. With neither, the key is omitted — an
+        // Adventure, Scene or JournalEntry pack that declares a system is
+        // hidden from every other system, which is rarely what a package that
+        // declined to name one meant.
+        const system = pack.system ?? config.stats.systemId;
+        return {
+            label: pack.label,
+            type: pack.type,
+            name: pack.name,
+            ...(system ? { system } : {}),
+            path: `packs/${pack.name}`,
+            private: pack.private,
+        };
+    });
 }
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@heroiclands/package-build",
-    "version": "3.0.0",
+    "version": "3.1.0",
     "description": "Shared toolchain for building and shipping a HeroicLands Foundry VTT package — content compilation, manifest, localization, staging, bundle, release and deployment.",
     "license": "GPL-3.0-or-later",
     "type": "module",

package/types/config.d.mts

@@ -47,6 +47,9 @@
  * @property {string|null} systemVersion  That system's version, when the shared
  *   configuration stamps one.
  * @property {string|null} containerImage  Image override for every stage.
+ * @property {string|null} containerName  Container name, minus the stage,
+ *   shared with the packages that declare the same one so a single signed
+ *   Foundry licence covers them all. `null` names it after the package.
  * @property {Readonly<Record<string, Readonly<{port: number|null, world: string|null, version: string|null}>>>} containerStages
  *   Container stages beyond the conventional four.
  * @property {string} e2eStage       Which stage the suite runs against.
@@ -232,6 +235,12 @@ export type PackageBuildConfig = {
      * Image override for every stage.
      */
     containerImage: string | null;
+    /**
+     * Container name, minus the stage,
+     * shared with the packages that declare the same one so a single signed
+     * Foundry licence covers them all. `null` names it after the package.
+     */
+    containerName: string | null;
     /**
      *   Container stages beyond the conventional four.
      */

package/types/container.d.mts

@@ -11,15 +11,26 @@ export function dataEnvVar(stage: string): string;
 /**
  * The container name for a package's stage.
  *
- * Named after the package so two HeroicLands packages can run their own
- * containers side by side, and stable so Foundry's signed licence — which is
- * bound to the container hostname — survives a recreate.
+ * Stable, so Foundry's signed licence — which is bound to the container
+ * hostname — survives a recreate. Named after the package by default, so two
+ * HeroicLands packages run their own containers side by side.
+ *
+ * A declared `base` replaces the package-scoped half, which is what lets
+ * several packages share one container and so one signed licence: a signature
+ * is issued for a hostname, not for a package, and a package that cannot name
+ * the host cannot be pointed at a signature that already exists.
+ *
+ * The stage stays in the name either way. Two stages are two containers over
+ * two data roots, and docker names are unique: were a declared name used
+ * whole, `container dev` would find the `test` container already there, start
+ * it, and serve the test data root on the dev port.
  *
  * @param {string} packageId - The Foundry package id.
  * @param {string} stage - The stage name.
+ * @param {string|null} [base] - Declared name, shareable between packages.
  * @returns {string} The container name.
  */
-export function containerName(packageId: string, stage: string): string;
+export function containerName(packageId: string, stage: string, base?: string | null): string;
 /**
  * A stage declared in `packageBuild.container.stages`.
  *

package/types/content-config.d.mts

@@ -113,6 +113,20 @@ export type PackSpec = {
      *     folder documents are emitted.
      */
     folders?: string | null | undefined;
+    /**
+     * Directory holding this pack's per-document
+     *        JSON, already built. Declaring it skips
+     *        generation for the pack and compiles from
+     *        there instead.
+     */
+    prebuilt?: string | undefined;
+    /**
+     * The system this pack depends on, written
+     *          to the manifest. Defaults to
+     *          `stats.systemId`; omitted when neither is
+     *          set.
+     */
+    system?: string | undefined;
     /**
      * Packs written by this pack's own compiler
      *   pass rather than a pass of their own (the
@@ -148,6 +162,8 @@ export type ResolvedPackSpec = {
     label: string;
     private: boolean;
     folders: string | null;
+    prebuilt: string | null;
+    system: string | null;
     companions: readonly Readonly<ResolvedPackSpec>[];
     mayBeEmpty: boolean;
     default: boolean;

package/types/engine/pack-config.d.mts

@@ -67,7 +67,7 @@ export const CONFIG_BASENAME: "package-build.config";
  * reach for them: YAML first, `.mjs` last.
  *
  * The `content-build.config.*` stem this package read before the two toolchains
- * merged is **not** resolved. 2.0.0 renames the file rather than accepting both:
+ * merged is **not** resolved. 3.0.0 renames the file rather than accepting both:
  * a deprecation window here would mean a repository could sit indefinitely on a
  * name for a package that no longer exists, and the upgrade already requires
  * touching the consumer's manifest and imports.