@visulima/task-runner 1.0.0-alpha.7 → 1.0.0-alpha.9

package/dist/packem_shared/{TaskOrchestrator-rf45vW5c.js → TaskOrchestrator-CdRaQhTO.js}

@@ -1,9 +1,11 @@
-import { d as resolveTaskCwd, a as createFailureResult, e as createXxh3Hasher } from './utils-zO0ZRgtf.js';
+import { d as resolveTaskCwd, a as createFailureResult, e as createXxh3Hasher } from './utils-Bmnj-H2J.js';
 import { resolve, join } from '@visulima/path';
-import { FingerprintManager } from './FingerprintManager-CV7U4f4f.js';
-import { generateRunSummary, writeLastRunSummary, writeRunSummary } from './generateRunSummary-BE1jnQ3H.js';
-import { computeTaskHash } from './computeTaskHash-DYqfrDGq.js';
-import { TrackedTaskExecutor } from './TrackedTaskExecutor-CFPpQfXF.js';
+import { retrieveByTaskHash, storeByTaskHash } from './actionDigestForTaskHash-BRE-9MT6.js';
+import { FingerprintManager } from './FingerprintManager-78DjwWQ4.js';
+import { generateRunSummary, writeLastRunSummary, writeRunSummary } from './generateRunSummary-Bah7CFay.js';
+import { computeTaskHash } from './computeTaskHash-DHoBJ_-V.js';
+import { TrackedTaskExecutor } from './TrackedTaskExecutor-CWSMfHAW.js';
+import { getCurrentBranch, evaluateWhen, explainWhen } from './getCurrentBranch-DVNikt0P.js';
 
 const hashFingerprint = (fingerprint) => {
   const hash = createXxh3Hasher();
@@ -25,6 +27,20 @@ const hashFingerprint = (fingerprint) => {
   }
   return hash.digest();
 };
+const detectWarnings = (patterns, output) => {
+  if (!patterns || patterns.length === 0 || !output) {
+    return false;
+  }
+  for (const source of patterns) {
+    try {
+      if (new RegExp(source).test(output)) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+};
 const createDeferred = () => {
   let resolve2;
   const promise = new Promise((r) => {
@@ -49,11 +65,14 @@ class TaskOrchestrator {
   #cacheDiagnostics;
   #resolveCommand;
   #remoteCache;
+  #onRemoteUploadError;
   #dryRun;
   #summarize;
   #taskGraph;
   #results = /* @__PURE__ */ new Map();
   #startTime;
+  #alwaysTasks;
+  #whenContext;
   /** Tracks in-flight task promises so the execution loop can await them */
   #inFlightTasks = /* @__PURE__ */ new Map();
   /** Deferred that gets resolved whenever a task completes, waking the loop */
@@ -74,10 +93,15 @@ class TaskOrchestrator {
     this.#cacheDiagnostics = options.cacheDiagnostics ?? false;
     this.#resolveCommand = options.resolveCommand ?? void 0;
     this.#remoteCache = options.remoteCache ?? void 0;
+    this.#onRemoteUploadError = options.onRemoteUploadError ?? void 0;
     this.#dryRun = options.dryRun ?? false;
     this.#summarize = options.summarize ?? false;
     this.#taskGraph = options.taskGraph ?? void 0;
     this.#startTime = Date.now();
+    this.#alwaysTasks = options.alwaysTasks ?? [];
+    this.#whenContext = options.whenContext ?? {
+      branch: getCurrentBranch(options.workspaceRoot)
+    };
     if (this.#autoFingerprint) {
       this.#fingerprintManager = new FingerprintManager(options.workspaceRoot);
       this.#trackedExecutor = new TrackedTaskExecutor(options.workspaceRoot);
@@ -96,6 +120,9 @@ class TaskOrchestrator {
     process.on("SIGTERM", signalHandler);
     try {
       await this.#executionLoop();
+      if (this.#alwaysTasks.length > 0 && !this.#aborted) {
+        await this.#runAlwaysTasks();
+      }
     } finally {
       process.removeListener("SIGINT", signalHandler);
       process.removeListener("SIGTERM", signalHandler);
@@ -110,6 +137,40 @@ class TaskOrchestrator {
     }
     return this.#results;
   }
+  /**
+   * Runs the configured `always: true` tasks sequentially after the
+   * main task graph completes. Each task's `when` clause is still
+   * honoured. Failures are recorded but never propagate — the whole
+   * point of an always-task is to fire regardless of upstream state.
+   *
+   * Always-tasks deliberately bypass `#processTask` /
+   * `#processTaskWithFingerprint`, which means **no cache lookup
+   * and no fingerprint check**. Cleanup / teardown / notification
+   * tasks are expected to run every invocation; serving them from
+   * cache would defeat the purpose.
+   */
+  async #runAlwaysTasks() {
+    for (const task of this.#alwaysTasks) {
+      this.#lifeCycle.scheduleTask?.(task);
+      this.#lifeCycle.startTasks?.([task]);
+      let result;
+      if (this.#shouldSkipForWhen(task)) {
+        result = this.#whenSkipResult(task);
+      } else {
+        const startTime = Date.now();
+        try {
+          result = await this.#executeTask(task, startTime);
+        } catch (error) {
+          result = createFailureResult(task, error, startTime);
+          this.#results.set(task.id, result);
+        }
+      }
+      this.#lifeCycle.endTasks?.([result]);
+      if (result.terminalOutput) {
+        this.#lifeCycle.printTaskTerminalOutput?.(result.task, result.status, result.terminalOutput);
+      }
+    }
+  }
   async #executionLoop() {
     while (!this.#scheduler.isComplete() && !this.#aborted) {
       const batch = this.#scheduler.getNextBatch();
@@ -130,7 +191,8 @@ class TaskOrchestrator {
       }
       this.#lifeCycle.startTasks?.(batch);
       for (const task of batch) {
-        const taskPromise = (this.#autoFingerprint ? this.#processTaskWithFingerprint(task) : this.#processTask(task)).catch((error) => {
+        const startPromise = this.#shouldSkipForWhen(task) ? Promise.resolve(this.#whenSkipResult(task)) : this.#autoFingerprint ? this.#processTaskWithFingerprint(task) : this.#processTask(task);
+        const taskPromise = startPromise.catch((error) => {
           const errorResult = createFailureResult(task, error, Date.now());
           this.#results.set(task.id, errorResult);
           return errorResult;
@@ -169,7 +231,7 @@ class TaskOrchestrator {
         return this.#applyCachedResult(task, cachedResult, startTime);
       }
       if (this.#remoteCache) {
-        const retrieved = await this.#remoteCache.retrieve(hash, this.#cache.cacheDirectory);
+        const retrieved = await retrieveByTaskHash(this.#remoteCache, hash, this.#cache.cacheDirectory);
         if (retrieved) {
           const remoteCached = await this.#cache.get(hash);
           if (remoteCached) {
@@ -182,7 +244,7 @@ class TaskOrchestrator {
     }
     const result = await this.#executeTask(task, startTime);
     if (result.code === 0 && task.cache !== false && task.hash && this.#remoteCache) {
-      this.#remoteCache.store(task.hash, this.#cache.cacheDirectory).catch(() => {
+      storeByTaskHash(this.#remoteCache, task.hash, this.#cache.cacheDirectory, this.#onRemoteUploadError).catch(() => {
       });
     }
     return result;
@@ -217,7 +279,7 @@ class TaskOrchestrator {
     return this.#executeTaskWithTracking(task, startTime);
   }
   async #applyCachedResult(task, cachedResult, startTime) {
-    const restored = await this.#cache.restoreOutputs(cachedResult.hash, task.outputs);
+    const restored = await this.#cache.restoreOutputs(cachedResult.hash, task.outputs, task.cacheRestore);
     const status = restored ? "local-cache" : "local-cache-kept-existing";
     const result = {
       code: cachedResult.code,
@@ -236,16 +298,19 @@ class TaskOrchestrator {
         captureOutput: this.#captureOutput,
         cwd: resolveTaskCwd(this.#workspaceRoot, task)
       });
+      const hadWarnings = code === 0 && detectWarnings(task.warningPattern, terminalOutput);
       const result = {
         code,
         endTime: Date.now(),
+        hadWarnings: hadWarnings || void 0,
         startTime,
         status: code === 0 ? "success" : "failure",
         task,
         terminalOutput
       };
       this.#results.set(task.id, result);
-      if (code === 0 && task.cache !== false && task.hash) {
+      const skipCacheOnWarning = hadWarnings && task.cacheOnWarning === false;
+      if (code === 0 && task.cache !== false && task.hash && !skipCacheOnWarning) {
         const modified = await this.#detectSelfModifiedInputs(task);
         if (modified.length > 0) {
           result.selfModified = true;
@@ -336,16 +401,19 @@ class TaskOrchestrator {
           this.#untrackedEnvVars
         );
       }
+      const hadWarnings = code === 0 && detectWarnings(task.warningPattern, terminalOutput);
       const result = {
         code,
         endTime: Date.now(),
+        hadWarnings: hadWarnings || void 0,
         startTime,
         status: code === 0 ? "success" : "failure",
         task,
         terminalOutput
       };
       this.#results.set(task.id, result);
-      if (code === 0 && task.cache !== false && fingerprint) {
+      const skipCacheOnWarning = hadWarnings && task.cacheOnWarning === false;
+      if (code === 0 && task.cache !== false && fingerprint && !skipCacheOnWarning) {
         const modified = this.#detectSelfModifiedFingerprint(fingerprint);
         const emptyFingerprintReason = this.#describeEmptyFingerprint(fingerprint, usedRealTracker, trackerAccessCount);
         if (modified.length > 0) {
@@ -413,6 +481,27 @@ class TaskOrchestrator {
     this.#results.set(task.id, result);
     return result;
   }
+  #shouldSkipForWhen(task) {
+    if (!task.when) {
+      return false;
+    }
+    return !evaluateWhen(task.when, this.#whenContext);
+  }
+  #whenSkipResult(task) {
+    const reason = explainWhen(task.when, this.#whenContext);
+    const startTime = Date.now();
+    this.#lifeCycle.printWhenSkip?.(task, reason);
+    const result = {
+      code: 0,
+      endTime: startTime,
+      startTime,
+      status: "skipped",
+      task,
+      terminalOutput: reason ? `Skipped: ${reason}` : "Skipped by when clause"
+    };
+    this.#results.set(task.id, result);
+    return result;
+  }
 }
 
 export { TaskOrchestrator };

package/dist/packem_shared/{TrackedTaskExecutor-CFPpQfXF.js → TrackedTaskExecutor-CWSMfHAW.js}

@@ -27,8 +27,8 @@ const {
   rm
 } = __cjs_getBuiltinModule("node:fs/promises");
 import { join } from '@visulima/path';
-import { FileAccessTracker, generatePreloadScript } from './FileAccessTracker-CQ5Ot7Hd.js';
-import { u as uniqueId } from './utils-zO0ZRgtf.js';
+import { FileAccessTracker, generatePreloadScript } from './FileAccessTracker-D8zIURPU.js';
+import { u as uniqueId } from './utils-Bmnj-H2J.js';
 
 class TrackedTaskExecutor {
   #tracker;

package/dist/packem_shared/V2_ROOT-DKBLxKo4.js

@@ -0,0 +1,14 @@
+import { join } from '@visulima/path';
+
+const V2_ROOT = "v2";
+const V2_CAS = "cas";
+const V2_AC = "ac";
+const V2_INDEX = "task-hash-index";
+const V2_TMP = "tmp";
+const shard = (hash) => hash.slice(0, 2);
+const casBlobPath = (root, hash) => join(root, V2_ROOT, V2_CAS, shard(hash), hash);
+const acEntryPath = (root, actionHash) => join(root, V2_ROOT, V2_AC, shard(actionHash), `${actionHash}.json`);
+const taskHashIndexPath = (root, taskHash) => join(root, V2_ROOT, V2_INDEX, shard(taskHash), taskHash);
+const tmpDirectory = (root) => join(root, V2_ROOT, V2_TMP);
+
+export { V2_AC, V2_CAS, V2_INDEX, V2_ROOT, V2_TMP, acEntryPath, casBlobPath, shard, taskHashIndexPath, tmpDirectory };

package/dist/packem_shared/actionDigestForTaskHash-BRE-9MT6.js

@@ -0,0 +1,121 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  createHash,
+  randomUUID
+} = __cjs_getBuiltinModule("node:crypto");
+const {
+  createReadStream
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  mkdir,
+  rm,
+  stat
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { join } from '@visulima/path';
+import { e as extractTarGz, c as createTarGz } from './archive-CnggHWb-.js';
+
+const TARBALL_OUTPUT_PATH = "vis-entry.tar.gz";
+const actionDigestForTaskHash = (taskHash) => {
+  const key = `vis-task:${taskHash}`;
+  return {
+    hash: createHash("sha256").update(Buffer.from(key, "utf8")).digest("hex"),
+    sizeBytes: 0
+  };
+};
+const containsByTaskHash = async (backend, taskHash) => {
+  try {
+    return await backend.containsAction(actionDigestForTaskHash(taskHash));
+  } catch {
+    return false;
+  }
+};
+const retrieveByTaskHash = async (backend, taskHash, localCacheDirectory) => {
+  const action = await backend.retrieveAction(actionDigestForTaskHash(taskHash));
+  if (action === null || action.outputFiles.length === 0) {
+    return false;
+  }
+  const tarballEntry = action.outputFiles[0];
+  if (!tarballEntry) {
+    return false;
+  }
+  const entryDirectory = join(localCacheDirectory, taskHash);
+  const archivePath = join(localCacheDirectory, `.download-${taskHash}-${randomUUID()}.tar.gz`);
+  try {
+    await mkdir(localCacheDirectory, { recursive: true });
+    const fetched = await backend.fetchBlob(tarballEntry.digest, archivePath);
+    if (!fetched) {
+      return false;
+    }
+    await mkdir(entryDirectory, { recursive: true });
+    await extractTarGz(archivePath, entryDirectory);
+    return true;
+  } catch {
+    await rm(entryDirectory, { force: true, recursive: true }).catch(() => {
+    });
+    return false;
+  } finally {
+    await rm(archivePath, { force: true }).catch(() => {
+    });
+  }
+};
+const storeByTaskHash = async (backend, taskHash, localCacheDirectory, onUploadError) => {
+  const entryDirectory = join(localCacheDirectory, taskHash);
+  const archivePath = join(localCacheDirectory, `.upload-${taskHash}-${randomUUID()}.tar.gz`);
+  try {
+    try {
+      await stat(join(entryDirectory, ".commit"));
+    } catch {
+      return false;
+    }
+    try {
+      await createTarGz(entryDirectory, archivePath);
+      const blobDigest = await digestFile(archivePath);
+      const result = {
+        exitCode: 0,
+        outputDirectories: [],
+        outputFiles: [{ digest: blobDigest, isExecutable: false, path: TARBALL_OUTPUT_PATH }]
+      };
+      const blob = {
+        digest: blobDigest,
+        open: () => Promise.resolve(createReadStream(archivePath))
+      };
+      return await backend.storeAction(actionDigestForTaskHash(taskHash), result, [blob]);
+    } catch (error) {
+      onUploadError?.(taskHash, error);
+      return false;
+    }
+  } finally {
+    await rm(archivePath, { force: true }).catch(() => {
+    });
+  }
+};
+const digestFile = async (path) => {
+  const hash = createHash("sha256");
+  let sizeBytes = 0;
+  for await (const chunk of createReadStream(path)) {
+    const buffer = chunk;
+    hash.update(buffer);
+    sizeBytes += buffer.byteLength;
+  }
+  return { hash: hash.digest("hex"), sizeBytes };
+};
+
+export { actionDigestForTaskHash, containsByTaskHash, retrieveByTaskHash, storeByTaskHash };

package/dist/packem_shared/archive-CnggHWb-.js

@@ -0,0 +1,152 @@
+import { createRequire as __cjs_createRequire } from "node:module";
+
+const __cjs_require = __cjs_createRequire(import.meta.url);
+
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
+
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  mkdir,
+  writeFile,
+  utimes,
+  readdir,
+  readFile,
+  stat
+} = __cjs_getBuiltinModule("node:fs/promises");
+const {
+  Readable
+} = __cjs_getBuiltinModule("node:stream");
+const {
+  pipeline
+} = __cjs_getBuiltinModule("node:stream/promises");
+const {
+  createGunzip,
+  createGzip,
+  createBrotliDecompress,
+  createBrotliCompress,
+  constants
+} = __cjs_getBuiltinModule("node:zlib");
+import { join, resolve, sep } from '@visulima/path';
+import { parseTar, createTar } from 'nanotar';
+
+const BROTLI_COMPRESS_OPTIONS = {
+  params: {
+    [constants.BROTLI_PARAM_MODE]: constants.BROTLI_MODE_TEXT,
+    [constants.BROTLI_PARAM_QUALITY]: 4
+  }
+};
+const collectEntries = async (sourceDirectory) => {
+  const entries = [];
+  const root = resolve(sourceDirectory);
+  const walk = async (absolute, relative) => {
+    const items = await readdir(absolute, { withFileTypes: true });
+    items.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const item of items) {
+      const childAbsolute = join(absolute, item.name);
+      const childRelative = relative === "" ? item.name : `${relative}/${item.name}`;
+      if (item.isDirectory()) {
+        await walk(childAbsolute, childRelative);
+        continue;
+      }
+      if (!item.isFile()) {
+        continue;
+      }
+      const [data, info] = await Promise.all([readFile(childAbsolute), stat(childAbsolute)]);
+      entries.push({
+        attrs: {
+          // eslint-disable-next-line no-bitwise -- POSIX file modes encode the rwx triplet in the low 12 bits; bitmask is the canonical extraction
+          mode: (info.mode & 4095).toString(8),
+          mtime: Math.floor(info.mtimeMs)
+        },
+        data,
+        name: childRelative
+      });
+    }
+  };
+  await walk(root, "");
+  return entries;
+};
+const safeJoinForExtract = (destinationDirectory, entryName) => {
+  if (entryName === "" || entryName === "." || entryName === "./") {
+    return null;
+  }
+  if (entryName.startsWith("/") || entryName.startsWith("\\") || /^[a-z]:[\\/]/i.test(entryName)) {
+    return null;
+  }
+  const resolvedDestination = resolve(destinationDirectory);
+  const resolvedEntry = resolve(resolvedDestination, entryName);
+  const prefix = resolvedDestination.endsWith(sep) ? resolvedDestination : `${resolvedDestination}${sep}`;
+  if (resolvedEntry !== resolvedDestination && !resolvedEntry.startsWith(prefix)) {
+    return null;
+  }
+  return resolvedEntry;
+};
+const writeTarEntries = async (entries, destinationDirectory, options = {}) => {
+  const preserveMtime = options.preserveMtime ?? true;
+  const preservePerms = options.preservePerms ?? true;
+  await mkdir(destinationDirectory, { recursive: true });
+  for (const entry of entries) {
+    if (entry.data === void 0) {
+      continue;
+    }
+    const writePath = safeJoinForExtract(destinationDirectory, entry.name);
+    if (writePath === null) {
+      throw new Error(`[task-runner] refusing to extract tar entry with unsafe path: ${entry.name}`);
+    }
+    await mkdir(join(writePath, ".."), { recursive: true });
+    const mode = preservePerms && entry.attrs?.mode !== void 0 ? Number.parseInt(entry.attrs.mode, 8) : void 0;
+    await writeFile(writePath, entry.data, mode === void 0 ? void 0 : { mode });
+    if (preserveMtime && entry.attrs?.mtime !== void 0) {
+      const mtime = new Date(entry.attrs.mtime * 1e3);
+      await utimes(writePath, mtime, mtime);
+    }
+  }
+};
+const compressBuffer = async (buffer, transform, outputPath) => {
+  const { createWriteStream } = await import('node:fs');
+  await pipeline(Readable.from(Buffer.from(buffer)), transform, createWriteStream(outputPath));
+};
+const decompressBuffer = async (sourcePath, transform) => {
+  const { createReadStream } = await import('node:fs');
+  const chunks = [];
+  await pipeline(createReadStream(sourcePath), transform, async (source) => {
+    for await (const chunk of source) {
+      chunks.push(chunk);
+    }
+  });
+  return Buffer.concat(chunks);
+};
+const createTarGz = async (sourceDirectory, outputPath) => {
+  const entries = await collectEntries(sourceDirectory);
+  const tarBytes = createTar(entries);
+  await compressBuffer(tarBytes, createGzip(), outputPath);
+};
+const extractTarGz = async (archivePath, destinationDirectory, options) => {
+  const tarBuffer = await decompressBuffer(archivePath, createGunzip());
+  const entries = parseTar(tarBuffer);
+  await writeTarEntries(entries, destinationDirectory, options);
+};
+const createTarBrotli = async (sourceDirectory, outputPath) => {
+  const entries = await collectEntries(sourceDirectory);
+  const tarBytes = createTar(entries);
+  await compressBuffer(tarBytes, createBrotliCompress(BROTLI_COMPRESS_OPTIONS), outputPath);
+};
+const extractTarBrotli = async (archivePath, destinationDirectory, options) => {
+  const tarBuffer = await decompressBuffer(archivePath, createBrotliDecompress());
+  const entries = parseTar(tarBuffer);
+  await writeTarEntries(entries, destinationDirectory, options);
+};
+
+export { extractTarBrotli as a, createTarBrotli as b, createTarGz as c, extractTarGz as e };

package/dist/packem_shared/{buildForwardDependencyMap-DLPgKEto.js → buildForwardDependencyMap-0BJFMMPv.js}

@@ -33,8 +33,7 @@ const findProjectForFile = (filePath, projects) => {
   let bestLength = 0;
   for (const [name, config] of Object.entries(projects)) {
     const { root } = config;
-    if ((filePath.startsWith(`${root}/`) || filePath === root) && // Prefer the most specific (longest) match
-    root.length > bestLength) {
+    if ((filePath.startsWith(`${root}/`) || filePath === root) && root.length > bestLength) {
       bestMatch = name;
       bestLength = root.length;
     }

package/dist/packem_shared/{collectFiles-ClXHnHhg.js → collectFiles-cc1gokGU.js}

@@ -18,5 +18,6 @@ const __cjs_getBuiltinModule = (module) => {
 };
 
 
-export { c as collectFiles, a as createFailureResult, h as hashFile, b as hashStrings, r as readPackageDeps, d as resolveTaskCwd, s as sortObjectKeys, u as uniqueId } from './utils-zO0ZRgtf.js';
+
+export { c as collectFiles, a as createFailureResult, h as hashFile, b as hashStrings, r as readPackageDeps, d as resolveTaskCwd, s as sortObjectKeys, u as uniqueId } from './utils-Bmnj-H2J.js';
 import '@visulima/path';

package/dist/packem_shared/{computeTaskHash-DYqfrDGq.js → computeTaskHash-DHoBJ_-V.js}

@@ -24,11 +24,12 @@ const {
   stat,
   readFile
 } = __cjs_getBuiltinModule("node:fs/promises");
-import { b as hashStrings, s as sortObjectKeys, c as collectFiles, x as xxh3Hash, e as createXxh3Hasher } from './utils-zO0ZRgtf.js';
+import { b as hashStrings, s as sortObjectKeys, c as collectFiles, x as xxh3Hash, e as createXxh3Hasher } from './utils-Bmnj-H2J.js';
 import { join, resolve, relative } from '@visulima/path';
-import { getFrameworkEnvVariables } from './detectFrameworks-CeFzKE6J.js';
-import { LockfileHasher } from './extractPackageName-BllKetnz.js';
+import { getFrameworkEnvVariables } from './detectFrameworks-D7nyTc-o.js';
+import { LockfileHasher } from './extractPackageName-CMHjqGj_.js';
 import { loadNativeBindings } from './isNativeAvailable-BpD28A6Z.js';
+import { looksLikeInputUri, parseInputUri } from './INPUT_URI_SCHEMES-DRm76YI5.js';
 
 const DEFAULT_GLOBAL_INPUTS = ["package-lock.json", "pnpm-lock.yaml", "yarn.lock", "tsconfig.base.json", "tsconfig.json", ".env"];
 const IGNORED_DIRS = /* @__PURE__ */ new Set([".git", "coverage", "dist", "node_modules"]);
@@ -254,7 +255,12 @@ class InProcessTaskHasher {
     const seen = /* @__PURE__ */ new Set();
     for (const input of inputs) {
       if (typeof input === "string") {
-        if (input.startsWith("{") || input.startsWith("!{")) {
+        if (looksLikeInputUri(input)) {
+          const parsed = parseInputUri(input);
+          if (parsed) {
+            result.push(parsed);
+          }
+        } else if (input.startsWith("{") || input.startsWith("!{")) {
           result.push({ fileset: input });
         } else if (input.startsWith("^")) {
           continue;