@cardanvil/frame-kit 0.5.0 → 0.7.0

package/dist/cli/sourceWatcher.js

@@ -0,0 +1,100 @@
+import { watch } from "node:fs";
+import path from "node:path";
+import { relativePosix } from "./discover.js";
+/** Directories never worth watching. Mirrors discovery's own skip list. */
+const SKIP_DIRS = new Set([
+    "node_modules",
+    "dist",
+    ".git",
+    ".pnpm-store",
+    "__fixtures__",
+]);
+/** Files a rebuild produces, or an editor leaves lying around. */
+const IGNORED_FILE = /(\.cardframe|frame-index\.json|\.preview\.[a-z]+|~|\.swp|\.tmp)$/i;
+/**
+ * How long to wait for changes to stop before reacting.
+ *
+ * One save can produce several events — a write, a rename, an attribute
+ * change — and a tool upstream may rewrite a whole directory.
+ */
+export const DEBOUNCE_MS = 200;
+/** Whether a path is build output, editor debris, or inside a skipped dir. */
+export function isIgnored(file) {
+    const segments = file.split(path.sep);
+    return (segments.some((segment) => SKIP_DIRS.has(segment) || segment.startsWith(".")) || IGNORED_FILE.test(file));
+}
+/**
+ * Watches directories and delivers debounced, non-overlapping change batches.
+ *
+ * Shared by `frame-kit build --watch` and `frame-kit studio`, which need the
+ * same three things and get them wrong in the same three ways otherwise:
+ * coalescing a burst of events from one save, never running two handlers at
+ * once, and surviving a handler that throws.
+ */
+export function startSourceWatcher(options) {
+    const { root, dirs, onChange, ignore, debounceMs = DEBOUNCE_MS, onError = (message) => {
+        console.error(message);
+    }, } = options;
+    const watchers = [];
+    const pending = new Set();
+    let timer;
+    let running = false;
+    async function drain() {
+        if (running) {
+            // Whatever arrived is already in `pending`, and the loop below picks it
+            // up when the in-flight handler finishes.
+            return;
+        }
+        running = true;
+        try {
+            // Keyed off `pending` rather than a flag: anything that arrived during a
+            // handler is still queued when it finishes.
+            while (pending.size > 0) {
+                const changed = [...pending];
+                pending.clear();
+                await onChange(changed);
+            }
+        }
+        catch (cause) {
+            // A failed handler must not end the session: the author is mid-edit and
+            // the next save is probably the fix.
+            onError(cause instanceof Error ? cause.message : String(cause));
+        }
+        finally {
+            running = false;
+        }
+    }
+    function onFileEvent(file) {
+        if (isIgnored(file) || ignore?.(file) === true) {
+            return;
+        }
+        pending.add(file);
+        if (timer) {
+            clearTimeout(timer);
+        }
+        timer = setTimeout(() => void drain(), debounceMs);
+    }
+    for (const dir of dirs) {
+        try {
+            watchers.push(watch(dir, { recursive: true }, (_event, name) => {
+                if (name !== null) {
+                    onFileEvent(path.join(dir, name));
+                }
+            }));
+        }
+        catch {
+            onError(`Could not watch ${relativePosix(root, dir)}. Recursive watching is ` +
+                `not supported on this filesystem.`);
+        }
+    }
+    return {
+        close() {
+            if (timer) {
+                clearTimeout(timer);
+            }
+            for (const watcher of watchers) {
+                watcher.close();
+            }
+        },
+    };
+}

package/dist/cli/studio/boxSets.d.ts

@@ -0,0 +1,33 @@
+/**
+ * What a `LayoutConfig` slot holds.
+ *
+ * `boxes` is the only kind the studio can edit geometry in; the other two are
+ * listed so the layer panel can offer them without hard-coding field names.
+ */
+export type SlotKind = "boxes" | "assets" | "masks" | "knobs";
+export interface LayoutSlot {
+    /** The `LayoutConfig` property, e.g. `sagaBackCreatureBoxes`. */
+    readonly key: string;
+    readonly kind: SlotKind;
+    /** False for every slot the contract marks optional. */
+    readonly required: boolean;
+}
+/**
+ * Every box / asset / mask / knob slot the frame contract defines, read off
+ * the schema rather than listed by hand.
+ *
+ * Identity is the test: a slot counts as boxes because its schema *is*
+ * `CardBoxesSchema`, not because its name ends in "Boxes". So a slot added to
+ * `LayoutConfigSchema` shows up here — and in the studio — with no change,
+ * and `boxSets.test.ts` fails if one is added that this cannot classify.
+ */
+export declare function layoutSlots(): LayoutSlot[];
+/** Just the slots holding `CardBoxes` — what the studio can edit. */
+export declare function boxSlots(): LayoutSlot[];
+/**
+ * Names of every member a `CardBoxes` can hold, in contract order.
+ *
+ * Used to enumerate a box set without assuming which optional members a given
+ * frame happens to define.
+ */
+export declare function cardBoxKeys(): string[];

package/dist/cli/studio/boxSets.js

@@ -0,0 +1,90 @@
+import { CardBoxesSchema, LayoutConfigSchema, SecondFaceBoxesSchema, } from "../../schema/frame.js";
+import { FrameAssetsSchema, LayoutMasksSchema, } from "../../schema/frameAssets.js";
+/** Strips `.optional()` and friends to reach the schema that carries identity. */
+function unwrap(schema) {
+    let current = schema;
+    let wrapped = false;
+    for (;;) {
+        const node = current.def;
+        if (node.innerType === undefined ||
+            ![
+                "optional",
+                "nullable",
+                "default",
+                "prefault",
+                "readonly",
+                "nonoptional",
+            ].includes(node.type)) {
+            return { inner: current, wrapped };
+        }
+        current = node.innerType;
+        wrapped = true;
+    }
+}
+const KIND_BY_SCHEMA = new Map([
+    [CardBoxesSchema, "boxes"],
+    // A second face's set is boxes like any other, only fewer of them.
+    [SecondFaceBoxesSchema, "boxes"],
+    [FrameAssetsSchema, "assets"],
+    [LayoutMasksSchema, "masks"],
+]);
+/**
+ * Whether a schema is an object of numbers — a layout's render knobs
+ * (`planeswalkerConfig`, `sagaConfig`, `sectionConfig`, `crownConfig`,
+ * `nicknameConfig`, `powerToughnessRow`). A group may also hold objects, such
+ * as `planeswalkerConfig.abilityDivider`; the studio edits only its numbers.
+ *
+ * Recognised by shape rather than by name, so a knob group added to the
+ * contract is editable in the studio without a change here. Records and enums
+ * do not qualify, which is what keeps `templateSettings`, `colorArtOverrides`
+ * and `hybridTitleMask` out.
+ */
+function isNumericObject(schema) {
+    const node = schema.def;
+    if (node.type !== "object" || !node.shape) {
+        return false;
+    }
+    const fields = Object.values(node.shape);
+    const types = fields.map((field) => unwrap(field).inner.def.type);
+    const isKnob = (type) => type === "number" || type === "boolean";
+    return (types.some(isKnob) &&
+        types.every((type) => isKnob(type) || type === "object"));
+}
+/**
+ * Every box / asset / mask / knob slot the frame contract defines, read off
+ * the schema rather than listed by hand.
+ *
+ * Identity is the test: a slot counts as boxes because its schema *is*
+ * `CardBoxesSchema`, not because its name ends in "Boxes". So a slot added to
+ * `LayoutConfigSchema` shows up here — and in the studio — with no change,
+ * and `boxSets.test.ts` fails if one is added that this cannot classify.
+ */
+export function layoutSlots() {
+    const shape = LayoutConfigSchema.def
+        .shape;
+    const slots = [];
+    for (const [key, schema] of Object.entries(shape)) {
+        const { inner, wrapped } = unwrap(schema);
+        const kind = KIND_BY_SCHEMA.get(inner) ??
+            (isNumericObject(inner) ? "knobs" : undefined);
+        if (kind) {
+            slots.push({ key, kind, required: !wrapped });
+        }
+    }
+    return slots;
+}
+/** Just the slots holding `CardBoxes` — what the studio can edit. */
+export function boxSlots() {
+    return layoutSlots().filter((slot) => slot.kind === "boxes");
+}
+/**
+ * Names of every member a `CardBoxes` can hold, in contract order.
+ *
+ * Used to enumerate a box set without assuming which optional members a given
+ * frame happens to define.
+ */
+export function cardBoxKeys() {
+    const shape = CardBoxesSchema.def
+        .shape;
+    return Object.keys(shape);
+}

package/dist/cli/studio/edit/applyEdits.d.ts

@@ -0,0 +1,71 @@
+import type { FramePath } from "../../../manifest/walk.js";
+import { type ResolveContext, type SourceLocation, type UnsupportedReason } from "./resolvePath.js";
+/** A value a literal may be replaced with. The contract has no others. */
+export type EditableValue = number | string | boolean;
+export interface Edit {
+    readonly path: FramePath;
+    readonly value: EditableValue;
+}
+export interface EditRejection {
+    readonly path: FramePath;
+    readonly reason: UnsupportedReason | "value-mismatch" | "stale" | "overlap";
+    readonly detail: string;
+    readonly source?: SourceLocation;
+}
+export interface AppliedEdit {
+    readonly path: FramePath;
+    readonly file: string;
+    readonly from: string;
+    readonly to: string;
+    /** True when the literal is a helper default other box sets also read. */
+    readonly sharedDefault: boolean;
+}
+export type ApplyResult = {
+    readonly ok: true;
+    readonly applied: readonly AppliedEdit[];
+    /** New sha256 of every file written, for the caller's self-write map. */
+    readonly files: ReadonlyMap<string, string>;
+} | {
+    readonly ok: false;
+    readonly rejected: readonly EditRejection[];
+};
+export interface ApplyOptions {
+    readonly ctx: ResolveContext;
+    readonly entryFile: string;
+    readonly exportName: string;
+    /**
+     * The frame as most recently loaded, used to verify that each literal we are
+     * about to overwrite really is the one that produced the current value.
+     */
+    readonly frame: unknown;
+    readonly edits: readonly Edit[];
+    /**
+     * sha256 each file is expected to still have. A file that has changed since
+     * the studio read it is refused rather than overwritten.
+     */
+    readonly expect?: ReadonlyMap<string, string>;
+}
+/** Whether a literal's source text really denotes `value`. */
+export declare function literalDenotes(text: string, value: unknown): boolean;
+/**
+ * Renders a new literal in the style of the one it replaces.
+ *
+ * Numbers are written plainly — every real frame uses integers, and a drag
+ * produces fractions nobody wants in source. Strings reuse the quote
+ * character already there so the file still satisfies Prettier.
+ */
+export declare function renderLiteral(value: EditableValue, previous: string): string;
+/**
+ * Rewrites literals in place, or refuses and writes nothing.
+ *
+ * Every edit is resolved to a source range, checked against the value the
+ * frame actually loaded with, and only then spliced. The check is the reason
+ * this is safe to run against someone's working tree: if the resolver is ever
+ * wrong — a mis-ordered spread, a followed import that was the wrong one — the
+ * literal will not match the value, and the whole batch is refused. The
+ * failure mode is "refuses to edit", never "edited the wrong number".
+ *
+ * Only the literal's own characters change, so comments, formatting and import
+ * order survive by construction; nothing is reprinted.
+ */
+export declare function applyEdits(options: ApplyOptions): Promise<ApplyResult>;

package/dist/cli/studio/edit/applyEdits.js

@@ -0,0 +1,177 @@
+import { createHash } from "node:crypto";
+import { formatPath, getAtPath } from "../../../manifest/walk.js";
+import { writeFileAtomic } from "../../atomic.js";
+import { resolveFramePath, } from "./resolvePath.js";
+import { normalizeFile } from "./sourceIndex.js";
+const sha256 = (text) => createHash("sha256").update(text).digest("hex");
+/** Whether a literal's source text really denotes `value`. */
+export function literalDenotes(text, value) {
+    if (typeof value === "number") {
+        return Number(text) === value;
+    }
+    if (typeof value === "boolean") {
+        return text === String(value);
+    }
+    if (typeof value === "string") {
+        const quote = text[0];
+        if (quote !== '"' && quote !== "'" && quote !== "`") {
+            return false;
+        }
+        return text.slice(1, -1) === value;
+    }
+    return false;
+}
+/**
+ * Renders a new literal in the style of the one it replaces.
+ *
+ * Numbers are written plainly — every real frame uses integers, and a drag
+ * produces fractions nobody wants in source. Strings reuse the quote
+ * character already there so the file still satisfies Prettier.
+ */
+export function renderLiteral(value, previous) {
+    if (typeof value === "number") {
+        return Number.isInteger(value) ? String(value) : String(Math.round(value));
+    }
+    if (typeof value === "boolean") {
+        return String(value);
+    }
+    const quote = previous.startsWith("'")
+        ? "'"
+        : previous.startsWith("`")
+            ? "`"
+            : '"';
+    const escaped = value
+        .replaceAll("\\", "\\\\")
+        .replaceAll(quote, `\\${quote}`);
+    return `${quote}${escaped}${quote}`;
+}
+/**
+ * Rewrites literals in place, or refuses and writes nothing.
+ *
+ * Every edit is resolved to a source range, checked against the value the
+ * frame actually loaded with, and only then spliced. The check is the reason
+ * this is safe to run against someone's working tree: if the resolver is ever
+ * wrong — a mis-ordered spread, a followed import that was the wrong one — the
+ * literal will not match the value, and the whole batch is refused. The
+ * failure mode is "refuses to edit", never "edited the wrong number".
+ *
+ * Only the literal's own characters change, so comments, formatting and import
+ * order survive by construction; nothing is reprinted.
+ */
+export async function applyEdits(options) {
+    const { ctx, entryFile, exportName, frame, edits, expect } = options;
+    const rejected = [];
+    const splices = [];
+    for (const edit of edits) {
+        const resolution = resolveFramePath(ctx, entryFile, exportName, edit.path);
+        if (!resolution.editable) {
+            rejected.push({
+                path: edit.path,
+                reason: resolution.reason,
+                detail: resolution.detail,
+                ...(resolution.source ? { source: resolution.source } : {}),
+            });
+            continue;
+        }
+        // The gate. `getAtPath` reads the value the frame really loaded with; if
+        // the literal we found does not denote it, we found the wrong literal.
+        const current = getAtPath(frame, edit.path);
+        if (!literalDenotes(resolution.text, current)) {
+            rejected.push({
+                path: edit.path,
+                reason: "value-mismatch",
+                detail: `${formatPath(edit.path)} is ${JSON.stringify(current)} in the loaded frame, but ` +
+                    `the literal found at ${resolution.location.file}:${String(resolution.location.line)} is ` +
+                    `${resolution.text}. Refusing to edit a value the studio cannot account for.`,
+                source: resolution.location,
+            });
+            continue;
+        }
+        splices.push({
+            file: resolution.file,
+            start: resolution.start,
+            end: resolution.end,
+            text: renderLiteral(edit.value, resolution.text),
+            applied: {
+                path: edit.path,
+                file: resolution.file,
+                from: resolution.text,
+                to: renderLiteral(edit.value, resolution.text),
+                sharedDefault: resolution.sharedDefault,
+            },
+        });
+    }
+    if (rejected.length > 0) {
+        return { ok: false, rejected };
+    }
+    // Group by file, then reject a batch whose ranges collide — two edits to one
+    // literal have no defined outcome, and silently picking one is worse.
+    const byFile = new Map();
+    for (const splice of splices) {
+        const key = normalizeFile(splice.file);
+        byFile.set(key, [...(byFile.get(key) ?? []), splice]);
+    }
+    for (const [file, group] of byFile) {
+        const sorted = [...group].sort((a, b) => a.start - b.start);
+        for (let i = 1; i < sorted.length; i++) {
+            const previous = sorted[i - 1];
+            const current = sorted[i];
+            if (previous && current && current.start < previous.end) {
+                rejected.push({
+                    path: current.applied.path,
+                    reason: "overlap",
+                    detail: `Two edits target overlapping text in ${file}.`,
+                });
+            }
+        }
+    }
+    if (rejected.length > 0) {
+        return { ok: false, rejected };
+    }
+    const written = new Map();
+    const pending = [];
+    for (const [file, group] of byFile) {
+        const text = ctx.index.text(file);
+        if (text === undefined) {
+            return {
+                ok: false,
+                rejected: [
+                    {
+                        path: group[0]?.applied.path ?? [],
+                        reason: "unreadable",
+                        detail: `Could not read ${file}.`,
+                    },
+                ],
+            };
+        }
+        const wanted = expect?.get(file);
+        if (wanted !== undefined && sha256(text) !== wanted) {
+            return {
+                ok: false,
+                rejected: [
+                    {
+                        path: group[0]?.applied.path ?? [],
+                        reason: "stale",
+                        detail: `${file} changed on disk since the studio last read it.`,
+                    },
+                ],
+            };
+        }
+        // Descending, so an earlier replacement never shifts a later offset.
+        let next = text;
+        for (const splice of [...group].sort((a, b) => b.start - a.start)) {
+            next = next.slice(0, splice.start) + splice.text + next.slice(splice.end);
+        }
+        pending.push({ file, text: next });
+        written.set(file, sha256(next));
+    }
+    for (const { file, text } of pending) {
+        await writeFileAtomic(file, text);
+        ctx.index.invalidate(file);
+    }
+    return {
+        ok: true,
+        applied: splices.map((splice) => splice.applied),
+        files: written,
+    };
+}

package/dist/cli/studio/edit/impact.d.ts

@@ -0,0 +1,53 @@
+import type { FramePath } from "../../../manifest/walk.js";
+import { type ResolveContext } from "./resolvePath.js";
+/** A box set the studio can address, as `session.ts` enumerates them. */
+export interface BoxSetRef {
+    readonly variant: string | null;
+    readonly layout: string;
+    readonly key: string;
+    readonly path: readonly string[];
+}
+/** One place a literal is read from, besides the one being edited. */
+export interface Impact {
+    readonly variant: string | null;
+    readonly layout: string;
+    readonly boxSet: string;
+    readonly path: FramePath;
+}
+export interface ImpactOptions {
+    readonly ctx: ResolveContext;
+    readonly entryFile: string;
+    readonly exportName: string;
+    /** Every `kind: "boxes"` slot in the frame. */
+    readonly boxSets: readonly BoxSetRef[];
+    /** The full logical path of the value being edited. */
+    readonly target: FramePath;
+}
+/**
+ * Every box set that reads the same literal as `target`.
+ *
+ * Frames share geometry heavily — `frame-borderless` spreads
+ * `borderlessNormalBoxes` into most of its layouts, and
+ * `withCollectorInfoDefaults` hands one `collectorInfo` to all ten box sets of
+ * every layout. Moving such a box moves it everywhere, so the studio has to be
+ * able to say so *before* it writes, rather than surprising the author after.
+ *
+ * Identity is the exact source range: two paths are the same value only when
+ * they resolve to the same characters in the same file.
+ *
+ * The scan is per-frame. A literal exported through `/extend` and read by a
+ * different frame package is not counted here; `resolveFramePath` reports that
+ * separately by way of the file it landed in.
+ */
+export declare function impactOf(options: ImpactOptions): Impact[];
+/**
+ * Memoises impact scans for one loaded revision of a frame.
+ *
+ * The scan resolves the same tail against every box set, which for a frame
+ * like `frame-borderless` is ~100 resolutions; the inspector asks for one per
+ * field. Parses are already cached by `sourceIndex`, so this only has to stop
+ * the walk itself from repeating.
+ */
+export declare function createImpactCache(): {
+    get: (revision: number, options: ImpactOptions) => Impact[];
+};

package/dist/cli/studio/edit/impact.js

@@ -0,0 +1,87 @@
+import { resolveFramePath } from "./resolvePath.js";
+/** Splits a leaf path into its box-set prefix and the tail inside that set. */
+function splitTarget(target, boxSets) {
+    for (const set of boxSets) {
+        if (target.length > set.path.length &&
+            set.path.every((segment, i) => target[i] === segment)) {
+            return { set, tail: target.slice(set.path.length) };
+        }
+    }
+    return undefined;
+}
+/**
+ * Every box set that reads the same literal as `target`.
+ *
+ * Frames share geometry heavily — `frame-borderless` spreads
+ * `borderlessNormalBoxes` into most of its layouts, and
+ * `withCollectorInfoDefaults` hands one `collectorInfo` to all ten box sets of
+ * every layout. Moving such a box moves it everywhere, so the studio has to be
+ * able to say so *before* it writes, rather than surprising the author after.
+ *
+ * Identity is the exact source range: two paths are the same value only when
+ * they resolve to the same characters in the same file.
+ *
+ * The scan is per-frame. A literal exported through `/extend` and read by a
+ * different frame package is not counted here; `resolveFramePath` reports that
+ * separately by way of the file it landed in.
+ */
+export function impactOf(options) {
+    const { ctx, entryFile, exportName, boxSets, target } = options;
+    const split = splitTarget(target, boxSets);
+    if (!split) {
+        return [];
+    }
+    const anchor = resolveFramePath(ctx, entryFile, exportName, target);
+    if (!anchor.editable) {
+        return [];
+    }
+    const shared = [];
+    for (const set of boxSets) {
+        const path = [...set.path, ...split.tail];
+        if (path.length === target.length &&
+            path.every((s, i) => s === target[i])) {
+            continue; // the value being edited
+        }
+        const resolution = resolveFramePath(ctx, entryFile, exportName, path);
+        if (resolution.editable &&
+            resolution.file === anchor.file &&
+            resolution.start === anchor.start &&
+            resolution.end === anchor.end) {
+            shared.push({
+                variant: set.variant,
+                layout: set.layout,
+                boxSet: set.key,
+                path,
+            });
+        }
+    }
+    return shared;
+}
+/**
+ * Memoises impact scans for one loaded revision of a frame.
+ *
+ * The scan resolves the same tail against every box set, which for a frame
+ * like `frame-borderless` is ~100 resolutions; the inspector asks for one per
+ * field. Parses are already cached by `sourceIndex`, so this only has to stop
+ * the walk itself from repeating.
+ */
+export function createImpactCache() {
+    let cachedRevision = -1;
+    let entries = new Map();
+    return {
+        get(revision, options) {
+            if (revision !== cachedRevision) {
+                cachedRevision = revision;
+                entries = new Map();
+            }
+            const key = options.target.join(".");
+            const hit = entries.get(key);
+            if (hit) {
+                return hit;
+            }
+            const computed = impactOf(options);
+            entries.set(key, computed);
+            return computed;
+        },
+    };
+}

package/dist/cli/studio/edit/resolveModule.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Absolute path a specifier resolves to from `importer`, or `undefined`.
+ *
+ * Relative specifiers are probed on disk; bare ones go through Node's own
+ * resolver, which honours `exports` maps and pnpm's workspace links. That
+ * matters because frame packages point their exports straight at TypeScript
+ * source (`"./extend": "./src/extend.ts"`), so `@cardanvil/frame-m15/extend`
+ * resolves to a file this can actually parse.
+ */
+export declare function resolveModuleFile(specifier: string, importer: string): string | undefined;

package/dist/cli/studio/edit/resolveModule.js

@@ -0,0 +1,55 @@
+import { statSync } from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { normalizeFile } from "./sourceIndex.js";
+/**
+ * Extensions tried for a relative import, in order.
+ *
+ * Frame packages import without extensions by convention (`./boxes`,
+ * `./base`), so a specifier names either a sibling module or a directory with
+ * a barrel. `.js` is mapped back to `.ts` for authors who write NodeNext-style
+ * specifiers.
+ */
+const CANDIDATES = [
+    (base) => `${base}.ts`,
+    (base) => `${base}.tsx`,
+    (base) => path.join(base, "index.ts"),
+    (base) => path.join(base, "index.tsx"),
+    (base) => base,
+];
+function firstExisting(base) {
+    for (const candidate of CANDIDATES) {
+        const file = candidate(base);
+        try {
+            if (statSync(file).isFile()) {
+                return normalizeFile(file);
+            }
+        }
+        catch {
+            /* not there; try the next candidate */
+        }
+    }
+    return undefined;
+}
+/**
+ * Absolute path a specifier resolves to from `importer`, or `undefined`.
+ *
+ * Relative specifiers are probed on disk; bare ones go through Node's own
+ * resolver, which honours `exports` maps and pnpm's workspace links. That
+ * matters because frame packages point their exports straight at TypeScript
+ * source (`"./extend": "./src/extend.ts"`), so `@cardanvil/frame-m15/extend`
+ * resolves to a file this can actually parse.
+ */
+export function resolveModuleFile(specifier, importer) {
+    if (specifier.startsWith(".")) {
+        const base = path.resolve(path.dirname(importer), specifier);
+        const stripped = base.replace(/\.js$/, "");
+        return firstExisting(base) ?? firstExisting(stripped);
+    }
+    try {
+        return normalizeFile(createRequire(importer).resolve(specifier));
+    }
+    catch {
+        return undefined;
+    }
+}