@blamejs/core 0.18.53 → 0.18.55

package/lib/watcher.js

@@ -231,7 +231,7 @@ var AUTO_PROBE_POLL_FSTYPES = new Set([
   "vboxsf",
 ]);
 
-function _detectAutoMode(rootPath) {
+function _detectAutoMode(rootPath, probe) {
   // Sync probe — looks at the kernel's view of the mount carrying the
   // watcher's root and decides whether fs.watch will deliver events.
   // Three signals contribute, in priority order:
@@ -246,7 +246,21 @@ function _detectAutoMode(rootPath) {
   //   3. Otherwise — fs.
   //
   // Returns { mode, reason, fsType, inContainer }.
-  if (process.platform !== "linux") {
+  // Injectable so the branches that only exist on a restricted Linux can be
+  // driven from any host. A rule about what happens when mountinfo cannot be
+  // read is untestable while reaching it requires unmounting /proc.
+  var platform = (probe && probe.platform) || process.platform;
+  var readEntries = (probe && probe.readEntries) ||
+    function () { return safeMountInfo.read(); };
+  // Injected for the same reason as readEntries, and for one more: "/.dockerenv"
+  // is drive-relative on Windows, so a direct probe there asks about C:\.dockerenv
+  // rather than about being in a container. It is only reached below the
+  // non-Linux return, but reaching a POSIX path through the injected reader is
+  // what keeps that ordering from being the only thing holding it up.
+  var exists = (probe && probe.exists) ||
+    function (p) { return nodeFs.existsSync(p); };
+
+  if (platform !== "linux") {
     // macOS + Windows fs.watch backends use FSEvents + ReadDirectoryChangesW
     // respectively, which DO deliver recursive events natively for
     // operator-owned local filesystems. Containerized Linux is the
@@ -255,7 +269,7 @@ function _detectAutoMode(rootPath) {
   }
 
   var inContainer = false;
-  try { inContainer = nodeFs.existsSync("/.dockerenv"); }
+  try { inContainer = exists("/.dockerenv"); }
   catch (_e) { inContainer = false; }
 
   // Route through b.safeMountInfo — single canonical parser that
@@ -263,13 +277,23 @@ function _detectAutoMode(rootPath) {
   // mount check below. Pre-v0.11.6 this parsed inline; centralizing
   // it means future container-escape / sealed-store / sandbox call
   // sites inherit the discipline.
-  var entries = safeMountInfo.read();
+  var entries = readEntries();
+  // Not knowing which filesystem this is resolves toward polling, not toward
+  // fs.watch. On Linux mountinfo is always there, so failing to read it means
+  // /proc is unmounted or restricted — which is the containerized case this
+  // probe exists for, and the one where inotify is least likely to deliver.
+  // The two answers are not symmetric: polling costs stat calls the operator
+  // can see, while fs.watch on a filesystem that does not chain inotify drops
+  // events silently and nothing downstream can tell that it did.
   if (entries === null || entries.length === 0) {
-    return { mode: "fs", reason: "no-mountinfo", fsType: null, inContainer: inContainer };
+    return { mode: "poll", reason: "no-mountinfo", fsType: null, inContainer: inContainer };
   }
   var bestMatch = safeMountInfo.bestMatch(entries, rootPath);
   if (!bestMatch) {
-    return { mode: "fs", reason: "no-mount-match", fsType: null, inContainer: inContainer };
+    // Same reasoning: "/" matches every path on a healthy Linux, so no match
+    // means the mount table did not describe this root and its fstype is
+    // unknown rather than known-good.
+    return { mode: "poll", reason: "no-mount-match", fsType: null, inContainer: inContainer };
   }
   if (AUTO_PROBE_POLL_FSTYPES.has(bestMatch.fstype)) {
     return {
@@ -687,4 +711,5 @@ module.exports = {
   // create() enforces, instead of pinning hand-copied mirror constants.
   MAX_IGNORE_PATTERN_LEN: MAX_IGNORE_PATTERN_LEN,
   MAX_IGNORE_STAR_COUNT:  MAX_IGNORE_STAR_COUNT,
+  _detectAutoModeForTest: _detectAutoMode,
 };

package/lib/ws-client.js

@@ -361,7 +361,12 @@ class WsClient extends EventEmitter {
       allowInternal: opts.allowInternal,
       errorClass:    WsClientError,
     });
-    this._ssrfPinnedIps = probe && probe.ips ? probe.ips : null;
+    // `null` when the gate produced no pin at all, the array when it did —
+    // including an EMPTY one. An empty pin means the gate admitted no address,
+    // so there is nothing to connect to; treating it as "no pin" would hand the
+    // connect back to the ordinary resolver and re-open the rebinding window
+    // the pin exists to close.
+    this._ssrfPinnedIps = probe && Array.isArray(probe.ips) ? probe.ips : null;
     this._dialParsed    = dialParsed;
     this._dialTlsOpts   = dialTlsOpts;
   }
@@ -405,12 +410,22 @@ class WsClient extends EventEmitter {
     // private one between the check and the connect.
     var pinnedIps = self._ssrfPinnedIps || null;
     var lookup = null;
-    if (pinnedIps && pinnedIps.length > 0) {
+    if (pinnedIps) {
       lookup = function (h, lookupOpts, cb) {
         // Node's lookup callback signatures:
         //   (err, address, family) for legacy { all: false } (default)
         //   (err, addresses)        for { all: true }
         if (typeof lookupOpts === "function") { cb = lookupOpts; lookupOpts = {}; }
+        // An empty pin admits no address, so there is nothing to connect to.
+        // Answer the lookup with an error, which fails the dial through the
+        // socket's ordinary error path — reading `pinnedIps[0].address` here
+        // would throw a TypeError out of a lookup callback instead, which is a
+        // crash rather than a refusal.
+        if (pinnedIps.length === 0) {
+          var noneErr = new Error("ws.connect: the SSRF gate admitted no address for " + h);
+          noneErr.code = "ENOTFOUND";
+          return cb(noneErr);
+        }
         var first = pinnedIps[0];
         if (lookupOpts && lookupOpts.all) {
           return cb(null, pinnedIps.map(function (ip) {

package/lib/yaml-lex.js

@@ -96,7 +96,44 @@ function _isVerbatimLine(line, indent) {
   return false;
 }
 
+// maskNonStructural(text) → the mask alone, which is what most callers want.
 function maskNonStructural(text) {
+  return lexLines(text).masked;
+}
+
+// lexLines(text) → { masked, nodeStarts }.
+//
+// `nodeStarts` is a byte per source character, 1 where a NODE may begin: the
+// first content character of a key, a value, or a flow-collection item. It
+// answers the question the mask cannot, because the mask blanks a key's own text
+// along with a comment's, and a screen that deliberately reports shapes which
+// are not valid structure needs them apart.
+//
+// A byte array rather than a sparse one keyed by offset. Sparse indices this
+// large put V8's array into dictionary mode, which measured ~200 bytes for each
+// node in the document: a 1.7 MB file of short keys allocated 71 MB, a 40x
+// amplification an attacker picks by choosing the shape of the input. A byte per
+// character is 1x, flat, and known before the scan starts.
+//
+// The merge-key screen is that kind of screen. `<<:*d` with no space after the
+// colon is not a mapping entry, and is reported anyway, because a parser variant
+// may read it as a merge and that is the shape being smuggled. So its test
+// cannot be "is this well-formed structure?" — it has to be "could a node begin
+// here at all?", which is false inside a comment, a quoted body, a block
+// scalar's body, and a plain scalar's continuation line, and true for both
+// `<<: *b` and `<<:*b`.
+//
+// Enumerating those regions instead was tried and is the wrong shape: a first
+// version excluded block-scalar bodies and quoted bodies and still reported a
+// merge key written in a comment, on a plain scalar's continuation line, and
+// after a document marker. There are more ways to be inside literal text than
+// anyone lists from memory, and the lexer is already tracking the one property
+// that separates them.
+//
+// Both come out of ONE pass. A second function walking the same grammar is how
+// two answers to one question start disagreeing, which is the defect this
+// module was written to end.
+function lexLines(text) {
   var src = String(text == null ? "" : text);
   // Split on the newline ALONE, keeping any `\r` with the line it terminates.
   // `codepointClass.splitLines` strips it, and rejoining those with "\n" drops
@@ -106,6 +143,13 @@ function maskNonStructural(text) {
   // mask, because the locations it reports are confidently wrong.
   var lines = src.split("\n");
   var out = [];
+  var nodeStarts = new Uint8Array(src.length);
+  // The absolute offset line `li` begins at. Derived at the TOP of each
+  // iteration from the PREVIOUS line's raw length, rather than advanced at the
+  // bottom, because the loop body leaves by a dozen different `continue`s and
+  // any one of them forgetting to advance would silently shift every offset
+  // after it.
+  var lineBase = 0;
   // A block scalar's body indentation is DETECTED from its first content line,
   // which is what YAML specifies and the only thing that works. Two fixed
   // columns were tried and each failed the other's case: measuring from the
@@ -149,6 +193,7 @@ function maskNonStructural(text) {
   var plainFromDash = false;
 
   for (var li = 0; li < lines.length; li += 1) {
+    if (li > 0) lineBase += lines[li - 1].length + 1;   // + the "\n" that ended it
     var raw = lines[li];
     // The carriage return of a CRLF pair is a line TERMINATOR, not content, so
     // it is held aside and put back verbatim. Letting it into the scan would
@@ -283,6 +328,14 @@ function maskNonStructural(text) {
       var jsonKeyBefore = prevWasJsonKey;
       prevWasJsonKey = false;
 
+      // The first content character of a node position. Whitespace carries the
+      // flag rather than clearing it, so this lands on the character that
+      // actually starts the node, and a `#` here opens a comment instead — no
+      // node begins inside one.
+      if (atNodeStart && !_isPlainSpace(ch) && ch !== "#") {
+        nodeStarts[lineBase + i] = 1;
+      }
+
       // A comment opens on `#` at the start of the content or after whitespace,
       // and runs to the end of the line. Its text is not YAML, whatever it
       // says: `x: 1 # note !bang` names no tag.
@@ -478,7 +531,7 @@ function maskNonStructural(text) {
     }
     out.push(masked + (cr ? "\r" : ""));
   }
-  return out.join("\n");
+  return { masked: out.join("\n"), nodeStarts: nodeStarts };
 }
 
 // A line kept for its structure, with any comment on it masked. Used for the
@@ -530,4 +583,5 @@ function _blanked(s) {
 
 module.exports = {
   maskNonStructural: maskNonStructural,
+  lexLines:          lexLines,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@blamejs/core",
-  "version": "0.18.53",
+  "version": "0.18.55",
   "description": "The Node framework that owns its stack.",
   "license": "Apache-2.0",
   "author": "blamejs contributors",

package/sbom.cdx.json

@@ -2,10 +2,10 @@
   "$schema": "http://cyclonedx.org/schema/bom-1.5.schema.json",
   "bomFormat": "CycloneDX",
   "specVersion": "1.5",
-  "serialNumber": "urn:uuid:f52f2ee6-253b-4bf4-9915-22d453a4407a",
+  "serialNumber": "urn:uuid:e557e6e1-623d-4598-87fa-caac0c468199",
   "version": 1,
   "metadata": {
-    "timestamp": "2026-08-24T12:08:00.505Z",
+    "timestamp": "2026-08-27T07:20:33.894Z",
     "lifecycles": [
       {
         "phase": "build"
@@ -19,14 +19,14 @@
       }
     ],
     "component": {
-      "bom-ref": "@blamejs/core@0.18.53",
+      "bom-ref": "@blamejs/core@0.18.55",
       "type": "application",
       "name": "blamejs",
-      "version": "0.18.53",
+      "version": "0.18.55",
       "scope": "required",
       "author": "blamejs contributors",
       "description": "The Node framework that owns its stack.",
-      "purl": "pkg:npm/%40blamejs/core@0.18.53",
+      "purl": "pkg:npm/%40blamejs/core@0.18.55",
       "properties": [],
       "externalReferences": [
         {
@@ -54,7 +54,7 @@
   "components": [],
   "dependencies": [
     {
-      "ref": "@blamejs/core@0.18.53",
+      "ref": "@blamejs/core@0.18.55",
       "dependsOn": []
     }
   ]