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

package/dist/packem_shared/utils-zO0ZRgtf.js

@@ -1,390 +0,0 @@
-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

@@ -1,55 +0,0 @@
-/**
- * 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 };

package/dist/run-summary.d.ts

@@ -1,89 +0,0 @@
-import type { TaskGraph, TaskHashDetails, TaskResults } from "./types.d.ts";
-/**
- * Summary of a single task execution.
- */
-interface TaskSummary {
-    /** Whether the task was cacheable */
-    cacheable: boolean;
-    /** Cache status */
-    cacheStatus: "HIT" | "MISS" | "REMOTE_HIT" | "SKIPPED";
-    /** Dependencies on other tasks */
-    dependencies: string[];
-    /** Duration in milliseconds */
-    duration: number | undefined;
-    /** End time (ISO 8601) */
-    endTime: string | undefined;
-    /** Exit code */
-    exitCode: number | undefined;
-    /** The computed cache hash */
-    hash: string | undefined;
-    /** Detailed hash information */
-    hashDetails: TaskHashDetails | undefined;
-    /** The task's declared outputs */
-    outputs: string[];
-    /** Start time (ISO 8601) */
-    startTime: string | undefined;
-    /** The task target */
-    target: {
-        configuration?: string;
-        project: string;
-        target: string;
-    };
-    /** The task ID (e.g., "app:build") */
-    taskId: string;
-}
-/**
- * Complete summary of a task runner execution.
- */
-interface RunSummary {
-    /** Total duration in milliseconds */
-    duration: number;
-    /** Run end time (ISO 8601) */
-    endTime: string;
-    /** Environment info */
-    environment: {
-        /** Architecture */
-        arch: string;
-        /** Node.js version */
-        nodeVersion: string;
-        /** Platform */
-        platform: string;
-    };
-    /** Unique run ID */
-    id: string;
-    /** Run start time (ISO 8601) */
-    startTime: string;
-    /** Overall execution statistics */
-    stats: {
-        /** Number of cached tasks (local + remote) */
-        cached: number;
-        /** Number of failed tasks */
-        failed: number;
-        /** Number of skipped tasks */
-        skipped: number;
-        /** Number of successful tasks */
-        succeeded: number;
-        /** Total number of tasks */
-        total: number;
-    };
-    /** The task graph used for this run */
-    taskGraph: {
-        dependencies: Record<string, string[]>;
-        roots: string[];
-    };
-    /** Summary of each task */
-    tasks: TaskSummary[];
-}
-/**
- * Generates a run summary from task results.
- */
-declare const generateRunSummary: (results: TaskResults, taskGraph: TaskGraph, startTime: number) => RunSummary;
-/**
- * Writes the run summary to a JSON file in the `.task-runner/runs/` directory.
- * @param summary The run summary to write
- * @param workspaceRoot The workspace root directory
- * @returns The path to the written summary file
- */
-declare const writeRunSummary: (summary: RunSummary, workspaceRoot: string) => Promise<string>;
-export type { RunSummary, TaskSummary };
-export { generateRunSummary, writeRunSummary };

package/dist/task-graph-utils.d.ts

@@ -1,39 +0,0 @@
-import type { TaskGraph } from "./types.d.ts";
-/**
- * Finds a single cycle in the task graph, if one exists.
- * Returns the cycle as an array of task IDs, or null if no cycle exists.
- */
-export declare const findCycle: (taskGraph: TaskGraph) => string[] | undefined;
-/**
- * Finds all cycles in the task graph.
- */
-export declare const findCycles: (taskGraph: TaskGraph) => string[][];
-/**
- * Walks the task graph in topological order (dependencies before dependents),
- * calling the callback for each task.
- *
- * Note: If the graph contains cycles, tasks involved in cycles will not be visited.
- * Use `findCycle` to detect cycles before walking if complete traversal is required.
- */
-export declare const walkTaskGraph: (taskGraph: TaskGraph, callback: (taskId: string) => void) => void;
-/**
- * Returns a reversed copy of the task graph (edges point in the opposite direction).
- */
-export declare const reverseTaskGraph: (taskGraph: TaskGraph) => TaskGraph;
-/**
- * Returns the leaf tasks (tasks with no dependencies of their own).
- */
-export declare const getLeafTasks: (taskGraph: TaskGraph) => string[];
-/**
- * Removes edges that form cycles, making the graph acyclic.
- * Returns a new task graph without the cycle-forming edges.
- */
-export declare const makeAcyclic: (taskGraph: TaskGraph) => TaskGraph;
-/**
- * Gets all tasks that depend on the given task (directly or transitively).
- */
-export declare const getDependentTasks: (taskGraph: TaskGraph, taskId: string) => string[];
-/**
- * Gets all tasks that the given task depends on (directly or transitively).
- */
-export declare const getTransitiveDependencies: (taskGraph: TaskGraph, taskId: string) => string[];

package/dist/task-graph.d.ts

@@ -1,22 +0,0 @@
-import type { ProjectGraph, TargetConfiguration, Task, TaskGraph, TaskTarget, WorkspaceConfiguration } from "./types.d.ts";
-interface CreateTaskGraphOptions {
-    /** The project graph */
-    projectGraph: ProjectGraph;
-    /** Target default configurations */
-    targetDefaults?: Record<string, Partial<TargetConfiguration>>;
-    /** The workspace configuration */
-    workspace: WorkspaceConfiguration;
-}
-/**
- * Creates a unique task ID from a target.
- */
-declare const getTaskId: (target: TaskTarget) => string;
-/**
- * Parses a task ID into its component parts.
- */
-declare const parseTaskId: (taskId: string) => TaskTarget;
-/**
- * Creates a task graph from a list of tasks, resolving all dependencies.
- */
-declare const createTaskGraph: (initialTasks: Task[], options: CreateTaskGraphOptions) => TaskGraph;
-export { createTaskGraph, getTaskId, parseTaskId };

package/dist/task-hasher.d.ts

@@ -1,67 +0,0 @@
-import type { NamedInputs, ProjectConfiguration, TargetConfiguration, Task, TaskHashDetails } from "./types.d.ts";
-/**
- * Interface for task hashers.
- */
-interface TaskHasher {
-    hashTask: (task: Task) => Promise<TaskHashDetails>;
-}
-/**
- * Options for creating an InProcessTaskHasher.
- */
-interface TaskHasherOptions {
-    /** Additional environment variables to include in hash */
-    envVars?: string[];
-    /**
-     * Enable framework environment variable inference.
-     * When true, auto-detects frameworks and includes their public
-     * env var prefixes in the task hash.
-     * @default false
-     */
-    frameworkInference?: boolean;
-    /**
-     * Global environment variables that invalidate all task hashes.
-     */
-    globalEnv?: string[];
-    /**
-     * Global input files that invalidate all task hashes when changed.
-     * These are workspace-root-relative paths (e.g., "pnpm-lock.yaml").
-     */
-    globalInputs?: string[];
-    /** Named input definitions */
-    namedInputs?: NamedInputs;
-    /** Project configurations keyed by project name */
-    projects: Record<string, ProjectConfiguration>;
-    /**
-     * Enable smart lockfile hashing.
-     * When true, instead of hashing the entire lockfile, only the resolved
-     * versions of a package's actual dependencies are hashed.
-     * This means changing the lockfile only busts cache for affected packages.
-     *
-     * Matches Turborepo's smart lockfile hashing behavior.
-     * @default false
-     */
-    smartLockfileHashing?: boolean;
-    /** Target default configurations */
-    targetDefaults?: Record<string, Partial<TargetConfiguration>>;
-    /** The workspace root directory */
-    workspaceRoot: string;
-}
-/**
- * Computes hashes for tasks based on their inputs.
- * Used to determine if a cached result can be reused.
- */
-declare class InProcessTaskHasher implements TaskHasher {
-    #private;
-    constructor(options: TaskHasherOptions);
-    hashTask(task: Task): Promise<TaskHashDetails>;
-    clearCache(): void;
-}
-/**
- * Computes the final hash for a task from its hash details.
- * Uses native Rust xxh3-128 when available, otherwise pure TS xxh3-ts.
- * Both produce identical xxh3-128 hashes, ensuring cache compatibility
- * regardless of whether the native addon is loaded.
- */
-declare const computeTaskHash: (hashDetails: TaskHashDetails) => string;
-export { computeTaskHash, InProcessTaskHasher };
-export type { TaskHasher, TaskHasherOptions };