@bobfrankston/npmglobalize 1.0.208 → 1.0.210

package/lib.d.ts

@@ -485,6 +485,14 @@ export declare function ensureWorkspaceDepModules(rootDir: string, members: Arra
  *  `npm error` lines minus stack frames and brace-only object-dump fragments,
  *  deduped. The full output belongs in a log file (saveNpmLog), not the terminal. */
 export declare function distillNpmErrors(combined: string): string[];
+/** True when a failed install is npm's "no such version" (ETARGET/E404) for the
+ *  very spec we just published — registry propagation or a stale local
+ *  packument, not a broken package. `pkgSpec` is `name@version`. */
+export declare function isPropagationFailure(combined: string, pkgSpec: string): boolean;
+/** What to tell the user when an install fails purely because npm cannot see a
+ *  just-published version yet. Says what IS true (published, will install),
+ *  what is NOT (nothing wrong with the package), and one command that works. */
+export declare function propagationHelp(pkgSpec: string): string[];
 /** Scan a puppeteer browser cache (layout <root>/<browser>/<platform-version>)
  *  and repair every version folder that has no browser executable in it — the
  *  residue of a truncated extraction (see extractBrowserArchive for the Node
@@ -570,6 +578,9 @@ export interface GitStatus {
     currentBranch: string;
     remoteBranch: string;
     isBehindRemote: boolean;
+    inProgressOp: string; /** 'rebase' | 'cherry-pick' | 'revert' | 'merge' | '' — a sequencer operation git never finished */
+    detachedFromBranch: string; /** Branch the unfinished operation started from (read from the rebase state's head-name) */
+    unmergedPaths: string[]; /** Files with unresolved conflict markers */
 }
 export declare function getGitStatus(cwd: string): GitStatus;
 /** Validate package.json for release */

package/lib.js

@@ -2128,13 +2128,30 @@ async function npmInstallWithCleanRetry(dir, verbose, context) {
  *  resolvable. We wait longer and re-probe `npm view` for the version
  *  string until it shows up (or we hit the cap). */
 function waitForNpmVersion(pkgName, version, isNewPackage = false, maxWaitMs) {
-    const effectiveMaxWait = maxWaitMs ?? (isNewPackage ? 600000 : 180000);
-    const interval = isNewPackage ? 5000 : 3000;
+    // 2026-09-01 10:15 EDT — Claude Code (Opus 5), at Bob's direction.
+    // This loop was polling npm's LOCAL cache, not the registry. Registry
+    // packuments carry `cache-control: public, max-age=300`, and npm's default
+    // (prefer-online=false) serves a cached packument for that whole window
+    // without revalidating — so once the first probe cached a packument that
+    // predates the publish, every probe for the next 5 minutes returned the
+    // same stale answer no matter what the registry actually held. Verified
+    // 2026-09-01 on @bobfrankston/brother-label@1.1.22: the npm debug log for
+    // the failing install shows `http cache … (cache hit)` — it never asked
+    // the registry — while the cached entry's own resHeaders read
+    // `cache-control: public, max-age=300`. `--prefer-online` forces the
+    // staleness check (a conditional request), which is the only way this
+    // poll can observe anything new.
+    // Same run: publish at 13:52:48Z, packument `last-modified 13:57:59Z` —
+    // real propagation took 5m11s, past the old 180s cap for an existing
+    // package. Raised; with a probe that actually revalidates, an early
+    // success still exits immediately, so the higher cap costs nothing.
+    const effectiveMaxWait = maxWaitMs ?? (isNewPackage ? 600000 : 420000);
+    const interval = 5000;
     const maxAttempts = Math.ceil(effectiveMaxWait / interval);
     const suffix = isNewPackage ? ' (new package, may take several minutes)' : '';
     process.stdout.write(`${timestamp()} Waiting for ${pkgName}@${version} on npm registry${suffix}`);
     for (let i = 0; i < maxAttempts; i++) {
-        const result = spawnSafe('npm', ['view', `${pkgName}@${version}`, 'version'], {
+        const result = spawnSafe('npm', ['view', '--prefer-online', `${pkgName}@${version}`, 'version'], {
             shell: process.platform === 'win32',
             stdio: ['pipe', 'pipe', 'pipe'],
             encoding: 'utf-8'
@@ -2147,6 +2164,10 @@ function waitForNpmVersion(pkgName, version, isNewPackage = false, maxWaitMs) {
         sleepSync(interval);
     }
     process.stdout.write(' timed out\n');
+    // Timing out here is not a publish failure — the version is on npm, this
+    // client just cannot see it yet. Say so, or the install error that follows
+    // reads as though the package itself were broken.
+    console.log(colors.yellow(`  ${pkgName}@${version} was published but is still not visible to npm after ${Math.round(effectiveMaxWait / 1000)}s — trying the install anyway.`));
     return false;
 }
 function cleanNestedDepModules(pkg, cwd, verbose) {
@@ -3729,6 +3750,38 @@ export function distillNpmErrors(combined) {
     }
     return key.slice(0, 12);
 }
+// 2026-09-01 10:40 EDT — Claude Code (Opus 5), at Bob's direction: "it installed
+// correctly on a retry - need better error messages". What the run printed was
+// npm's own text — "No matching version found ... In most cases you or one of
+// your dependencies are requesting a package version that doesn't exist" —
+// which is flatly wrong here: WE published that exact version 4 seconds
+// earlier, and a manual retry a minute later installed it. The two helpers
+// below name the real situation instead.
+/** True when a failed install is npm's "no such version" (ETARGET/E404) for the
+ *  very spec we just published — registry propagation or a stale local
+ *  packument, not a broken package. `pkgSpec` is `name@version`. */
+export function isPropagationFailure(combined, pkgSpec) {
+    if (pkgSpec === '.')
+        return false; // local-directory install can't be a registry-visibility problem
+    if (!/npm (?:error|ERR!)\s+code E(?:TARGET|404)\b/.test(combined))
+        return false;
+    const name = pkgSpec.replace(/@[^@/]+$/, ''); // strip the trailing @version, keep any @scope
+    return combined.includes(pkgSpec) || combined.includes(name);
+}
+/** What to tell the user when an install fails purely because npm cannot see a
+ *  just-published version yet. Says what IS true (published, will install),
+ *  what is NOT (nothing wrong with the package), and one command that works. */
+export function propagationHelp(pkgSpec) {
+    return [
+        `${pkgSpec} is published — npm just can't see it from this machine yet.`,
+        `  The registry takes up to several minutes to propagate a new version, and npm`,
+        `  caches the package's version list for 5 minutes (cache-control: max-age=300),`,
+        `  so a retry inside that window can still miss it unless the cache is bypassed.`,
+        `  Nothing is wrong with the package or the publish; the global copy is simply the`,
+        `  previous version until you re-run:`,
+        `      npm install -g --prefer-online ${pkgSpec}`,
+    ];
+}
 /** Write the full output of a failed npm command to a log file under the temp
  *  dir and return its path (null if the write itself fails). */
 function saveNpmLog(label, content) {
@@ -4054,8 +4107,16 @@ async function installGlobalWithRetry(pkgSpec, cwd, isNewPackage = false, maxRet
     // stays behind npm's allowScripts gate.
     const allowArgs = allowOwnScriptsArgs(cwd);
     while (true) {
-        console.log(colors.cyan(`> npm install -g ${pkgSpec}${allowArgs.length ? ` ${allowArgs.join(' ')}` : ''}`));
-        result = await runCommandAsync('npm', ['install', '-g', pkgSpec, ...allowArgs], { cwd, silent: true });
+        // 2026-09-01 10:15 EDT — Claude Code (Opus 5), at Bob's direction.
+        // `--prefer-online`: this install always targets a version published
+        // seconds ago, so a cached packument is exactly the hazard. Without it
+        // all three ETARGET retries re-read the same stale local cache and are
+        // guaranteed to fail identically — confirmed in npm's debug log for
+        // brother-label@1.1.22 (`http cache … (cache hit)`, no registry
+        // request at all). Costs one conditional request per packument.
+        const online = pkgSpec === '.' ? [] : ['--prefer-online'];
+        console.log(colors.cyan(`> npm install -g ${[...online, pkgSpec, ...allowArgs].join(' ')}`));
+        result = await runCommandAsync('npm', ['install', '-g', ...online, pkgSpec, ...allowArgs], { cwd, silent: true });
         const combined = `${result.output}\n${result.stderr}`;
         fullLog += `===== attempt ${attempt + 1}: npm install -g ${pkgSpec} =====\n${combined}\n`;
         if (result.success) {
@@ -4076,8 +4137,19 @@ async function installGlobalWithRetry(pkgSpec, cwd, isNewPackage = false, maxRet
         const cleanupFails = (combined.match(/npm warn cleanup\s+\[Error: EPERM/g) || []).length;
         if (cleanupFails)
             console.log(colors.dim(`  (npm couldn't remove ${cleanupFails} leftover dir(s) — EPERM cleanup warnings, details in log)`));
-        for (const line of distillNpmErrors(combined))
+        const propagating = isPropagationFailure(combined, pkgSpec);
+        for (const line of distillNpmErrors(combined)) {
+            // npm's stock follow-up to ETARGET blames the request ("you or one of
+            // your dependencies are requesting a version that doesn't exist").
+            // For a version we published seconds ago that sends the reader
+            // hunting a nonexistent dependency bug — drop it and say the real
+            // thing below.
+            if (propagating && /In most cases you or one of your dependencies/.test(line))
+                continue;
             console.error(colors.red(`  ${line}`));
+        }
+        if (propagating)
+            console.error(colors.yellow(`  ↻ ${pkgSpec} not visible to npm yet — registry propagation, not a bad package.`));
         // Known-fixable failure: repair and retry immediately — the cause is
         // local, so waiting for registry propagation is pointless. Puppeteer
         // reports one corrupted browser per run, so allow a few repair rounds
@@ -4288,7 +4360,10 @@ async function waitForNpmVersionInWsl(spec, maxWaitMs = 180000) {
     const maxAttempts = Math.ceil(maxWaitMs / interval);
     process.stdout.write(`${timestamp()} Waiting for ${spec} on npm registry (WSL view)`);
     for (let i = 0; i < maxAttempts; i++) {
-        const r = await runCommandAsync('wsl', ['npm', 'view', spec, 'version'], { silent: true });
+        // 2026-09-01 10:15 EDT — Claude Code: --prefer-online for the same
+        // reason as waitForNpmVersion — WSL's npm has its own cache with the
+        // same 300s packument freshness window to poll past.
+        const r = await runCommandAsync('wsl', ['npm', 'view', '--prefer-online', spec, 'version'], { silent: true });
         if (r.success && (r.output || '').trim()) {
             process.stdout.write(' ready\n');
             return true;
@@ -4663,7 +4738,10 @@ export function getGitStatus(cwd) {
         isDetachedHead: false,
         currentBranch: '',
         remoteBranch: '',
-        isBehindRemote: false
+        isBehindRemote: false,
+        inProgressOp: '',
+        detachedFromBranch: '',
+        unmergedPaths: []
     };
     // Check if git repo — walk up the directory tree to find the enclosing
     // .git, like git itself does. Previously this only looked for `.git/` at
@@ -4680,9 +4758,42 @@ export function getGitStatus(cwd) {
         return status;
     }
     status.isRepo = true;
-    // Check for merge conflicts
+    // 2026-09-01 14:5x EDT — Claude Code (Opus 5), at Bob's direction.
+    // Detect a sequencer operation git never finished. This is the usual cause of a
+    // detached HEAD in these trees: an npmglobalize run does `git pull --rebase`, the
+    // run is interrupted, and the rebase stops after applying its patches but before
+    // moving the branch ref — so HEAD sits on a real commit that belongs to no branch.
+    // Previously getGitStatus saw only "detached" and the caller printed a lecture about
+    // checking out a tag, which is not what happened and names the wrong branch.
     const mergeHead = path.join(gitDir, 'MERGE_HEAD');
-    status.hasMergeConflict = fs.existsSync(mergeHead);
+    const rebaseMerge = path.join(gitDir, 'rebase-merge');
+    const rebaseApply = path.join(gitDir, 'rebase-apply');
+    if (fs.existsSync(rebaseMerge) || fs.existsSync(rebaseApply)) {
+        status.inProgressOp = 'rebase';
+        for (const dir of [rebaseMerge, rebaseApply]) {
+            const headName = path.join(dir, 'head-name');
+            if (!fs.existsSync(headName))
+                continue;
+            status.detachedFromBranch = fs.readFileSync(headName, 'utf-8').trim().replace(/^refs\/heads\//, '');
+            break;
+        }
+    }
+    else if (fs.existsSync(path.join(gitDir, 'CHERRY_PICK_HEAD')))
+        status.inProgressOp = 'cherry-pick';
+    else if (fs.existsSync(path.join(gitDir, 'REVERT_HEAD')))
+        status.inProgressOp = 'revert';
+    else if (fs.existsSync(mergeHead))
+        status.inProgressOp = 'merge';
+    // Unresolved conflicts — the one state where the working tree is NOT authoritative,
+    // because it still holds conflict markers rather than the content Bob wants published.
+    try {
+        const unmerged = execSync('git diff --name-only --diff-filter=U', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        status.unmergedPaths = unmerged ? unmerged.split(/\r?\n/) : [];
+    }
+    catch (error) {
+        // Ignore - repo may have no commits yet
+    }
+    status.hasMergeConflict = status.unmergedPaths.length > 0;
     // Get branch info
     try {
         const branch = execSync('git rev-parse --abbrev-ref HEAD', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
@@ -4736,6 +4847,97 @@ export function getGitStatus(cwd) {
     }
     return status;
 }
+/** One-line `abbrev "subject"` description of a commit, for messages that must name what moved */
+function describeCommit(cwd, rev) {
+    // Arg array, not a command string: the format contains a space and %s expands to a
+    // commit subject that may contain quotes.
+    const result = runCommand('git', ['log', '-1', '--format=%h %s', rev], { cwd, silent: true });
+    if (!result.success)
+        return rev;
+    const line = result.output.trim().split(/\r?\n/)[0];
+    const space = line.indexOf(' ');
+    return space < 0 ? line : `${line.slice(0, space)} "${line.slice(space + 1)}"`;
+}
+/** Which branch a detached HEAD should be reattached to */
+function pickReattachBranch(cwd, status) {
+    // The branch the unfinished rebase was rebuilding is the one that was meant to end up here.
+    if (status.detachedFromBranch)
+        return status.detachedFromBranch;
+    // Otherwise the remote's own default branch, which is what a clone would have checked out.
+    try {
+        const originHead = execSync('git symbolic-ref --short refs/remotes/origin/HEAD', { cwd, encoding: 'utf-8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        if (originHead.startsWith('origin/'))
+            return originHead.slice('origin/'.length);
+    }
+    catch (error) {
+        // No origin/HEAD — fall through
+    }
+    // Otherwise whichever conventional branch this repo actually has.
+    for (const name of ['main', 'master']) {
+        const exists = runCommand('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${name}`], { cwd, silent: true }).success
+            || runCommand('git', ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${name}`], { cwd, silent: true }).success;
+        if (exists)
+            return name;
+    }
+    return 'master';
+}
+/**
+ * 2026-09-01 14:5x EDT — Claude Code (Opus 5), at Bob's direction.
+ * Reattach a detached HEAD to its branch instead of printing a menu of git commands.
+ *
+ * Bob: "The local directory is authoritative so I want legacy mismatches just cleaned up."
+ * The working tree and the commit HEAD points at are what he wants published; a branch ref
+ * left behind by an interrupted run is bookkeeping, not content. So: drop the unfinished
+ * sequencer state, move the branch to this commit, and say exactly what moved and how to
+ * get the old tip back. The commit the branch moved off of stays in the reflog, and the
+ * message names it, so nothing is silently lost.
+ *
+ * Refuses only when the tree still has unresolved conflict markers — the one case where the
+ * working tree is not what Bob means by authoritative.
+ */
+async function reattachDetachedHead(cwd, status, dryRun) {
+    const branch = pickReattachBranch(cwd, status);
+    const head = describeCommit(cwd, 'HEAD');
+    const opLabel = status.inProgressOp ? `an unfinished ${status.inProgressOp}` : 'a checkout of a bare commit';
+    console.log('');
+    console.log(colors.yellow(`⚠ HEAD is not on a branch — left by ${opLabel}, at ${head}`));
+    let oldTip = '';
+    if (runCommand('git', ['rev-parse', '--verify', '--quiet', `refs/heads/${branch}`], { cwd, silent: true }).success) {
+        const isAncestor = runCommand('git', ['merge-base', '--is-ancestor', branch, 'HEAD'], { cwd, silent: true }).success;
+        if (!isAncestor)
+            oldTip = describeCommit(cwd, branch);
+    }
+    if (dryRun) {
+        console.log(colors.dim(`  [dry-run] Would clear the ${status.inProgressOp || 'detached'} state and move branch ${branch} to ${head}`));
+        if (oldTip)
+            console.log(colors.dim(`  [dry-run] Branch ${branch} currently points at ${oldTip}, which is not in this history`));
+        return true;
+    }
+    if (status.inProgressOp && status.inProgressOp !== 'merge') {
+        // --quit drops the sequencer bookkeeping and leaves HEAD and the working tree alone,
+        // unlike --abort, which would throw away the commits the interrupted run produced.
+        const quit = await runCommandAsync('git', [status.inProgressOp === 'rebase' ? 'rebase' : status.inProgressOp, '--quit'], { cwd, silent: true });
+        if (!quit.success) {
+            console.error(colors.red(`✗ Could not clear the unfinished ${status.inProgressOp}: ${quit.stderr.trim()}`));
+            return false;
+        }
+        console.log(`  Cleared the unfinished ${status.inProgressOp} (its commits are kept)`);
+    }
+    const checkout = await runCommandAsync('git', ['checkout', '-B', branch], { cwd, silent: true });
+    if (!checkout.success) {
+        console.error(colors.red(`✗ Could not move branch ${branch} to ${head}: ${checkout.stderr.trim()}`));
+        return false;
+    }
+    console.log(colors.green(`✓ On branch ${branch} at ${head}`));
+    if (oldTip) {
+        console.log(`  Branch ${branch} previously pointed at ${oldTip}, which is not in this history.`);
+        console.log(colors.dim(`  To put ${branch} back there: git reset --hard ${oldTip.split(' ')[0]}`));
+    }
+    if (runCommand('git', ['rev-parse', '--verify', '--quiet', `refs/remotes/origin/${branch}`], { cwd, silent: true }).success)
+        runCommand('git', ['branch', `--set-upstream-to=origin/${branch}`, branch], { cwd, silent: true });
+    console.log('');
+    return true;
+}
 /** Validate package.json for release */
 export function validatePackageJson(pkg) {
     const errors = [];
@@ -5816,7 +6018,9 @@ async function doLocalInstall(cwd, options) {
             console.log('  [dry-run] Would run: wsl npm install -g .');
         return true;
     }
-    const result = await runCommandAsync('npm', ['install', '-g', '.', ...allowOwnScriptsArgs(cwd)], { cwd, silent: false, showCommand: true });
+    // 2026-09-01 10:55 EDT — Claude Code: see the note on the sibling local-install
+    // path — captured, distilled output instead of raw npm chatter.
+    const result = await installGlobalWithRetry('.', cwd, false, 1);
     if (result.success) {
         console.log(colors.green(`✓ Installed locally: ${pkgName}@${pkgVersion}`));
     }
@@ -5932,7 +6136,16 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                 console.log('  [dry-run] Would run: wsl npm install -g .');
             return true;
         }
-        const result = await runCommandAsync('npm', ['install', '-g', '.', ...allowOwnScriptsArgs(cwd)], { cwd, silent: false, showCommand: true });
+        // 2026-09-01 10:55 EDT — Claude Code (Opus 5), at Bob's direction. Was a
+        // raw streamed `npm install -g .`, so the terminal got npm's chatter
+        // verbatim — including `npm warn allow-scripts .npmrc allow-scripts
+        // setting is being ignored because --allow-scripts was passed`, a
+        // warning npmglobalize provokes on itself by passing that flag, and
+        // which no reader can act on. installGlobalWithRetry captures the
+        // output and prints only what matters (the added/changed/removed line,
+        // or distilled errors plus a log file), which is what every other
+        // install path here already does.
+        const result = await installGlobalWithRetry('.', cwd, false, 1);
         if (result.success) {
             console.log(colors.green(`✓ Installed locally: ${pkgName}@${pkgVersion}`));
         }
@@ -6285,70 +6498,37 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
     let currentGitStatus = getGitStatus(cwd);
     // Validate git state
     if (currentGitStatus.hasMergeConflict) {
-        console.error(colors.red('ERROR: Merge conflict detected. Resolve before releasing.'));
+        console.error(colors.red(`ERROR: ${currentGitStatus.unmergedPaths.length} file(s) still have unresolved conflicts. Resolve before releasing:`));
+        for (const file of currentGitStatus.unmergedPaths)
+            console.error(`  ${file}`);
         return false;
     }
-    if (currentGitStatus.isDetachedHead && !force) {
-        if (conform && !noPublish) {
-            // Conform already happened earlier, just exit gracefully
-            console.log('');
-            console.log(colors.green('✓ Files have been updated successfully!'));
-            console.log('  • .gitignore updated');
-            console.log('  • .npmignore updated');
-            console.log('  • .gitattributes created/updated (LF line endings)');
-            console.log('  • Git configured: core.autocrlf=false, core.eol=lf');
-            console.log('');
-            console.log(colors.yellow('ℹ What is "Detached HEAD"?'));
-            console.log('  Your git repository is not on a branch (master, main, etc.)');
-            console.log('  This happens after checking out a specific commit or tag.');
-            console.log('  Publishing requires being on a branch so git can track changes.');
-            console.log('');
-            console.log(colors.yellow('✓ Good news: Your files are already fixed!'));
-            console.log(colors.yellow('  You don\'t need to run --conform again.'));
-            console.log('');
-            console.log(colors.yellow('To publish, merge back to your branch:'));
-            console.log('  git checkout -B master    \x1b[2m# moves master to current commit\x1b[0m');
-            console.log('  npmglobalize              \x1b[2m# will now work normally\x1b[0m');
-            console.log('');
-            console.log(colors.yellow('Or if you haven\'t made commits yet:'));
-            console.log('  git checkout master       \x1b[2m# just switch back\x1b[0m');
-            console.log('');
-            return true; // Success - conform was completed
+    // 2026-09-01 14:5x EDT — Claude Code (Opus 5), at Bob's direction.
+    // A detached HEAD used to be a hard stop with a menu of git commands to type — and the
+    // commands named "master" whether or not the repo had one. It is a bookkeeping mismatch,
+    // not a content problem: the working tree is authoritative, so repair it and carry on.
+    if (currentGitStatus.isDetachedHead) {
+        if (!await reattachDetachedHead(cwd, currentGitStatus, dryRun))
+            return false;
+        currentGitStatus = getGitStatus(cwd);
+    }
+    // Reaching this means HEAD is still off a branch after the reattach above. A dry run
+    // changes nothing by design, so it lands here and is expected; anything else is a real
+    // failure and the reattach already printed why.
+    if (currentGitStatus.isDetachedHead && !dryRun) {
+        if (noPublish) {
+            console.log(colors.yellow('Note: HEAD is not on a branch (this run does not publish)'));
         }
-        else if (noPublish) {
-            // Just doing non-publish operations, detached HEAD is fine
-            console.log(colors.yellow('Note: Detached HEAD state (no publishing will occur)'));
+        else if (force) {
+            console.log(colors.yellow('⚠ Publishing with HEAD off a branch (-force): the version tag and commits'));
+            console.log(colors.yellow('  will not be reachable from any branch, so git push will not carry them.'));
         }
         else {
-            console.log('');
-            console.error(colors.red('ERROR: Cannot publish from Detached HEAD state'));
-            console.log('');
-            console.log(colors.yellow('ℹ What is "Detached HEAD"?'));
-            console.log('  Your git repository is not on a branch (master, main, etc.)');
-            console.log('  This happens after checking out a specific commit or tag.');
-            console.log('  Publishing requires being on a branch so git can track changes.');
-            console.log('');
-            console.log(colors.yellow('To fix this (if you have commits to keep):'));
-            console.log('  git checkout -B master    \x1b[2m# moves master branch to current commit\x1b[0m');
-            console.log('  npmglobalize              \x1b[2m# will now work\x1b[0m');
-            console.log('');
-            console.log(colors.yellow('Or if you haven\'t made commits (safe to discard):'));
-            console.log('  git checkout master       \x1b[2m# just switch back to branch\x1b[0m');
-            console.log('  npmglobalize              \x1b[2m# will now work\x1b[0m');
-            console.log('');
-            console.log(colors.yellow('Or force publish anyway (risky):'));
-            console.log('  npmglobalize --force      \x1b[2m# proceeds despite detached HEAD\x1b[0m');
-            console.log('');
+            console.error(colors.red('ERROR: HEAD is still not on a branch, so there is nothing for git push to advance.'));
+            console.error(`  Put a branch on the current commit and rerun: git checkout -B ${pickReattachBranch(cwd, currentGitStatus)}`);
             return false;
         }
     }
-    if (currentGitStatus.isDetachedHead && force) {
-        console.log('');
-        console.log(colors.yellow('⚠ Warning: Publishing from Detached HEAD state (--force)'));
-        console.log('  This means you\'re not on a branch. The published commits may be');
-        console.log('  hard to track. Consider: git checkout master && git merge HEAD');
-        console.log('');
-    }
     // Check if local branch is behind remote
     if (currentGitStatus.isBehindRemote && !dryRun) {
         console.log(colors.yellow('Local branch is behind remote.'));
@@ -7243,8 +7423,15 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                                         console.error(colors.yellow(`  Run 'npm login' to fix, then: npm install -g ${pkgName}@${pkgVersion}`));
                                     }
                                     else {
-                                        console.error(colors.red(`✗ Global install failed`));
-                                        console.error(colors.yellow(`  Try running manually: npm install -g ${pkgName}@${pkgVersion}`));
+                                        const spec = `${pkgName}@${pkgVersion}`;
+                                        if (isPropagationFailure(`${registryInstallResult.output}\n${registryInstallResult.stderr}`, spec)) {
+                                            for (const line of propagationHelp(spec))
+                                                console.error(colors.yellow(`  ${line}`));
+                                        }
+                                        else {
+                                            console.error(colors.red(`✗ Global install failed`));
+                                            console.error(colors.yellow(`  Try running manually: npm install -g --prefer-online ${spec}`));
+                                        }
                                     }
                                 }
                             }
@@ -8088,9 +8275,17 @@ export async function globalize(cwd, options = {}, configOptions = {}) {
                             recordBuildIssue(pkgName, 'warning', `Global install failed (${auth.error || 'auth issue'}) — run 'npm login'`);
                         }
                         else {
-                            console.error(colors.red(`✗ Global install failed`));
-                            console.error(colors.yellow(`  Try running manually: npm install -g ${pkgName}@${pkgVersion}`));
-                            recordBuildIssue(pkgName, 'warning', 'Global install failed');
+                            const spec = `${pkgName}@${pkgVersion}`;
+                            if (isPropagationFailure(`${installResult.output}\n${installResult.stderr}`, spec)) {
+                                for (const line of propagationHelp(spec))
+                                    console.error(colors.yellow(`  ${line}`));
+                                recordBuildIssue(pkgName, 'warning', `Published, but npm could not see ${spec} yet — install with: npm install -g --prefer-online ${spec}`);
+                            }
+                            else {
+                                console.error(colors.red(`✗ Global install failed`));
+                                console.error(colors.yellow(`  Try running manually: npm install -g --prefer-online ${spec}`));
+                                recordBuildIssue(pkgName, 'warning', 'Global install failed');
+                            }
                         }
                     }
                 }

package/package.json

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