@intentius/chant 0.124.13 → 0.124.14

package/dist/discovery/entity-wire-codec.js

@@ -0,0 +1,391 @@
+/**
+ * chant #1045 (Phase 1) — the JSON wire format for a discovered, named,
+ * ref-resolved entity set. Split out of `./entity-wire.ts` in Phase 2 so this
+ * codec (`encodeEntitySet`/`decodeEntitySet`, no dependency on `discover()`
+ * or anything that pulls in the `typescript` compiler package) can be
+ * bundled ALONE into the sandboxed child's driver (`./sandbox/driver.ts`)
+ * without dragging in `discover()`'s whole fold/import graph — `entity-
+ * wire.ts` re-exports everything here unchanged, so nothing outside this
+ * pair of files needs to know about the split.
+ *
+ * `discover()` (./index.ts) produces a `Map<string, Declarable>` whose cross-
+ * entity references are live object identity: an `AttrRef.parent` is a
+ * `WeakRef<object>`, and a resource can embed ANOTHER resource directly as a
+ * prop value (e.g. `DependsOn: [otherResource]`) — the lexicon serializers
+ * detect this by looking the embedded object up (by identity) in a
+ * `Map<Declarable, string>` built from the very same entities map
+ * (`serializer-walker.ts`'s `resourceRef` dispatch; see also
+ * `resource-attributes.ts`'s `resolveDependsOn`). Neither a `WeakRef` nor bare
+ * object identity survives a process boundary.
+ *
+ * {@link encodeEntitySet} converts that live map into plain, JSON-safe data:
+ * every identity-based reference (an `AttrRef`, or a whole entity embedded by
+ * value) becomes a name-keyed marker instead. {@link decodeEntitySet} is the
+ * inverse — it rebuilds a live `Map<string, Declarable>` whose entities are
+ * BEHAVIORALLY indistinguishable from what `discover()` would have produced
+ * in-process: real `AttrRef` instances, not a duck-typed `{__attrRef}`
+ * envelope alone. `new AttrRef(...)` here is plain, direct construction from
+ * this module's own class — this codec runs inside the same module graph as
+ * every downstream reader (`intrinsic-interpolation.ts`'s
+ * `defaultInterpolationSerializer`, `discovery/graph.ts`'s
+ * `buildDependencyGraph`, `build.ts`'s `detectCrossLexiconRefs`/
+ * `computeStackGraph`, all converted to `isAttrRefLike` duck-typing by chant
+ * #1137 for the OTHER hazard, a separately-loaded lexicon copy) — so there is
+ * no dual-package boundary to duck-type across here, and building the real
+ * class is simply less code than hand-assembling a shape-alike stand-in with
+ * matching methods, and whole-entity embeds restored to the SAME object
+ * reference (not a structurally-equal clone), so `entityNames.get(decl)`
+ * keeps working by identity exactly as it does today.
+ *
+ * `serializer-walker.ts`'s `walkValue` needs NO changes for this: it already
+ * falls back to reading a plain `{__attrRef}` envelope (added for intrinsics
+ * whose own `toJSON()` embeds one). `decodeEntitySet` goes further and
+ * reconstructs the real class, both simpler here and a belt-and-suspenders
+ * match for any call site that still checks `instanceof AttrRef` directly.
+ *
+ * Naming happens exactly once, inside the boundary — `resolveAttrRefs`
+ * (./resolve.ts) runs as part of `discover()`, before `encodeEntitySet` is
+ * ever called (in-process), or inside the sandboxed child, over just the
+ * run-fallback subset (chant #1045 Phase 2, `./sandbox/run.ts`). This module
+ * does not re-derive names; it only carries already-resolved ones across.
+ *
+ * Scope (see the chant#1045 PR description for the full list): resource and
+ * property `Declarable`s, `StackOutput` (itself a marked `Declarable`), and
+ * `LexiconOutput` (not a `Declarable` — it is carried as its own wire form)
+ * all round-trip. A `ChildProjectInstance` (`nestedStack()`) does not — its
+ * `outputs` field is a lazy `Proxy`, not data — and {@link encodeEntitySet}
+ * throws rather than silently mis-encoding it. No corpus entry under
+ * `examples/` or any lexicon's `examples/` directory uses `nestedStack()`
+ * today.
+ */
+import { DECLARABLE_MARKER, isResourceDeclarable } from "../declarable.js";
+import { AttrRef } from "../attrref.js";
+import { INTRINSIC_MARKER } from "../intrinsic.js";
+import { isAttrRefLike } from "../utils.js";
+import { isLexiconOutput, LexiconOutput } from "../lexicon-output.js";
+import { isChildProject } from "../child-project.js";
+const CORE_FIELD_NAMES = new Set(["lexicon", "entityType", "kind", "props", "attributes"]);
+// ─────────────────────────────────────────────────────────────────────────
+// Encode: live entities map → JSON-safe wire data.
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * Read a `LexiconOutput`'s internal ref without re-deriving it — see the
+ * `_intrinsic`/`_sourceParent`/`_literalValue` fields in `../lexicon-output.ts`.
+ * When it was built from an `AttrRef`, `LexiconOutput` keeps only the parent
+ * `WeakRef` + attribute name (not the original `AttrRef` instance), so a
+ * fresh one is synthesized here — its logical name must be set explicitly
+ * (from `entityNames`, the same map every other reference in this module
+ * resolves names through) since it never went through `resolveAttrRefs`.
+ *
+ * chant #1121 — a literal-valued output (a real string/number/boolean the
+ * author's code already computed, not a reference) has neither a parent nor
+ * an intrinsic to hand back; its `_literalValue` round-trips as a plain wire
+ * primitive instead, and `LexiconOutput`'s own constructor reconstructs it
+ * identically on decode (see `decodeEntitySet` below).
+ */
+function lexiconOutputRef(output, entityNames) {
+    if (output._intrinsic)
+        return output._intrinsic;
+    if (output._literalValue !== null)
+        return output._literalValue;
+    const parent = output._sourceParent?.deref();
+    const parentName = parent ? entityNames.get(parent) : undefined;
+    if (!parent || output.sourceAttribute === null || !parentName) {
+        throw new Error(`encodeEntitySet: LexiconOutput "${output.outputName}" has neither a resolvable AttrRef parent nor an intrinsic`);
+    }
+    const ref = new AttrRef(parent, output.sourceAttribute);
+    ref._setLogicalName(parentName);
+    return ref;
+}
+/** Walk `root`'s OWN fields (not through `toJSON()`) collecting any `AttrRef`/tracked-entity reference found — see {@link WireValue}'s `__intrinsic.refs` doc. */
+function collectEmbeddedRefs(root, entityNames) {
+    const refs = [];
+    const seen = new Set();
+    function walk(value) {
+        if (value === null || value === undefined || typeof value !== "object")
+            return;
+        if (seen.has(value))
+            return;
+        seen.add(value);
+        if (isAttrRefLike(value)) {
+            const entity = value.getLogicalName();
+            if (entity)
+                refs.push({ __attrRef: { entity, attribute: value.attribute } });
+            return;
+        }
+        if ("entityType" in value) {
+            const name = entityNames.get(value);
+            if (name) {
+                refs.push({ __entityRef: { entity: name } });
+                return;
+            }
+        }
+        if (Array.isArray(value)) {
+            for (const item of value)
+                walk(item);
+            return;
+        }
+        for (const val of Object.values(value))
+            walk(val);
+    }
+    walk(root);
+    return refs;
+}
+/** Encode one value found in an entity's props/attributes/extra-field tree — mirrors `serializer-walker.ts`'s `walkValue` dispatch, targeting the wire format instead of a lexicon format. */
+function encodeValue(value, entityNames) {
+    if (value === null || value === undefined)
+        return null;
+    if (isAttrRefLike(value)) {
+        const entity = value.getLogicalName();
+        if (!entity) {
+            throw new Error(`encodeEntitySet: AttrRef for attribute "${value.attribute}" has no logical name — was resolveAttrRefs run before encoding?`);
+        }
+        return { __attrRef: { entity, attribute: value.attribute } };
+    }
+    if (typeof value === "object" && INTRINSIC_MARKER in value) {
+        const intrinsic = value;
+        const toJSONResult = typeof intrinsic.toJSON === "function" ? intrinsic.toJSON() : null;
+        const wire = {
+            value: encodeValue(toJSONResult, entityNames),
+            refs: collectEmbeddedRefs(value, entityNames),
+        };
+        if (typeof intrinsic.toYAML === "function") {
+            wire.yaml = encodeValue(intrinsic.toYAML(), entityNames);
+        }
+        return { __intrinsic: wire };
+    }
+    if (typeof value === "object" && "entityType" in value) {
+        const decl = value;
+        const name = entityNames.get(decl);
+        if (name) {
+            // A tracked, top-level entity referenced by identity (e.g. `DependsOn:
+            // [otherResource]`).
+            return { __entityRef: { entity: name } };
+        }
+        // Untracked — either genuinely property-kind (never independently named
+        // to begin with), or a resource-kind Declarable embedded as a bare
+        // nested VALUE that never became its own top-level entity (e.g. Helm's
+        // `Helm::Test`/`Helm::Hook` wrap a `new Pod({...})` as their `resource`
+        // field, and a Helm chart's own k8s resources — `new Container(...)`,
+        // `new PersistentVolumeClaim(...)` inside a `StatefulSet`'s props — are
+        // likewise embedded values, never independent entities). Neither case
+        // has (or can have) a resolvable logical name: no lexicon serializer's
+        // generic dispatch (`serializer-walker.ts`'s `walkValue`) is what reads
+        // such a value in practice — every one that touches it reaches straight
+        // into its `.props` (see `Helm::Test`'s handling in
+        // `lexicons/helm/src/serializer.ts`, which extracts `resource.props`
+        // directly rather than walking `resource` as a Declarable reference).
+        // Inline exactly that, discarding the unresolvable (and, in every corpus
+        // entry today, unread) identity layer.
+        const props = isResourceDeclarable(decl) ? decl.props : undefined;
+        return { __property: { lexicon: decl.lexicon, entityType: decl.entityType, props: props !== undefined ? encodeValue(props, entityNames) : undefined } };
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => (item === undefined ? null : encodeValue(item, entityNames)));
+    }
+    if (typeof value === "object") {
+        const result = {};
+        for (const [key, val] of Object.entries(value)) {
+            if (val === undefined)
+                continue;
+            result[key] = encodeValue(val, entityNames);
+        }
+        return result;
+    }
+    return value;
+}
+function encodeDeclarable(entity, entityNames) {
+    const wire = { lexicon: entity.lexicon, entityType: entity.entityType, markers: [] };
+    if (entity.kind !== undefined)
+        wire.kind = entity.kind;
+    if (isResourceDeclarable(entity)) {
+        if (entity.props !== undefined) {
+            wire.props = encodeValue(entity.props, entityNames);
+        }
+        if (entity.attributes !== undefined) {
+            wire.attributes = encodeValue(entity.attributes, entityNames);
+        }
+    }
+    const markers = [];
+    for (const sym of Object.getOwnPropertySymbols(entity)) {
+        if (sym.description && entity[sym] === true) {
+            markers.push(sym.description);
+        }
+    }
+    wire.markers = markers;
+    const extra = {};
+    for (const key of Object.keys(entity)) {
+        if (CORE_FIELD_NAMES.has(key))
+            continue;
+        const val = entity[key];
+        if (val === undefined)
+            continue;
+        extra[key] = encodeValue(val, entityNames);
+    }
+    if (Object.keys(extra).length > 0)
+        wire.extra = extra;
+    return wire;
+}
+/**
+ * Encode a discovered, named, ref-resolved entities map into pure JSON.
+ *
+ * @throws if any entity is a `ChildProjectInstance` (`nestedStack()`) — its
+ *   `outputs` field is a lazy `Proxy`, not representable as data. No corpus
+ *   entry uses it today (chant#1045 Phase 1).
+ */
+export function encodeEntitySet(entities) {
+    const entityNames = new Map();
+    for (const [name, entity] of entities)
+        entityNames.set(entity, name);
+    const wireEntities = [];
+    for (const [name, entity] of entities) {
+        if (isChildProject(entity)) {
+            throw new Error(`encodeEntitySet: entity "${name}" is a child project (nestedStack()) — not yet supported by the JSON entity boundary (chant#1045 Phase 1)`);
+        }
+        if (isLexiconOutput(entity)) {
+            const ref = lexiconOutputRef(entity, entityNames);
+            wireEntities.push({ form: "lexiconOutput", name, outputName: entity.outputName, ref: encodeValue(ref, entityNames) });
+            continue;
+        }
+        wireEntities.push({ form: "declarable", name, ...encodeDeclarable(entity, entityNames) });
+    }
+    return { entities: wireEntities };
+}
+// ─────────────────────────────────────────────────────────────────────────
+// Decode: JSON-safe wire data → live entities map.
+// ─────────────────────────────────────────────────────────────────────────
+/**
+ * Decode one wire value, resolving `__attrRef`/`__entityRef`/`__property`/
+ * `__intrinsic` markers against `registry` (name → already-reconstructed live
+ * object).
+ *
+ * Reads via an explicit cast (`asRecord`) rather than relying on TS's `in`-
+ * narrowing across the {@link WireValue} union: the union's catch-all plain-
+ * object member (`{ [key: string]: WireValue }`) structurally overlaps every
+ * marker shape too (an index signature accepts any key), so narrowing alone
+ * can't tell TS which shape's fields are actually present at runtime.
+ */
+function decodeValue(wire, registry) {
+    if (wire === null || typeof wire !== "object")
+        return wire;
+    if (Array.isArray(wire)) {
+        return wire.map((item) => decodeValue(item, registry));
+    }
+    const asRecord = wire;
+    if ("__attrRef" in asRecord) {
+        const { entity, attribute } = asRecord.__attrRef;
+        const parent = registry.get(entity);
+        if (!parent)
+            throw new Error(`decodeEntitySet: __attrRef refers to unknown entity "${entity}"`);
+        const ref = new AttrRef(parent, attribute);
+        ref._setLogicalName(entity);
+        return ref;
+    }
+    if ("__entityRef" in asRecord) {
+        const { entity } = asRecord.__entityRef;
+        const target = registry.get(entity);
+        if (!target)
+            throw new Error(`decodeEntitySet: __entityRef refers to unknown entity "${entity}"`);
+        return target;
+    }
+    if ("__property" in asRecord) {
+        const { lexicon, entityType, props } = asRecord.__property;
+        const obj = {};
+        Object.defineProperty(obj, DECLARABLE_MARKER, { value: true, enumerable: false });
+        Object.defineProperty(obj, "lexicon", { value: lexicon, enumerable: false, configurable: true });
+        Object.defineProperty(obj, "entityType", { value: entityType, enumerable: false, configurable: true });
+        Object.defineProperty(obj, "kind", { value: "property", enumerable: false, configurable: true });
+        if (props !== undefined) {
+            Object.defineProperty(obj, "props", { value: decodeValue(props, registry), enumerable: false, configurable: true });
+        }
+        return obj;
+    }
+    if ("__intrinsic" in asRecord) {
+        const intrinsicWire = asRecord.__intrinsic;
+        const decodedValue = decodeValue(intrinsicWire.value, registry);
+        const decodedRefs = intrinsicWire.refs.map((ref) => decodeValue(ref, registry));
+        const wrapper = {
+            [INTRINSIC_MARKER]: true,
+            __chantWireRefs: decodedRefs,
+            toJSON() {
+                return decodedValue;
+            },
+        };
+        // Only present when the original intrinsic ALSO implemented `toYAML()`
+        // (see {@link WireValue}'s doc) — gitlab/github's serializers duck-type
+        // this method, so it must exist on the reconstructed wrapper only when
+        // it existed on the original, not unconditionally.
+        if ("yaml" in intrinsicWire) {
+            const decodedYaml = decodeValue(intrinsicWire.yaml, registry);
+            wrapper.toYAML = () => decodedYaml;
+        }
+        return wrapper;
+    }
+    const result = {};
+    for (const [key, val] of Object.entries(asRecord)) {
+        result[key] = decodeValue(val, registry);
+    }
+    return result;
+}
+function decodeDeclarableShell(wire) {
+    const obj = {};
+    for (const marker of wire.markers) {
+        Object.defineProperty(obj, Symbol.for(marker), { value: true, enumerable: false, configurable: true });
+    }
+    // DECLARABLE_MARKER is always one of `wire.markers` (every Declarable carries
+    // it), but define it defensively in case an entity somehow didn't round-trip
+    // it, so a decoded entity always satisfies `isDeclarable()`.
+    if (!(DECLARABLE_MARKER in obj)) {
+        Object.defineProperty(obj, DECLARABLE_MARKER, { value: true, enumerable: false });
+    }
+    Object.defineProperty(obj, "lexicon", { value: wire.lexicon, enumerable: false, configurable: true });
+    Object.defineProperty(obj, "entityType", { value: wire.entityType, enumerable: false, configurable: true });
+    if (wire.kind !== undefined) {
+        Object.defineProperty(obj, "kind", { value: wire.kind, enumerable: false, configurable: true });
+    }
+    return obj;
+}
+/**
+ * Decode a JSON entity set (see {@link encodeEntitySet}) back into a live
+ * `Map<string, Declarable>`, functionally indistinguishable from what
+ * `discover()` would have produced in-process.
+ */
+export function decodeEntitySet(wire) {
+    const registry = new Map();
+    // Pass 1: create every declarable's shell up front, so pass 2 can resolve a
+    // forward (or circular, e.g. mutual DependsOn) reference to any entity by
+    // name regardless of declaration order — exactly like the live WeakRef graph
+    // discover() produces tolerates today.
+    for (const entry of wire.entities) {
+        if (entry.form === "declarable") {
+            registry.set(entry.name, decodeDeclarableShell(entry));
+        }
+    }
+    const result = new Map();
+    for (const entry of wire.entities) {
+        if (entry.form === "declarable") {
+            const obj = registry.get(entry.name);
+            if (entry.props !== undefined) {
+                Object.defineProperty(obj, "props", { value: decodeValue(entry.props, registry), enumerable: false, configurable: true });
+            }
+            if (entry.attributes !== undefined) {
+                Object.defineProperty(obj, "attributes", { value: decodeValue(entry.attributes, registry), enumerable: false, configurable: true });
+            }
+            for (const [key, val] of Object.entries(entry.extra ?? {})) {
+                obj[key] = decodeValue(val, registry);
+            }
+            result.set(entry.name, obj);
+            continue;
+        }
+        // LexiconOutput — constructed via its real constructor from the decoded
+        // ref, so it derives sourceLexicon/_sourceParent/sourceAttribute/
+        // _literalValue exactly the way constructing it from a live
+        // AttrRef/Intrinsic/literal would (chant #1121 for the literal case: a
+        // plain wire primitive decodes back to itself, see `decodeValue` above).
+        const ref = decodeValue(entry.ref, registry);
+        const output = new LexiconOutput(ref, entry.outputName);
+        registry.set(entry.name, output);
+        result.set(entry.name, output);
+    }
+    return result;
+}

package/dist/discovery/entity-wire.js

@@ -0,0 +1,42 @@
+/**
+ * chant #1045 (Phase 1) — the JSON wire format for a discovered, named,
+ * ref-resolved entity set, plus (below) the standalone `discover()` +
+ * encode entry point.
+ *
+ * The codec itself — {@link WireValue}, {@link EntitySetWire},
+ * {@link encodeEntitySet}, {@link decodeEntitySet}, and friends — lives in
+ * `./entity-wire-codec.ts` (chant #1045 Phase 2 split this out) and is
+ * re-exported here unchanged. That file has NO dependency on `discover()` (or
+ * anything that pulls in the `typescript` compiler package), which matters
+ * because chant #1045 Phase 2's sandboxed child bundles JUST the codec —
+ * bundling this file, `discoverEntitySetJson` and all, would drag `discover`
+ * → `fold-import` → `typescript` (a multi-megabyte CJS package that doesn't
+ * survive ESM bundling on its own) into a driver that only ever needs to
+ * encode, never to discover. See `./sandbox/driver.ts`.
+ */
+export { encodeEntitySet, decodeEntitySet } from "./entity-wire-codec.js";
+import { discover } from "./index.js";
+import { encodeEntitySet } from "./entity-wire-codec.js";
+/**
+ * Run discovery over `path` — scanning files, importing/folding modules,
+ * naming entities, and resolving `AttrRef`s (all unchanged, reusing
+ * `discover()` as-is) — and return the result as pure JSON via
+ * {@link encodeEntitySet}. This is the boundary chant#1045 Phase 2 moved into
+ * a sandboxed child process for the run-fallback subset — see
+ * `./sandbox/run.ts` — Phase 1 only proved the data can cross it losslessly
+ * (see the fold-vs-JSON differential in `examples/`).
+ *
+ * Reuses `discover()` unchanged, so the fold/run-fallback split and the
+ * `planFoldTaint` identity-taint invariant (`./fold-import.ts`) are exactly
+ * what they are today — this function only serializes whatever `discover()`
+ * already decided to produce.
+ */
+export async function discoverEntitySetJson(path, options) {
+    const result = await discover(path, options);
+    return {
+        entitySet: encodeEntitySet(result.entities),
+        sourceFiles: result.sourceFiles,
+        errors: result.errors.map((e) => e.toJSON()),
+        foldDecisions: result.foldDecisions,
+    };
+}

package/dist/discovery/files.js

@@ -0,0 +1,121 @@
+import { open } from "node:fs/promises";
+import { relative, sep, isAbsolute } from "node:path";
+// @ts-ignore — picomatch has no types declaration
+import picomatch from "picomatch";
+import { resolveDiscoveryGlobs } from "../config.js";
+import { readHead, walkDiscovery, workspaceMemberDirs } from "./walk.js";
+/**
+ * Marker chant writes at the top of files it generates (a hosting lexicon's
+ * worker/bootstrap output, and the like). Discovery must not treat these as
+ * authored infra source: they hold no Declarables, they self-execute on import,
+ * and they use runtime patterns the authored-source lint
+ * rules forbid (dynamic `process.env[...]` access, spreads). Skipping them keeps
+ * `chant lint`/`build` from importing or linting the tool's own output.
+ */
+export const GENERATED_MARKER = "Generated by chant — do not edit directly";
+/**
+ * Comment a hand-written file carries to keep discovery out of it (#2519): a
+ * runnable script with top-level side effects, say, that lives next to the
+ * project's declarations. It must be a comment of its own (`// chant-discovery-skip`
+ * or inside a block comment) within the first {@link SKIP_MARKER_HEAD_BYTES}
+ * bytes of the file. See {@link hasSkipMarker}.
+ */
+export const SKIP_MARKER = "chant-discovery-skip";
+/** How much of a file's head {@link hasSkipMarker} reads: room for a shebang and a license header. */
+const SKIP_MARKER_HEAD_BYTES = 1024;
+/** {@link SKIP_MARKER} opening a `//`, `/*` or ` * ` comment line, as a whole word. */
+const SKIP_MARKER_PATTERN = /^[ \t]*(?:\/\/|\/\*+|\*)[ \t]*chant-discovery-skip(?![\w-])/m;
+/** True when `head`, the start of a file, carries the {@link SKIP_MARKER} comment. */
+export function hasSkipMarker(head) {
+    return SKIP_MARKER_PATTERN.test(head.slice(0, SKIP_MARKER_HEAD_BYTES));
+}
+/**
+ * Whether a file's head carries the {@link GENERATED_MARKER} or the
+ * {@link SKIP_MARKER}. Reads only the head. The generated marker is looked for
+ * in the first 256 bytes, as it always was.
+ */
+export async function hasDiscoveryMarker(file) {
+    let fh;
+    try {
+        fh = await open(file, "r");
+        const { buffer, bytesRead } = await fh.read({ buffer: Buffer.alloc(SKIP_MARKER_HEAD_BYTES), position: 0 });
+        if (buffer.toString("utf8", 0, Math.min(bytesRead, 256)).includes(GENERATED_MARKER))
+            return true;
+        return hasSkipMarker(buffer.toString("utf8", 0, bytesRead));
+    }
+    catch {
+        return false;
+    }
+    finally {
+        await fh?.close();
+    }
+}
+/** Whether a file's head carries the {@link GENERATED_MARKER} or the {@link SKIP_MARKER}. The synchronous form of {@link hasDiscoveryMarker}. */
+export function hasDiscoveryMarkerSync(file) {
+    const head = readHead(file, SKIP_MARKER_HEAD_BYTES);
+    return head.slice(0, 256).includes(GENERATED_MARKER) || hasSkipMarker(head);
+}
+/**
+ * Compile a project's `exclude`/`include` globs (#2519) into a predicate that
+ * is true for a file discovery must skip, or `undefined` when there is nothing
+ * to skip.
+ *
+ * Each pattern is matched, with picomatch and dot files included, against the
+ * file's path relative to `globs.root` (forward slashes) and against the path
+ * of every directory above it, so a pattern naming a directory covers
+ * everything under it. A file is skipped when some `exclude` pattern matches
+ * and no `include` pattern does: `include` always wins. Files outside
+ * `globs.root` are never skipped. The discovery walk (`./walk.ts`) applies the
+ * same rule, and also lets `include` re-admit what its default rules skip.
+ */
+export function compileDiscoveryFilter(globs) {
+    if (!globs || globs.exclude.length === 0)
+        return undefined;
+    const excluded = picomatch(globs.exclude, { dot: true });
+    const included = globs.include.length > 0 ? picomatch(globs.include, { dot: true }) : () => false;
+    return (file) => {
+        const rel = relative(globs.root, file);
+        if (rel === "" || rel === ".." || rel.startsWith(`..${sep}`) || isAbsolute(rel))
+            return false;
+        const parts = rel.split(sep);
+        const candidates = parts.map((_, i) => parts.slice(0, i + 1).join("/"));
+        return candidates.some((c) => excluded(c)) && !candidates.some((c) => included(c));
+    };
+}
+/** A TypeScript source file by name: `.ts`, not a test or spec. */
+export function isSourceFileName(name) {
+    return name.endsWith(".ts") && !name.endsWith(".test.ts") && !name.endsWith(".spec.ts");
+}
+/**
+ * Find every TypeScript infrastructure file under `path`, through the one
+ * discovery walk (`./walk.ts`, #2527): test and spec files, chant-generated
+ * files, skip-marked files and whatever the walk's rules and the project's
+ * globs skip are left out.
+ */
+export async function findInfraFiles(path, options) {
+    const globs = options?.globs === null ? undefined : (options?.globs ?? (await resolveDiscoveryGlobs(path)));
+    return walkDiscovery({
+        walker: "source",
+        root: path,
+        globs,
+        excludeDirs: await workspaceMemberDirs(path),
+        accept: (name, full) => isSourceFileName(name) && !hasDiscoveryMarkerSync(full),
+    });
+}
+/**
+ * Find the files under `path` that `accept` wants, through the same walk and
+ * the same project globs as {@link findInfraFiles}: a lexicon that reads
+ * source of its own beside the TypeScript (the sql lexicon's `.sql` files)
+ * sees exactly the tree source discovery sees, so `dist`, git-ignored paths,
+ * child projects and the project's `exclude` globs are left out for it too.
+ */
+export async function findSourceFiles(path, accept, options) {
+    const globs = options?.globs === null ? undefined : (options?.globs ?? (await resolveDiscoveryGlobs(path)));
+    return walkDiscovery({
+        walker: "source",
+        root: path,
+        globs,
+        excludeDirs: await workspaceMemberDirs(path),
+        accept,
+    });
+}

package/dist/discovery/fold-import.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fold-import.d.ts","sourceRoot":"","sources":["../../src/discovery/fold-import.ts"],"names":[],"mappings":"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"}