omp-fabric 1.0.2 → 1.0.4

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## 1.0.4
+
+### Fixed
+
+- `omp.ls` was the one core tool that never emitted the partial-result marker, so a listing the host clamped at its entry cap looked complete to any program following the documented contract. It now carries the same marker, and its continuation is real: the host does not clamp a larger `ls` limit, so the marker offers one that returns the rest.
+
+## 1.0.3
+
+### Fixed
+
+- **Reads never paged on Windows.** The guard that decides whether a path is pageable scanned for the last colon in the whole path string, and a Windows drive designator is a colon, so `omp.read` stopped at the host's per-call line cap and reported the wrong reason for stopping. The drive root is now excluded from that scan on every platform. Windows users were getting the truncated reads that 1.0.0 set out to fix.
+- Three test files assumed a POSIX environment: a drive-letter path encoding, two bash fixtures that read `/dev/zero`, and PATH fixtures that Windows could not resolve. All three now run on both platforms with no skips.
+
 ## 1.0.2
 
 ### Fixed

package/dist/fabric-runtime-state.js

@@ -8730,6 +8730,8 @@ var countLines = (text) => {
 };
 var READ_SELECTOR_PATTERN = /:(raw:)?(\d+)(-(\d+)?)?$/i;
 var READ_RAW_SELECTOR_PATTERN = /:raw$/i;
+var WINDOWS_PATH_ROOT_PATTERN = /^(?:\\\\[?.]\\)?[A-Za-z]:(?=[\\/])/;
+var withoutWindowsRoot = (rawPath) => rawPath.slice(WINDOWS_PATH_ROOT_PATTERN.exec(rawPath)?.[0].length ?? 0);
 var readPageSelector = (target, offset) => target.endLimit === Number.POSITIVE_INFINITY ? `${target.base}:raw:${offset}-` : `${target.base}:raw:${offset}-${target.endLimit}`;
 var parseReadTarget = (rawPath) => {
   if (typeof rawPath !== "string" || rawPath.length === 0 || rawPath.includes("://")) return void 0;
@@ -8747,8 +8749,9 @@ var parseReadTarget = (rawPath) => {
       selected: true
     };
   }
-  const lastColon = rawPath.lastIndexOf(":");
-  const suffix = lastColon === -1 ? "" : rawPath.slice(lastColon + 1);
+  const body = withoutWindowsRoot(rawPath);
+  const lastColon = body.lastIndexOf(":");
+  const suffix = lastColon === -1 ? "" : body.slice(lastColon + 1);
   const pageable = suffix.length === 0;
   return { base: rawPath, start: 1, endLimit: Number.POSITIVE_INFINITY, pageable, selected: false };
 };
@@ -8868,6 +8871,19 @@ var findTruncationSignal = (details) => {
     note: `The host caps find at ${reached ?? "its result limit"} results and clamps any larger limit, so narrow pattern or path, or enumerate with omp.bash.`
   };
 };
+var lsTruncationSignal = (details) => {
+  const reached = finiteNumber2(asRecord(details)?.entryLimitReached);
+  if (reached === void 0) return void 0;
+  const next = reached * 2;
+  return {
+    tool: "ls",
+    partial: true,
+    reasons: ["entryLimit"],
+    entryLimit: reached,
+    continue: { limit: next },
+    note: `The host stopped the listing at ${reached} entries; re-run omp.ls with limit=${next} \u2014 the host does not clamp a larger ls limit \u2014 or enumerate with omp.bash.`
+  };
+};
 var resultHasTruncation = (details) => {
   if (details === null || typeof details !== "object" || Array.isArray(details)) return false;
   const meta = Reflect.get(details, "meta");
@@ -8898,7 +8914,10 @@ var normalizeResult = (name, result, artifactPaths, appendReadNewline = true, ex
     const signal = findTruncationSignal(result.details);
     return signal ? appendTruncationMarker(text, signal) : text;
   }
-  if (name === "ls") return text;
+  if (name === "ls") {
+    const signal = lsTruncationSignal(result.details);
+    return signal ? appendTruncationMarker(text, signal) : text;
+  }
   let details = result.details;
   let output = text;
   if (isOmpShellToolName(name) && details && typeof details === "object" && !Array.isArray(details)) {