@steve31415/baselib 3.36.0 → 3.36.2

package/dist/deploy/deploy.js

@@ -15,6 +15,20 @@ import { acquireLock, clearHold, publishRetainedAssets, readHold, readReleaseRec
 import { consistentBaseSha, readServingState, SHA40 } from './plan.js';
 const RELEASE_DEADLINE_MS = 25 * 60_000;
 const IMAGE_DIGEST = /@sha256:[0-9a-f]{64}$/;
+const MAX_DIRTY_PATHS = 20;
+/** The clean-worktree refusal, naming what made the tree dirty (`git status
+ * --porcelain` lines) so the reader need not go and look (2026-10-11: games'
+ * deploy checkout held untracked Cloudflare-era build outputs). */
+function dirtyWorktreeMessage(porcelain) {
+    const lines = porcelain.split('\n').filter((l) => l.trim() !== '');
+    const shown = lines.slice(0, MAX_DIRTY_PATHS);
+    const more = lines.length - shown.length;
+    return [
+        'deploys require a clean worktree; uncommitted or untracked files:',
+        ...shown.map((l) => `  ${l}`),
+        ...(more > 0 ? [`  … and ${more} more`] : []),
+    ].join('\n');
+}
 export async function runDeploy(options) {
     const log = options.log ?? ((m) => console.error(`[pw-deploy] ${m}`));
     const runner = options.runner;
@@ -37,9 +51,9 @@ export async function runDeploy(options) {
             throw new Error('deploys run from main');
         const dirty = (await must(runner, 'git', ['status', '--porcelain=v1', '--untracked-files=all'], {
             cwd: options.repoRoot,
-        })).stdout.trim();
-        if (dirty)
-            throw new Error('deploys require a clean worktree');
+        })).stdout;
+        if (dirty.trim())
+            throw new Error(dirtyWorktreeMessage(dirty));
         const sha = (await must(runner, 'git', ['rev-parse', 'HEAD'], { cwd: options.repoRoot })).stdout.trim();
         const originMain = (await must(runner, 'git', ['rev-parse', 'origin/main'], { cwd: options.repoRoot })).stdout.trim();
         if (sha !== originMain)

package/dist/test-owners.js

@@ -9,32 +9,65 @@
 //
 // Scope is `.ts` only; `.tsx` is out of scope by decision (docs/TESTING.md,
 // "The src -> test mapping"). `.d.ts` files are declarations, not modules.
+//
+// Files git ignores are not part of the repo and are skipped in both
+// directions. A long-lived deploy checkout can hold leftovers of a build step
+// that no longer exists — games' clone kept a generated `src/build-version.ts`
+// from 2026-07-15, gitignored once its generator was deleted, and verify
+// failed on it in every deploy while passing in every fresh worktree
+// (2026-10-12, Coder task 37e13f8e). Untracked files that are NOT ignored still
+// count, so a new module is checked before its first `git add`. Outside a git
+// work tree (or without git) nothing is filtered.
+import { execFile } from 'node:child_process';
 import { readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 const MODULE_EXT = '.ts';
 const TEST_EXT = '.test.ts';
-/** Files under `dir` (recursively) ending in `ext`, as paths relative to
- *  `dir` with forward slashes. A missing directory yields no files. */
-async function listFiles(dir, ext) {
+/** The subset of `paths` (relative to `root`) that git ignores. Tracked
+ *  files are never reported, even when a pattern matches them. Empty when
+ *  `root` is not in a git work tree or git is unavailable. */
+function gitIgnored(root, paths) {
+    if (paths.length === 0)
+        return Promise.resolve(new Set());
+    return new Promise((resolve, reject) => {
+        const child = execFile('git', ['check-ignore', '-z', '--stdin'], { cwd: root, maxBuffer: 64 * 1024 * 1024 }, (err, stdout) => {
+            // Exit 1 means "none ignored"; 128 (not a repo) or a missing git
+            // binary means there is nothing to filter against.
+            const code = err?.code;
+            if (err && code !== 1 && code !== 128 && code !== 'ENOENT') {
+                reject(err);
+                return;
+            }
+            resolve(new Set(err ? [] : stdout.split('\0').filter((p) => p !== '')));
+        });
+        child.stdin?.on('error', () => { }); // git exited before reading: the callback reports it
+        child.stdin?.end(paths.join('\0') + '\0');
+    });
+}
+/** Files under `root/dir` (recursively) ending in `ext` and not ignored by
+ *  git, as paths relative to `dir` with forward slashes. A missing directory
+ *  yields no files. */
+async function listFiles(root, dir, ext) {
     let entries;
     try {
-        entries = await readdir(dir, { recursive: true });
+        entries = await readdir(join(root, dir), { recursive: true });
     }
     catch (err) {
         if (err.code === 'ENOENT')
             return [];
         throw err;
     }
-    return entries
+    const files = entries
         .map((e) => e.split('\\').join('/'))
-        .filter((e) => e.endsWith(ext) && !e.endsWith('.d.ts'))
-        .sort();
+        .filter((e) => e.endsWith(ext) && !e.endsWith('.d.ts'));
+    const ignored = await gitIgnored(root, files.map((f) => `${dir}/${f}`));
+    return files.filter((f) => !ignored.has(`${dir}/${f}`)).sort();
 }
 export async function checkTestOwners(opts) {
     const srcDir = opts.srcDir ?? 'src';
     const testDir = opts.testDir ?? 'test';
-    const modules = (await listFiles(join(opts.root, srcDir), MODULE_EXT)).filter((m) => !m.endsWith(TEST_EXT));
-    const tests = new Set(await listFiles(join(opts.root, testDir), TEST_EXT));
+    const modules = (await listFiles(opts.root, srcDir, MODULE_EXT)).filter((m) => !m.endsWith(TEST_EXT));
+    const tests = new Set(await listFiles(opts.root, testDir, TEST_EXT));
     const missing = [];
     for (const mod of modules) {
         const expected = `${mod.slice(0, -MODULE_EXT.length)}${TEST_EXT}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.36.0",
+  "version": "3.36.2",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",