superpowers-manager 0.4.0 → 0.5.1

package/dist/harnesses/pi/state.js

@@ -0,0 +1,311 @@
+import { join } from "node:path";
+import { sharedPiSkillsActivity } from "./shared-skills.js";
+import { failureResult, successResult, } from "../../adapter-result.js";
+import { readArtifactObject } from "../../artifact-tree.js";
+import { samePiSource } from "./compatibility.js";
+import { digestPiTree, readPiPackageAssessment, readPiReceipt, } from "./package.js";
+import { piPaths } from "./paths.js";
+import { readPiSettings, resolveCanonicalPiLocalSource, resolvePiLocalSource, } from "./settings.js";
+import { classifyPathNoFollow } from "../../safe-path.js";
+// Verified remote spellings only: Pi 0.85.1 accepts http:// as Git. Unprefixed
+// github: and git+ forms stay local; git:-wrapped aliases and explicit transports
+// normalize only an exact GitHub authority and repository path (native source
+// citations are in pi-settings.ts).
+const KNOWN_UPSTREAM_PI_SOURCE_BASES = [
+    "git:github.com/obra/superpowers",
+    "git:github.com/obra/superpowers.git",
+    "git:git@github.com:obra/superpowers",
+    "git:git@github.com:obra/superpowers.git",
+    "git:git@github.com/obra/superpowers",
+    "git:git@github.com/obra/superpowers.git",
+    "git:github:obra/superpowers",
+    "git:github:obra/superpowers.git",
+    "git:obra/superpowers",
+    "git:obra/superpowers.git",
+    "http://github.com/obra/superpowers",
+    "http://github.com/obra/superpowers.git",
+    "https://github.com/obra/superpowers",
+    "https://github.com/obra/superpowers.git",
+    "ssh://github.com/obra/superpowers",
+    "ssh://github.com/obra/superpowers.git",
+    "ssh://git@github.com/obra/superpowers",
+    "ssh://git@github.com/obra/superpowers.git",
+    "git://github.com/obra/superpowers",
+    "git://github.com/obra/superpowers.git",
+];
+const SHARED_PI_SKILLS_CONFLICT = "native Pi skills route ~/.agents/skills/superpowers";
+const SHARED_PI_SKILLS_INDETERMINATE = `${SHARED_PI_SKILLS_CONFLICT} has indeterminate activity`;
+function blocked(...stderr) {
+    return { kind: "blocked", output: { stdout: [], stderr } };
+}
+function pathsFor(ctx) {
+    return piPaths(ctx.env ?? {}, process.cwd());
+}
+function isNonemptyControlFree(value) {
+    if (value.length === 0)
+        return false;
+    for (const character of value) {
+        const code = character.codePointAt(0);
+        if (code <= 0x20 || code === 0x7f)
+            return false;
+    }
+    return true;
+}
+function normalizeVerifiedGithubSource(candidate) {
+    const match = /^(https?|ssh|git):\/\/([^/?#]+)(\/obra\/superpowers(?:\.git)?\/?(?:[@#].*)?)$/u.exec(candidate);
+    if (match === null)
+        return candidate;
+    const [, transport, authority, path] = match;
+    const at = authority.lastIndexOf("@");
+    const userinfo = at === -1 ? null : authority.slice(0, at);
+    if ((userinfo !== null &&
+        (authority.indexOf("@") !== at || !isNonemptyControlFree(userinfo))) ||
+        authority.slice(at + 1) === "")
+        return candidate;
+    const host = authority.slice(at + 1);
+    const normalizedHost = host.startsWith("www.") ? host.slice(4) : host;
+    if (normalizedHost !== "github.com")
+        return candidate;
+    return `${transport}://github.com${path}`;
+}
+function isKnownUpstreamPiSource(raw) {
+    const source = raw.trim();
+    const outerBody = source.startsWith("git:") ? source.slice(4).trim() : null;
+    const candidates = [
+        source,
+        ...(outerBody === null
+            ? []
+            : [
+                outerBody.startsWith("git+https://") ||
+                    outerBody.startsWith("git+ssh://")
+                    ? outerBody.slice(4)
+                    : outerBody,
+            ]),
+    ];
+    return candidates.some((candidate) => {
+        const normalized = normalizeVerifiedGithubSource(candidate);
+        return KNOWN_UPSTREAM_PI_SOURCE_BASES.some((base) => {
+            if (normalized === base)
+                return true;
+            if (!normalized.startsWith(base))
+                return false;
+            let suffix = normalized.slice(base.length);
+            if (suffix.startsWith("/"))
+                suffix = suffix.slice(1);
+            if (suffix === "")
+                return true;
+            if (suffix.at(0) !== "@" && suffix.at(0) !== "#")
+                return false;
+            return isNonemptyControlFree(suffix.slice(1));
+        });
+    });
+}
+async function observeSettings(paths) {
+    const settings = await readPiSettings(paths.settingsFile, paths.homeDir);
+    const installedRoot = await resolveCanonicalPiLocalSource(paths.installedRoot, paths.agentDir, paths.homeDir);
+    let registration = null;
+    for (const entry of settings.packages) {
+        if ((await resolveCanonicalPiLocalSource(entry.source, paths.agentDir, paths.homeDir)) === installedRoot) {
+            registration = entry;
+        }
+    }
+    return { settings, registration };
+}
+async function observeSnapshot(paths) {
+    const kind = await classifyPathNoFollow(paths.installedRoot);
+    if (kind === "missing")
+        return { kind: "absent" };
+    if (kind !== "directory")
+        return { kind: "unverified" };
+    try {
+        const receipt = await readPiReceipt(paths.installedRoot);
+        const digest = await digestPiTree(paths.installedRoot);
+        return receipt.digest === digest
+            ? { kind: "owned", receipt, digest }
+            : { kind: "unverified" };
+    }
+    catch {
+        return { kind: "unverified" };
+    }
+}
+async function isNamedLocalSuperpowers(entry, paths, canonicalInstalledRoot) {
+    const root = resolvePiLocalSource(entry.source, paths.agentDir, paths.homeDir);
+    if (root === null ||
+        (await resolveCanonicalPiLocalSource(entry.source, paths.agentDir, paths.homeDir)) === canonicalInstalledRoot)
+        return false;
+    const rootKind = await classifyPathNoFollow(root);
+    if (rootKind !== "directory" && rootKind !== "symlink")
+        return false;
+    const metadata = join(root, "package.json");
+    const metadataKind = await classifyPathNoFollow(metadata);
+    if (metadataKind === "missing")
+        return false;
+    if (metadataKind !== "regular-file") {
+        throw new Error("registered local Pi package metadata is not a regular file");
+    }
+    const pkg = await readArtifactObject(root, metadata);
+    return pkg.name === "superpowers";
+}
+async function unmanagedConflicts(settings, paths) {
+    const conflicts = new Set();
+    const canonicalInstalledRoot = await resolveCanonicalPiLocalSource(paths.installedRoot, paths.agentDir, paths.homeDir);
+    if (canonicalInstalledRoot === null)
+        throw new Error("Pi installed root is not local");
+    for (const entry of settings.packages) {
+        if (entry.resourceState === "disabled")
+            continue;
+        if (isKnownUpstreamPiSource(entry.source)) {
+            conflicts.add("registered Pi package for obra/superpowers");
+        }
+        else if (await isNamedLocalSuperpowers(entry, paths, canonicalInstalledRoot)) {
+            conflicts.add("registered local Pi package named superpowers");
+        }
+    }
+    if ((await classifyPathNoFollow(join(paths.agentDir, "extensions", "superpowers.ts"))) !== "missing") {
+        conflicts.add("native Pi extension superpowers.ts");
+    }
+    if ((await classifyPathNoFollow(join(paths.agentDir, "skills", "using-superpowers", "SKILL.md"))) !== "missing") {
+        conflicts.add("native Pi skill using-superpowers");
+    }
+    const sharedSkills = await sharedPiSkillsActivity(settings, paths);
+    if (sharedSkills === "active") {
+        conflicts.add(SHARED_PI_SKILLS_CONFLICT);
+    }
+    else if (sharedSkills === "indeterminate") {
+        conflicts.add(SHARED_PI_SKILLS_INDETERMINATE);
+    }
+    return [...conflicts];
+}
+function inspectionFailure(operation, subject) {
+    return failureResult(operation, "invalid-state", `cannot inspect ${subject}`, [], []);
+}
+export async function inspectPiOwnership(ctx) {
+    const operation = "inspect-pi-ownership";
+    const paths = pathsFor(ctx);
+    try {
+        const [{ settings, registration }, snapshot] = await Promise.all([
+            observeSettings(paths),
+            observeSnapshot(paths),
+        ]);
+        if (snapshot.kind === "unverified") {
+            return inspectionFailure(operation, `Pi ownership at ${paths.installedRoot}`);
+        }
+        const conflicts = await unmanagedConflicts(settings, paths);
+        let installEligibility = { kind: "allowed" };
+        if (registration?.resourceState === "disabled") {
+            installEligibility = blocked("error: the Manager Pi registration disables required resources", "Enable both Manager-provided Pi resources manually, then retry.");
+        }
+        else if (registration?.resourceState === "indeterminate") {
+            installEligibility = blocked("error: the Manager Pi registration uses unsupported resource filters", "Remove the filters or enable both Manager-provided Pi resources manually, then retry.");
+        }
+        else if (conflicts.length > 0) {
+            installEligibility = blocked("Conflicting unmanaged Superpowers Pi resources require manual resolution:", ...conflicts.map((conflict) => `- ${conflict}`), "Remove or disable each resource manually, then retry.");
+        }
+        let removalVerification = { kind: "allowed" };
+        if (registration !== null) {
+            removalVerification = blocked("error: the Manager Pi package registration is still present after removal");
+        }
+        else if (snapshot.kind === "owned") {
+            removalVerification = blocked("error: the Manager-owned Pi snapshot is still present after removal");
+        }
+        const presentationValue = snapshot.kind === "owned"
+            ? registration === null
+                ? `managed snapshot ${snapshot.digest}`
+                : `managed ${snapshot.digest}`
+            : registration === null
+                ? "absent"
+                : "registered without an installed snapshot";
+        return successResult(operation, {
+            installEligibility,
+            removalInput: {
+                installedRoot: paths.installedRoot,
+                registrationIdentity: registration?.source ?? null,
+                receiptDigest: snapshot.kind === "owned" ? snapshot.receipt.digest : null,
+            },
+            removalVerification,
+            postRemovalOutput: { stdout: [], stderr: [] },
+            presentationValue,
+            presentationConflicts: conflicts,
+        }, []);
+    }
+    catch {
+        return inspectionFailure(operation, `Pi ownership at ${paths.installedRoot}`);
+    }
+}
+export async function inspectPiInstalled(selection, ctx) {
+    const operation = "inspect-pi-installed";
+    const paths = pathsFor(ctx);
+    let settings;
+    let snapshot;
+    try {
+        [settings, snapshot] = await Promise.all([
+            observeSettings(paths),
+            observeSnapshot(paths),
+        ]);
+    }
+    catch {
+        return inspectionFailure(operation, `Pi installed state at ${paths.installedRoot}`);
+    }
+    if (snapshot.kind === "absent") {
+        return successResult(operation, settings.registration === null
+            ? { kind: "absent", observedIdentity: "" }
+            : {
+                kind: "mismatch",
+                observedIdentity: "registered without an installed snapshot",
+            }, []);
+    }
+    if (snapshot.kind === "unverified") {
+        return successResult(operation, { kind: "mismatch", observedIdentity: "unverified installed snapshot" }, []);
+    }
+    const mismatch = successResult(operation, { kind: "mismatch", observedIdentity: snapshot.digest }, []);
+    if (settings.registration === null ||
+        settings.registration.resourceState !== "enabled") {
+        return mismatch;
+    }
+    try {
+        const intended = await readPiPackageAssessment(paths.preparedRoot);
+        if ((intended.compatibility.kind !== "supported" &&
+            intended.compatibility.kind !== "experimental") ||
+            intended.receipt.commit !== selection.desiredCommit ||
+            !samePiSource(intended.receipt.source, selection.effectiveSource) ||
+            snapshot.receipt.commit !== intended.receipt.commit ||
+            !samePiSource(snapshot.receipt.source, intended.receipt.source) ||
+            snapshot.digest !== intended.receipt.digest) {
+            return mismatch;
+        }
+    }
+    catch {
+        return mismatch;
+    }
+    return successResult(operation, { kind: "current", observedIdentity: snapshot.digest }, []);
+}
+export async function inspectPiControl(ctx) {
+    const operation = "inspect-pi-control";
+    const paths = pathsFor(ctx);
+    try {
+        const { settings, registration } = await observeSettings(paths);
+        const conflicts = await unmanagedConflicts(settings, paths);
+        const probeEligibility = { kind: "allowed" };
+        const mutationEligibility = registration?.resourceState === "disabled"
+            ? blocked("error: the Manager Pi registration disables required resources")
+            : registration?.resourceState === "indeterminate"
+                ? blocked("error: the Manager Pi registration uses unsupported resource filters")
+                : conflicts.length > 0
+                    ? blocked("error: unmanaged Superpowers Pi resources prevent managed update control")
+                    : { kind: "allowed" };
+        return successResult(operation, {
+            probeEligibility,
+            mutationEligibility,
+            presentationValue: registration === null
+                ? conflicts.length > 0
+                    ? "unmanaged conflicts"
+                    : "unregistered"
+                : registration.resourceState === "enabled"
+                    ? "managed local registration"
+                    : "manual resource configuration",
+        }, []);
+    }
+    catch {
+        return inspectionFailure(operation, `Pi update control at ${paths.settingsFile}`);
+    }
+}

package/dist/python-text.js

@@ -72,3 +72,19 @@ export function pythonSplitlines(value) {
         lines.push(value.slice(start));
     return lines;
 }
+/** Python `sorted()` orders by code point; JavaScript's default sort does not. */
+export function compareByCodePoint(left, right) {
+    // `Array.from` splits by code point, exactly as spreading would; oxlint's
+    // `no-misused-spread` rejects the spread form, and grapheme segmentation is
+    // the wrong unit here — Python compares code points.
+    const leftPoints = Array.from(left);
+    const rightPoints = Array.from(right);
+    const shared = Math.min(leftPoints.length, rightPoints.length);
+    for (let index = 0; index < shared; index += 1) {
+        const a = leftPoints[index].codePointAt(0);
+        const b = rightPoints[index].codePointAt(0);
+        if (a !== b)
+            return a - b;
+    }
+    return leftPoints.length - rightPoints.length;
+}

package/dist/resource-lock.js

@@ -0,0 +1,265 @@
+import { createHash, randomUUID } from "node:crypto";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, readFile, realpath, rmdir, unlink, writeFile, } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { canonicalizeProspectivePath } from "./safe-path.js";
+import { SafetyError } from "./safety-error.js";
+function errnoIs(cause, code) {
+    return (cause instanceof Error &&
+        "code" in cause &&
+        cause.code === code);
+}
+async function nearestExistingDirectory(path) {
+    let cursor = path;
+    for (;;) {
+        try {
+            return await realpath(cursor);
+        }
+        catch (cause) {
+            if (!errnoIs(cause, "ENOENT"))
+                throw cause;
+            const parent = dirname(cursor);
+            if (parent === cursor)
+                throw cause;
+            cursor = parent;
+        }
+    }
+}
+async function resourceLockPaths(resource) {
+    let lockParent;
+    try {
+        lockParent = await nearestExistingDirectory(dirname(resource));
+    }
+    catch (cause) {
+        throw new SafetyError("resource-lock", `cannot locate resource lock parent: ${resource}`, { cause });
+    }
+    const digest = createHash("sha256").update(resource).digest("hex");
+    const lockName = `.superpowers-manager.${digest}.resource-lock`;
+    const paths = [];
+    let cursor = lockParent;
+    for (;;) {
+        paths.push(join(cursor, lockName));
+        const parent = dirname(cursor);
+        if (parent === cursor)
+            break;
+        cursor = parent;
+    }
+    return paths;
+}
+async function resourceLock(resource) {
+    const canonical = await canonicalizeProspectivePath(resource);
+    const paths = await resourceLockPaths(canonical);
+    for (const candidate of paths) {
+        try {
+            await lstat(candidate);
+            return { resource: canonical, lockPath: candidate };
+        }
+        catch (cause) {
+            if (!errnoIs(cause, "ENOENT")) {
+                throw new SafetyError("resource-lock", `cannot inspect resource lock: ${canonical}`, { cause });
+            }
+        }
+    }
+    return {
+        resource: canonical,
+        lockPath: paths[0],
+    };
+}
+async function assertNoCompetingResourceLock(lock, held) {
+    for (const candidate of await resourceLockPaths(lock.resource)) {
+        try {
+            await lstat(candidate);
+        }
+        catch (cause) {
+            if (errnoIs(cause, "ENOENT"))
+                continue;
+            throw new SafetyError("resource-lock", `cannot inspect resource lock: ${lock.resource}`, { cause });
+        }
+        if (held.get(candidate)?.resource === lock.resource)
+            continue;
+        throw new SafetyError("resource-lock", `resource is busy: ${lock.resource}`);
+    }
+}
+function ownerRecord(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        return undefined;
+    }
+    if (!("token" in value) ||
+        typeof value.token !== "string" ||
+        !("resource" in value) ||
+        typeof value.resource !== "string") {
+        return undefined;
+    }
+    return { token: value.token, resource: value.resource };
+}
+function releaseFailure(resource, cause) {
+    return new SafetyError("resource-lock", `cannot release resource lock: ${resource}`, { cause });
+}
+async function releaseOwned(held) {
+    if (held.count > 1) {
+        held.count -= 1;
+        return { keepHeld: true, failure: null };
+    }
+    const metadataPath = join(held.lockPath, "owner.json");
+    let owner;
+    try {
+        owner = ownerRecord(JSON.parse(await readFile(metadataPath, "utf8")));
+    }
+    catch (cause) {
+        return {
+            keepHeld: false,
+            failure: releaseFailure(held.resource, cause),
+        };
+    }
+    if (owner === undefined ||
+        owner.token !== held.token ||
+        owner.resource !== held.resource) {
+        return {
+            keepHeld: false,
+            failure: releaseFailure(held.resource),
+        };
+    }
+    try {
+        await unlink(metadataPath);
+        await rmdir(held.lockPath);
+    }
+    catch (cause) {
+        // A lock whose contents changed or cannot be inspected is not ours to
+        // clear. Leaving it busy is safer than guessing at stale ownership.
+        return {
+            keepHeld: false,
+            failure: releaseFailure(held.resource, cause),
+        };
+    }
+    return { keepHeld: false, failure: null };
+}
+class FilesystemResourceCoordinator {
+    #held = new Map();
+    async observeResources(paths) {
+        return await Promise.all(paths.map(async (path) => {
+            const lock = await resourceLock(path);
+            const observation = (state, markerIdentity = "") => ({
+                resource: lock.resource,
+                state,
+                markerIdentity,
+            });
+            try {
+                const before = await lstat(lock.lockPath);
+                if (!before.isDirectory())
+                    return observation("uninspectable");
+                const metadataPath = join(lock.lockPath, "owner.json");
+                const file = await open(metadataPath, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+                try {
+                    const metadata = await file.stat();
+                    if (!metadata.isFile() || metadata.size > 8192)
+                        return observation("uninspectable");
+                    const owner = ownerRecord(JSON.parse(await file.readFile("utf8")));
+                    const after = await lstat(lock.lockPath);
+                    const metadataAfter = await lstat(metadataPath);
+                    if (!owner ||
+                        !owner.token ||
+                        owner.resource !== lock.resource ||
+                        before.dev !== after.dev ||
+                        before.ino !== after.ino ||
+                        !after.isDirectory() ||
+                        !metadataAfter.isFile() ||
+                        metadata.dev !== metadataAfter.dev ||
+                        metadata.ino !== metadataAfter.ino ||
+                        metadata.mtimeMs !== metadataAfter.mtimeMs ||
+                        metadata.size !== metadataAfter.size)
+                        return observation("uninspectable");
+                    const held = this.#held.get(lock.lockPath);
+                    const owned = held?.token === owner.token && held.resource === owner.resource;
+                    return observation(owned ? "owned" : "busy", `${before.dev}:${before.ino}:${metadata.dev}:${metadata.ino}:${owner.token}`);
+                }
+                finally {
+                    await file.close();
+                }
+            }
+            catch (cause) {
+                if (errnoIs(cause, "ENOENT")) {
+                    try {
+                        await lstat(lock.lockPath);
+                    }
+                    catch (again) {
+                        if (errnoIs(again, "ENOENT"))
+                            return observation(this.#held.has(lock.lockPath) ? "uninspectable" : "idle");
+                    }
+                }
+                return observation("uninspectable");
+            }
+        }));
+    }
+    async withResources(paths, action) {
+        const resolved = await Promise.all(paths.map(resourceLock));
+        const locks = [
+            ...new Map(resolved.map((entry) => [entry.lockPath, entry])).values(),
+        ].sort((left, right) => left.lockPath < right.lockPath
+            ? -1
+            : left.lockPath > right.lockPath
+                ? 1
+                : 0);
+        const acquired = [];
+        let completion;
+        try {
+            for (const lock of locks) {
+                const existing = this.#held.get(lock.lockPath);
+                if (existing !== undefined) {
+                    existing.count += 1;
+                    acquired.push({ held: existing });
+                    continue;
+                }
+                const token = randomUUID();
+                try {
+                    await mkdir(lock.lockPath);
+                }
+                catch (cause) {
+                    if (errnoIs(cause, "EEXIST")) {
+                        throw new SafetyError("resource-lock", `resource is busy: ${lock.resource}`, { cause });
+                    }
+                    throw new SafetyError("resource-lock", `cannot acquire resource lock: ${lock.resource}`, { cause });
+                }
+                const held = { ...lock, token, count: 1 };
+                try {
+                    await writeFile(join(lock.lockPath, "owner.json"), JSON.stringify({
+                        token,
+                        pid: process.pid,
+                        resource: lock.resource,
+                    }), { flag: "wx" });
+                }
+                catch (cause) {
+                    throw new SafetyError("resource-lock", `cannot record resource lock ownership: ${lock.resource}`, { cause });
+                }
+                this.#held.set(lock.lockPath, held);
+                acquired.push({ held });
+            }
+            // A missing ancestor can appear between placement discovery and mkdir,
+            // leaving concurrently acquired markers at different depths. Checking
+            // every placement also prevents our descendant marker from hiding a
+            // competing ancestor marker.
+            for (const lock of locks) {
+                await assertNoCompetingResourceLock(lock, this.#held);
+            }
+            completion = { kind: "returned", value: await action() };
+        }
+        catch (cause) {
+            completion = { kind: "threw", cause };
+        }
+        let firstReleaseFailure = null;
+        for (const entry of acquired.reverse()) {
+            const released = await releaseOwned(entry.held);
+            if (!released.keepHeld) {
+                this.#held.delete(entry.held.lockPath);
+            }
+            firstReleaseFailure ??= released.failure;
+        }
+        if (completion.kind === "threw")
+            throw completion.cause;
+        if (firstReleaseFailure !== null)
+            throw firstReleaseFailure;
+        return completion.value;
+    }
+}
+export function createResourceCoordinator() {
+    return new FilesystemResourceCoordinator();
+}

package/dist/safe-path.js

@@ -73,9 +73,27 @@ export async function assertProspectiveContained(root, candidate) {
     requireContained(lexicalRoot, lexicalCandidate);
     try {
         const resolvedRoot = await realpath(lexicalRoot);
+        const resolvedCandidate = await canonicalizeProspectivePath(lexicalCandidate);
+        requireContained(resolvedRoot, resolvedCandidate);
+        return lexicalCandidate;
+    }
+    catch (cause) {
+        if (cause instanceof SafetyError)
+            throw cause;
+        throw new SafetyError("safe-path", `cannot resolve prospective path: ${lexicalCandidate}`, { cause });
+    }
+}
+// Resolve every existing component and retain a normalized suffix for
+// components that do not exist yet. Unlike assertProspectiveContained this is
+// not a containment assertion: resource coordination needs one canonical
+// identity even when two package roots reach the target through different
+// symlink aliases.
+export async function canonicalizeProspectivePath(path) {
+    const lexicalPath = resolve(path);
+    try {
         const missing = [];
         const visitedCursors = new Set();
-        let cursor = lexicalCandidate;
+        let cursor = lexicalPath;
         let resolvedAncestor;
         for (;;) {
             if (visitedCursors.has(cursor)) {
@@ -110,14 +128,12 @@ export async function assertProspectiveContained(root, candidate) {
                 cursor = parent;
             }
         }
-        const resolvedCandidate = resolve(resolvedAncestor, ...missing);
-        requireContained(resolvedRoot, resolvedCandidate);
-        return lexicalCandidate;
+        return resolve(resolvedAncestor, ...missing);
     }
     catch (cause) {
         if (cause instanceof SafetyError)
             throw cause;
-        throw new SafetyError("safe-path", `cannot resolve prospective path: ${lexicalCandidate}`, { cause });
+        throw new SafetyError("safe-path", `cannot resolve prospective path: ${lexicalPath}`, { cause });
     }
 }
 export async function assertSymlinkTargetContained(root, candidate) {