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

package/dist/packem_shared/{Cache-CWaX_c8U.js → Cache-CbhoA268.js}

@@ -17,8 +17,12 @@ const __cjs_getBuiltinModule = (module) => {
     return __cjs_require(module);
 };
 
+const {
+  createWriteStream
+} = __cjs_getBuiltinModule("node:fs");
 const {
   readFile,
+  utimes,
   mkdir,
   writeFile,
   rename,
@@ -27,11 +31,71 @@ const {
   stat,
   cp
 } = __cjs_getBuiltinModule("node:fs/promises");
+const {
+  pipeline
+} = __cjs_getBuiltinModule("node:stream/promises");
 import { formatBytes, parseBytes } from '@visulima/humanizer';
-import { join, resolve, dirname } from '@visulima/path';
-import { e as extractTarBrotli, c as createTarBrotli } from './archive-UQHAnZUa.js';
+import { dirname, join, resolve } from '@visulima/path';
+import { a as extractTarBrotli, b as createTarBrotli } from './archive-CnggHWb-.js';
+import { u as uniqueId } from './utils-Bmnj-H2J.js';
+import { acEntryPath, taskHashIndexPath, tmpDirectory, V2_ROOT } from './V2_ROOT-DKBLxKo4.js';
+import { fetchBlobToFile, containsBlob, putBlobFromFile } from './containsBlob-CwGB0a_q.js';
 import { resolveOutputs } from './resolveOutputs-n6MCKoTe.js';
-import { u as uniqueId } from './utils-zO0ZRgtf.js';
+
+const writeActionEntry = async (root, actionHash, result) => {
+  const finalPath = acEntryPath(root, actionHash);
+  const tmpDirectoryPath = tmpDirectory(root);
+  const stagingPath = `${tmpDirectoryPath}/${uniqueId()}`;
+  await mkdir(tmpDirectoryPath, { recursive: true });
+  await mkdir(dirname(finalPath), { recursive: true });
+  const payload = `${JSON.stringify(result, null, 2)}
+`;
+  await writeFile(stagingPath, payload);
+  try {
+    await rename(stagingPath, finalPath);
+  } catch (error) {
+    await rm(stagingPath, { force: true }).catch(() => {
+    });
+    throw error;
+  }
+};
+const readActionEntry = async (root, actionHash) => {
+  const path = acEntryPath(root, actionHash);
+  try {
+    const content = await readFile(path, "utf8");
+    const parsed = JSON.parse(content);
+    const now = /* @__PURE__ */ new Date();
+    await utimes(path, now, now).catch(() => {
+    });
+    return parsed;
+  } catch {
+    return null;
+  }
+};
+const writeTaskHashIndex = async (root, taskHash, actionHash) => {
+  const finalPath = taskHashIndexPath(root, taskHash);
+  const tmpDirectoryPath = tmpDirectory(root);
+  const stagingPath = `${tmpDirectoryPath}/${uniqueId()}`;
+  await mkdir(tmpDirectoryPath, { recursive: true });
+  await mkdir(dirname(finalPath), { recursive: true });
+  await writeFile(stagingPath, actionHash);
+  try {
+    await rename(stagingPath, finalPath);
+  } catch (error) {
+    await rm(stagingPath, { force: true }).catch(() => {
+    });
+    throw error;
+  }
+};
+const readTaskHashIndex = async (root, taskHash) => {
+  try {
+    const content = await readFile(taskHashIndexPath(root, taskHash), "utf8");
+    const trimmed = content.trim();
+    return trimmed.length > 0 ? trimmed : null;
+  } catch {
+    return null;
+  }
+};
 
 const DEFAULT_MAX_CACHE_AGE = 7 * 24 * 60 * 60 * 1e3;
 const DEFAULT_CACHE_DIRECTORY_NAME = ".task-runner-cache";
@@ -100,6 +164,82 @@ class Cache {
   get cacheDirectory() {
     return this.#cacheDirectory;
   }
+  /**
+   * Root for v2 CAS-shaped reads/writes. Backend implementations
+   * (HTTP today, REAPI gRPC next) take this path so they can
+   * hydrate fetched blobs into the same CAS the local cache reads
+   * from. Equal to {@link cacheDirectory} — `v2/` lives under that.
+   */
+  get casRoot() {
+    return this.#cacheDirectory;
+  }
+  /**
+   * Read a v2 {@link ActionResult} by action digest. Resolves to
+   * `null` on miss. The orchestrator is expected to follow up with
+   * {@link materializeOutputs} to place the referenced blobs into
+   * the workspace.
+   */
+  async getActionResult(actionDigest) {
+    return readActionEntry(this.#cacheDirectory, actionDigest.hash);
+  }
+  /**
+   * Look up an action digest by the legacy task hash. Returns
+   * `null` when the bridge file isn't present — caller falls
+   * through to the legacy `<hash>/` layout (or executes the task).
+   */
+  async resolveActionDigestForTaskHash(taskHash) {
+    return readTaskHashIndex(this.#cacheDirectory, taskHash);
+  }
+  /**
+   * Persist a v2 entry: writes the AC JSON, copies referenced
+   * blobs into the CAS via the lazy {@link BlobSource} handles,
+   * and binds the task hash → action digest redirect last so a
+   * partial failure can't surface a half-written entry.
+   */
+  async putActionResult(taskHash, actionDigest, result, blobs) {
+    await this.#ensureBlobs(blobs);
+    await writeActionEntry(this.#cacheDirectory, actionDigest.hash, result);
+    await writeTaskHashIndex(this.#cacheDirectory, taskHash, actionDigest.hash);
+  }
+  /**
+   * Materialize an action's outputs into the workspace. Streams
+   * each referenced blob from the local CAS to its workspace path.
+   * Returns `false` when any blob is missing — caller treats that
+   * as a cache miss and re-executes.
+   */
+  async materializeOutputs(result, workspaceRoot) {
+    for (const file of result.outputFiles) {
+      const destination = resolve(workspaceRoot, file.path);
+      const ok = await fetchBlobToFile(this.#cacheDirectory, file.digest, destination);
+      if (!ok) {
+        return false;
+      }
+    }
+    return true;
+  }
+  /**
+   * Sequentially materializes each {@link BlobSource} into the local
+   * CAS. Serial on purpose: a single Action typically references a
+   * handful of blobs, and parallelizing would multiply RSS by the
+   * largest payload's size while gaining nothing on disk-bound IO.
+   * The small per-blob loop also keeps tmp-file naming and rename
+   * pressure predictable instead of fanning out a burst of writers.
+   */
+  async #ensureBlobs(blobs) {
+    for (const blob of blobs) {
+      const present = await containsBlob(this.#cacheDirectory, blob.digest);
+      if (present) {
+        continue;
+      }
+      const tmpPath = join(this.#cacheDirectory, V2_ROOT, "tmp", `.put-${uniqueId()}`);
+      await mkdir(dirname(tmpPath), { recursive: true });
+      const source = await blob.open();
+      await pipeline(source, createWriteStream(tmpPath));
+      await putBlobFromFile(this.#cacheDirectory, blob.digest, tmpPath);
+      await rm(tmpPath, { force: true }).catch(() => {
+      });
+    }
+  }
   /**
    * Retrieves a cached result for the given task hash.
    * Returns undefined if no valid cache entry exists.
@@ -175,9 +315,9 @@ class Cache {
    * extracted staging become the set of swap roots. Still accepted
    * for backward compat.
    */
-  async restoreOutputs(hash, _outputs) {
+  async restoreOutputs(hash, _outputs, options) {
     const cacheEntryDirectory = join(this.#cacheDirectory, hash);
-    return restoreOutputsCompressed(cacheEntryDirectory, this.#workspaceRoot);
+    return restoreOutputsCompressed(cacheEntryDirectory, this.#workspaceRoot, options);
   }
   /**
    * Retrieves the most recent cached result for a task by its ID.
@@ -311,7 +451,7 @@ const archiveOutputsCompressed = async (workspaceRoot, cacheEntryDirectory, outp
       const stagedOutput = join(stagingDirectory, relativePath);
       try {
         await mkdir(dirname(stagedOutput), { recursive: true });
-        await cp(absoluteOutput, stagedOutput, { recursive: true });
+        await cp(absoluteOutput, stagedOutput, { preserveTimestamps: true, recursive: true });
         return true;
       } catch {
         return false;
@@ -342,7 +482,7 @@ const runBounded = async (limit, items, fn) => {
   await Promise.all(workers);
   return results;
 };
-const restoreOutputsCompressed = async (cacheEntryDirectory, workspaceRoot) => {
+const restoreOutputsCompressed = async (cacheEntryDirectory, workspaceRoot, options) => {
   const archivePath = join(cacheEntryDirectory, OUTPUTS_ARCHIVE_FILENAME);
   try {
     await stat(archivePath);
@@ -351,10 +491,11 @@ const restoreOutputsCompressed = async (cacheEntryDirectory, workspaceRoot) => {
   }
   const stagingDirectory = join(cacheEntryDirectory, `.restore-${uniqueId()}`);
   const backups = [];
+  const preserveMtime = options?.preserveMtime ?? true;
   try {
     await mkdir(stagingDirectory, { recursive: true });
-    await extractTarBrotli(archivePath, stagingDirectory);
-    const topLevel = await readdir(stagingDirectory);
+    await extractTarBrotli(archivePath, stagingDirectory, options);
+    const topLevel = (await readdir(stagingDirectory)).sort();
     await runBounded(STAGE_CONCURRENCY, topLevel, async (entry) => {
       const absoluteOutput = resolve(workspaceRoot, entry);
       const stagedOutput = join(stagingDirectory, entry);
@@ -366,7 +507,7 @@ const restoreOutputsCompressed = async (cacheEntryDirectory, workspaceRoot) => {
         backups.push({ backup, original: absoluteOutput });
       } catch {
       }
-      await cp(stagedOutput, absoluteOutput, { recursive: true });
+      await cp(stagedOutput, absoluteOutput, { preserveTimestamps: preserveMtime, recursive: true });
     });
     await Promise.all(backups.map(({ backup }) => rm(backup, { force: true, recursive: true }).catch(() => {
     })));

package/dist/packem_shared/{FileAccessTracker-CQ5Ot7Hd.js → FileAccessTracker-D8zIURPU.js}

@@ -30,7 +30,7 @@ const {
   platform
 } = __cjs_getBuiltinModule("node:os");
 import { resolve, join } from '@visulima/path';
-import { u as uniqueId } from './utils-zO0ZRgtf.js';
+import { u as uniqueId } from './utils-Bmnj-H2J.js';
 
 import __cjs_mod__ from "node:module"; // -- packem CommonJS require shim --
 const require = __cjs_mod__.createRequire(import.meta.url);

package/dist/packem_shared/{FingerprintManager-CV7U4f4f.js → FingerprintManager-78DjwWQ4.js}

@@ -22,7 +22,7 @@ const {
   stat
 } = __cjs_getBuiltinModule("node:fs/promises");
 import { resolve, relative } from '@visulima/path';
-import { b as hashStrings, s as sortObjectKeys, h as hashFile } from './utils-zO0ZRgtf.js';
+import { b as hashStrings, s as sortObjectKeys, h as hashFile } from './utils-Bmnj-H2J.js';
 
 class FingerprintManager {
   #workspaceRoot;

package/dist/packem_shared/HttpRemoteCache-BTXUBH7t.js

@@ -0,0 +1,290 @@
+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 {
+  createHmac,
+  timingSafeEqual,
+  createHash
+} = __cjs_getBuiltinModule("node:crypto");
+const {
+  createWriteStream,
+  createReadStream
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  mkdir,
+  rm,
+  stat
+} = __cjs_getBuiltinModule("node:fs/promises");
+const {
+  tmpdir
+} = __cjs_getBuiltinModule("node:os");
+const {
+  pipeline
+} = __cjs_getBuiltinModule("node:stream/promises");
+import { join } from '@visulima/path';
+import { fetchBlobToFile, putBlobFromFile } from './containsBlob-CwGB0a_q.js';
+import { u as uniqueId } from './utils-Bmnj-H2J.js';
+
+const SIGNATURE_HEADER = "X-Artifact-Signature";
+const MIN_SECRET_LENGTH = 16;
+const BLOB_OUTPUT_PATH = "vis-entry.tar.gz";
+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 };
+};
+const computeArtifactSignatureStream = async (secret, hash, archivePath) => {
+  const hmac = createHmac("sha256", secret);
+  hmac.update(hash);
+  const source = createReadStream(archivePath);
+  for await (const chunk of source) {
+    hmac.update(chunk);
+  }
+  return hmac.digest("hex");
+};
+const signaturesMatch = (a, b) => {
+  if (a.length !== b.length) {
+    return false;
+  }
+  try {
+    return timingSafeEqual(Buffer.from(a, "hex"), Buffer.from(b, "hex"));
+  } catch {
+    return false;
+  }
+};
+class HttpRemoteCache {
+  #url;
+  #token;
+  #teamId;
+  #timeout;
+  #read;
+  #write;
+  #onUploadError;
+  #compression;
+  #signingSecret;
+  #verifyOnDownload;
+  #localCasRoot;
+  /**
+   * Per-digest in-flight upload dedup. Two concurrent `storeAction`
+   * calls referencing the same blob upload it once per process
+   * lifetime, matching REAPI's `FindMissingBlobs` elision.
+   */
+  #inflightUploads = /* @__PURE__ */ new Map();
+  constructor(options) {
+    this.#url = options.url.replace(/\/$/, "");
+    this.#token = options.token;
+    this.#teamId = options.teamId;
+    this.#timeout = options.timeout ?? 3e4;
+    const mode = options.mode ?? "readwrite";
+    this.#read = mode === "read" || mode === "readwrite";
+    this.#write = mode === "write" || mode === "readwrite";
+    this.#onUploadError = options.onUploadError;
+    this.#compression = options.compression ?? "gzip";
+    this.#localCasRoot = options.localCasRoot;
+    if (options.signing) {
+      if (options.signing.secret.length < MIN_SECRET_LENGTH) {
+        throw new Error(`Remote cache signing secret must be at least ${String(MIN_SECRET_LENGTH)} characters.`);
+      }
+      this.#signingSecret = options.signing.secret;
+      this.#verifyOnDownload = options.signing.verifyOnDownload ?? false;
+    } else {
+      this.#signingSecret = void 0;
+      this.#verifyOnDownload = false;
+    }
+  }
+  /**
+   * No-op. The HTTP backend uses Node's global `fetch`, which has no
+   * persistent connection to release. Implemented to satisfy the
+   * {@link RemoteCacheBackend.close} contract uniformly.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  async close() {
+  }
+  /**
+   * {@link RemoteCacheBackend.containsAction}: HEAD on the artifact URL.
+   * Resolves `false` on any wire failure — existence checks are best
+   * effort and never block the caller.
+   */
+  async containsAction(actionDigest) {
+    if (!this.#read) {
+      return false;
+    }
+    try {
+      const artifactUrl = this.#buildUrl(`/v8/artifacts/${actionDigest.hash}`);
+      const response = await fetch(artifactUrl, {
+        headers: this.#buildHeaders(),
+        method: "HEAD",
+        signal: AbortSignal.timeout(this.#timeout)
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * {@link RemoteCacheBackend.fetchBlob}: streams a blob out of the
+   * local CAS that was hydrated by a previous {@link retrieveAction}
+   * call. The HTTP wire ships one tarball per action, so per-blob
+   * fetches are local-only — there's no remote endpoint to call.
+   */
+  async fetchBlob(digest, destinationPath) {
+    if (!this.#localCasRoot) {
+      return false;
+    }
+    return fetchBlobToFile(this.#localCasRoot, digest, destinationPath);
+  }
+  /**
+   * {@link RemoteCacheBackend.retrieveAction}: GETs the artifact at
+   * `/v8/artifacts/{actionDigest.hash}`, ingests the response bytes
+   * as a single CAS blob in the local store, and synthesises an
+   * {@link ActionResult} that points at that blob. Resolves to `null`
+   * on a 404 / signature mismatch / missing local CAS root.
+   */
+  async retrieveAction(actionDigest) {
+    if (!this.#read || !this.#localCasRoot) {
+      return null;
+    }
+    const stagingRoot = join(this.#localCasRoot, "v2", "tmp");
+    const stagingPath = join(stagingRoot, `.remote-${actionDigest.hash}-${uniqueId()}`);
+    try {
+      await mkdir(stagingRoot, { recursive: true });
+      const artifactUrl = this.#buildUrl(`/v8/artifacts/${actionDigest.hash}`);
+      const response = await fetch(artifactUrl, {
+        headers: this.#buildHeaders(),
+        method: "GET",
+        signal: AbortSignal.timeout(this.#timeout)
+      });
+      if (!response.ok || !response.body) {
+        return null;
+      }
+      const receivedSignature = this.#signingSecret ? response.headers.get(SIGNATURE_HEADER.toLowerCase()) ?? response.headers.get(SIGNATURE_HEADER) : null;
+      if (this.#signingSecret && !receivedSignature && this.#verifyOnDownload) {
+        return null;
+      }
+      await pipeline(response.body, createWriteStream(stagingPath));
+      if (this.#signingSecret && receivedSignature) {
+        const expected = await computeArtifactSignatureStream(this.#signingSecret, actionDigest.hash, stagingPath);
+        if (!signaturesMatch(receivedSignature, expected)) {
+          return null;
+        }
+      }
+      const blobDigest = await digestFile(stagingPath);
+      await putBlobFromFile(this.#localCasRoot, blobDigest, stagingPath);
+      return {
+        exitCode: 0,
+        outputDirectories: [],
+        outputFiles: [{ digest: blobDigest, isExecutable: false, path: BLOB_OUTPUT_PATH }]
+      };
+    } catch {
+      return null;
+    } finally {
+      await rm(stagingPath, { force: true }).catch(() => {
+      });
+    }
+  }
+  /**
+   * {@link RemoteCacheBackend.storeAction}: takes the single blob
+   * referenced by `result.outputFiles[0]`, streams its bytes as the
+   * PUT body, and signs the body when a signing secret is configured.
+   * Per-digest in-flight dedup means parallel writers racing on the
+   * same action upload exactly once.
+   */
+  async storeAction(actionDigest, result, blobs) {
+    if (!this.#write) {
+      return false;
+    }
+    if (result.outputFiles.length !== 1 || blobs.length === 0) {
+      return false;
+    }
+    const tarballEntry = result.outputFiles[0];
+    if (!tarballEntry) {
+      return false;
+    }
+    const blob = blobs.find((candidate) => candidate.digest.hash === tarballEntry.digest.hash);
+    if (!blob) {
+      return false;
+    }
+    const existing = this.#inflightUploads.get(actionDigest.hash);
+    if (existing) {
+      return existing;
+    }
+    const upload = this.#uploadAction(actionDigest, blob).finally(() => {
+      this.#inflightUploads.delete(actionDigest.hash);
+    });
+    this.#inflightUploads.set(actionDigest.hash, upload);
+    return upload;
+  }
+  async #uploadAction(actionDigest, blob) {
+    const stagingRoot = this.#localCasRoot ? join(this.#localCasRoot, "v2", "tmp") : join(tmpdir(), "visulima-task-runner-uploads");
+    const stagingPath = join(stagingRoot, `.upload-${actionDigest.hash}-${uniqueId()}`);
+    try {
+      await mkdir(stagingRoot, { recursive: true });
+      const source = await blob.open();
+      await pipeline(source, createWriteStream(stagingPath));
+      const artifactUrl = this.#buildUrl(`/v8/artifacts/${actionDigest.hash}`);
+      const { size } = await stat(stagingPath);
+      const uploadHeaders = {
+        ...this.#buildHeaders(),
+        "Content-Length": String(size),
+        "Content-Type": "application/octet-stream",
+        "X-Artifact-Compression": this.#compression
+      };
+      if (this.#signingSecret) {
+        uploadHeaders[SIGNATURE_HEADER] = await computeArtifactSignatureStream(this.#signingSecret, actionDigest.hash, stagingPath);
+      }
+      const response = await fetch(artifactUrl, {
+        body: createReadStream(stagingPath),
+        // @ts-expect-error — `duplex` is a Node-specific fetch
+        // option required when the body is a stream.
+        duplex: "half",
+        headers: uploadHeaders,
+        method: "PUT",
+        signal: AbortSignal.timeout(this.#timeout)
+      });
+      return response.ok;
+    } catch (error) {
+      this.#onUploadError?.(actionDigest.hash, error);
+      return false;
+    } finally {
+      await rm(stagingPath, { force: true }).catch(() => {
+      });
+    }
+  }
+  #buildUrl(path) {
+    const url = `${this.#url}${path}`;
+    if (this.#teamId) {
+      return `${url}?teamId=${encodeURIComponent(this.#teamId)}`;
+    }
+    return url;
+  }
+  #buildHeaders() {
+    const headers = {};
+    if (this.#token) {
+      headers["Authorization"] = `Bearer ${this.#token}`;
+    }
+    return headers;
+  }
+}
+
+export { HttpRemoteCache };

package/dist/packem_shared/INPUT_URI_SCHEMES-DRm76YI5.js

@@ -0,0 +1,69 @@
+const INPUT_URI_SCHEMES = ["file", "glob", "env", "func", "dep"];
+const URI_SCHEME_RE = /^([a-z][a-z0-9+.-]*):\/\//i;
+class InvalidInputUriError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InvalidInputUriError";
+  }
+}
+const parseInputUri = (input) => {
+  const negated = input.startsWith("!");
+  const body = negated ? input.slice(1) : input;
+  const match = URI_SCHEME_RE.exec(body);
+  if (!match) {
+    return void 0;
+  }
+  const scheme = match[1].toLowerCase();
+  const rest = body.slice(match[0].length);
+  switch (scheme) {
+    case "file":
+    case "glob": {
+      if (rest.length === 0) {
+        throw new InvalidInputUriError(`${scheme}:// input requires a path or pattern (got "${input}").`);
+      }
+      return { fileset: negated ? `!${rest}` : rest };
+    }
+    case "env": {
+      if (negated) {
+        throw new InvalidInputUriError(`Negation is not supported for env:// inputs (got "${input}"). Drop env vars from the named-input set instead.`);
+      }
+      if (rest.length === 0) {
+        throw new InvalidInputUriError(`env:// input requires a variable name (got "${input}").`);
+      }
+      return { env: rest };
+    }
+    case "func": {
+      if (negated) {
+        throw new InvalidInputUriError(`Negation is not supported for func:// inputs (got "${input}").`);
+      }
+      if (rest.length === 0) {
+        throw new InvalidInputUriError(`func:// input requires a command (got "${input}").`);
+      }
+      return { runtime: rest };
+    }
+    case "dep": {
+      if (negated) {
+        throw new InvalidInputUriError(`Negation is not supported for dep:// inputs (got "${input}").`);
+      }
+      if (rest.length === 0) {
+        throw new InvalidInputUriError(`dep:// input requires at least one dependency name (got "${input}").`);
+      }
+      const names = rest.split(",").map((s) => s.trim());
+      if (names.some((s) => s.length === 0)) {
+        throw new InvalidInputUriError(`dep:// input contains an empty dependency segment (got "${input}"). Remove trailing or repeated commas.`);
+      }
+      return { externalDependencies: names };
+    }
+    default: {
+      throw new InvalidInputUriError(
+        `Unknown input URI scheme "${scheme}://" in "${input}". Recognized schemes: ${INPUT_URI_SCHEMES.map((s) => `${s}://`).join(", ")}.`
+      );
+    }
+  }
+};
+const looksLikeInputUri = (input) => {
+  const body = input.startsWith("!") ? input.slice(1) : input;
+  return URI_SCHEME_RE.test(body);
+};
+
+export { INPUT_URI_SCHEMES, InvalidInputUriError, looksLikeInputUri, parseInputUri };

package/dist/packem_shared/{IncrementalFileHasher-BRS76-mb.js → IncrementalFileHasher-BBhVK491.js}

@@ -23,7 +23,7 @@ const {
   writeFile,
   stat
 } = __cjs_getBuiltinModule("node:fs/promises");
-import { c as collectFiles, x as xxh3Hash } from './utils-zO0ZRgtf.js';
+import { c as collectFiles, x as xxh3Hash } from './utils-Bmnj-H2J.js';
 import { join, dirname, relative } from '@visulima/path';
 
 const DEFAULT_IGNORED_DIRS = /* @__PURE__ */ new Set([".cache", ".git", ".task-runner-cache", "coverage", "dist", "node_modules"]);