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

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

@@ -1,10 +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-B5APHW7e.js';
-import { TrackedTaskExecutor } from './TrackedTaskExecutor-CFPpQfXF.js';
-import { getCurrentBranch, evaluateWhen, explainWhen } from './getCurrentBranch-DsKPDoVj.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();
@@ -26,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) => {
@@ -50,6 +65,7 @@ class TaskOrchestrator {
   #cacheDiagnostics;
   #resolveCommand;
   #remoteCache;
+  #onRemoteUploadError;
   #dryRun;
   #summarize;
   #taskGraph;
@@ -77,6 +93,7 @@ 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;
@@ -214,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) {
@@ -227,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;
@@ -262,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,
@@ -281,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;
@@ -381,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) {

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/{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-B5APHW7e.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-CbVNW-dr.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;

package/dist/packem_shared/containsBlob-CwGB0a_q.js

@@ -0,0 +1,125 @@
+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 {
+  createReadStream,
+  createWriteStream
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  stat,
+  mkdir,
+  writeFile,
+  rename,
+  rm,
+  utimes
+} = __cjs_getBuiltinModule("node:fs/promises");
+const {
+  pipeline
+} = __cjs_getBuiltinModule("node:stream/promises");
+import { dirname } from '@visulima/path';
+import { u as uniqueId } from './utils-Bmnj-H2J.js';
+import { digestFile } from './digestBuffer-CPdI2E1d.js';
+import { casBlobPath, tmpDirectory } from './V2_ROOT-DKBLxKo4.js';
+
+const containsBlob = async (root, digest) => {
+  try {
+    const stats = await stat(casBlobPath(root, digest.hash));
+    return stats.isFile() && stats.size === digest.sizeBytes;
+  } catch {
+    return false;
+  }
+};
+const putBlobFromFile = async (root, digest, sourcePath) => {
+  const finalPath = casBlobPath(root, digest.hash);
+  if (await containsBlob(root, digest)) {
+    await touchBlob(root, digest).catch(() => {
+    });
+    return;
+  }
+  const stagingPath = await stageBlob(root, sourcePath);
+  try {
+    await mkdir(dirname(finalPath), { recursive: true });
+    await rename(stagingPath, finalPath);
+  } catch (error) {
+    await rm(stagingPath, { force: true }).catch(() => {
+    });
+    if (!isAlreadyExistsError(error)) {
+      throw error;
+    }
+  }
+};
+const putBlobFromBytes = async (root, digest, bytes) => {
+  const finalPath = casBlobPath(root, digest.hash);
+  if (await containsBlob(root, digest)) {
+    await touchBlob(root, digest).catch(() => {
+    });
+    return;
+  }
+  const tmpDirectoryPath = tmpDirectory(root);
+  const stagingPath = `${tmpDirectoryPath}/${uniqueId()}`;
+  await mkdir(tmpDirectoryPath, { recursive: true });
+  await writeFile(stagingPath, bytes);
+  try {
+    await mkdir(dirname(finalPath), { recursive: true });
+    await rename(stagingPath, finalPath);
+  } catch (error) {
+    await rm(stagingPath, { force: true }).catch(() => {
+    });
+    if (!isAlreadyExistsError(error)) {
+      throw error;
+    }
+  }
+};
+const fetchBlobToFile = async (root, digest, destinationPath) => {
+  const sourcePath = casBlobPath(root, digest.hash);
+  try {
+    await stat(sourcePath);
+  } catch {
+    return false;
+  }
+  await mkdir(dirname(destinationPath), { recursive: true });
+  await pipeline(createReadStream(sourcePath), createWriteStream(destinationPath));
+  await touchBlob(root, digest).catch(() => {
+  });
+  return true;
+};
+const verifyBlob = async (filePath, expected) => {
+  const computed = await digestFile(filePath);
+  return computed?.hash === expected.hash && computed.sizeBytes === expected.sizeBytes;
+};
+const touchBlob = async (root, digest) => {
+  const now = /* @__PURE__ */ new Date();
+  await utimes(casBlobPath(root, digest.hash), now, now);
+};
+const stageBlob = async (root, sourcePath) => {
+  const tmpDirectoryPath = tmpDirectory(root);
+  const stagingPath = `${tmpDirectoryPath}/${uniqueId()}`;
+  await mkdir(tmpDirectoryPath, { recursive: true });
+  await pipeline(createReadStream(sourcePath), createWriteStream(stagingPath));
+  return stagingPath;
+};
+const isAlreadyExistsError = (error) => {
+  if (typeof error !== "object" || error === null) {
+    return false;
+  }
+  const { code } = error;
+  return code === "EEXIST" || code === "ENOTEMPTY";
+};
+
+export { containsBlob, fetchBlobToFile, putBlobFromBytes, putBlobFromFile, touchBlob, verifyBlob };

package/dist/packem_shared/{createTaskGraph-B5YrfAMx.js → createTaskGraph-Bwl4hwAf.js}

@@ -16,6 +16,13 @@ const parseTaskId = (taskId) => {
     target: parts[1]
   };
 };
+const normalizeWarningPattern = (value) => {
+  if (value === void 0) {
+    return void 0;
+  }
+  const list = typeof value === "string" ? [value] : value;
+  return list.length === 0 ? void 0 : list;
+};
 const getTaskOutputs = (projectName, targetName, workspace, targetDefaults) => {
   const project = workspace.projects[projectName];
   const targetConfig = project?.targets?.[targetName];
@@ -40,12 +47,17 @@ const getSameProjectTask = (projectName, targetName, overrides, workspace, targe
     {
       always: project.targets?.[targetName]?.always ?? targetDefaults?.[targetName]?.always,
       cache: project.targets?.[targetName]?.cache ?? targetDefaults?.[targetName]?.cache,
+      cacheOnWarning: project.targets?.[targetName]?.cacheOnWarning ?? targetDefaults?.[targetName]?.cacheOnWarning,
+      cacheRestore: project.targets?.[targetName]?.cacheRestore ?? targetDefaults?.[targetName]?.cacheRestore,
       id: getTaskId(target),
       outputs: getTaskOutputs(projectName, targetName, workspace, targetDefaults),
       overrides,
       parallelism: project.targets?.[targetName]?.parallelism ?? targetDefaults?.[targetName]?.parallelism,
       projectRoot: project.root,
       target,
+      warningPattern: normalizeWarningPattern(
+        project.targets?.[targetName]?.warningPattern ?? targetDefaults?.[targetName]?.warningPattern
+      ),
       when: project.targets?.[targetName]?.when ?? targetDefaults?.[targetName]?.when
     }
   ];
@@ -67,12 +79,17 @@ const getDependencyProjectTasks = (projectName, targetName, overrides, workspace
       tasks.push({
         always: depProject.targets?.[targetName]?.always ?? targetDefaults?.[targetName]?.always,
         cache: depProject.targets?.[targetName]?.cache ?? targetDefaults?.[targetName]?.cache,
+        cacheOnWarning: depProject.targets?.[targetName]?.cacheOnWarning ?? targetDefaults?.[targetName]?.cacheOnWarning,
+        cacheRestore: depProject.targets?.[targetName]?.cacheRestore ?? targetDefaults?.[targetName]?.cacheRestore,
         id: getTaskId(target),
         outputs: getTaskOutputs(dep.target, targetName, workspace, targetDefaults),
         overrides,
         parallelism: depProject.targets?.[targetName]?.parallelism ?? targetDefaults?.[targetName]?.parallelism,
         projectRoot: depProject.root,
         target,
+        warningPattern: normalizeWarningPattern(
+          depProject.targets?.[targetName]?.warningPattern ?? targetDefaults?.[targetName]?.warningPattern
+        ),
         when: depProject.targets?.[targetName]?.when ?? targetDefaults?.[targetName]?.when
       });
     }