@bobfrankston/npmglobalize 1.0.218 → 1.0.220

package/README.md

@@ -756,7 +756,7 @@ As with import maps, these have historically been built only by a second `.vscod
 Before building, `npmglobalize` looks for sub-projects, in this order:
 
 1. `.vscode/tasks.json` has a task that runs `tsc` or `importgen` with `"options": { "cwd": "${workspaceFolder}/client" }`, or runs `tsc` with `-p`/`--project` naming a sub-directory (authoritative — it's how the project is actually built today; the task's `label` is quoted back in the prompt).
-2. An immediate sub-directory containing its own `package.json` build script or `tsconfig.json`. Build output and vendored trees (`node_modules`, `prev`, `dist`, `built`, `out`, `wwwroot`, `coverage`, `temp`, `preflight`, dot-directories) are never scanned.
+2. An immediate sub-directory that is a build of its own: a `package.json` with a `build` script or an import map to regenerate (a sub-package gets its build script set up the same way the root does — importgen, `tsc`, its own sub-projects — before the root delegates to it), or a `tsconfig.json` the root `tsconfig.json` does not already compile. A `package.json` that only holds dependencies for files the root `tsc` compiles (`whts/pdfToImg`) is not a sub-project. Build output and vendored trees (`node_modules`, `prev`, `dist`, `built`, `out`, `wwwroot`, `coverage`, `temp`, `preflight`, dot-directories) are never scanned.
 
 Nothing is detected when the root `tsconfig.json` uses project `references` — that build graph belongs to `tsc -b` and isn't second-guessed.
 

package/lib.d.ts

@@ -397,16 +397,6 @@ export declare function missingDeps(pkgDir: string, pkg: any): string[];
  *  re-run" (partial-sync) cases. Also covers `cwd` itself on the first call.
  *  Cycle-safe via the shared `visited` set. */
 export declare function ensureFileDepModules(cwd: string, verbose?: boolean, visited?: Set<string>): Promise<boolean>;
-/** Cheap freshness check so the build cascade can skip packages whose output is
- *  already current. Returns true only when provably up to date:
- *  - outDir projects: newest source (.ts/.tsx/.mts/.cts + tsconfig*.json) must
- *    not be newer than the newest file under outDir.
- *  - side-by-side projects: every source must have an emitted sibling
- *    (.js/.jsx/.mjs/.cjs or declaration) at least as new.
- *  Conservative: project references, allowJs, missing outputs, or unreadable
- *  tsconfig all report stale (→ build). package.json mtime is deliberately
- *  ignored — npmglobalize itself rewrites it around every publish, which would
- *  otherwise force a rebuild on every run. */
 export declare function isBuildUpToDate(cwd: string): boolean;
 /** Detect whether a package is an importgen project — a browser app whose HTML
  *  carries a generated `<script type="importmap">`. Signals, in order:
@@ -430,7 +420,7 @@ export declare function ensureImportgenInBuild(cwd: string): Promise<void>;
 /** A sub-directory the root build must build, and how. */
 interface SubProject {
     dir: string; /** Relative directory with its on-disk casing */
-    kind: 'package' | 'tsconfig'; /** package: delegate to its build script; tsconfig: `tsc -p` */
+    kind: 'package' | 'tsconfig'; /** package: has its own package.json, delegate to its build script; tsconfig: `tsc -p` */
     reason: string; /** The signal that found it, quoted in prompts */
 }
 /** Sub-directories the root build must build itself. A package can hold more
@@ -452,11 +442,20 @@ export declare function detectSubProjects(cwd: string): SubProject[];
  *  own idea of what to compile. Declining records `subProjects: false` in
  *  .globalize.json5. */
 export declare function ensureSubProjectsInBuild(cwd: string): Promise<void>;
-/** Build a single project: detect tsconfig, prompt to add `build: tsc` if a
- *  TypeScript project lacks a build script, run `npm run build`, record
- *  failures. Returns true if build succeeded (or was skipped because no
- *  tsconfig / noEmit / no build script after declining the prompt / output
- *  already up to date). Pass `forceBuild` to skip the freshness check. */
+/** Make sure `cwd`'s package.json has the build script it needs: importgen
+ *  for an importgen project, `tsc` for a TypeScript project (prompted), and a
+ *  step per sub-project. Returns the package plus whether the script runs
+ *  importgen, or null when there is nothing to build here (no package.json, no
+ *  tsconfig or `noEmit` and no importgen, or the user declined the prompt). */
+export declare function ensureBuildScript(cwd: string): Promise<{
+    pkg: any;
+    runsImportgen: boolean;
+} | null>;
+/** Build a single project: set up its build script (see `ensureBuildScript`),
+ *  run `npm run build`, record failures. Returns true if build succeeded (or
+ *  was skipped because there was nothing to build / the user declined the
+ *  build-script prompt / output already up to date). Pass `forceBuild` to
+ *  skip the freshness check. */
 export declare function buildProject(cwd: string, opts?: {
     verbose?: boolean;
     force?: boolean;

package/lib.js

@@ -2888,6 +2888,35 @@ function newestMtimeUnder(dir) {
  *  tsconfig all report stale (→ build). package.json mtime is deliberately
  *  ignored — npmglobalize itself rewrites it around every publish, which would
  *  otherwise force a rebuild on every run. */
+/** The directories a parsed tsconfig's `exclude` keeps out of the compile, as
+ *  lower-cased relative paths. Matches on the literal path prefix (glob tails
+ *  like "tests/**" reduce to "tests"). */
+function tsconfigExcludedDirs(tsconfig) {
+    return (Array.isArray(tsconfig?.exclude) ? tsconfig.exclude : [])
+        .filter((x) => typeof x === 'string')
+        .map((x) => x.replace(/^\.\//, '').replace(/[\\/]?\*.*$/, '').replace(/[\\/]+$/, '').toLowerCase())
+        .filter((x) => x.length > 0 && !x.includes('*'));
+}
+/** True when the root tsconfig in `cwd` already compiles the sources under
+ *  `rel`: it exists, doesn't narrow the compile with `files`/`include`, and
+ *  doesn't `exclude` the directory. Conservative — a root that uses `include`
+ *  is treated as not covering the sub-directory. */
+function rootTsconfigCompiles(cwd, rel) {
+    let tsconfig;
+    try {
+        tsconfig = JSON5.parse(fs.readFileSync(path.join(cwd, 'tsconfig.json'), 'utf-8'));
+    }
+    catch {
+        return false;
+    }
+    if (Array.isArray(tsconfig.files) || Array.isArray(tsconfig.include))
+        return false;
+    const target = normalizeProjectPath(rel).toLowerCase();
+    const parts = target.split('/');
+    const excludes = tsconfigExcludedDirs(tsconfig);
+    // Excluding a parent excludes everything under it.
+    return !parts.some((_, i) => excludes.includes(parts.slice(0, i + 1).join('/')));
+}
 export function isBuildUpToDate(cwd) {
     let tsconfig;
     try {
@@ -2901,12 +2930,8 @@ export function isBuildUpToDate(cwd) {
         return false;
     const outDir = typeof co.outDir === 'string' ? path.resolve(cwd, co.outDir) : null;
     // tsconfig "exclude" dirs aren't compiled, so their .ts files never get
-    // outputs — don't count them as sources. Match on the literal path prefix
-    // (glob tails like "tests/**" reduce to "tests").
-    const excludes = (Array.isArray(tsconfig.exclude) ? tsconfig.exclude : [])
-        .filter((x) => typeof x === 'string')
-        .map((x) => x.replace(/^\.\//, '').replace(/[\\/]?\*.*$/, '').replace(/[\\/]+$/, '').toLowerCase())
-        .filter((x) => x.length > 0 && !x.includes('*'));
+    // outputs — don't count them as sources.
+    const excludes = tsconfigExcludedDirs(tsconfig);
     const sources = [];
     const collect = (dir, rel) => {
         let entries;
@@ -3198,18 +3223,31 @@ function resolveOnDiskCase(base, rel) {
     }
     return out.length ? out.join('/') : null;
 }
-/** Classify `rel` under `cwd`: a package with its own build script, a plain
- *  tsconfig sub-project, or null when it's neither. */
+/** Classify `rel` under `cwd`: a package (its own package.json with a build
+ *  script, or an importgen project — `ensureBuildScript` sets its script up),
+ *  a plain tsconfig sub-project the root tsc doesn't compile, or null when it
+ *  is neither.
+ *  2026-09-06 — Claude Code (Fable 5.1), at Bob's direction. whts/pdfToImg has
+ *  a package.json that only holds puppeteer/sharp for a file the root tsc
+ *  already compiles; treating every package.json as a sub-package gave it a
+ *  `build: tsc` it never needed and a second compile under its stale tsconfig.
+ *  A package.json is a build of its own only when it has something the root
+ *  can't do — its own build script, or an import map to regenerate. */
 function subProjectKind(cwd, rel) {
-    try {
-        const pkg = readPackageJson(path.join(cwd, rel));
-        if (typeof pkg?.scripts?.build === 'string' && pkg.scripts.build.trim())
+    const dir = path.join(cwd, rel);
+    if (fs.existsSync(path.join(dir, 'package.json'))) {
+        let pkg = {};
+        try {
+            pkg = readPackageJson(dir);
+        }
+        catch { /* unreadable — treat as having no build script */ }
+        const hasBuild = typeof pkg?.scripts?.build === 'string' && pkg.scripts.build.trim();
+        if (hasBuild || detectImportgen(dir))
             return 'package';
     }
-    catch {
-        // No package.json there — fall through to the tsconfig test
-    }
-    return fs.existsSync(path.join(cwd, rel, 'tsconfig.json')) ? 'tsconfig' : null;
+    if (!fs.existsSync(path.join(dir, 'tsconfig.json')))
+        return null;
+    return rootTsconfigCompiles(cwd, rel) ? null : 'tsconfig';
 }
 /** The command the root build script runs for a sub-project. */
 function subProjectBuildCommand(s) {
@@ -3303,7 +3341,7 @@ export function detectSubProjects(cwd) {
                 continue;
             const kind = subProjectKind(cwd, e.name);
             if (kind)
-                add(e.name, kind === 'package' ? `${e.name}/package.json has a build script` : `${e.name}/tsconfig.json`);
+                add(e.name, kind === 'package' ? `${e.name}/package.json` : `${e.name}/tsconfig.json`);
         }
     }
     catch {
@@ -3328,6 +3366,20 @@ function configuredSubProjects(cwd, config) {
     }
     return detectSubProjects(cwd);
 }
+/** The sub-projects the root build should run, each ready to be run: a
+ *  sub-package gets its own build script set up first (importgen, tsc, its own
+ *  sub-projects — the same setup the root gets), and one that still has
+ *  nothing to build afterwards is left out, since delegating to it would only
+ *  fail with "missing script: build". */
+async function readySubProjects(cwd, config) {
+    const ready = [];
+    for (const s of configuredSubProjects(cwd, config)) {
+        if (s.kind === 'package' && !(await ensureBuildScript(path.join(cwd, s.dir))))
+            continue;
+        ready.push(s);
+    }
+    return ready;
+}
 /** Quote a path for a package.json script only when it needs it. */
 function quoteScriptPath(p) {
     return /[\s&|<>]/.test(p) ? `"${p}"` : p;
@@ -3351,14 +3403,8 @@ export async function ensureSubProjectsInBuild(cwd) {
     const buildScript = typeof pkg.scripts?.build === 'string' ? pkg.scripts.build.trim() : '';
     if (!buildScript || !scriptRunsTsc(buildScript))
         return;
-    const subs = configuredSubProjects(cwd, config);
-    // A sub-package owns its own import map: give its build script the same
-    // importgen check the root gets, so delegating to it is enough.
-    for (const s of subs) {
-        if (s.kind === 'package')
-            await ensureImportgenInBuild(path.join(cwd, s.dir));
-    }
-    const missing = subs.filter(s => !scriptBuildsSubProject(buildScript, s.dir));
+    const missing = (await readySubProjects(cwd, config))
+        .filter(s => !scriptBuildsSubProject(buildScript, s.dir));
     if (missing.length === 0)
         return;
     const name = pkg.name || path.basename(cwd);
@@ -3367,7 +3413,7 @@ export async function ensureSubProjectsInBuild(cwd) {
     // — a bare nested tsconfig (tests, examples) is a weaker signal, and this
     // prompt rewrites a build script that currently works.
     const strong = missing.every(s => s.reason.startsWith('.vscode/tasks.json') || s.reason.startsWith('listed in'));
-    console.log(colors.yellow(`${name}'s build script doesn't compile ${missing.length === 1 ? 'a sub-project' : 'its sub-projects'}:`));
+    console.log(colors.yellow(`${name}'s build script doesn't build ${missing.length === 1 ? 'a sub-project' : 'its sub-projects'}:`));
     for (const s of missing)
         console.log(colors.yellow(`  ${s.dir}/ — ${s.reason}`));
     const addIt = await confirm(`Set "build": "${newScript}" in ${name}'s package.json?`, strong);
@@ -3417,76 +3463,61 @@ function areSubProjectsUpToDate(cwd, subs) {
     }
     return true;
 }
-/** Build a single project: detect tsconfig, prompt to add `build: tsc` if a
- *  TypeScript project lacks a build script, run `npm run build`, record
- *  failures. Returns true if build succeeded (or was skipped because no
- *  tsconfig / noEmit / no build script after declining the prompt / output
- *  already up to date). Pass `forceBuild` to skip the freshness check. */
-export async function buildProject(cwd, opts = {}) {
+// 2026-09-06 — Claude Code (Fable 5.1), at Bob's direction ("when you add
+// importgen for a client dir you should set up the proper package.json").
+// Factored out of buildProject so a sub-package (itemw/client) gets the SAME
+// build-script setup as the root — importgen wired in, `tsc` added when it has
+// a tsconfig, its own sub-projects appended — instead of a second recipe.
+/** Make sure `cwd`'s package.json has the build script it needs: importgen
+ *  for an importgen project, `tsc` for a TypeScript project (prompted), and a
+ *  step per sub-project. Returns the package plus whether the script runs
+ *  importgen, or null when there is nothing to build here (no package.json, no
+ *  tsconfig or `noEmit` and no importgen, or the user declined the prompt). */
+export async function ensureBuildScript(cwd) {
     // Do this before the tsconfig check: an importgen project may be plain JS
     // with no tsconfig at all, and still need its import map regenerated.
     await ensureImportgenInBuild(cwd);
     let shouldBuild = false;
-    let hasTsconfig = false;
     try {
-        const tsconfigPath = path.join(cwd, 'tsconfig.json');
-        const content = fs.readFileSync(tsconfigPath, 'utf-8');
-        const tsconfig = JSON5.parse(content);
-        hasTsconfig = true;
+        const tsconfig = JSON5.parse(fs.readFileSync(path.join(cwd, 'tsconfig.json'), 'utf-8'));
         shouldBuild = tsconfig.compilerOptions?.noEmit !== true;
     }
     catch {
-        // No tsconfig — skip
+        // No tsconfig — nothing for tsc to do
     }
-    // Fix removed-in-TS7 tsconfig settings up front rather than waiting for a
-    // build to fail on them. A deprecated `moduleResolution` is only a *hard*
-    // error under the tsc that flags it (TS6+, and the editor's bundled
-    // compiler), so a package pinned to an older tsc — or one that never gets
-    // to the build at all (noEmit, no build script, output already fresh) —
-    // would otherwise keep the deprecation until TS7 removes it outright.
-    // Deliberately ahead of every early return below: the tsconfig is worth
-    // fixing whether or not this package builds. Migrating also touches
-    // tsconfig.json, which makes the freshness check correctly read as stale.
-    const tsconfigSnapshot = new Map();
-    const issueMark = markBuildIssues();
-    const migratedUpFront = hasTsconfig && migrateTsconfigDeprecations(cwd, tsconfigSnapshot);
-    let earlyPkg;
+    let pkg;
     try {
-        earlyPkg = readPackageJson(cwd);
+        pkg = readPackageJson(cwd);
     }
     catch {
-        return true;
+        return null;
     }
-    const runsImportgen = scriptRunsImportgen(typeof earlyPkg.scripts?.build === 'string' ? earlyPkg.scripts.build : '');
+    const runsImportgen = scriptRunsImportgen(typeof pkg.scripts?.build === 'string' ? pkg.scripts.build : '');
     // A build script that regenerates the import map is worth running even when
     // there's nothing for tsc to emit.
     if (!shouldBuild && !runsImportgen)
-        return true;
-    const pkg = earlyPkg;
+        return null;
     const existingBuild = typeof pkg.scripts?.build === 'string' ? pkg.scripts.build.trim() : '';
     // A build script ensureImportgenInBuild just created for a package that had
     // none still needs its tsc pass — treat importgen-only as "no build yet".
     const importgenOnly = !!existingBuild && existingBuild.split(/\s*&&\s*/).every(scriptRunsImportgen);
     if (shouldBuild && (!existingBuild || importgenOnly)) {
-        // Compile the sub-projects (service worker, …) in the same breath: the
-        // root tsc excludes them, so a bare "tsc" would leave them unbuilt.
-        const subs = configuredSubProjects(cwd, readConfig(cwd));
+        // Build the sub-projects (service worker, client package, …) in the same
+        // breath: the root tsc excludes them, so a bare "tsc" would leave them unbuilt.
+        const subs = await readySubProjects(cwd, readConfig(cwd));
         const tscParts = ['tsc', ...subs.map(subProjectBuildCommand)];
         const newScript = [...(existingBuild ? [existingBuild] : []), ...tscParts].join(' && ');
         console.log(colors.yellow(`TypeScript project has no "build" script in ${pkg.name || cwd}`));
         for (const s of subs)
             console.log(colors.yellow(`  sub-project ${s.dir}/ — ${s.reason}`));
         const addIt = await confirm(`Add "build": "${newScript}" to ${pkg.name || path.basename(cwd)}'s package.json?`, true);
-        if (addIt) {
-            if (!pkg.scripts)
-                pkg.scripts = {};
-            pkg.scripts.build = newScript;
-            writePackageJson(cwd, pkg);
-            console.log(colors.green(`✓ Added "build": "${newScript}" to ${pkg.name || path.basename(cwd)}`));
-        }
-        else {
-            return true;
-        }
+        if (!addIt)
+            return null;
+        if (!pkg.scripts)
+            pkg.scripts = {};
+        pkg.scripts.build = newScript;
+        writePackageJson(cwd, pkg);
+        console.log(colors.green(`✓ Added "build": "${newScript}" to ${pkg.name || path.basename(cwd)}`));
     }
     else if (existingBuild) {
         await ensureSubProjectsInBuild(cwd);
@@ -3498,10 +3529,44 @@ export async function buildProject(cwd, opts = {}) {
         catch { /* keep the script we already have */ }
     }
     ensureTsconfigNodeTypes(cwd);
+    return { pkg, runsImportgen };
+}
+/** Build a single project: set up its build script (see `ensureBuildScript`),
+ *  run `npm run build`, record failures. Returns true if build succeeded (or
+ *  was skipped because there was nothing to build / the user declined the
+ *  build-script prompt / output already up to date). Pass `forceBuild` to
+ *  skip the freshness check. */
+export async function buildProject(cwd, opts = {}) {
+    // Fix removed-in-TS7 tsconfig settings up front rather than waiting for a
+    // build to fail on them. A deprecated `moduleResolution` is only a *hard*
+    // error under the tsc that flags it (TS6+, and the editor's bundled
+    // compiler), so a package pinned to an older tsc — or one that never gets
+    // to the build at all (noEmit, no build script, output already fresh) —
+    // would otherwise keep the deprecation until TS7 removes it outright.
+    // Deliberately ahead of every early return below: the tsconfig is worth
+    // fixing whether or not this package builds. Migrating also touches
+    // tsconfig.json, which makes the freshness check correctly read as stale.
+    const tsconfigSnapshot = new Map();
+    const issueMark = markBuildIssues();
+    let migratedUpFront = fs.existsSync(path.join(cwd, 'tsconfig.json')) && migrateTsconfigDeprecations(cwd, tsconfigSnapshot);
+    const setup = await ensureBuildScript(cwd);
+    if (!setup)
+        return true;
+    const { pkg, runsImportgen } = setup;
     // Only the sub-projects the final build script really compiles count toward
     // freshness — one the user declined to wire in isn't this build's business.
     const finalBuild = typeof pkg.scripts?.build === 'string' ? pkg.scripts.build : '';
     const wiredSubs = detectSubProjects(cwd).filter(s => scriptBuildsSubProject(finalBuild, s.dir));
+    // 2026-09-06 — Claude Code (Fable 5.1), at Bob's direction.
+    // The sub-projects this build runs get the same TS7 migration as the root.
+    // whts: `tsc -p pdfToImg` failed on pdfToImg/tsconfig.json's
+    // `moduleResolution: node10` (TS5107) and the retry below re-migrated only
+    // the root chain, which had nothing left to fix — so no retry ever happened.
+    const migrateSubProjects = () => wiredSubs
+        .map(s => migrateTsconfigDeprecations(path.join(cwd, s.dir), tsconfigSnapshot))
+        .some(Boolean);
+    if (migrateSubProjects())
+        migratedUpFront = true;
     // A migration just changed how modules resolve — never report that as fresh;
     // the rebuild is what validates it (and what the revert path above needs).
     if (!opts.forceBuild && !migratedUpFront && isBuildUpToDate(cwd) && areSubProjectsUpToDate(cwd, wiredSubs)
@@ -3517,7 +3582,7 @@ export async function buildProject(cwd, opts = {}) {
         // We don't silence with ignoreDeprecations — the retry may now surface real
         // resolution errors, which are genuine bugs to fix, not deprecations.
         const out = (buildResult.stderr || '') + (buildResult.output || '');
-        if (/error TS510[17]\b/.test(out) && migrateTsconfigDeprecations(cwd, tsconfigSnapshot)) {
+        if (/error TS510[17]\b/.test(out) && [migrateTsconfigDeprecations(cwd, tsconfigSnapshot), migrateSubProjects()].some(Boolean)) {
             buildResult = await runCommandAsync('npm', ['run', 'build'], { cwd, silent: true });
         }
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bobfrankston/npmglobalize",
-  "version": "1.0.218",
+  "version": "1.0.220",
   "description": "Transform file: dependencies to npm versions for publishing",
   "main": "index.js",
   "type": "module",