@astrosheep/keiyaku 2.9.13 → 4.0.1

package/build/core/worktree-bootstrap.js

@@ -1,195 +0,0 @@
-import { spawn as nodeSpawn } from "node:child_process";
-import { terminateProcessGroup } from "./run-control/process-tree.js";
-export const WORKTREE_BOOTSTRAP_OUTPUT_TAIL_BYTES = 2048;
-export const WORKTREE_BOOTSTRAP_KILL_GRACE_MS = 10_000;
-function defaultWait(ms) {
-    return new Promise((resolve) => {
-        const timer = setTimeout(resolve, ms);
-        timer.unref?.();
-    });
-}
-/** Retain the last 2048 UTF-8 bytes and decode lossily (partial leading code point → U+FFFD). */
-export function tailUtf8Bytes(bytes, maxBytes = WORKTREE_BOOTSTRAP_OUTPUT_TAIL_BYTES) {
-    const truncated = bytes.byteLength > maxBytes;
-    const slice = truncated ? bytes.subarray(bytes.byteLength - maxBytes) : bytes;
-    return { text: slice.toString("utf8"), truncated };
-}
-/**
- * Rolling output accumulator: holds at most `maxBytes` across every chunk and
- * remembers whether any earlier prefix was dropped.
- */
-function createRollingByteTail(maxBytes = WORKTREE_BOOTSTRAP_OUTPUT_TAIL_BYTES) {
-    let tail = Buffer.alloc(0);
-    let truncated = false;
-    return {
-        append(chunk) {
-            const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-            if (bytes.byteLength === 0)
-                return;
-            if (bytes.byteLength >= maxBytes) {
-                // Keep last maxBytes. Mark truncated only when this chunk itself exceeds
-                // maxBytes or when any already-retained prefix is displaced. Prior true sticks.
-                if (bytes.byteLength > maxBytes || tail.byteLength > 0) {
-                    truncated = true;
-                }
-                tail = Buffer.from(bytes.subarray(bytes.byteLength - maxBytes));
-                return;
-            }
-            const combinedLength = tail.byteLength + bytes.byteLength;
-            if (combinedLength <= maxBytes) {
-                const next = Buffer.allocUnsafe(combinedLength);
-                tail.copy(next, 0);
-                bytes.copy(next, tail.byteLength);
-                tail = next;
-                return;
-            }
-            truncated = true;
-            const keepFromTail = maxBytes - bytes.byteLength;
-            const next = Buffer.allocUnsafe(maxBytes);
-            tail.copy(next, 0, tail.byteLength - keepFromTail);
-            bytes.copy(next, keepFromTail);
-            tail = next;
-        },
-        snapshot() {
-            if (tail.byteLength === 0)
-                return { bytes: null, truncated: false };
-            return { bytes: tail, truncated };
-        },
-    };
-}
-function observationFrom(result, durationMs, output) {
-    const safeDuration = Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(durationMs)));
-    return {
-        result,
-        durationMs: safeDuration,
-        ...(output.stdout ? { stdoutTail: output.stdout.bytes.toString("utf8") } : {}),
-        ...(output.stdout?.truncated ? { stdoutTruncated: true } : {}),
-        ...(output.stderr ? { stderrTail: output.stderr.bytes.toString("utf8") } : {}),
-        ...(output.stderr?.truncated ? { stderrTruncated: true } : {}),
-    };
-}
-function spawnFailureObservation(message, durationMs) {
-    const tail = tailUtf8Bytes(Buffer.from(message, "utf8"));
-    const safeDuration = Math.max(0, Math.min(Number.MAX_SAFE_INTEGER, Math.trunc(durationMs)));
-    return {
-        result: { kind: "spawn", message: tail.text },
-        durationMs: safeDuration,
-        ...(tail.truncated ? { stderrTruncated: true } : {}),
-    };
-}
-/**
- * Run the project-declared worktree bootstrap once.
- * argv only (shell: false), cwd = new worktree, inherited env, stdin ignored.
- * Output capture is opt-in so bind retains its established stdio and persistence behavior.
- */
-export async function runWorktreeBootstrap(input, dependencies = {}) {
-    const spawn = dependencies.spawn ?? nodeSpawn;
-    const nowMs = dependencies.nowMs ?? Date.now;
-    const wait = dependencies.wait ?? defaultWait;
-    const [program, ...args] = input.plan.command;
-    if (!program) {
-        return {
-            result: { kind: "spawn", message: "bootstrap command is empty" },
-            durationMs: 0,
-        };
-    }
-    const startedAt = nowMs();
-    const stdoutTail = input.captureOutput ? createRollingByteTail() : null;
-    const stderrTail = createRollingByteTail();
-    let child;
-    try {
-        child = spawn(program, args, {
-            cwd: input.cwd,
-            env: process.env,
-            shell: false,
-            detached: process.platform !== "win32",
-            stdio: ["ignore", input.captureOutput ? "pipe" : "ignore", "pipe"],
-        });
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        return spawnFailureObservation(message, Math.max(0, nowMs() - startedAt));
-    }
-    return await new Promise((resolve) => {
-        let settled = false;
-        let timedOut = false;
-        let exited = false;
-        let timeoutHandle;
-        const finish = (observation) => {
-            if (settled)
-                return;
-            settled = true;
-            if (timeoutHandle)
-                clearTimeout(timeoutHandle);
-            resolve(observation);
-        };
-        child.stdout?.on("data", (chunk) => {
-            stdoutTail?.append(chunk);
-        });
-        child.stderr?.on("data", (chunk) => {
-            stderrTail.append(chunk);
-        });
-        child.on("error", (error) => {
-            const message = error instanceof Error ? error.message : String(error);
-            finish(spawnFailureObservation(message, Math.max(0, nowMs() - startedAt)));
-        });
-        child.on("close", (code, signal) => {
-            exited = true;
-            const durationMs = Math.max(0, nowMs() - startedAt);
-            const stdoutSnapshot = stdoutTail?.snapshot();
-            const stderrSnapshot = stderrTail.snapshot();
-            const capturedOutput = {
-                stdout: stdoutSnapshot?.bytes ? { bytes: stdoutSnapshot.bytes, truncated: stdoutSnapshot.truncated } : null,
-                stderr: stderrSnapshot.bytes ? { bytes: stderrSnapshot.bytes, truncated: stderrSnapshot.truncated } : null,
-            };
-            const failureOutput = { stdout: capturedOutput.stdout, stderr: capturedOutput.stderr };
-            if (timedOut) {
-                finish(observationFrom({ kind: "timeout" }, durationMs, failureOutput));
-                return;
-            }
-            if (signal) {
-                finish(observationFrom({ kind: "signal", signal }, durationMs, failureOutput));
-                return;
-            }
-            const exitCode = typeof code === "number" ? code : 1;
-            const normalized = Math.max(0, Math.min(255, exitCode));
-            if (normalized === 0) {
-                const successOutput = input.captureOutput ? capturedOutput : { stdout: null, stderr: null };
-                finish(observationFrom({ kind: "exit", code: 0 }, durationMs, successOutput));
-                return;
-            }
-            finish(observationFrom({ kind: "exit", code: normalized }, durationMs, failureOutput));
-        });
-        timeoutHandle = setTimeout(() => {
-            void (async () => {
-                if (settled || exited)
-                    return;
-                timedOut = true;
-                try {
-                    await terminateProcessGroup(child, { graceMs: WORKTREE_BOOTSTRAP_KILL_GRACE_MS, wait });
-                }
-                catch {
-                    const stdoutSnapshot = stdoutTail?.snapshot();
-                    const stderrSnapshot = stderrTail.snapshot();
-                    finish(observationFrom({ kind: "timeout" }, Math.max(0, nowMs() - startedAt), {
-                        stdout: stdoutSnapshot?.bytes ? { bytes: stdoutSnapshot.bytes, truncated: stdoutSnapshot.truncated } : null,
-                        stderr: stderrSnapshot.bytes ? { bytes: stderrSnapshot.bytes, truncated: stderrSnapshot.truncated } : null,
-                    }));
-                }
-            })();
-        }, input.plan.timeoutMs);
-        timeoutHandle.unref?.();
-    });
-}
-export function bootstrapEntryDataFromObservation(observation) {
-    const retainFailureStderr = !isBootstrapSuccess(observation);
-    return {
-        result: observation.result,
-        durationMs: observation.durationMs,
-        ...(retainFailureStderr && observation.stderrTail !== undefined ? { stderrTail: observation.stderrTail } : {}),
-        ...(retainFailureStderr && observation.stderrTruncated ? { stderrTruncated: true } : {}),
-    };
-}
-export function isBootstrapSuccess(observation) {
-    return observation.result.kind === "exit" && observation.result.code === 0;
-}

package/build/core/worktree-path.js

@@ -1,371 +0,0 @@
-import * as path from "node:path";
-import * as fs from "node:fs/promises";
-import { FlowError } from "../flow-error.js";
-import { createGit, runGitProcess, wrapGitError } from "../git/core.js";
-import { resolveLocalBranchHead } from "../git/refs.js";
-import { readCurrentContractLifecycle } from "./repository-ledger/read-model.js";
-import { normalizeFilesystemCoordinate } from "../fs/path-coordinate.js";
-import { gitCommonRootPath, resolveGitCommonRoot } from "../git/path-coordinate.js";
-function record(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value)
-        ? value
-        : undefined;
-}
-/** Reconstruct the public terminal-cleanup fact from its independent replay receipts. */
-export function terminalCleanupFacts(worktreeValue, deliveryRefValue) {
-    const worktree = record(worktreeValue);
-    const delivery = record(deliveryRefValue);
-    if (!worktree || !Array.isArray(worktree.absent) || !delivery)
-        return undefined;
-    const absent = worktree.absent.filter((item) => item === "worktree");
-    const base = {
-        absent,
-        ...(typeof worktree.removedWorktreePath === "string" ? { removedWorktreePath: worktree.removedWorktreePath } : {}),
-    };
-    const failure = record(worktree.worktreeRemoveFailure);
-    if (failure && typeof failure.path === "string" && typeof failure.reason === "string") {
-        base.worktreeRemoveFailure = { path: failure.path, reason: failure.reason };
-    }
-    if (delivery.status === "aligned"
-        && typeof delivery.ref === "string"
-        && delivery.expected === "absent"
-        && delivery.observed === "absent") {
-        return { ...base, deliveryRef: { status: "aligned", ref: delivery.ref, expected: "absent", observed: "absent" } };
-    }
-    const mismatch = record(delivery.mismatch);
-    const observed = record(mismatch?.observed);
-    if (delivery.status === "mismatch"
-        && mismatch?.kind === "projected-surface-mismatch"
-        && mismatch.surface === "delivery-ref"
-        && typeof mismatch.ref === "string"
-        && mismatch.expected === "absent"
-        && observed?.state === "present"
-        && typeof observed.head === "string") {
-        return {
-            ...base,
-            deliveryRef: {
-                status: "mismatch",
-                mismatch: {
-                    kind: "projected-surface-mismatch",
-                    surface: "delivery-ref",
-                    ref: mismatch.ref,
-                    expected: "absent",
-                    observed: { state: "present", head: observed.head },
-                },
-            },
-        };
-    }
-    return undefined;
-}
-function parseWorktreeListPorcelainZ(output) {
-    const listings = [];
-    let current;
-    for (const field of output.split("\0")) {
-        if (field.startsWith("worktree ")) {
-            if (current)
-                listings.push(current);
-            current = { path: field.slice("worktree ".length) };
-            continue;
-        }
-        if (field.startsWith("branch ") && current) {
-            current.branch = field.slice("branch ".length);
-        }
-    }
-    if (current)
-        listings.push(current);
-    return listings;
-}
-async function listWorktrees(cwd, signal) {
-    if (signal) {
-        const result = await runGitProcess(cwd, ["worktree", "list", "--porcelain", "-z"], { signal });
-        if (result.error || result.status !== 0) {
-            if (result.error?.name === "AbortError")
-                throw result.error;
-            throw wrapGitError("worktree list --porcelain -z", result.error ?? new Error(result.stderr || `exit ${String(result.status)}`), cwd);
-        }
-        return parseWorktreeListPorcelainZ(result.stdout);
-    }
-    const git = createGit(cwd);
-    try {
-        return parseWorktreeListPorcelainZ(await git.raw(["worktree", "list", "--porcelain", "-z"]));
-    }
-    catch (error) {
-        throw wrapGitError("worktree list --porcelain -z", error, cwd);
-    }
-}
-export function worktreeContainsCoordinate(root, candidate) {
-    const normalizedRoot = normalizeFilesystemCoordinate(root);
-    const normalizedCandidate = normalizeFilesystemCoordinate(candidate);
-    const relative = path.relative(normalizedRoot, normalizedCandidate);
-    return relative === "" || (!path.isAbsolute(relative) && relative !== ".." && !relative.startsWith(`..${path.sep}`));
-}
-export async function stableRepoRoot(cwd) {
-    const git = createGit(cwd);
-    let facts;
-    try {
-        facts = (await git.raw(["rev-parse", "--is-bare-repository", "--path-format=absolute", "--git-common-dir"])).trim().split("\n");
-    }
-    catch (error) {
-        throw wrapGitError("rev-parse repository coordinate", error, cwd);
-    }
-    const [bare, commonDir] = facts;
-    if (bare === "true") {
-        throw new FlowError("INTERNAL_STATE", "Keiyaku worktree operations require a non-bare repository");
-    }
-    if (!commonDir)
-        throw new FlowError("INTERNAL_STATE", "Git did not report its common directory");
-    const stableRoot = gitCommonRootPath(commonDir);
-    if (!path.isAbsolute(stableRoot)) {
-        throw new FlowError("INTERNAL_STATE", `git common directory is not absolute: ${commonDir}`);
-    }
-    try {
-        return await resolveGitCommonRoot(commonDir);
-    }
-    catch (error) {
-        throw new FlowError("INTERNAL_STATE", `cannot resolve git common directory ${stableRoot}`, { cause: error });
-    }
-}
-export async function contractWorktreePathFromBind(cwd, contractId, bind) {
-    return contractWorktreePathFromStableRoot(await stableRepoRoot(cwd), contractId, bind);
-}
-export function contractWorktreePathFromStableRoot(stableRoot, contractId, bind) {
-    return path.join(stableRoot, ".keiyaku", "wt", bind?.data.place ?? contractId);
-}
-export async function contractWorktreePath(cwd, contractId) {
-    const stableRoot = await stableRepoRoot(cwd);
-    const outcome = await readCurrentContractLifecycle(stableRoot, contractId);
-    return path.join(stableRoot, ".keiyaku", "wt", outcome.status === "healthy" || outcome.status === "diseased"
-        ? outcome.model.resources.worktree?.place ?? contractId
-        : contractId);
-}
-export async function requireContractWorktreePath(cwd, contractId) {
-    const stableRoot = await stableRepoRoot(cwd);
-    const outcome = await readCurrentContractLifecycle(stableRoot, contractId);
-    if (outcome.status !== "healthy" || !outcome.model.resources.worktree) {
-        throw new FlowError("INTERNAL_STATE", `contract ${contractId} not found`);
-    }
-    return path.join(stableRoot, ".keiyaku", "wt", outcome.model.resources.worktree.place);
-}
-async function findContractWorktree(cwd, contractId) {
-    const expectedBranch = `refs/heads/keiyaku/${contractId}`;
-    for (const worktree of await listWorktrees(await stableRepoRoot(cwd))) {
-        if (worktree.branch === expectedBranch) {
-            const dotGit = await fs.stat(path.join(worktree.path, ".git"));
-            if (!dotGit.isDirectory())
-                return { path: worktree.path, primary: false };
-            return { primary: true };
-        }
-    }
-    return { primary: false };
-}
-export async function findContractWorktreePath(cwd, contractId) {
-    return (await findContractWorktree(cwd, contractId)).path;
-}
-export async function findRegisteredContractWorktreePath(cwd, contractId) {
-    const stableRoot = await stableRepoRoot(cwd);
-    const outcome = await readCurrentContractLifecycle(stableRoot, contractId);
-    if (outcome.status !== "healthy" || outcome.model.resources.worktree?.state !== "held")
-        return undefined;
-    return findRegisteredContractWorktreePathFromModel(stableRoot, outcome.model);
-}
-export async function findRegisteredContractWorktreePathFromModel(stableRoot, model) {
-    const worktree = model.resources.worktree;
-    if (!worktree)
-        return undefined;
-    const expected = path.join(stableRoot, ".keiyaku", "wt", worktree.place);
-    for (const registered of await listWorktrees(stableRoot)) {
-        if (registered.branch !== model.resources.deliveryRef)
-            continue;
-        try {
-            if (normalizeFilesystemCoordinate(await fs.realpath(registered.path)) === normalizeFilesystemCoordinate(await fs.realpath(expected))) {
-                return await fs.realpath(registered.path);
-            }
-        }
-        catch { /* stale registration is not lifecycle evidence */ }
-    }
-    return undefined;
-}
-async function findRegisteredContractWorktreePathFromBind(stableRoot, contractId, _bind) {
-    const expectedBranch = `refs/heads/keiyaku/${contractId}`;
-    for (const worktree of await listWorktrees(stableRoot)) {
-        let ownsBranch = worktree.branch === expectedBranch;
-        if (!ownsBranch && !worktree.branch) {
-            for (const statePath of ["rebase-merge/head-name", "rebase-apply/head-name"]) {
-                try {
-                    const gitPath = (await createGit(worktree.path).raw(["rev-parse", "--git-path", statePath])).trim();
-                    if ((await fs.readFile(gitPath, "utf8")).trim() === expectedBranch) {
-                        ownsBranch = true;
-                        break;
-                    }
-                }
-                catch {
-                    // No owned rebase coordinate at this registered worktree.
-                }
-            }
-        }
-        if (!ownsBranch)
-            continue;
-        try {
-            const dotGit = await fs.stat(path.join(worktree.path, ".git"));
-            if (dotGit.isDirectory())
-                continue;
-            return await fs.realpath(worktree.path);
-        }
-        catch {
-            // A stale Git registration is not an engine-owned worktree fact.
-        }
-    }
-    return undefined;
-}
-/** Prove the sole carrier target from stable-root, bind, and Git registration facts. */
-export async function resolveContractCarrierTarget(stableRoot, contractId, bind) {
-    if (bind.data.workspace === "here") {
-        const root = await fs.realpath(stableRoot);
-        return { status: "available", root, path: path.join(root, ".keiyaku", "KEIYAKU.md"), workspace: "here" };
-    }
-    const root = await findRegisteredContractWorktreePathFromBind(stableRoot, contractId, bind);
-    if (!root) {
-        return {
-            status: "unavailable",
-            workspace: "worktree",
-            reason: `contract ${contractId} has no verified registered engine worktree`,
-        };
-    }
-    return { status: "available", root, path: path.join(root, ".keiyaku", "KEIYAKU.md"), workspace: "worktree" };
-}
-/**
- * Resolve the contract id for an engine-owned bound worktree containing cwd.
- * Matches the canonical bind place path and worktree workspace only; ledger
- * terminal state is optional so residual worktrees after cleanup still bind.
- */
-async function contractIdForEngineOwnedWorktree(cwd, options) {
-    const stableRoot = options.stableRoot ?? await stableRepoRoot(cwd);
-    const candidate = await contractIdentityFromWorktreeWitness(cwd, stableRoot);
-    if (!candidate)
-        return undefined;
-    const outcome = await readCurrentContractLifecycle(stableRoot, candidate.contractId);
-    if (outcome.status !== "healthy" || !outcome.model.resources.worktree)
-        return undefined;
-    if (options.requireActive && ["claimed", "forfeited"].includes(outcome.model.phase))
-        return undefined;
-    let expectedWorktree;
-    try {
-        expectedWorktree = await fs.realpath(path.join(stableRoot, ".keiyaku", "wt", outcome.model.resources.worktree.place));
-    }
-    catch {
-        return undefined;
-    }
-    return candidate.path === expectedWorktree ? candidate.contractId : undefined;
-}
-/** Resolve only Git's local registered-worktree witness; lifecycle facts must verify it separately. */
-export async function contractIdentityFromWorktreeWitness(cwd, stableRoot, signal) {
-    const canonicalCwd = await fs.realpath(cwd);
-    const branchPrefix = "refs/heads/keiyaku/";
-    const candidates = [];
-    for (const worktree of await listWorktrees(stableRoot, signal)) {
-        if (!worktree.branch?.startsWith(branchPrefix))
-            continue;
-        let canonicalWorktree;
-        try {
-            canonicalWorktree = await fs.realpath(worktree.path);
-        }
-        catch {
-            continue;
-        }
-        if (!worktreeContainsCoordinate(canonicalWorktree, canonicalCwd))
-            continue;
-        candidates.push({
-            contractId: worktree.branch.slice(branchPrefix.length),
-            path: canonicalWorktree,
-            branch: worktree.branch,
-        });
-    }
-    return candidates.sort((left, right) => right.path.length - left.path.length || left.contractId.localeCompare(right.contractId))[0];
-}
-/**
- * Resolve the contract bound by an engine-owned worktree containing cwd,
- * including when the ledger is already terminal. Task CLI context uses this
- * residual binding; call uses the active-only sibling below.
- */
-export async function contractBoundByEngineWorktree(cwd, stableRoot) {
-    return contractIdForEngineOwnedWorktree(cwd, { requireActive: false, stableRoot });
-}
-/** Existing-contract verbs and no-selector call attachment use only this verified active binding. */
-export async function activeContractBoundByEngineWorktree(cwd, stableRoot) {
-    return contractIdForEngineOwnedWorktree(cwd, { requireActive: true, stableRoot });
-}
-/**
- * Verify a worktree binding against a folded current-ledger model. Git's
- * registration is only a physical witness here; it cannot create lifecycle
- * state or select a contract absent from the supplied read model.
- */
-export async function currentContractBoundByWorktreeWitness(input) {
-    let canonicalCwd;
-    try {
-        canonicalCwd = await fs.realpath(input.cwd);
-    }
-    catch {
-        return undefined;
-    }
-    const registeredWorktrees = await listWorktrees(input.stableRoot);
-    const candidates = [];
-    for (const model of input.contracts) {
-        const worktree = model.resources.worktree;
-        if (!worktree || worktree.state !== "held")
-            continue;
-        const expectedPath = path.join(input.stableRoot, ".keiyaku", "wt", worktree.place);
-        let canonicalExpectedPath;
-        try {
-            canonicalExpectedPath = await fs.realpath(expectedPath);
-        }
-        catch {
-            continue;
-        }
-        if (!worktreeContainsCoordinate(canonicalExpectedPath, canonicalCwd))
-            continue;
-        const registered = registeredWorktrees.some((candidate) => candidate.branch === model.resources.deliveryRef &&
-            normalizeFilesystemCoordinate(candidate.path) === normalizeFilesystemCoordinate(canonicalExpectedPath));
-        if (registered)
-            candidates.push({ contract: model.contract, path: canonicalExpectedPath });
-    }
-    candidates.sort((left, right) => right.path.length - left.path.length || left.contract.localeCompare(right.contract));
-    return candidates[0]?.contract;
-}
-/** Remove only the derived linked worktree. Authoritative refs are outside this adapter. */
-export async function cleanupContractWorkspace(cwd, lifecycle) {
-    const stableRoot = await stableRepoRoot(cwd);
-    const git = createGit(stableRoot);
-    const worktreePath = await findRegisteredContractWorktreePathFromModel(stableRoot, lifecycle);
-    const facts = { absent: [] };
-    if (worktreePath) {
-        try {
-            await git.raw(["worktree", "remove", "--force", worktreePath]);
-            facts.removedWorktreePath = worktreePath;
-        }
-        catch (error) {
-            facts.worktreeRemoveFailure = { path: worktreePath, reason: wrapGitError(`worktree remove ${worktreePath}`, error, stableRoot).message };
-        }
-    }
-    else {
-        facts.absent.push("worktree");
-    }
-    return facts;
-}
-/** Observe the terminal transaction's expected delivery-ref absence without reconciling it. */
-export async function observeTerminalDeliveryRef(cwd, contractId) {
-    const stableRoot = await stableRepoRoot(cwd);
-    const ref = `refs/heads/keiyaku/${contractId}`;
-    const observed = await resolveLocalBranchHead(stableRoot, ref);
-    if (!observed)
-        return { status: "aligned", ref, expected: "absent", observed: "absent" };
-    return {
-        status: "mismatch",
-        mismatch: {
-            kind: "projected-surface-mismatch",
-            surface: "delivery-ref",
-            ref,
-            expected: "absent",
-            observed: { state: "present", head: observed.head },
-        },
-    };
-}

package/build/errno.js

@@ -1,3 +0,0 @@
-export function isErrnoException(error) {
-    return error instanceof Error && "code" in error;
-}