@ebrindley/build 0.0.0-stage → 1.42.1-rc28

package/dist/chunk-QYQOVOLR.js

@@ -0,0 +1,196 @@
+// src/core/locking/fenced-file-lock.ts
+import { randomUUID } from "crypto";
+import { constants as fsConstants } from "fs";
+import * as fs from "fs/promises";
+import * as path from "path";
+import lockfile from "proper-lockfile";
+var FileLockCompromisedError = class extends Error {
+  constructor(message, options) {
+    super(message, options?.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "FileLockCompromisedError";
+  }
+};
+function noFollowFlag() {
+  return fsConstants.O_NOFOLLOW ?? 0;
+}
+function isSymlinkRefusal(error) {
+  const code = error.code;
+  return code === "ELOOP" || code === "EMLINK";
+}
+async function ensureLockTargetFile(lockTarget) {
+  let handle;
+  try {
+    handle = await fs.open(
+      lockTarget,
+      fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_APPEND | noFollowFlag(),
+      438
+    );
+  } catch (error) {
+    if (isSymlinkRefusal(error)) {
+      throw new Error(`Refusing to use a symlinked lock target at ${lockTarget}.`);
+    }
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+}
+async function writeLockTargetFileNoFollow(lockTarget, contents) {
+  let handle;
+  try {
+    handle = await fs.open(
+      lockTarget,
+      fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_TRUNC | noFollowFlag(),
+      438
+    );
+    await handle.writeFile(contents, "utf8");
+  } catch (error) {
+    if (isSymlinkRefusal(error)) {
+      throw new Error(`Refusing to write a symlinked lock target at ${lockTarget}.`);
+    }
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+}
+async function acquireFencedFileLock(lockTarget, options) {
+  let compromiseError;
+  let fenceSuperseded = false;
+  let underlyingLost = false;
+  const compromiseController = new AbortController();
+  const markCompromised = (cause, message) => {
+    compromiseError ??= new FileLockCompromisedError(message, { cause });
+    if (!compromiseController.signal.aborted) {
+      compromiseController.abort(compromiseError);
+    }
+    return compromiseError;
+  };
+  const releaseUnderlying = await lockfile.lock(lockTarget, {
+    stale: options.stale,
+    ...options.update === void 0 ? {} : { update: options.update },
+    realpath: options.realpath ?? false,
+    retries: options.retries,
+    onCompromised: (error) => {
+      underlyingLost = true;
+      markCompromised(error, `${options.description} ownership was compromised.`);
+    }
+  });
+  const ownerTokenPath = `${path.resolve(lockTarget)}.owner-token`;
+  const ownerToken = randomUUID();
+  const readOwnerTokenOnce = async () => {
+    let handle;
+    try {
+      handle = await fs.open(ownerTokenPath, fsConstants.O_RDONLY | noFollowFlag());
+      return await handle.readFile("utf8");
+    } finally {
+      await handle?.close();
+    }
+  };
+  const readOwnerToken = async () => {
+    let lastError;
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        return await readOwnerTokenOnce();
+      } catch (error) {
+        lastError = error;
+        if (error.code === "ENOENT") {
+          throw error;
+        }
+        if (attempt < 2) {
+          await new Promise((resolve2) => setTimeout(resolve2, 10 * (attempt + 1)));
+        }
+      }
+    }
+    throw lastError;
+  };
+  try {
+    const handle = await fs.open(
+      ownerTokenPath,
+      fsConstants.O_WRONLY | fsConstants.O_CREAT | fsConstants.O_TRUNC | noFollowFlag(),
+      384
+    );
+    try {
+      await handle.writeFile(`${ownerToken}
+`, "utf8");
+    } finally {
+      await handle.close();
+    }
+  } catch (error) {
+    markCompromised(error, `${options.description} could not establish its ownership fence.`);
+    await releaseUnderlying().catch(() => void 0);
+    throw compromiseError;
+  }
+  const inspectFence = async () => {
+    try {
+      const raw = await readOwnerToken();
+      return raw.trim() === ownerToken ? { state: "owned" } : { state: "superseded" };
+    } catch (error) {
+      if (error.code === "ENOENT") {
+        return { state: "superseded", cause: error };
+      }
+      return { state: "unverifiable", cause: error };
+    }
+  };
+  const assertOwned = async () => {
+    if (compromiseError) {
+      throw compromiseError;
+    }
+    const fence = await inspectFence();
+    if (fence.state === "superseded") {
+      fenceSuperseded = true;
+      throw markCompromised(
+        fence.cause,
+        `${options.description} ownership was superseded by another process.`
+      );
+    }
+    if (fence.state === "unverifiable") {
+      throw markCompromised(fence.cause, `${options.description} ownership could not be verified.`);
+    }
+  };
+  let released = false;
+  const release = (async () => {
+    if (released) {
+      return;
+    }
+    if (fenceSuperseded) {
+      return;
+    }
+    if (underlyingLost) {
+      return;
+    }
+    const fence = await inspectFence();
+    if (fence.state === "superseded") {
+      fenceSuperseded = true;
+      markCompromised(
+        fence.cause,
+        `${options.description} ownership was superseded before release.`
+      );
+      return;
+    }
+    if (fence.state === "unverifiable") {
+      markCompromised(
+        fence.cause,
+        `${options.description} ownership could not be verified before release.`
+      );
+      await releaseUnderlying().catch(() => void 0);
+      return;
+    }
+    released = true;
+    await fs.unlink(ownerTokenPath).catch(() => void 0);
+    await releaseUnderlying().catch(() => void 0);
+  });
+  release.assertOwned = assertOwned;
+  release.isOwned = () => compromiseError === void 0;
+  Object.defineProperty(release, "signal", {
+    value: compromiseController.signal,
+    enumerable: true
+  });
+  return release;
+}
+
+export {
+  FileLockCompromisedError,
+  ensureLockTargetFile,
+  writeLockTargetFileNoFollow,
+  acquireFencedFileLock
+};
+//# sourceMappingURL=chunk-QYQOVOLR.js.map

package/dist/chunk-R2CKS6WT.js

@@ -0,0 +1,73 @@
+// src/core/verification/verdict-label.ts
+var EXPLICIT_FAILURE_STATUSES = /* @__PURE__ */ new Set([
+  "failed",
+  "error",
+  "timeout",
+  // Synthesis/gate vocabularies that mean a real failure.
+  "rejected"
+]);
+var EXPLICIT_UNAVAILABLE_STATUSES = /* @__PURE__ */ new Set([
+  "not_run",
+  "skipped",
+  "unavailable",
+  "unsupported",
+  "no_data",
+  "no-data"
+]);
+function gateStatusToDisplayVerdict(status) {
+  const normalized = typeof status === "string" ? status.trim().toLowerCase() : "";
+  if (normalized === "passed") return "passed";
+  if (EXPLICIT_FAILURE_STATUSES.has(normalized)) return "failed";
+  if (EXPLICIT_UNAVAILABLE_STATUSES.has(normalized)) return "unavailable";
+  return "unavailable";
+}
+function isExecutedFailureStatus(status) {
+  const normalized = typeof status === "string" ? status.trim().toLowerCase() : "";
+  return normalized === "failed" || normalized === "timeout" || normalized === "rejected";
+}
+function hasExecutedFailureSignal(input) {
+  if (isExecutedFailureStatus(input.rawTestStatus) || isExecutedFailureStatus(input.testStatus)) {
+    return true;
+  }
+  return typeof input.failedTests === "number" && input.failedTests > 0;
+}
+function deriveTestVerificationDisplay(input) {
+  if (input.testsUnavailable === true && !hasExecutedFailureSignal(input)) {
+    return "unavailable";
+  }
+  const rawVerdict = gateStatusToDisplayVerdict(input.rawTestStatus);
+  if (rawVerdict === "failed") return "failed";
+  if (typeof input.exitCode === "number" && input.exitCode !== 0) return "failed";
+  if (typeof input.failedTests === "number" && input.failedTests > 0) return "failed";
+  const derivedVerdict = gateStatusToDisplayVerdict(input.testStatus);
+  if (derivedVerdict === "failed") return "failed";
+  if (derivedVerdict === "passed" && rawVerdict !== "unavailable") {
+    return "passed";
+  }
+  if (derivedVerdict === "passed" && input.rawTestStatus == null) {
+    return "passed";
+  }
+  if (derivedVerdict === "passed" && rawVerdict === "passed") {
+    return "passed";
+  }
+  return derivedVerdict === "passed" ? "unavailable" : derivedVerdict;
+}
+function formatVerificationLabel(verification) {
+  const statuses = Object.values(verification.gates).map((gate) => gate.status);
+  if (verification.status === "failed" && !statuses.includes("failed")) {
+    if (statuses.includes("timeout")) return "timeout";
+  }
+  if (verification.status === "not_run" && statuses.includes("unavailable")) return "unavailable";
+  return verification.status;
+}
+function gatesAlsoFailingOnBase(gates) {
+  return ["build", "lint", "test"].filter((channel) => gates[channel].alsoFailingOnBase);
+}
+
+export {
+  gateStatusToDisplayVerdict,
+  deriveTestVerificationDisplay,
+  formatVerificationLabel,
+  gatesAlsoFailingOnBase
+};
+//# sourceMappingURL=chunk-R2CKS6WT.js.map

package/dist/chunk-R2TIYG7U.js

@@ -0,0 +1,68 @@
+// src/planning/task-spec-fenced-blocks.ts
+var FENCE_LINE = /^(`{3,}|~{3,})(.*)$/;
+var LEADING_WHITESPACE = /^[ \t]+/;
+var CONTAINER_MARKER = /^(?:>[ \t]?|[-*+][ \t]+|\d{1,9}[.)][ \t]+)/;
+var MAX_CONTAINER_DEPTH = 8;
+function stripContainerPrefix(line) {
+  let rest = line.replace(LEADING_WHITESPACE, "");
+  for (let depth = 0; depth < MAX_CONTAINER_DEPTH; depth++) {
+    const stripped = rest.replace(CONTAINER_MARKER, "");
+    if (stripped === rest) break;
+    rest = stripped.replace(LEADING_WHITESPACE, "");
+  }
+  return rest;
+}
+function findFencedCodeSpans(content) {
+  const spans = [];
+  let open = null;
+  let offset = 0;
+  for (const line of content.split("\n")) {
+    const lineStart = offset;
+    offset += line.length + 1;
+    const fence = FENCE_LINE.exec(stripContainerPrefix(line));
+    if (!fence) continue;
+    const marker = fence[1] ?? "";
+    const info = fence[2] ?? "";
+    const char = marker[0] ?? "";
+    if (!open) {
+      if (char === "`" && info.includes("`")) continue;
+      open = { char, length: marker.length, start: lineStart };
+      continue;
+    }
+    if (char === open.char && marker.length >= open.length && info.trim() === "") {
+      spans.push({ start: open.start, end: Math.min(offset, content.length) });
+      open = null;
+    }
+  }
+  if (open) spans.push({ start: open.start, end: content.length });
+  return spans;
+}
+function isInsideFencedCodeSpan(spans, index) {
+  return spans.some((span) => index >= span.start && index < span.end);
+}
+function matchOutsideFences(content, pattern, from = 0, spans = findFencedCodeSpans(content)) {
+  const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+  const regex = new RegExp(pattern.source, flags);
+  regex.lastIndex = from;
+  for (let match = regex.exec(content); match; match = regex.exec(content)) {
+    if (!isInsideFencedCodeSpan(spans, match.index)) return match;
+    if (match[0].length === 0) regex.lastIndex++;
+  }
+  return null;
+}
+function extractMarkdownSection(content, heading, terminator) {
+  const spans = findFencedCodeSpans(content);
+  const match = matchOutsideFences(content, heading, 0, spans);
+  if (!match) return null;
+  const start = match.index + match[0].length;
+  const end = matchOutsideFences(content, terminator, start, spans)?.index ?? content.length;
+  return content.slice(start, end);
+}
+
+export {
+  findFencedCodeSpans,
+  isInsideFencedCodeSpan,
+  matchOutsideFences,
+  extractMarkdownSection
+};
+//# sourceMappingURL=chunk-R2TIYG7U.js.map