@visulima/task-runner 1.0.0-alpha.4 → 1.0.0-alpha.6

package/dist/packem_shared/{RemoteCache-BFceSe4a.js → RemoteCache-DSU3lc87.js}

@@ -18,40 +18,45 @@ const __cjs_getBuiltinModule = (module) => {
 };
 
 const {
-  execFile
-} = __cjs_getBuiltinModule("node:child_process");
+  createHmac,
+  timingSafeEqual
+} = __cjs_getBuiltinModule("node:crypto");
 const {
-  createWriteStream
+  createWriteStream,
+  createReadStream
 } = __cjs_getBuiltinModule("node:fs");
 const {
   mkdir,
   rm,
-  stat,
-  readFile
+  stat
 } = __cjs_getBuiltinModule("node:fs/promises");
 const {
   pipeline
 } = __cjs_getBuiltinModule("node:stream/promises");
 import { join } from '@visulima/path';
+import { e as extractTarBrotli, a as extractTarGz, c as createTarBrotli, b as createTarGz } from './archive-UQHAnZUa.js';
 
-const createTarGz = (sourceDirectory, outputPath) => new Promise((resolve, reject) => {
-  execFile("tar", ["-czf", outputPath, "-C", sourceDirectory, "."], (error) => {
-    if (error) {
-      reject(error);
-    } else {
-      resolve();
-    }
-  });
-});
-const extractTarGz = (archivePath, destinationDirectory) => new Promise((resolve, reject) => {
-  execFile("tar", ["-xzf", archivePath, "-C", destinationDirectory], (error) => {
-    if (error) {
-      reject(error);
-    } else {
-      resolve();
-    }
-  });
-});
+const SIGNATURE_HEADER = "X-Artifact-Signature";
+const MIN_SECRET_LENGTH = 16;
+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 RemoteCache {
   #url;
   #token;
@@ -60,6 +65,9 @@ class RemoteCache {
   #read;
   #write;
   #onUploadError;
+  #compression;
+  #signingSecret;
+  #verifyOnDownload;
   constructor(options) {
     this.#url = options.url.replace(/\/$/, "");
     this.#token = options.token;
@@ -68,6 +76,17 @@ class RemoteCache {
     this.#read = options.read ?? true;
     this.#write = options.write ?? true;
     this.#onUploadError = options.onUploadError;
+    this.#compression = options.compression ?? "gzip";
+    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;
+    }
   }
   /**
    * Retrieves a cached artifact from the remote cache.
@@ -89,15 +108,23 @@ class RemoteCache {
       if (!response.ok) {
         return false;
       }
-      await mkdir(localCacheDirectory, { recursive: true });
-      const { body } = response;
-      if (!body) {
+      const receivedSignature = this.#signingSecret ? response.headers.get(SIGNATURE_HEADER.toLowerCase()) ?? response.headers.get(SIGNATURE_HEADER) : null;
+      if (this.#signingSecret && !receivedSignature && this.#verifyOnDownload) {
+        return false;
+      }
+      if (!response.body) {
         return false;
       }
-      const fileStream = createWriteStream(archivePath);
-      await pipeline(body, fileStream);
+      await mkdir(localCacheDirectory, { recursive: true });
+      await pipeline(response.body, createWriteStream(archivePath));
+      if (this.#signingSecret && receivedSignature) {
+        const expected = await computeArtifactSignatureStream(this.#signingSecret, hash, archivePath);
+        if (!signaturesMatch(receivedSignature, expected)) {
+          return false;
+        }
+      }
       await mkdir(entryDirectory, { recursive: true });
-      await extractTarGz(archivePath, entryDirectory);
+      await (this.#compression === "brotli" ? extractTarBrotli(archivePath, entryDirectory) : extractTarGz(archivePath, entryDirectory));
       await rm(archivePath, { force: true });
       return true;
     } catch {
@@ -119,16 +146,29 @@ class RemoteCache {
     const archivePath = join(localCacheDirectory, `.upload-${hash}.tar.gz`);
     try {
       await stat(join(entryDirectory, ".commit"));
-      await createTarGz(entryDirectory, archivePath);
+      await (this.#compression === "brotli" ? createTarBrotli(entryDirectory, archivePath) : createTarGz(entryDirectory, archivePath));
       const artifactUrl = this.#buildUrl(`/v8/artifacts/${hash}`);
-      const archiveContent = await readFile(archivePath);
+      const { size } = await stat(archivePath);
+      const uploadHeaders = {
+        ...this.#buildHeaders(),
+        "Content-Length": String(size),
+        // Advertise the compression format in a custom header so
+        // spec-compatible servers (and the matching download side)
+        // can branch if needed. The body is still an opaque blob
+        // from the server's perspective.
+        "Content-Type": "application/octet-stream",
+        "X-Artifact-Compression": this.#compression
+      };
+      if (this.#signingSecret) {
+        uploadHeaders[SIGNATURE_HEADER] = await computeArtifactSignatureStream(this.#signingSecret, hash, archivePath);
+      }
       const response = await fetch(artifactUrl, {
-        body: archiveContent,
-        headers: {
-          ...this.#buildHeaders(),
-          "Content-Length": String(archiveContent.length),
-          "Content-Type": "application/octet-stream"
-        },
+        body: createReadStream(archivePath),
+        // @ts-expect-error — `duplex` is a Node-specific fetch
+        // option required when the body is a stream. The DOM
+        // `RequestInit` type doesn't include it yet.
+        duplex: "half",
+        headers: uploadHeaders,
         method: "PUT",
         signal: AbortSignal.timeout(this.#timeout)
       });

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

@@ -1,9 +1,9 @@
 import { d as resolveTaskCwd, a as createFailureResult, e as createXxh3Hasher } from './utils-zO0ZRgtf.js';
-import { join } from '@visulima/path';
-import { FingerprintManager } from './FingerprintManager-Cu-ta9ee.js';
-import { generateRunSummary, writeRunSummary } from './generateRunSummary-qn-_jKwt.js';
-import { computeTaskHash } from './computeTaskHash-B2SVZqgp.js';
-import { TrackedTaskExecutor } from './TrackedTaskExecutor-BGUKFE-7.js';
+import { resolve, join } from '@visulima/path';
+import { FingerprintManager } from './FingerprintManager-CV7U4f4f.js';
+import { generateRunSummary, writeLastRunSummary, writeRunSummary } from './generateRunSummary-BE1jnQ3H.js';
+import { computeTaskHash } from './computeTaskHash-DYqfrDGq.js';
+import { TrackedTaskExecutor } from './TrackedTaskExecutor-CFPpQfXF.js';
 
 const hashFingerprint = (fingerprint) => {
   const hash = createXxh3Hasher();
@@ -26,11 +26,11 @@ const hashFingerprint = (fingerprint) => {
   return hash.digest();
 };
 const createDeferred = () => {
-  let resolve;
+  let resolve2;
   const promise = new Promise((r) => {
-    resolve = r;
+    resolve2 = r;
   });
-  return { promise, resolve };
+  return { promise, resolve: resolve2 };
 };
 class TaskOrchestrator {
   #taskHasher;
@@ -101,9 +101,12 @@ class TaskOrchestrator {
       process.removeListener("SIGTERM", signalHandler);
       this.#lifeCycle.endCommand?.();
     }
-    if (this.#summarize && this.#taskGraph) {
+    if (this.#taskGraph && !this.#aborted) {
       const summary = generateRunSummary(this.#results, this.#taskGraph, this.#startTime);
-      await writeRunSummary(summary, this.#workspaceRoot);
+      await writeLastRunSummary(summary, this.#workspaceRoot);
+      if (this.#summarize) {
+        await writeRunSummary(summary, this.#workspaceRoot);
+      }
     }
     return this.#results;
   }
@@ -243,7 +246,13 @@ class TaskOrchestrator {
       };
       this.#results.set(task.id, result);
       if (code === 0 && task.cache !== false && task.hash) {
-        await this.#cache.put(task.hash, terminalOutput, task.outputs, code);
+        const modified = await this.#detectSelfModifiedInputs(task);
+        if (modified.length > 0) {
+          result.selfModified = true;
+          this.#lifeCycle.printSelfModifyingSkip?.(task, modified);
+        } else {
+          await this.#cache.put(task.hash, terminalOutput, task.outputs, code);
+        }
       }
       return result;
     } catch (error) {
@@ -252,6 +261,28 @@ class TaskOrchestrator {
       return result;
     }
   }
+  /**
+   * Re-hashes every file recorded in `task.hashDetails.nodes` and returns
+   * the workspace-relative paths whose post-execution hash differs from the
+   * pre-execution hash. A non-empty result means the task wrote to its own
+   * tracked inputs and the cache entry would be unsafe to persist.
+   */
+  async #detectSelfModifiedInputs(task) {
+    const nodes = task.hashDetails?.nodes;
+    if (!nodes || typeof this.#taskHasher.rehashFile !== "function") {
+      return [];
+    }
+    const rehash = this.#taskHasher.rehashFile.bind(this.#taskHasher);
+    const entries = Object.entries(nodes);
+    const checks = await Promise.all(
+      entries.map(async ([path, priorHash]) => {
+        const absolute = resolve(this.#workspaceRoot, path);
+        const fresh = await rehash(absolute);
+        return fresh !== void 0 && fresh !== priorHash ? path : void 0;
+      })
+    );
+    return checks.filter((path) => path !== void 0);
+  }
   async #executeTaskWithTracking(task, startTime) {
     if (!this.#fingerprintManager) {
       return this.#executeTask(task, startTime);
@@ -262,12 +293,18 @@ class TaskOrchestrator {
       let code;
       let terminalOutput;
       let fingerprint;
+      let trackerAccessCount = 0;
+      let usedRealTracker = false;
+      let autoWrites;
       const shellCommand = this.#resolveCommand?.(task);
       const canTrack = shellCommand && this.#trackedExecutor?.isTrackingSupported;
       if (canTrack && this.#trackedExecutor) {
         const trackedResult = await this.#trackedExecutor.execute(task, { captureOutput: this.#captureOutput, cwd }, shellCommand);
         code = trackedResult.code;
         terminalOutput = trackedResult.terminalOutput;
+        trackerAccessCount = trackedResult.accesses.length;
+        usedRealTracker = true;
+        autoWrites = trackedResult.accesses.filter((a) => a.type === "write").map((a) => a.path);
         fingerprint = await this.#fingerprintManager.createFingerprint(
           trackedResult.accesses,
           taskCommand,
@@ -309,10 +346,20 @@ class TaskOrchestrator {
       };
       this.#results.set(task.id, result);
       if (code === 0 && task.cache !== false && fingerprint) {
-        const hash = hashFingerprint(fingerprint);
-        Object.assign(task, { hash });
-        await this.#cache.put(hash, terminalOutput, task.outputs, code, fingerprint);
-        await this.#cache.setTaskIndex(task.id, hash);
+        const modified = this.#detectSelfModifiedFingerprint(fingerprint);
+        const emptyFingerprintReason = this.#describeEmptyFingerprint(fingerprint, usedRealTracker, trackerAccessCount);
+        if (modified.length > 0) {
+          result.selfModified = true;
+          this.#lifeCycle.printSelfModifyingSkip?.(task, modified);
+        } else if (emptyFingerprintReason) {
+          result.emptyFingerprint = true;
+          this.#lifeCycle.printEmptyFingerprintWarning?.(task, emptyFingerprintReason);
+        } else {
+          const hash = hashFingerprint(fingerprint);
+          Object.assign(task, { hash });
+          await this.#cache.put(hash, terminalOutput, task.outputs, code, fingerprint, autoWrites);
+          await this.#cache.setTaskIndex(task.id, hash);
+        }
       }
       return result;
     } catch (error) {
@@ -321,6 +368,38 @@ class TaskOrchestrator {
       return result;
     }
   }
+  /**
+   * In auto-fingerprint mode, returns the workspace-relative paths the
+   * task both read *and* wrote during execution. {@link FingerprintManager}
+   * populates `modifiedInputs` from the tracker's `"write"`-typed accesses;
+   * backends that don't yet emit write accesses leave it empty.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  #detectSelfModifiedFingerprint(fingerprint) {
+    return fingerprint.modifiedInputs ?? [];
+  }
+  /**
+   * Returns a human-readable reason string when a fingerprint looks
+   * suspiciously empty (tracker ran but observed no workspace files),
+   * or `undefined` when the fingerprint is trustworthy. Caching is
+   * skipped for empty fingerprints — silently persisting one would
+   * guarantee false cache hits on every subsequent run.
+   *
+   * Only flags results from the real tracker; the glob-based fallback
+   * path legitimately produces wide fingerprints and isn't at risk.
+   */
+  // eslint-disable-next-line class-methods-use-this
+  #describeEmptyFingerprint(fingerprint, usedRealTracker, trackerAccessCount) {
+    if (!usedRealTracker) {
+      return void 0;
+    }
+    const hasAnyAccess = Object.keys(fingerprint.fileHashes).length > 0 || Object.keys(fingerprint.directoryListings).length > 0 || fingerprint.missingFiles.length > 0;
+    if (hasAnyAccess) {
+      return void 0;
+    }
+    const zeroAccesses = trackerAccessCount === 0;
+    return zeroAccesses ? "Tracker observed no workspace file accesses — likely a static binary on a platform without strace. Caching skipped." : "Tracker returned accesses but none fell inside the workspace. Caching skipped to avoid false cache hits.";
+  }
   #dryRunResult(task, startTime) {
     const cacheStatus = task.hash ? `[hash: ${task.hash.slice(0, 12)}...]` : "[no hash]";
     const result = {

package/dist/packem_shared/{TerminalBuffer-D6zP2zLh.js → TerminalBuffer-qVJvbRQZ.js}

@@ -23,11 +23,7 @@ class TerminalBuffer {
           i = consumed;
           continue;
         }
-        if (data[i + 1] === "(" || data[i + 1] === ")") {
-          i += 3;
-        } else {
-          i += 2;
-        }
+        i += data[i + 1] === "(" || data[i + 1] === ")" ? 3 : 2;
         continue;
       }
       if (ch === "\r") {
@@ -61,7 +57,7 @@ class TerminalBuffer {
     let j = start;
     let params = "";
     while (j < data.length && (data[j] >= "0" && data[j] <= "9" || data[j] === ";")) {
-      params += data[j];
+      params += data[j] ?? "";
       j++;
     }
     if (j >= data.length) {
@@ -70,36 +66,42 @@ class TerminalBuffer {
     const cmd = data[j];
     const n = Number.parseInt(params, 10) || 1;
     switch (cmd) {
-      case "A":
+      case "A": {
         this.#row = Math.max(0, this.#row - n);
         break;
-      case "B":
+      }
+      case "B": {
         this.#row = Math.min(this.#lines.length - 1, this.#row + n);
         break;
-      case "C":
+      }
+      case "C": {
         this.#col += n;
         break;
-      case "D":
+      }
+      case "D": {
         this.#col = Math.max(0, this.#col - n);
         break;
-      case "G":
-        this.#col = Math.max(0, n - 1);
-        break;
-      case "H":
-      // cursor position (row;col, 1-based)
-      case "f": {
+      }
+      case "f":
+      case "H": {
         const parts = params.split(";");
         this.#row = Math.max(0, (Number.parseInt(parts[0] ?? "1", 10) || 1) - 1);
         this.#col = Math.max(0, (Number.parseInt(parts[1] ?? "1", 10) || 1) - 1);
         this.#ensureRow(this.#row);
         break;
       }
-      case "J":
+      case "G": {
+        this.#col = Math.max(0, n - 1);
+        break;
+      }
+      case "J": {
         this.#eraseDisplay(Number.parseInt(params, 10) || 0);
         break;
-      case "K":
+      }
+      case "K": {
         this.#eraseLine(Number.parseInt(params, 10) || 0);
         break;
+      }
       case "m": {
         const seq = `\x1B[${params}m`;
         this.#ensureRow(this.#row);
@@ -161,30 +163,44 @@ class TerminalBuffer {
     this.#lines[this.#row] = line.slice(0, strIndex) + seq + line.slice(strIndex);
   }
   #eraseDisplay(mode) {
-    if (mode === 2) {
-      this.#lines = [""];
-      this.#row = 0;
-      this.#col = 0;
-    } else if (mode === 0) {
-      this.#ensureRow(this.#row);
-      this.#truncateLineAtCol(this.#row, this.#col);
-      this.#lines.length = this.#row + 1;
-    } else if (mode === 1) {
-      for (let r = 0; r < this.#row; r++) {
-        this.#lines[r] = "";
+    switch (mode) {
+      case 0: {
+        this.#ensureRow(this.#row);
+        this.#truncateLineAtCol(this.#row, this.#col);
+        this.#lines.length = this.#row + 1;
+        break;
+      }
+      case 1: {
+        for (let r = 0; r < this.#row; r++) {
+          this.#lines[r] = "";
+        }
+        this.#ensureRow(this.#row);
+        this.#fillLineToCol(this.#row, this.#col);
+        break;
+      }
+      case 2: {
+        this.#lines = [""];
+        this.#row = 0;
+        this.#col = 0;
+        break;
       }
-      this.#ensureRow(this.#row);
-      this.#fillLineToCol(this.#row, this.#col);
     }
   }
   #eraseLine(mode) {
     this.#ensureRow(this.#row);
-    if (mode === 2) {
-      this.#lines[this.#row] = "";
-    } else if (mode === 0) {
-      this.#truncateLineAtCol(this.#row, this.#col);
-    } else if (mode === 1) {
-      this.#fillLineToCol(this.#row, this.#col);
+    switch (mode) {
+      case 0: {
+        this.#truncateLineAtCol(this.#row, this.#col);
+        break;
+      }
+      case 1: {
+        this.#fillLineToCol(this.#row, this.#col);
+        break;
+      }
+      case 2: {
+        this.#lines[this.#row] = "";
+        break;
+      }
     }
   }
   /** Truncate a line at the given visual column. */

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

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

package/dist/packem_shared/archive-UQHAnZUa.js

@@ -0,0 +1,102 @@
+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 {
+  execFile
+} = __cjs_getBuiltinModule("node:child_process");
+const {
+  createReadStream,
+  createWriteStream
+} = __cjs_getBuiltinModule("node:fs");
+const {
+  rm
+} = __cjs_getBuiltinModule("node:fs/promises");
+const {
+  pipeline
+} = __cjs_getBuiltinModule("node:stream/promises");
+const {
+  createBrotliDecompress,
+  createBrotliCompress,
+  constants
+} = __cjs_getBuiltinModule("node:zlib");
+
+const BROTLI_COMPRESS_OPTIONS = {
+  params: {
+    [constants.BROTLI_PARAM_MODE]: constants.BROTLI_MODE_TEXT,
+    [constants.BROTLI_PARAM_QUALITY]: 4
+  }
+};
+const createTar = (sourceDirectory, outputPath) => new Promise((resolve, reject) => {
+  execFile("tar", ["-cf", outputPath, "-C", sourceDirectory, "."], (error) => {
+    if (error) {
+      reject(error);
+    } else {
+      resolve();
+    }
+  });
+});
+const extractTar = (archivePath, destinationDirectory) => new Promise((resolve, reject) => {
+  execFile("tar", ["-xf", archivePath, "-C", destinationDirectory], (error) => {
+    if (error) {
+      reject(error);
+    } else {
+      resolve();
+    }
+  });
+});
+const createTarGz = (sourceDirectory, outputPath) => new Promise((resolve, reject) => {
+  execFile("tar", ["-czf", outputPath, "-C", sourceDirectory, "."], (error) => {
+    if (error) {
+      reject(error);
+    } else {
+      resolve();
+    }
+  });
+});
+const extractTarGz = (archivePath, destinationDirectory) => new Promise((resolve, reject) => {
+  execFile("tar", ["-xzf", archivePath, "-C", destinationDirectory], (error) => {
+    if (error) {
+      reject(error);
+    } else {
+      resolve();
+    }
+  });
+});
+const createTarBrotli = async (sourceDirectory, outputPath) => {
+  const tarPath = `${outputPath}.tar`;
+  try {
+    await createTar(sourceDirectory, tarPath);
+    await pipeline(createReadStream(tarPath), createBrotliCompress(BROTLI_COMPRESS_OPTIONS), createWriteStream(outputPath));
+  } finally {
+    await rm(tarPath, { force: true }).catch(() => {
+    });
+  }
+};
+const extractTarBrotli = async (archivePath, destinationDirectory) => {
+  const tarPath = `${archivePath}.tar`;
+  try {
+    await pipeline(createReadStream(archivePath), createBrotliDecompress(), createWriteStream(tarPath));
+    await extractTar(tarPath, destinationDirectory);
+  } finally {
+    await rm(tarPath, { force: true }).catch(() => {
+    });
+  }
+};
+
+export { extractTarGz as a, createTarGz as b, createTarBrotli as c, extractTarBrotli as e };

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

@@ -22,8 +22,10 @@ const {
 } = __cjs_getBuiltinModule("node:child_process");
 
 const validateGitRef = (ref) => {
-  if (!/^[\w.\-/~^@{}]+$/.test(ref)) {
-    throw new Error(`Invalid git ref: "${ref}". Only alphanumeric characters, dots, dashes, underscores, slashes, tildes, carets, and @ are allowed.`);
+  if (!/^[\w./~^@{}][\w.\-/~^@{}]*$/.test(ref)) {
+    throw new Error(
+      `Invalid git ref: "${ref}". Refs must start with an alphanumeric character or one of _ . / ~ ^ @ { } and may only contain letters, digits, dots, dashes, underscores, slashes, tildes, carets, @, and braces.`
+    );
   }
 };
 const findProjectForFile = (filePath, projects) => {
@@ -31,7 +33,8 @@ const findProjectForFile = (filePath, projects) => {
   let bestLength = 0;
   for (const [name, config] of Object.entries(projects)) {
     const { root } = config;
-    if ((filePath.startsWith(`${root}/`) || filePath === root) && root.length > bestLength) {
+    if ((filePath.startsWith(`${root}/`) || filePath === root) && // Prefer the most specific (longest) match
+    root.length > bestLength) {
       bestMatch = name;
       bestLength = root.length;
     }