@visulima/task-runner 0.0.1 → 1.0.0-alpha.2

package/dist/packem_shared/projectGraphToDot-VdTjHcVp.js

@@ -0,0 +1,202 @@
+var __freeze = Object.freeze;
+var __defProp = Object.defineProperty;
+var __template = (cooked, raw) => __freeze(__defProp(cooked, "raw", { value: __freeze(raw || cooked.slice()) }));
+const getNodeColor = (taskId, focused, statuses) => {
+  if (focused && !focused.has(taskId)) {
+    return "#eeeeee";
+  }
+  const status = statuses?.get(taskId);
+  switch (status) {
+    case "failure": {
+      return "#FFB6C1";
+    }
+    case "local-cache":
+    case "local-cache-kept-existing":
+    case "remote-cache": {
+      return "#87CEEB";
+    }
+    case "running": {
+      return "#FFD700";
+    }
+    case "skipped": {
+      return "#D3D3D3";
+    }
+    case "success": {
+      return "#90EE90";
+    }
+    default: {
+      return "#FFFFFF";
+    }
+  }
+};
+const getStatusIcon = (status) => {
+  switch (status) {
+    case "failure": {
+      return "[FAIL] ";
+    }
+    case "local-cache":
+    case "local-cache-kept-existing":
+    case "remote-cache": {
+      return "[cache] ";
+    }
+    case "running": {
+      return "[...] ";
+    }
+    case "skipped": {
+      return "[skip] ";
+    }
+    case "success": {
+      return "[ok] ";
+    }
+    default: {
+      return "";
+    }
+  }
+};
+const formatTaskLine = (taskId, statuses) => {
+  const icon = getStatusIcon(statuses?.get(taskId));
+  return `${icon}${taskId}`;
+};
+const printTree = (taskId, prefix, isLast, taskGraph, printed, lines, statuses) => {
+  let connector;
+  if (prefix === "") {
+    connector = "";
+  } else if (isLast) {
+    connector = "└── ";
+  } else {
+    connector = "├── ";
+  }
+  const isDuplicate = printed.has(taskId);
+  const suffix = isDuplicate ? " (*)" : "";
+  const statusIcon = getStatusIcon(statuses?.get(taskId));
+  lines.push(`${prefix}${connector}${statusIcon}${taskId}${suffix}`);
+  if (isDuplicate) {
+    return;
+  }
+  printed.add(taskId);
+  const deps = taskGraph.dependencies[taskId] ?? [];
+  let childPrefix;
+  if (prefix === "") {
+    childPrefix = "";
+  } else if (isLast) {
+    childPrefix = `${prefix}    `;
+  } else {
+    childPrefix = `${prefix}│   `;
+  }
+  for (let i = 0; i < deps.length; i += 1) {
+    const isChildLast = i === deps.length - 1;
+    const dependency = deps[i];
+    if (dependency) {
+      printTree(dependency, childPrefix, isChildLast, taskGraph, printed, lines, statuses);
+    }
+  }
+};
+const toGraphvizDot = (taskGraph, options = {}) => {
+  const { focusedTasks, groupByProject = true, taskStatuses } = options;
+  const focused = focusedTasks ? new Set(focusedTasks) : void 0;
+  const lines = ["digraph TaskGraph {", "  rankdir=LR;", '  node [shape=box, style=filled, fontname="monospace"];'];
+  if (groupByProject) {
+    const projectTasks = /* @__PURE__ */ new Map();
+    for (const task of Object.values(taskGraph.tasks)) {
+      const { project } = task.target;
+      const list = projectTasks.get(project) ?? [];
+      list.push(task);
+      projectTasks.set(project, list);
+    }
+    for (const [project, tasks] of projectTasks) {
+      lines.push(`  subgraph "cluster_${project}" {`, `    label="${project}";`, "    style=dashed;", '    color="#888888";');
+      for (const task of tasks) {
+        const color = getNodeColor(task.id, focused, taskStatuses);
+        lines.push(`    "${task.id}" [label="${task.target.target}", fillcolor="${color}"];`);
+      }
+      lines.push("  }");
+    }
+  } else {
+    for (const task of Object.values(taskGraph.tasks)) {
+      const color = getNodeColor(task.id, focused, taskStatuses);
+      lines.push(`  "${task.id}" [fillcolor="${color}"];`);
+    }
+  }
+  for (const [taskId, deps] of Object.entries(taskGraph.dependencies)) {
+    for (const dep of deps) {
+      const edgeColor = focused && !focused.has(taskId) ? "#cccccc" : "#333333";
+      lines.push(`  "${taskId}" -> "${dep}" [color="${edgeColor}"];`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+};
+const toGraphJson = (taskGraph, taskStatuses) => {
+  const nodes = Object.values(taskGraph.tasks).map((task) => {
+    return {
+      configuration: task.target.configuration,
+      id: task.id,
+      project: task.target.project,
+      status: taskStatuses?.get(task.id),
+      target: task.target.target
+    };
+  });
+  const edges = [];
+  for (const [source, deps] of Object.entries(taskGraph.dependencies)) {
+    for (const target of deps) {
+      edges.push({ source, target });
+    }
+  }
+  return { edges, nodes, roots: taskGraph.roots };
+};
+var _a;
+const toGraphHtml = (taskGraph, options = {}) => {
+  const graphData = toGraphJson(taskGraph, options.taskStatuses);
+  if (options.focusedTasks && options.focusedTasks.length > 0) {
+    const focused = new Set(options.focusedTasks);
+    graphData.nodes = graphData.nodes.filter((n) => focused.has(n.id));
+    graphData.edges = graphData.edges.filter((e) => focused.has(e.source) && focused.has(e.target));
+    graphData.roots = graphData.roots.filter((r) => focused.has(r));
+  }
+  return String.raw(_a || (_a = __template(['<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="UTF-8">\n<title>Task Graph</title>\n<style>\n  * { margin: 0; padding: 0; box-sizing: border-box; }\n  body { font-family: system-ui, -apple-system, sans-serif; background: #1a1a2e; color: #eee; }\n  svg { width: 100vw; height: 100vh; }\n  .node rect { rx: 6; ry: 6; stroke: #555; stroke-width: 1.5; cursor: pointer; }\n  .node text { font-size: 11px; fill: #1a1a2e; font-weight: 600; pointer-events: none; }\n  .node:hover rect { stroke: #fff; stroke-width: 2; }\n  .edge { stroke: #444; stroke-width: 1.5; fill: none; marker-end: url(#arrow); }\n  .label { font-size: 10px; fill: #888; }\n  #info { position: fixed; top: 12px; right: 12px; background: #16213e; padding: 12px 16px; border-radius: 8px; font-size: 13px; }\n  #info b { color: #e94560; }\n</style>\n</head>\n<body>\n<div id="info">\n  <b>', "</b> tasks &middot; <b>", "</b> dependencies &middot; <b>", '</b> roots\n</div>\n<svg id="graph">\n  <defs>\n    <marker id="arrow" viewBox="0 0 10 10" refX="10" refY="5" markerWidth="6" markerHeight="6" orient="auto">\n      <path d="M 0 0 L 10 5 L 0 10 z" fill="#666"/>\n    </marker>\n  </defs>\n</svg>\n<script>\nconst data = ', ";\nconst svg = document.getElementById('graph');\nconst W = window.innerWidth, H = window.innerHeight;\nconst statusColors = {\n  success: '#2ecc71', 'local-cache': '#3498db', 'remote-cache': '#9b59b6',\n  failure: '#e74c3c', running: '#f39c12', skipped: '#95a5a6', pending: '#ecf0f1'\n};\nconst projectColors = {};\nconst palette = ['#e94560','#0f3460','#533483','#16c79a','#f39c12','#2ecc71','#3498db','#e67e22','#9b59b6','#1abc9c'];\nlet ci = 0;\ndata.nodes.forEach(n => {\n  if (!projectColors[n.project]) projectColors[n.project] = palette[ci++ % palette.length];\n});\n\n// Simple force-directed layout\nconst nodes = data.nodes.map((n, i) => ({\n  ...n, x: W/2 + (Math.random()-0.5)*400, y: H/2 + (Math.random()-0.5)*300, vx: 0, vy: 0\n}));\nconst nodeMap = new Map(nodes.map(n => [n.id, n]));\nconst edges = data.edges.map(e => ({ source: nodeMap.get(e.source), target: nodeMap.get(e.target) }));\n\nfunction simulate() {\n  for (let iter = 0; iter < 300; iter++) {\n    // Repulsion\n    for (let i = 0; i < nodes.length; i++) {\n      for (let j = i+1; j < nodes.length; j++) {\n        let dx = nodes[j].x - nodes[i].x, dy = nodes[j].y - nodes[i].y;\n        let d = Math.sqrt(dx*dx + dy*dy) || 1;\n        let f = 8000 / (d * d);\n        nodes[i].vx -= dx/d * f; nodes[i].vy -= dy/d * f;\n        nodes[j].vx += dx/d * f; nodes[j].vy += dy/d * f;\n      }\n    }\n    // Attraction (edges)\n    edges.forEach(e => {\n      if (!e.source || !e.target) return;\n      let dx = e.target.x - e.source.x, dy = e.target.y - e.source.y;\n      let d = Math.sqrt(dx*dx + dy*dy) || 1;\n      let f = (d - 150) * 0.01;\n      e.source.vx += dx/d * f; e.source.vy += dy/d * f;\n      e.target.vx -= dx/d * f; e.target.vy -= dy/d * f;\n    });\n    // Gravity\n    nodes.forEach(n => {\n      n.vx += (W/2 - n.x) * 0.001;\n      n.vy += (H/2 - n.y) * 0.001;\n      n.x += n.vx * 0.3; n.y += n.vy * 0.3;\n      n.vx *= 0.8; n.vy *= 0.8;\n      n.x = Math.max(60, Math.min(W-60, n.x));\n      n.y = Math.max(30, Math.min(H-30, n.y));\n    });\n  }\n}\nsimulate();\n\n// Render\nedges.forEach(e => {\n  if (!e.source || !e.target) return;\n  const line = document.createElementNS('http://www.w3.org/2000/svg','line');\n  line.setAttribute('x1', e.source.x); line.setAttribute('y1', e.source.y);\n  line.setAttribute('x2', e.target.x); line.setAttribute('y2', e.target.y);\n  line.setAttribute('class','edge');\n  svg.appendChild(line);\n});\nnodes.forEach(n => {\n  const g = document.createElementNS('http://www.w3.org/2000/svg','g');\n  g.setAttribute('class','node');\n  g.setAttribute('transform','translate('+(n.x-50)+','+(n.y-14)+')');\n  const rect = document.createElementNS('http://www.w3.org/2000/svg','rect');\n  rect.setAttribute('width','100'); rect.setAttribute('height','28');\n  rect.setAttribute('fill', n.status ? (statusColors[n.status]||'#ecf0f1') : projectColors[n.project]);\n  g.appendChild(rect);\n  const text = document.createElementNS('http://www.w3.org/2000/svg','text');\n  text.setAttribute('x','50'); text.setAttribute('y','18'); text.setAttribute('text-anchor','middle');\n  text.textContent = n.id.length > 14 ? n.target : n.id;\n  g.appendChild(text);\n  g.addEventListener('click', () => {\n    const deps = data.edges.filter(e => e.source === n.id).map(e => e.target);\n    const rdeps = data.edges.filter(e => e.target === n.id).map(e => e.source);\n    alert(n.id + '\n\nDepends on: ' + (deps.join(', ')||'none') + '\nRequired by: ' + (rdeps.join(', ')||'none'));\n  });\n  svg.appendChild(g);\n});\n<\/script>\n</body>\n</html>"], ['<!DOCTYPE html>\n<html lang="en">\n<head>\n<meta charset="UTF-8">\n<title>Task Graph</title>\n<style>\n  * { margin: 0; padding: 0; box-sizing: border-box; }\n  body { font-family: system-ui, -apple-system, sans-serif; background: #1a1a2e; color: #eee; }\n  svg { width: 100vw; height: 100vh; }\n  .node rect { rx: 6; ry: 6; stroke: #555; stroke-width: 1.5; cursor: pointer; }\n  .node text { font-size: 11px; fill: #1a1a2e; font-weight: 600; pointer-events: none; }\n  .node:hover rect { stroke: #fff; stroke-width: 2; }\n  .edge { stroke: #444; stroke-width: 1.5; fill: none; marker-end: url(#arrow); }\n  .label { font-size: 10px; fill: #888; }\n  #info { position: fixed; top: 12px; right: 12px; background: #16213e; padding: 12px 16px; border-radius: 8px; font-size: 13px; }\n  #info b { color: #e94560; }\n</style>\n</head>\n<body>\n<div id="info">\n  <b>', "</b> tasks &middot; <b>", "</b> dependencies &middot; <b>", '</b> roots\n</div>\n<svg id="graph">\n  <defs>\n    <marker id="arrow" viewBox="0 0 10 10" refX="10" refY="5" markerWidth="6" markerHeight="6" orient="auto">\n      <path d="M 0 0 L 10 5 L 0 10 z" fill="#666"/>\n    </marker>\n  </defs>\n</svg>\n<script>\nconst data = ', ";\nconst svg = document.getElementById('graph');\nconst W = window.innerWidth, H = window.innerHeight;\nconst statusColors = {\n  success: '#2ecc71', 'local-cache': '#3498db', 'remote-cache': '#9b59b6',\n  failure: '#e74c3c', running: '#f39c12', skipped: '#95a5a6', pending: '#ecf0f1'\n};\nconst projectColors = {};\nconst palette = ['#e94560','#0f3460','#533483','#16c79a','#f39c12','#2ecc71','#3498db','#e67e22','#9b59b6','#1abc9c'];\nlet ci = 0;\ndata.nodes.forEach(n => {\n  if (!projectColors[n.project]) projectColors[n.project] = palette[ci++ % palette.length];\n});\n\n// Simple force-directed layout\nconst nodes = data.nodes.map((n, i) => ({\n  ...n, x: W/2 + (Math.random()-0.5)*400, y: H/2 + (Math.random()-0.5)*300, vx: 0, vy: 0\n}));\nconst nodeMap = new Map(nodes.map(n => [n.id, n]));\nconst edges = data.edges.map(e => ({ source: nodeMap.get(e.source), target: nodeMap.get(e.target) }));\n\nfunction simulate() {\n  for (let iter = 0; iter < 300; iter++) {\n    // Repulsion\n    for (let i = 0; i < nodes.length; i++) {\n      for (let j = i+1; j < nodes.length; j++) {\n        let dx = nodes[j].x - nodes[i].x, dy = nodes[j].y - nodes[i].y;\n        let d = Math.sqrt(dx*dx + dy*dy) || 1;\n        let f = 8000 / (d * d);\n        nodes[i].vx -= dx/d * f; nodes[i].vy -= dy/d * f;\n        nodes[j].vx += dx/d * f; nodes[j].vy += dy/d * f;\n      }\n    }\n    // Attraction (edges)\n    edges.forEach(e => {\n      if (!e.source || !e.target) return;\n      let dx = e.target.x - e.source.x, dy = e.target.y - e.source.y;\n      let d = Math.sqrt(dx*dx + dy*dy) || 1;\n      let f = (d - 150) * 0.01;\n      e.source.vx += dx/d * f; e.source.vy += dy/d * f;\n      e.target.vx -= dx/d * f; e.target.vy -= dy/d * f;\n    });\n    // Gravity\n    nodes.forEach(n => {\n      n.vx += (W/2 - n.x) * 0.001;\n      n.vy += (H/2 - n.y) * 0.001;\n      n.x += n.vx * 0.3; n.y += n.vy * 0.3;\n      n.vx *= 0.8; n.vy *= 0.8;\n      n.x = Math.max(60, Math.min(W-60, n.x));\n      n.y = Math.max(30, Math.min(H-30, n.y));\n    });\n  }\n}\nsimulate();\n\n// Render\nedges.forEach(e => {\n  if (!e.source || !e.target) return;\n  const line = document.createElementNS('http://www.w3.org/2000/svg','line');\n  line.setAttribute('x1', e.source.x); line.setAttribute('y1', e.source.y);\n  line.setAttribute('x2', e.target.x); line.setAttribute('y2', e.target.y);\n  line.setAttribute('class','edge');\n  svg.appendChild(line);\n});\nnodes.forEach(n => {\n  const g = document.createElementNS('http://www.w3.org/2000/svg','g');\n  g.setAttribute('class','node');\n  g.setAttribute('transform','translate('+(n.x-50)+','+(n.y-14)+')');\n  const rect = document.createElementNS('http://www.w3.org/2000/svg','rect');\n  rect.setAttribute('width','100'); rect.setAttribute('height','28');\n  rect.setAttribute('fill', n.status ? (statusColors[n.status]||'#ecf0f1') : projectColors[n.project]);\n  g.appendChild(rect);\n  const text = document.createElementNS('http://www.w3.org/2000/svg','text');\n  text.setAttribute('x','50'); text.setAttribute('y','18'); text.setAttribute('text-anchor','middle');\n  text.textContent = n.id.length > 14 ? n.target : n.id;\n  g.appendChild(text);\n  g.addEventListener('click', () => {\n    const deps = data.edges.filter(e => e.source === n.id).map(e => e.target);\n    const rdeps = data.edges.filter(e => e.target === n.id).map(e => e.source);\n    alert(n.id + '\\n\\nDepends on: ' + (deps.join(', ')||'none') + '\\nRequired by: ' + (rdeps.join(', ')||'none'));\n  });\n  svg.appendChild(g);\n});\n<\/script>\n</body>\n</html>"])), graphData.nodes.length, graphData.edges.length, graphData.roots.length, JSON.stringify(graphData).replaceAll("</", String.raw`<\/`));
+};
+const toGraphAscii = (taskGraph, options = {}) => {
+  const { taskStatuses } = options;
+  const lines = [];
+  const taskCount = Object.keys(taskGraph.tasks).length;
+  const edgeCount = Object.values(taskGraph.dependencies).reduce((s, d) => s + d.length, 0);
+  lines.push(`Task Graph (${taskCount} tasks, ${edgeCount} dependencies)`, "");
+  const allDeps = /* @__PURE__ */ new Set();
+  for (const deps of Object.values(taskGraph.dependencies)) {
+    for (const dep of deps) {
+      allDeps.add(dep);
+    }
+  }
+  const roots = Object.keys(taskGraph.tasks).filter((id) => !allDeps.has(id));
+  if (roots.length === 0) {
+    for (const taskId of Object.keys(taskGraph.tasks)) {
+      lines.push(formatTaskLine(taskId, taskStatuses));
+    }
+    return lines.join("\n");
+  }
+  const printed = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    printTree(root, "", true, taskGraph, printed, lines, taskStatuses);
+  }
+  if (printed.size < taskCount) {
+    lines.push("", "(*) = already shown above");
+  }
+  return lines.join("\n");
+};
+const projectGraphToDot = (projectGraph) => {
+  const lines = ["digraph ProjectGraph {", "  rankdir=LR;", '  node [shape=box, style=filled, fillcolor="#87CEEB", fontname="monospace"];'];
+  for (const node of Object.values(projectGraph.nodes)) {
+    const color = node.type === "application" ? "#FFD700" : "#87CEEB";
+    lines.push(`  "${node.name}" [fillcolor="${color}"];`);
+  }
+  for (const [project, deps] of Object.entries(projectGraph.dependencies)) {
+    for (const dep of deps) {
+      const style = dep.type === "implicit" ? "dashed" : "solid";
+      lines.push(`  "${project}" -> "${dep.target}" [style=${style}];`);
+    }
+  }
+  lines.push("}");
+  return lines.join("\n");
+};
+
+export { projectGraphToDot, toGraphAscii, toGraphHtml, toGraphJson, toGraphvizDot };

package/dist/packem_shared/utils-zO0ZRgtf.js

@@ -0,0 +1,390 @@
+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 {
+  stat,
+  realpath,
+  readdir,
+  readFile
+} = __cjs_getBuiltinModule("node:fs/promises");
+import { join } from '@visulima/path';
+
+const MASK_128 = (1n << 128n) - 1n;
+const MASK_64 = (1n << 64n) - 1n;
+const MASK_32 = (1n << 32n) - 1n;
+const PRIME32_1 = 0x9E3779B1n;
+const PRIME32_2 = 0x85EBCA77n;
+const PRIME32_3 = 0xC2B2AE3Dn;
+const PRIME64_1 = 0x9E3779B185EBCA87n;
+const PRIME64_2 = 0xC2B2AE3D27D4EB4Fn;
+const PRIME64_3 = 0x165667B19E3779F9n;
+const PRIME64_4 = 0x85EBCA77C2B2AE63n;
+const PRIME64_5 = 0x27D4EB2F165667C5n;
+const PRIME_MX1 = 0x165667919E3779F9n;
+const PRIME_MX2 = 0x9FB21C651E98DF25n;
+const STRIPE_LEN = 64;
+const ACC_NB = STRIPE_LEN / 8;
+const U64 = 8;
+const KKEY = Buffer.from(
+  "b8fe6c3923a44bbe7c01812cf721ad1cded46de9839097db7240a4a4b7b3671fcb79e64eccc0e578825ad07dccff7221b8084674f743248ee03590e6813a264c3c2852bb91c300cb88d0658b1b532ea371644897a20df94e3819ef46a9deacd8a8fa763fe39c343ff9dcbbc7c70b4f1d8a51e04bcdb45931c89f7ec9d9787364eac5ac8334d3ebc3c581a0fffa1363eb170ddd51b7f0da49d316552629d4689e2b16be587d47a1fc8ff8b8d17ad031ce45cb3a8f95160428afd7fbcabb4b407e",
+  "hex"
+);
+const getView = (buf, offset = 0) => Buffer.from(buf.buffer, buf.byteOffset + offset, buf.length - offset);
+const bswap64 = (a) => {
+  const scratch = Buffer.allocUnsafe(8);
+  scratch.writeBigUInt64LE(a);
+  return scratch.readBigUInt64BE();
+};
+const bswap32 = (a) => {
+  let v = a;
+  v = (v & 0x0000FFFFn) << 16n | (v & 0xFFFF0000n) >> 16n;
+  v = (v & 0x00FF00FFn) << 8n | (v & 0xFF00FF00n) >> 8n;
+  return v;
+};
+const multU32ToU64 = (a, b) => (a & MASK_32) * (b & MASK_32) & MASK_64;
+const rotl32 = (a, b) => (a << b | a >> 32n - b) & MASK_32;
+const xorshift64 = (b, shift) => b ^ b >> shift;
+const inv64 = (x) => ~x + 1n & MASK_64;
+const mul128Fold64 = (a, b) => {
+  const lll = a * b & MASK_128;
+  return lll & MASK_64 ^ lll >> 64n;
+};
+const avalanche = (h) => {
+  let v = h;
+  v ^= v >> 37n;
+  v = v * PRIME_MX1 & MASK_64;
+  v ^= v >> 32n;
+  return v;
+};
+const avalanche64 = (h) => {
+  let v = h;
+  v ^= v >> 33n;
+  v = v * PRIME64_2 & MASK_64;
+  v ^= v >> 29n;
+  v = v * PRIME64_3 & MASK_64;
+  v ^= v >> 32n;
+  return v;
+};
+const accumulate512 = (acc, data, key) => {
+  for (let i = 0; i < ACC_NB; i++) {
+    const dataVal = data.readBigUInt64LE(i * 8);
+    const dataKey = dataVal ^ key.readBigUInt64LE(i * 8);
+    acc[i ^ 1] += dataVal;
+    acc[i] += multU32ToU64(dataKey, dataKey >> 32n);
+  }
+  return acc;
+};
+const accumulate = (acc, data, key, nbStripes) => {
+  for (let i = 0; i < nbStripes; i++) {
+    accumulate512(acc, getView(data, i * STRIPE_LEN), getView(key, i * 8));
+  }
+  return acc;
+};
+const scrambleAcc = (acc, key) => {
+  for (let i = 0; i < ACC_NB; i++) {
+    const key64 = key.readBigUInt64LE(i * 8);
+    let acc64 = acc[i];
+    acc64 = xorshift64(acc64, 47n);
+    acc64 ^= key64;
+    acc64 *= PRIME32_1;
+    acc[i] = acc64 & MASK_64;
+  }
+  return acc;
+};
+const mix2Accs = (acc, key) => (
+  // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+  mul128Fold64(acc[0] ^ key.readBigUInt64LE(0), acc[1] ^ key.readBigUInt64LE(U64))
+);
+const mergeAccs = (acc, key, start) => {
+  let result64 = start;
+  result64 += mix2Accs(acc.slice(0), getView(key, 0));
+  result64 += mix2Accs(acc.slice(2), getView(key, 16));
+  result64 += mix2Accs(acc.slice(4), getView(key, 32));
+  result64 += mix2Accs(acc.slice(6), getView(key, 48));
+  return avalanche(result64 & MASK_64);
+};
+const hashLong = (acc, data, secret) => {
+  const nbStripesPerBlock = Math.floor((secret.byteLength - STRIPE_LEN) / 8);
+  const blockLen = STRIPE_LEN * nbStripesPerBlock;
+  const nbBlocks = Math.floor((data.byteLength - 1) / blockLen);
+  for (let i = 0; i < nbBlocks; i++) {
+    accumulate(acc, getView(data, i * blockLen), secret, nbStripesPerBlock);
+    scrambleAcc(acc, getView(secret, secret.byteLength - STRIPE_LEN));
+  }
+  const nbStripes = Math.floor((data.byteLength - 1 - blockLen * nbBlocks) / STRIPE_LEN);
+  accumulate(acc, getView(data, nbBlocks * blockLen), secret, nbStripes);
+  accumulate512(acc, getView(data, data.byteLength - STRIPE_LEN), getView(secret, secret.byteLength - STRIPE_LEN - 7));
+  return acc;
+};
+const hashLong128b = (data, secret) => {
+  const acc = new BigUint64Array([PRIME32_3, PRIME64_1, PRIME64_2, PRIME64_3, PRIME64_4, PRIME32_2, PRIME64_5, PRIME32_1]);
+  hashLong(acc, data, secret);
+  const low64 = mergeAccs(acc, getView(secret, 11), BigInt(data.byteLength) * PRIME64_1 & MASK_64);
+  const high64 = mergeAccs(
+    acc,
+    getView(secret, secret.byteLength - STRIPE_LEN - 11),
+    ~(BigInt(data.byteLength) * PRIME64_2) & MASK_64
+  );
+  return high64 << 64n | low64;
+};
+const mix16B = (data, key, seed) => mul128Fold64(
+  (data.readBigUInt64LE(0) ^ key.readBigUInt64LE(0) + seed) & MASK_64,
+  (data.readBigUInt64LE(8) ^ key.readBigUInt64LE(8) - seed) & MASK_64
+);
+const mix32B = (acc, data1, data2, key, seed) => {
+  let accl = acc & MASK_64;
+  let acch = acc >> 64n & MASK_64;
+  accl += mix16B(data1, key, seed);
+  accl ^= data2.readBigUInt64LE(0) + data2.readBigUInt64LE(8);
+  accl &= MASK_64;
+  acch += mix16B(data2, getView(key, 16), seed);
+  acch ^= data1.readBigUInt64LE(0) + data1.readBigUInt64LE(8);
+  acch &= MASK_64;
+  return acch << 64n | accl;
+};
+const len1to3_128b = (data, key32, seed) => {
+  const len = data.byteLength;
+  const combined = BigInt(data.readUInt8(len - 1)) | BigInt(len << 8) | BigInt(data.readUInt8(0) << 16) | BigInt(data.readUInt8(len >> 1) << 24);
+  const blow = (BigInt(key32.readUInt32LE(0)) ^ BigInt(key32.readUInt32LE(4))) + seed;
+  const low = (combined ^ blow) & MASK_64;
+  const bhigh = (BigInt(key32.readUInt32LE(8)) ^ BigInt(key32.readUInt32LE(12))) - seed;
+  const high = (rotl32(bswap32(combined), 13n) ^ bhigh) & MASK_64;
+  return (avalanche64(high) & MASK_64) << 64n | avalanche64(low);
+};
+const len4to8_128b = (data, key32, seed) => {
+  const len = data.byteLength;
+  const l1 = data.readUInt32LE(0);
+  const l2 = data.readUInt32LE(len - 4);
+  const l64 = BigInt(l1) | BigInt(l2) << 32n;
+  const bitflip = (key32.readBigUInt64LE(16) ^ key32.readBigUInt64LE(24)) + seed & MASK_64;
+  const keyed = l64 ^ bitflip;
+  let m128 = keyed * (PRIME64_1 + (BigInt(len) << 2n)) & MASK_128;
+  m128 += (m128 & MASK_64) << 65n;
+  m128 &= MASK_128;
+  m128 ^= m128 >> 67n;
+  return xorshift64(xorshift64(m128 & MASK_64, 35n) * PRIME_MX2 & MASK_64, 28n) | avalanche(m128 >> 64n) << 64n;
+};
+const len9to16_128b = (data, key64, seed) => {
+  const len = data.byteLength;
+  const bitflipl = (key64.readBigUInt64LE(32) ^ key64.readBigUInt64LE(40)) + seed & MASK_64;
+  const bitfliph = (key64.readBigUInt64LE(48) ^ key64.readBigUInt64LE(56)) - seed & MASK_64;
+  const ll1 = data.readBigUInt64LE();
+  let ll2 = data.readBigUInt64LE(len - 8);
+  let m128 = (ll1 ^ ll2 ^ bitflipl) * PRIME64_1;
+  const m128l = (m128 & MASK_64) + (BigInt(len - 1) << 54n);
+  m128 = m128 & (MASK_128 ^ MASK_64) | m128l;
+  ll2 ^= bitfliph;
+  m128 += ll2 + (ll2 & MASK_32) * (PRIME32_2 - 1n) << 64n;
+  m128 &= MASK_128;
+  m128 ^= bswap64(m128 >> 64n);
+  let h128 = (m128 & MASK_64) * PRIME64_2;
+  h128 += (m128 >> 64n) * PRIME64_2 << 64n;
+  h128 &= MASK_128;
+  return avalanche(h128 & MASK_64) | avalanche(h128 >> 64n) << 64n;
+};
+const len0to16_128b = (data, seed) => {
+  const len = data.byteLength;
+  if (len > 8) {
+    return len9to16_128b(data, KKEY, seed);
+  }
+  if (len >= 4) {
+    return len4to8_128b(data, KKEY, seed);
+  }
+  if (len > 0) {
+    return len1to3_128b(data, KKEY, seed);
+  }
+  return avalanche64(seed ^ KKEY.readBigUInt64LE(64) ^ KKEY.readBigUInt64LE(72)) | avalanche64(seed ^ KKEY.readBigUInt64LE(80) ^ KKEY.readBigUInt64LE(88)) << 64n;
+};
+const len17to128_128b = (data, secret, seed) => {
+  let acc = BigInt(data.byteLength) * PRIME64_1 & MASK_64;
+  let i = BigInt(data.byteLength - 1) / 32n;
+  while (i >= 0n) {
+    const ni = Number(i);
+    acc = mix32B(acc, getView(data, 16 * ni), getView(data, data.byteLength - 16 * (ni + 1)), getView(secret, 32 * ni), seed);
+    i--;
+  }
+  let h128l = acc + (acc >> 64n) & MASK_64;
+  h128l = avalanche(h128l);
+  let h128h = (acc & MASK_64) * PRIME64_1 + (acc >> 64n) * PRIME64_4 + (BigInt(data.byteLength) - seed & MASK_64) * PRIME64_2;
+  h128h &= MASK_64;
+  h128h = inv64(avalanche(h128h));
+  return h128l | h128h << 64n;
+};
+const len129to240_128b = (data, secret, seed) => {
+  let acc = BigInt(data.byteLength) * PRIME64_1 & MASK_64;
+  for (let i = 32; i < 160; i += 32) {
+    acc = mix32B(acc, getView(data, i - 32), getView(data, i - 16), getView(secret, i - 32), seed);
+  }
+  acc = avalanche(acc & MASK_64) | avalanche(acc >> 64n) << 64n;
+  for (let i = 160; i <= data.byteLength; i += 32) {
+    acc = mix32B(acc, getView(data, i - 32), getView(data, i - 16), getView(secret, 3 + i - 160), seed);
+  }
+  acc = mix32B(acc, getView(data, data.byteLength - 16), getView(data, data.byteLength - 32), getView(secret, 136 - 17 - 16), inv64(seed));
+  let h128l = acc + (acc >> 64n) & MASK_64;
+  h128l = avalanche(h128l);
+  let h128h = (acc & MASK_64) * PRIME64_1 + (acc >> 64n) * PRIME64_4 + (BigInt(data.byteLength) - seed & MASK_64) * PRIME64_2;
+  h128h &= MASK_64;
+  h128h = inv64(avalanche(h128h));
+  return h128l | h128h << 64n;
+};
+const xxh3_128 = (data, seed = 0n) => {
+  const len = data.byteLength;
+  if (len <= 16) {
+    return len0to16_128b(data, seed);
+  }
+  if (len <= 128) {
+    return len17to128_128b(data, KKEY, seed);
+  }
+  if (len <= 240) {
+    return len129to240_128b(data, KKEY, seed);
+  }
+  return hashLong128b(data, KKEY);
+};
+const bigintToHex = (value) => {
+  const hi = value >> 64n & MASK_64;
+  const lo = value & MASK_64;
+  return hi.toString(16).padStart(16, "0") + lo.toString(16).padStart(16, "0");
+};
+const xxh3Hash = (data) => bigintToHex(xxh3_128(data));
+class Xxh3Hasher {
+  #chunks = [];
+  update(data) {
+    if (typeof data === "string") {
+      this.#chunks.push(Buffer.from(data));
+    } else {
+      this.#chunks.push(data);
+    }
+    return this;
+  }
+  digest() {
+    return xxh3Hash(Buffer.concat(this.#chunks));
+  }
+}
+const createXxh3Hasher = () => new Xxh3Hasher();
+
+const hashFile = async (filePath) => {
+  try {
+    const content = await readFile(filePath);
+    return xxh3Hash(content);
+  } catch {
+    return void 0;
+  }
+};
+const hashStrings = (...values) => {
+  const hash = createXxh3Hasher();
+  for (const v of values) {
+    hash.update(v);
+    hash.update("\0");
+  }
+  return hash.digest();
+};
+const sortObjectKeys = (object) => {
+  const sorted = {};
+  for (const key of Object.keys(object).toSorted()) {
+    const value = object[key];
+    sorted[key] = value !== void 0 && value !== null && typeof value === "object" && !Array.isArray(value) ? sortObjectKeys(value) : value;
+  }
+  return sorted;
+};
+const collectFiles = async (directory, ignoredDirectories, visitedRealPaths) => {
+  const visited = visitedRealPaths ?? /* @__PURE__ */ new Set();
+  const results = [];
+  try {
+    const directoryStat = await stat(directory);
+    if (directoryStat.isFile()) {
+      return [directory];
+    }
+    const resolvedPath = await realpath(directory);
+    if (visited.has(resolvedPath)) {
+      return [];
+    }
+    visited.add(resolvedPath);
+    const entries = await readdir(directory, { withFileTypes: true });
+    const promises = entries.map(async (entry) => {
+      if (ignoredDirectories.has(entry.name)) {
+        return [];
+      }
+      const fullPath = join(directory, entry.name);
+      if (entry.isDirectory()) {
+        return collectFiles(fullPath, ignoredDirectories, visited);
+      }
+      if (entry.isFile()) {
+        return [fullPath];
+      }
+      if (entry.isSymbolicLink()) {
+        try {
+          const linkStat = await stat(fullPath);
+          if (linkStat.isFile()) {
+            return [fullPath];
+          }
+          if (linkStat.isDirectory()) {
+            return collectFiles(fullPath, ignoredDirectories, visited);
+          }
+        } catch {
+        }
+      }
+      return [];
+    });
+    const nested = await Promise.all(promises);
+    for (const files of nested) {
+      results.push(...files);
+    }
+  } catch {
+  }
+  return results;
+};
+const resolveTaskCwd = (workspaceRoot, task) => task.projectRoot ? join(workspaceRoot, task.projectRoot) : workspaceRoot;
+const createFailureResult = (task, error, startTime) => {
+  return {
+    code: 1,
+    endTime: Date.now(),
+    startTime,
+    status: "failure",
+    task,
+    terminalOutput: error instanceof Error ? error.message : String(error)
+  };
+};
+const READ_PACKAGE_DEPS_DEFAULTS = { optional: true, peer: true };
+const readPackageDeps = async (packageJsonPath, options = READ_PACKAGE_DEPS_DEFAULTS) => {
+  try {
+    const content = await readFile(packageJsonPath, "utf8");
+    const pkg = JSON.parse(content);
+    const deps = /* @__PURE__ */ new Set();
+    const maps = [pkg.dependencies, pkg.devDependencies];
+    if (options.peer !== false) {
+      maps.push(pkg.peerDependencies);
+    }
+    if (options.optional !== false) {
+      maps.push(pkg.optionalDependencies);
+    }
+    for (const depMap of maps) {
+      if (depMap) {
+        for (const name of Object.keys(depMap)) {
+          deps.add(name);
+        }
+      }
+    }
+    return deps;
+  } catch {
+    return void 0;
+  }
+};
+const uniqueId = () => `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+
+export { createFailureResult as a, hashStrings as b, collectFiles as c, resolveTaskCwd as d, createXxh3Hasher as e, hashFile as h, readPackageDeps as r, sortObjectKeys as s, uniqueId as u, xxh3Hash as x };

package/dist/remote-cache.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Options for the remote cache.
+ */
+interface RemoteCacheOptions {
+    /**
+     * Called when a fire-and-forget upload fails.
+     * Since uploads are non-blocking, errors are silently swallowed by default.
+     * Provide this callback to log or report upload failures.
+     */
+    onUploadError?: (hash: string, error: unknown) => void;
+    /** Whether to enable remote cache reads */
+    read?: boolean;
+    /** Team ID or namespace for cache isolation */
+    teamId?: string;
+    /** Request timeout in milliseconds (default: 30000) */
+    timeout?: number;
+    /** Authentication token for the remote cache */
+    token?: string;
+    /** Remote cache server URL (e.g., "https://cache.example.com") */
+    url: string;
+    /** Whether to enable remote cache writes */
+    write?: boolean;
+}
+/**
+ * HTTP-based remote cache compatible with the Turborepo remote cache protocol.
+ *
+ * Protocol:
+ * - GET  /v8/artifacts/{hash}?teamId={team}  -> retrieve cached artifact (gzipped tar)
+ * - PUT  /v8/artifacts/{hash}?teamId={team}  -> store artifact
+ * - POST /v8/artifacts/events                -> analytics (optional)
+ *
+ * Authentication via `Authorization: Bearer {token}` header.
+ *
+ * The cache entry is a gzipped tarball containing the cache directory contents
+ * (code, terminalOutput, fingerprint.json, outputs/, .commit).
+ */
+declare class RemoteCache {
+    #private;
+    constructor(options: RemoteCacheOptions);
+    /**
+     * Retrieves a cached artifact from the remote cache.
+     * Returns the local path to the extracted cache entry, or undefined if not found.
+     */
+    retrieve(hash: string, localCacheDirectory: string): Promise<boolean>;
+    /**
+     * Stores a cache entry in the remote cache.
+     */
+    store(hash: string, localCacheDirectory: string): Promise<boolean>;
+    /**
+     * Checks if an artifact exists in the remote cache without downloading it.
+     */
+    exists(hash: string): Promise<boolean>;
+}
+export type { RemoteCacheOptions };
+export { RemoteCache };