@maka/meteor-sdk 0.2.8 → 0.2.10

package/isopackets/combined/npm/node_modules/meteor/modules/node_modules/.package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "package-new-6gguidiwzx",
+  "name": "package-new-17en99ibbmv",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/isopackets/combined/npm/node_modules/meteor/modules-runtime/node_modules/.package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "package-new-ovtntj9ibd",
+  "name": "package-new-1cp3re039w9",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/isopackets/combined/npm/node_modules/meteor/npm-mongo/node_modules/.package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "package-new-t8jk4dq32z",
+  "name": "package-new-1wkg0541fwq",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/isopackets/combined/npm/node_modules/meteor/package-version-parser/node_modules/.package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "package-new-1t8h3r5p5mc",
+  "name": "package-new-b5a9l27ykfp",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/isopackets/combined/npm/node_modules/meteor/promise/node_modules/.package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "package-new-19ro17vxabi",
+  "name": "package-new-1f74r589ogwk",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/isopackets/combined/npm/node_modules/meteor/react-fast-refresh/node_modules/.package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "package-new-1mbjo8u1bdw",
+  "name": "package-new-1v9u2tnhfn",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/isopackets/combined/npm/node_modules/meteor/socket-stream-client/node_modules/.package-lock.json

@@ -1,5 +1,5 @@
 {
-  "name": "package-new-1bskl16cqu8",
+  "name": "package-new-lsdjl8inhw",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@maka/meteor-sdk",
-  "version": "0.2.8",
+  "version": "0.2.10",
   "description": "Programmatic Node API over the Meteor build tool (bundle/run/create/etc.) -- for driving Meteor's build system from plain Node code instead of shelling out to a meteor CLI (there isn't one anymore; see README.md). \"dependencies\" is generated by scripts/write-tool-package-json.js from scripts/dev-bundle-tool-package.js at the monorepo root -- do not hand-edit that field, edit that file and re-run the script instead.",
   "main": "src/index.js",
   "exports": {

package/src/project.js

@@ -65,6 +65,19 @@ async function loadProject(projectDir) {
     projectDir: standardProjectDir,
   });
 
+  // Second-stage npm-deps prewarm (bootstrap.js fired the restore-only
+  // first stage): now that an app is known, its .meteor/versions names
+  // the exact core-package set the build will need, so cache MISSES can
+  // be npm-installed too -- in parallel (small pool; concurrent npm
+  // processes contend on npm's shared content cache) and BEFORE the
+  // build's serial per-package walk, which also keeps those installs'
+  // .npm churn from re-firing the app runner's file watcher mid-build.
+  // Un-awaited: every prewarm operation holds the same cross-process
+  // per-package lock updateDependencies() takes, so the build below
+  // simply waits on (or wins) each package's lock. Best-effort by
+  // design -- on any failure the build installs serially as before.
+  startAppNpmDepsPrewarm(standardProjectDir);
+
   await runCaptured("preparing project", () =>
     projectContext.prepareProjectForBuild()
   );
@@ -72,4 +85,31 @@ async function loadProject(projectDir) {
   return new Project(projectContext);
 }
 
+function startAppNpmDepsPrewarm(standardProjectDir) {
+  try {
+    const files = require("../tools/fs/files");
+    const versionsFile = files.pathJoin(
+      standardProjectDir, ".meteor", "versions");
+    // name@version lines; author:package names never match the bundled
+    // core-package directory names, so no special-casing needed. A
+    // missing versions file (brand-new app) just skips this stage.
+    const names = files.readFile(versionsFile, "utf8")
+      .split("\n")
+      .map((line) => line.trim().split("@")[0])
+      .filter(Boolean);
+    if (!names.length) {
+      return;
+    }
+    const meteorNpm = require("../tools/isobuild/meteor-npm.js");
+    Promise.resolve(
+      meteorNpm.prewarmNpmDepsCache(
+        path.resolve(__dirname, "..", "packages"),
+        { onlyPackages: names, installOnMiss: true }
+      )
+    ).catch(() => {});
+  } catch (e) {
+    // Best-effort: the build's own per-package install path still works.
+  }
+}
+
 module.exports = { loadProject, Project };

package/tools/fs/optimistic.ts

@@ -85,9 +85,40 @@ function makeOptimistic<
 // subscribing to file changes.
 const optimisticFindAppDir = wrap(findAppDir);
 
+// The running tool's own installation root (tools/fs/optimistic.ts ->
+// two levels up). When the tool is installed as an npm package (e.g.
+// @maka/meteor-sdk under a global node_modules), every file it owns
+// lives beneath one or more node_modules segments, which made the
+// nested-node_modules rule below refuse to watch ANY tool file. With no
+// watcher, an optimistic result cached while a package's .npm directory
+// was being atomically swapped (renameDirAlmostAtomically's brief gap
+// during npm dependency updates) could never be invalidated -- observed
+// as optimisticHashOrNull permanently returning null for an existing
+// npm-shrinkwrap.json, convincing every isopack up-to-date check and
+// the app runner's watchset that a build input was deleted: an eternal
+// rebuild/restart loop ("flapping") after a fresh install. A git
+// checkout has no node_modules prefix and always watched these files;
+// ignoring node_modules segments inside the tool's own prefix restores
+// exactly those semantics.
+const toolRootParts = pathDirname(pathDirname(__dirname))
+  .split("\\").join(pathSep)
+  .split(pathSep);
+
+function toolRootPrefixLength(parts: string[]): number {
+  if (parts.length <= toolRootParts.length) {
+    return 0;
+  }
+  for (let i = 0; i < toolRootParts.length; i++) {
+    if (parts[i] !== toolRootParts[i]) {
+      return 0;
+    }
+  }
+  return toolRootParts.length;
+}
+
 const shouldWatch = wrap(Profile("shouldWatch", (path: string) => {
   const parts = path.split(pathSep);
-  const nmi = parts.indexOf("node_modules");
+  const nmi = parts.indexOf("node_modules", toolRootPrefixLength(parts));
 
   if (nmi < 0) {
     // Watch everything not in a node_modules directory.
@@ -204,6 +235,36 @@ function dependOnParentDirectory(path: string) {
   }
 }
 
+// For files belonging to the running tool itself, never let a negative
+// (missing-file) result stick: these paths only ever go missing during
+// meteor-npm.js's atomic .npm directory swaps, and every event- or
+// dirty-based invalidation can be raced by a computation that STARTED
+// before the swap and commits its cached null after them (the
+// dirtyReplacedDirectory call included). A null that survives such a
+// race convinced every rebuild that npm-shrinkwrap.json was deleted --
+// the eternal restart loop. Self-dirtying on the next tick makes the
+// null last at most one turn of the event loop; the recompute then sees
+// the real post-swap file. Genuinely missing tool files are rare enough
+// that losing negative-caching for them costs nothing measurable.
+function scheduleEphemeralNull(
+  wrapper: { dirty: (...args: any[]) => any },
+  args: IArguments | any[],
+) {
+  const path = args[0];
+  if (typeof path !== "string") {
+    return;
+  }
+  if (toolRootPrefixLength(path.split(pathSep)) === 0) {
+    return;
+  }
+  const argArray = Array.prototype.slice.call(args);
+  setImmediate(() => {
+    try {
+      wrapper.dirty(...argArray);
+    } catch (e) {}
+  });
+}
+
 // Called by any optimistic function that receives a */node_modules/* path
 // as its first argument, so that we can later bulk-invalidate the results
 // of those calls if the contents of the node_modules directory change.
@@ -255,6 +316,7 @@ export const optimisticStatOrNull = makeCheapPathFunction(
     const result = statOrNull(path);
     if (result === null) {
       dependOnParentDirectory(path);
+      scheduleEphemeralNull(optimisticStatOrNull, [path]);
     }
     return result;
   },
@@ -268,6 +330,8 @@ export const optimisticLStatOrNull = makeCheapPathFunction(
     } catch (e: any) {
       if (e.code !== "ENOENT") throw e;
       dependOnParentDirectory(path);
+      scheduleEphemeralNull(optimisticLStatOrNull, [path]);
+      scheduleEphemeralNull(optimisticLStat, [path]);
       return null;
     }
   },
@@ -290,6 +354,10 @@ export const optimisticHashOrNull = makeOptimistic("hashOrNull", (
   }
 
   dependOnParentDirectory(path);
+  scheduleEphemeralNull(
+    optimisticHashOrNull, options === undefined ? [path] : [path, options]);
+  scheduleEphemeralNull(
+    optimisticReadFile, options === undefined ? [path] : [path, options]);
 
   return null;
 });
@@ -312,6 +380,12 @@ makeOptimistic("readJsonOrNull", (
   } catch (e: any) {
     if (e.code === "ENOENT") {
       dependOnParentDirectory(path);
+      scheduleEphemeralNull(
+        optimisticReadJsonOrNull,
+        options === undefined ? [path] : [path, options]);
+      scheduleEphemeralNull(
+        optimisticReadFile,
+        options === undefined ? [path] : [path, options]);
       return null;
     }
     throw e;
@@ -338,6 +412,37 @@ makeOptimistic("readJsonOrNull", (
   }
 });
 
+// Deterministically forget cached results for a directory that was
+// just replaced wholesale (meteor-npm.js's atomic .npm swap via
+// renameDirAlmostAtomically). Watcher-event-driven invalidation cannot
+// be relied on for such swaps: the events arrive only for the
+// directory's own path (see safe-watcher's fireEntriesUnder), can race
+// the read that cached the stale result, and in npm-installed tool
+// trees per-file watches historically never existed at all (see
+// toolRootPrefixLength above). A stale null cached here convinced
+// every rebuild that npm-shrinkwrap.json was deleted -- an eternal
+// rebuild/restart loop after fresh installs. An explicit dirty at the
+// mutation site is the only race-free invalidation. Dirties the
+// directory, its parent, and its current immediate children across
+// every per-path optimistic function.
+export function dirtyReplacedDirectory(dir: string) {
+  const paths = [dir, pathDirname(dir)];
+  try {
+    readdir(dir).forEach(name => paths.push(pathJoin(dir, name)));
+  } catch (e) {}
+  paths.forEach(path => {
+    optimisticStatOrNull.dirty(path);
+    optimisticLStat.dirty(path);
+    optimisticLStatOrNull.dirty(path);
+    optimisticReadFile.dirty(path);
+    optimisticReaddir.dirty(path);
+    optimisticHashOrNull.dirty(path);
+    optimisticReadJsonOrNull.dirty(path);
+    dependOnDirectory.dirty(path);
+    dependOnPath.dirty(path);
+  });
+}
+
 export const optimisticReadMeteorIgnore = wrap((dir: string) => {
   const meteorIgnorePath = pathJoin(dir, ".meteorignore");
   const meteorIgnoreStat = optimisticStatOrNull(meteorIgnorePath);

package/tools/fs/safe-watcher.ts

@@ -93,6 +93,25 @@ function deleteEntry(path: string): void {
   entries.delete(path);
 }
 
+// A rename or removal of a DIRECTORY reaches us as a single event for
+// the directory's own path; entries registered for files INSIDE it
+// (e.g. the optimistic layer's per-file watches under a package's .npm
+// directory, which meteor-npm.js swaps wholesale via
+// renameDirAlmostAtomically) would otherwise never hear about it --
+// findNearestEntry only walks UP. Observed failure: an
+// optimisticHashOrNull result cached as null during the swap was never
+// invalidated, convincing every rebuild a build input was deleted (an
+// eternal rebuild/restart loop after fresh installs). Fire every
+// registered descendant of the changed path too.
+function fireEntriesUnder(changedPath: string, evtType: string): void {
+  const prefix = pathResolve(changedPath) + "/";
+  for (const [entryPath, entry] of entries) {
+    if (entry && entryPath.startsWith(prefix)) {
+      entry._fire(evtType);
+    }
+  }
+}
+
 function findNearestEntry(startPath: string): Entry | null {
   let currentPath = pathResolve(startPath);
 
@@ -353,6 +372,27 @@ async function ensureWatchRoot(dirPath: string): Promise<void> {
           for (const event of events) {
             const changedPath = toPosixPath(event.path);
             const entry = findNearestEntry(changedPath);
+            // Deletes/creates can be directory renames whose contents
+            // never get their own events -- notify entries BELOW the
+            // path as well (see fireEntriesUnder).
+            if (event.type !== "update") {
+              fireEntriesUnder(
+                changedPath, event.type === "delete" ? "delete" : "change");
+            }
+            if (process.env.METEOR_WATCH_DEBUG) {
+              // Re-derive the matched registration so flap debugging can
+              // see WHICH registered path a deep event was attributed to.
+              let cursor = pathResolve(changedPath);
+              let matched = null;
+              while (true) {
+                if (getEntry(cursor)) { matched = cursor; break; }
+                const parent = pathDirname(cursor);
+                if (parent === cursor) break;
+                cursor = parent;
+              }
+              console.log("WATCH-FIRE", event.type, changedPath,
+                "->", matched || "(no entry)");
+            }
             if (!entry) continue;
             // In Meteor's safe-watcher API, both create/update trigger "change" events.
             const evtType = event.type === "delete" ? "delete" : "change";

package/tools/fs/watch.ts

@@ -123,6 +123,14 @@ export class WatchSet {
         return;
       }
       // Nope, inconsistent.
+      if (process.env.METEOR_WATCH_DEBUG) {
+        // The file changed DURING the build (recorded twice with
+        // different hashes). Every Watcher built on this set now fires
+        // immediately -- flap debugging needs the culprit's name.
+        console.log("WATCHSET-CONFLICT", filePath,
+          "recorded", this.files[filePath], "now", hash, "at",
+          new Error("watchset-conflict").stack);
+      }
       this.alwaysFire = true;
       return;
     }
@@ -448,6 +456,10 @@ export class Watcher {
 
     // Were we given an inconsistent WatchSet? Fire now and be done with it.
     if (this.watchSet.alwaysFire) {
+      if (process.env.METEOR_WATCH_DEBUG) {
+        console.log("WATCHER-ALWAYSFIRE: inconsistent watchSet -- " +
+          "restarting immediately (see WATCHSET-CONFLICT above)");
+      }
       this.fire();
       return;
     }
@@ -481,12 +493,18 @@ export class Watcher {
         return false;
       }
       // Nope, not what we expected.
+      if (process.env.METEOR_WATCH_DEBUG) {
+        console.log("WATCH-CHANGED-FILE (deleted/now-dir)", absPath);
+      }
       this.fire();
       return true;
     }
 
     // File exists! Is that what we expected?
     if (oldHash === null) {
+      if (process.env.METEOR_WATCH_DEBUG) {
+        console.log("WATCH-CHANGED-FILE (appeared)", absPath);
+      }
       this.fire();
       return true;
     }
@@ -496,6 +514,9 @@ export class Watcher {
       return false;
     }
 
+    if (process.env.METEOR_WATCH_DEBUG) {
+      console.log("WATCH-CHANGED-FILE", absPath, oldHash, "->", newHash);
+    }
     this.fire();
     return true;
   }
@@ -513,6 +534,11 @@ export class Watcher {
 
       // If the directory has changed (including being deleted or created).
       if (! _.isEqual(info.contents, newContents)) {
+        if (process.env.METEOR_WATCH_DEBUG) {
+          console.log("WATCH-CHANGED-DIR", info.absPath,
+            "expected", JSON.stringify(info.contents),
+            "found", JSON.stringify(newContents));
+        }
         this.fire();
         return true;
       }
@@ -678,6 +704,11 @@ export class Watcher {
     let stat = files.statOrNull(absPath);
     const mustNotExist = this.mustNotExist(absPath);
     const mustBeAFile = this.mustBeAFile(absPath);
+    if (process.env.METEOR_WATCH_DEBUG) {
+      // Tag the path before any of the fires below so the adjacent
+      // WATCH-FIRE-STACK line can be attributed to a file.
+      (this as any)._debugLastStatPath = absPath;
+    }
 
     if (stat && lastStat === undefined) {
       // We have not checked for this file before, so our expectations are
@@ -787,6 +818,14 @@ export class Watcher {
 
   private fire() {
     if (this.stopped) return;
+    if (process.env.METEOR_WATCH_DEBUG) {
+      // The chokepoint every restart-triggering change funnels through;
+      // the stack identifies WHICH check fired when the per-site logs
+      // (WATCH-CHANGED-*, WATCHSET-CONFLICT) didn't catch it.
+      console.log("WATCH-FIRE-STACK",
+        "lastStatPath=" + ((this as any)._debugLastStatPath || "(none)"),
+        new Error("watcher-fired").stack);
+    }
     this.stop();
     this.onChange();
   }