@clossys/writer 0.3.2

package/dist/passage.js

@@ -0,0 +1,463 @@
+/**
+ * The PASSAGE LAYER — issue #373. `@example/copy` (now `writer`,
+ * per issue #373's own retargeting comment) has terms (a glossary) and
+ * entries (single addressable strings) and nothing between them.
+ * `@clossys/designer` has tokens, atoms, AND BLOCKS. This file is the
+ * missing middle: a `Passage` composes `CopyEntry`/glossary-term
+ * REFERENCES the way a block composes atoms — never a raw sentence of its
+ * own. Terms ≈ tokens, entries ≈ atoms, passages ≈ blocks, documents (a
+ * later, composition-layer concern, out of scope here — see the issue)
+ * ≈ views.
+ *
+ * WHERE THE MIRROR STOPS. This file deliberately does NOT port
+ * `@clossys/designer/tokens`' `brandable` boolean onto a `Passage`
+ * field. In tokens, `brandable` marks a subset WITHIN one namespace (154
+ * ship, 42 are brandable). The voice record's own consumer/machinery
+ * split runs between FILES instead (a consumer's own `VoiceRecord` vs.
+ * this package's shipped machinery) — forcing a boolean into a field here
+ * would be false symmetry with a split that does not exist at this
+ * layer. This file mirrors the LADDER (structure: terms/entries/passages/
+ * documents), not the binding mechanism.
+ *
+ * ============================================================================
+ * WHAT A `Passage` IS
+ * ============================================================================
+ *
+ * One reusable, addressable unit of composed language — an empty-state
+ * (title + body + action), an FAQ item (question + answer), an error
+ * (message + recovery) — never a single string, and never real prose of
+ * its own. `fields` is a plain `Record<string, unknown>` AT THE TYPE
+ * LEVEL, deliberately: a field's value is exactly what
+ * `classifyPassageField`/`checkPassageComposition` below classify at
+ * RUNTIME, not what a compile-time type could statically forbid a
+ * malformed registry file (real JSON on disk, not TypeScript-checked
+ * code) from containing. See "THE TERNARY" below for why a field holding
+ * a raw literal string must reach the GATE as a real, reportable
+ * violation rather than being rejected upstream as a schema error.
+ *
+ * This file ships no example content of anyone's real copy — the same
+ * "vocabulary layer, never a source of real words" constraint `types.ts`
+ * documents for `CopyEntry`/`CopyRecord`. Every fixture in this package's
+ * own tests is structural placeholder text, never something a product
+ * would actually show a user.
+ *
+ * ============================================================================
+ * THE GATE, WITH THE TERNARY (issue #373)
+ * ============================================================================
+ *
+ *   0 — SATISFIED: every passage references only entries and terms, and
+ *       at least one passage was evaluated.
+ *   1 — VIOLATED: a passage inlines a literal string instead of
+ *       referencing an entry (the verbal equivalent of a hardcoded color
+ *       instead of a token), OR a passage references another passage's
+ *       OWN INTERNALS (`{ ref: "passage", id, field }`) rather than
+ *       composing entries/terms the way a block composes atoms, never
+ *       reaching directly into a sibling block's own implementation.
+ *   2 — INDETERMINATE: the registry could not be read/parsed/validated,
+ *       zero passages were evaluated (an empty `passages: []`), or a
+ *       field's value could not be confidently classified as any of the
+ *       above (not a string, not a recognized `{ ref: ... }` shape).
+ *
+ * PRECEDENCE — a real violation outranks an incomplete picture. This
+ * package already settled this exact question for a different gate
+ * (`addressability.ts`, issue #407/#433): letting "at least one
+ * unclassifiable field" outrank a confirmed violation would make the
+ * `"violated"` branch practically unreachable the moment a registry ever
+ * mixes a genuinely new/unknown field shape in with a real inlined
+ * literal — the identical collapse #407 fixed for addressability is fixed
+ * here from the start, not discovered later. `checkPassageComposition`
+ * applies the same "violated wins" ordering `checkAddressability` does.
+ *
+ * ============================================================================
+ * THE ADVERSARIAL SEPARATION (the weaker tool this gate must beat)
+ * ============================================================================
+ *
+ * A weaker tool that only checks "every referenced entry id exists"
+ * passes a passage built ENTIRELY from inline literals, because such a
+ * passage has ZERO references for that tool to check — nothing to
+ * validate is indistinguishable, to that tool, from everything being
+ * valid. The separating fixture: a passage with zero references and real
+ * prose sitting directly in its fields. The reference-checker reports
+ * clean (0 references, 0 problems). This gate must exit 1 — see
+ * `passage.adversarial.test.ts`, which runs both tools against the
+ * identical fixture in the same test, plus the sanity check that the weak
+ * tool is not simply broken (it correctly reports 0 when references truly
+ * do all exist).
+ *
+ * ============================================================================
+ * WHAT THIS GATE DELIBERATELY DOES NOT DO
+ * ============================================================================
+ *
+ *   - It does not verify a referenced entry id or term actually EXISTS in
+ *     a real `CopyRecord`/glossary. That is a DIFFERENT, weaker question
+ *     ("does this id resolve") than the one this gate answers ("is this
+ *     field a reference at all, or a smuggled-in literal") — the same
+ *     split `addressability.ts` draws from `copy-gate.ts`'s traceability
+ *     check (see that file's own top doc comment: "this gate has no
+ *     `CopyRecord` input at all"). A gate with visibility into both a
+ *     `PassageRecord` and a real `CopyRecord`/glossary to check
+ *     referential integrity is a different, later gate — precisely the
+ *     "weaker tool" this file's own adversarial proof names and beats on
+ *     the property that actually matters here: composition purity.
+ *   - It does not resolve/render a passage into text. Rendering a
+ *     `Passage` against a real `CopyRecord`/`VoiceRecord` glossary is a
+ *     consumer-owned, later concern — this file only ever validates
+ *     SHAPE and COMPOSITION PURITY.
+ */
+import { readFileSync } from "node:fs";
+// ---------------------------------------------------------------------------
+// Shape validation
+// ---------------------------------------------------------------------------
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+/** Same shape `COPY_ENTRY_ID_RE` (`schema.ts`) checks a `CopyEntryId` against — see `PassageId`'s own doc comment for why this is redefined locally rather than imported. */
+const PASSAGE_ID_RE = /^[a-z0-9]+(-[a-z0-9]+)*(\.[a-z0-9]+(-[a-z0-9]+)*)+$/;
+/**
+ * Validates one `Passage`'s SHAPE only: `id` present/well-formed,
+ * `context` present, `fields` a non-empty object. Deliberately does NOT
+ * validate each field VALUE's shape — see this file's top doc comment,
+ * "THE GATE": rejecting a field that holds a raw literal string here, as
+ * a schema error, would turn every real violation `checkPassageComposition`
+ * exists to catch into an "indeterminate" (invalid-schema) read instead
+ * of a "violated" one, the exact collapse #407/#433 already fixed for a
+ * different gate in this same package.
+ */
+function validatePassageShape(value, path) {
+    if (!isPlainObject(value)) {
+        return [{ rule: "passage-shape", severity: "error", message: `${path} must be an object.`, path }];
+    }
+    // Snapshot every field this function reads, exactly once, before any
+    // check runs — the same defensive discipline `schema.ts`'s
+    // `validateCopyEntryShape` documents (a hostile/badly-behaved `value`
+    // could otherwise return a different result on each property read).
+    const id = value.id;
+    const context = value.context;
+    const fields = value.fields;
+    const findings = [];
+    if (!isNonEmptyString(id)) {
+        findings.push({
+            rule: "id-shape",
+            severity: "error",
+            message: `${path}.id must be a non-empty string, got ${JSON.stringify(id)}.`,
+            path: `${path}.id`,
+        });
+    }
+    else if (!PASSAGE_ID_RE.test(id)) {
+        findings.push({
+            rule: "id-well-formed",
+            severity: "error",
+            message: `${path}.id "${id}" must be dot-separated and lowercase, with at least one dot (e.g. "onboarding.empty-state"), got ${JSON.stringify(id)}.`,
+            path: `${path}.id`,
+        });
+    }
+    if (!isNonEmptyString(context)) {
+        findings.push({
+            rule: "context-shape",
+            severity: "error",
+            message: `${path}.context must be a non-empty string, got ${JSON.stringify(context)}. A passage with no stated location cannot be reviewed.`,
+            path: `${path}.context`,
+        });
+    }
+    if (!isPlainObject(fields)) {
+        findings.push({
+            rule: "fields-shape",
+            severity: "error",
+            message: `${path}.fields must be an object, got ${JSON.stringify(fields)}.`,
+            path: `${path}.fields`,
+        });
+    }
+    else if (Object.keys(fields).length === 0) {
+        findings.push({
+            rule: "fields-non-empty",
+            severity: "error",
+            message: `${path}.fields must have at least one field — a passage with zero fields composes nothing.`,
+            path: `${path}.fields`,
+        });
+    }
+    return findings;
+}
+/**
+ * Validates that `value` conforms to the `PassageRecord` shape. Returns a
+ * `PassageFinding[]`; empty means `value` is a well-formed `PassageRecord`.
+ * Never throws — mirrors `schema.ts`'s `validateCopyRecordShape` exactly:
+ * any input, including `null`/a string/a wildly malformed object,
+ * produces findings rather than an exception.
+ */
+export function validatePassageRecordShape(value) {
+    if (!isPlainObject(value)) {
+        return [{ rule: "record-present", severity: "error", message: "A passage record must be an object.", path: "$" }];
+    }
+    const id = value.id;
+    const passages = value.passages;
+    const findings = [];
+    if (!isNonEmptyString(id)) {
+        findings.push({
+            rule: "id-shape",
+            severity: "error",
+            message: `id must be a non-empty string, got ${JSON.stringify(id)}.`,
+            path: "id",
+        });
+    }
+    if (!Array.isArray(passages)) {
+        findings.push({
+            rule: "passages-shape",
+            severity: "error",
+            message: `passages must be an array, got ${JSON.stringify(passages)}.`,
+            path: "passages",
+        });
+    }
+    else {
+        passages.forEach((passage, i) => findings.push(...validatePassageShape(passage, `passages.${i}`)));
+        // Uniqueness is a whole-record property, checked here rather than
+        // inside validatePassageShape — mirrors validateCopyRecordShape's own
+        // id-unique pass exactly, including only comparing passages whose own
+        // id already passed shape validation.
+        const seen = new Map();
+        passages.forEach((passage, i) => {
+            if (!isPlainObject(passage))
+                return;
+            const passageId = passage.id;
+            if (typeof passageId !== "string" || passageId.length === 0)
+                return;
+            const firstIndex = seen.get(passageId);
+            if (firstIndex === undefined) {
+                seen.set(passageId, i);
+            }
+            else {
+                findings.push({
+                    rule: "id-unique",
+                    severity: "error",
+                    message: `passages.${i}.id "${passageId}" duplicates passages.${firstIndex}.id — every passage's id must be unique within a PassageRecord.`,
+                    path: `passages.${i}.id`,
+                });
+            }
+        });
+    }
+    return findings;
+}
+function buildPassageRecord(value) {
+    const passagesRaw = value.passages;
+    const built = passagesRaw.map((raw) => {
+        const passage = raw;
+        return {
+            id: passage.id,
+            context: passage.context,
+            fields: { ...passage.fields },
+        };
+    });
+    return {
+        id: value.id,
+        passages: built,
+    };
+}
+/**
+ * Parses `value` as a `PassageRecord`, throwing a plain `Error` (never a
+ * `PassageFinding[]`) if it does not conform — mirrors `schema.ts`'s
+ * `parseCopyRecord` exactly, including the two-pass validate-then-build
+ * shape and why (see that function's own doc comment for the fuller
+ * argument).
+ */
+export function parsePassageRecord(value) {
+    const findings = validatePassageRecordShape(value);
+    if (findings.length > 0) {
+        const detail = findings.map((f) => `  - ${f.path ?? "(root)"}: ${f.message}`).join("\n");
+        throw new Error(`parsePassageRecord: value is not a valid PassageRecord:\n${detail}`);
+    }
+    // Safe: validatePassageRecordShape returning no findings means every
+    // field buildPassageRecord reads below is present and correctly typed.
+    return buildPassageRecord(value);
+}
+/**
+ * Reads and validates the `PassageRecord` at `path`. Never throws: every
+ * failure — an unreadable file, invalid JSON, or a schema violation — is
+ * recorded into `issues` and reflected in `.complete`. Mirrors
+ * `registry.ts`'s `readCopyRecord` exactly, including the discipline it
+ * documents: an unreadable/invalid registry is "could not run" (fed into
+ * exit `2` by the CLI), never a clean pass produced from a record this
+ * function could not actually trust.
+ */
+export function readPassageRecord(path) {
+    let raw;
+    try {
+        raw = readFileSync(path, "utf8");
+    }
+    catch (error) {
+        return {
+            path,
+            issues: [{ reason: "unreadable", detail: error instanceof Error ? error.message : String(error) }],
+            complete: false,
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        return {
+            path,
+            issues: [{ reason: "unparseable", detail: error instanceof Error ? error.message : String(error) }],
+            complete: false,
+        };
+    }
+    try {
+        const record = parsePassageRecord(parsed);
+        return { path, record, issues: [], complete: true };
+    }
+    catch (error) {
+        return {
+            path,
+            issues: [{ reason: "invalid-schema", detail: error instanceof Error ? error.message : String(error) }],
+            complete: false,
+        };
+    }
+}
+/** A short, length-capped JSON preview of an arbitrary field value, for a finding's own message — never large enough to make a report unreadable. */
+function safePreview(value) {
+    let text;
+    try {
+        text = JSON.stringify(value) ?? String(value);
+    }
+    catch {
+        text = String(value);
+    }
+    return text.length > 120 ? `${text.slice(0, 120)}…` : text;
+}
+/**
+ * Classifies one `Passage` field's raw value into exactly one of the five
+ * `PassageFieldClassification` outcomes. Pure — no I/O, never throws on
+ * any input shape.
+ *
+ *   - A plain string is ALWAYS `"inline-literal"` — real prose (or
+ *     anything else) sitting directly in the field instead of a
+ *     reference. This is the shape the adversarial proof's separating
+ *     fixture is built from — see this file's top doc comment.
+ *   - `{ ref: "entry", id: <non-empty string> }` is `"entry-reference"`.
+ *   - `{ ref: "term", term: <non-empty string> }` is `"term-reference"`.
+ *   - `{ ref: "passage", ... }` — REGARDLESS of what else it carries — is
+ *     always `"passage-internals-reference"`: a passage may compose
+ *     entries and terms, never reach directly into another passage's own
+ *     fields. This is a VIOLATION, not something this function treats as
+ *     merely unclassifiable, because the shape is unambiguous the moment
+ *     `ref === "passage"` is seen.
+ *   - `{ ref: "entry" | "term", ... }` with a missing/malformed
+ *     `id`/`term` is `"unclassifiable"` — the AUTHOR'S intent (compose an
+ *     entry or a term) is legible, but the reference itself is broken, so
+ *     this function refuses to guess which finding shape to promote it
+ *     to rather than silently treating a broken reference as either
+ *     "fine" or "definitely a literal."
+ *   - Anything else (a number, boolean, null, array, or an object with no
+ *     recognized `ref`) is `"unclassifiable"`.
+ */
+export function classifyPassageField(value) {
+    if (typeof value === "string") {
+        return {
+            classification: "inline-literal",
+            detail: `field holds a literal string ${JSON.stringify(safePreview(value))} instead of a reference to a registered entry — the verbal equivalent of inlining a raw value instead of a token`,
+        };
+    }
+    if (isPlainObject(value)) {
+        const ref = value.ref;
+        if (ref === "entry") {
+            const id = value.id;
+            if (isNonEmptyString(id)) {
+                return { classification: "entry-reference", detail: `references entry "${id}"` };
+            }
+            return {
+                classification: "unclassifiable",
+                detail: `{ ref: "entry" } is missing a valid non-empty "id" (got ${safePreview(id)})`,
+            };
+        }
+        if (ref === "term") {
+            const term = value.term;
+            if (isNonEmptyString(term)) {
+                return { classification: "term-reference", detail: `references term "${term}"` };
+            }
+            return {
+                classification: "unclassifiable",
+                detail: `{ ref: "term" } is missing a valid non-empty "term" (got ${safePreview(term)})`,
+            };
+        }
+        if (ref === "passage") {
+            const id = typeof value.id === "string" && value.id.length > 0 ? value.id : "?";
+            const field = typeof value.field === "string" && value.field.length > 0 ? value.field : "?";
+            return {
+                classification: "passage-internals-reference",
+                detail: `reaches directly into passage "${id}"'s own field "${field}" instead of referencing an entry or a term — a passage may compose entries and terms, never another passage's internals`,
+            };
+        }
+    }
+    return {
+        classification: "unclassifiable",
+        detail: `field value ${safePreview(value)} is neither a literal string, an { ref: "entry" }/{ ref: "term" } reference, nor an { ref: "passage" } internals reference — cannot be classified`,
+    };
+}
+/**
+ * Pure — takes an already-parsed `PassageRecord` (see `readPassageRecord`/
+ * `parsePassageRecord`), classifies every field of every passage, and
+ * decides the ternary verdict. Never throws, does no I/O.
+ *
+ * PRECEDENCE: a real violation wins over an incomplete picture — see this
+ * file's top doc comment, "THE TERNARY", for why this mirrors
+ * `checkAddressability`'s own post-#407 ordering rather than the older
+ * "indeterminate wins" precedence `checkCopyTraceability`/`scan.ts` still
+ * use for a different reason (see `checkAddressability`'s own doc comment
+ * for the fuller argument against letting a permanent-in-practice
+ * coverage gap make a real violation unreachable).
+ */
+export function checkPassageComposition(record) {
+    const violations = [];
+    const unclassified = [];
+    let passagesEvaluated = 0;
+    for (const passage of record.passages) {
+        const fieldNames = Object.keys(passage.fields);
+        if (fieldNames.length === 0)
+            continue; // defensive only — validatePassageRecordShape already requires >= 1 field
+        passagesEvaluated++;
+        for (const field of fieldNames) {
+            const value = passage.fields[field];
+            const { classification, detail } = classifyPassageField(value);
+            if (classification === "inline-literal") {
+                violations.push({
+                    passageId: passage.id,
+                    field,
+                    rule: "field-inlines-literal",
+                    message: `${passage.id}.${field}: ${detail}`,
+                });
+            }
+            else if (classification === "passage-internals-reference") {
+                violations.push({
+                    passageId: passage.id,
+                    field,
+                    rule: "field-references-passage-internals",
+                    message: `${passage.id}.${field}: ${detail}`,
+                });
+            }
+            else if (classification === "unclassifiable") {
+                unclassified.push({ passageId: passage.id, field, detail: `${passage.id}.${field}: ${detail}` });
+            }
+            // "entry-reference" / "term-reference": exactly the property this gate requires — no finding.
+        }
+    }
+    const reasons = [];
+    if (passagesEvaluated === 0) {
+        reasons.push(record.passages.length === 0 ? "no passages are registered" : "no passage had at least one field to evaluate");
+    }
+    if (unclassified.length > 0) {
+        reasons.push(`${unclassified.length} field(s) could not be confidently classified`);
+    }
+    const base = { violations, unclassified, passagesEvaluated };
+    // A real violation wins over an incomplete picture — see this file's
+    // top doc comment, "THE TERNARY". The coverage gap is not hidden:
+    // `reasons`/`unclassified` are still populated and still printed by
+    // `cli.ts`'s `printPassagesReport` regardless of verdict.
+    if (violations.length > 0)
+        return { verdict: "violated", reasons, ...base };
+    if (reasons.length > 0)
+        return { verdict: "indeterminate", reasons, ...base };
+    return { verdict: "satisfied", reasons, ...base };
+}
+//# sourceMappingURL=passage.js.map

package/dist/passage.js.map

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

package/dist/path-exclusions.d.ts

@@ -0,0 +1,114 @@
+/**
+ * Path exclusions for `scan.ts`'s SCANNING SURFACE — `scanCopySourceTree`'s
+ * directory walk — never to be confused with `scan.ts`'s existing
+ * `ExclusionReason`/`ExcludedLiteral`, a DIFFERENT feature this file does
+ * not touch. Read `scan.ts`'s own top doc comment ("THE BOUNDARY") before
+ * this one: that mechanism decides, for a LITERAL already found inside a
+ * file that IS being scanned, whether that one literal is real copy or
+ * something structural (an import specifier, a CSS class, an aria label,
+ * ...) — a per-LITERAL classification made from the few dozen characters of
+ * context immediately around it. This file answers a completely different
+ * question, at a completely different granularity: should this FILE be
+ * looked at for copy candidates AT ALL, before a single character of it is
+ * ever tokenized? That is a per-FILE scope decision, made once, from the
+ * file's own path alone — extending `ExclusionReason` to cover it would be
+ * a coincidence of both being named "exclusion", not a shared mechanism;
+ * this is why it is a new, separate type (`PathExclusion`) and a new,
+ * separate `ScanResult` field (`excludedFiles`), not a tenth
+ * `ExclusionReason`.
+ *
+ * THE MOTIVATING CASE ("mention vs. use"): a style guide or README that
+ * documents this voice's own banned terms — "never say X, say Y instead" —
+ * necessarily CONTAINS the literal banned text, as a MENTION, not a USE.
+ * Scanned like any other file, that mention looks identical to real,
+ * unregistered product copy to `checkCopyTraceability` (`copy-gate.ts`):
+ * the traceability gate has no notion of "this file's job is to talk about
+ * copy, not ship it". A `PathExclusion` on that one file's path is the fix
+ * — the file is never tokenized at all, so it can never produce a
+ * candidate, `unregistered-copy` finding, or citation. See this file's
+ * README section, "Path exclusions vs. per-literal exclusions", for the
+ * fuller argument, including why this stays scoped to `scan.ts`'s existing
+ * scanning surface (copy TRACEABILITY) rather than inventing a new
+ * directory-scanning feature for VOICE/glossary rules, which this package
+ * does not otherwise have — a consumer building their own "walk a
+ * directory, then run each file's text through `checkCopy`" tool gets the
+ * identical mention-vs-use protection by reusing THIS mechanism (call
+ * `scanCopySourceTree` with `pathExclusions`, then feed its candidates'
+ * text through `checkCopy` themselves) rather than this package growing a
+ * second, redundant exclusion list.
+ *
+ * FAILS CLOSED, mirroring `checker.ts`'s `VoiceCheckWaiver` handling (the
+ * established precedent for "a caller-supplied list of exceptions" in this
+ * package's ecosystem) almost exactly:
+ *
+ *   - A MALFORMED entry (not an object, `path`/`reason` missing or not a
+ *     non-empty string, or a `path` this file's own small pattern language
+ *     cannot parse — see `classifyPathExclusionPattern`) is never applied:
+ *     it exempts NOTHING, and is reported as its own `"error"`-severity
+ *     `PathExclusionFinding` — the exact "a malformed exclusion entry is a
+ *     finding, never a silent exemption" requirement. This mirrors
+ *     `"waiver:invalid"`.
+ *   - An exclusion that never matched a single scanned file is dead
+ *     configuration — reported as its own `"warning"`-severity
+ *     `PathExclusionFinding`, mirroring `"waiver:unused"`, so a stale
+ *     exclusion (the file it named was renamed or deleted) cannot silently
+ *     sit in a config forever looking like it is still doing something.
+ */
+export interface PathExclusion {
+    /**
+     * A repo-relative, `/`-joined path pattern — see
+     * `classifyPathExclusionPattern`'s doc comment for the exact, small,
+     * hand-rolled pattern language this supports (no glob library — this
+     * package's zero-runtime-dependency rule applies here too).
+     */
+    path: string;
+    /** Required — an exclusion with no stated reason is not auditable, the same discipline `GlossaryEntry.reason` and `VoiceCheckWaiver.reason` already hold every other exception in this package's ecosystem to. */
+    reason: string;
+}
+/** One file `scanCopySourceTree` skipped entirely because its path matched a `PathExclusion` — never tokenized, contributes zero candidates/excluded-literals/citations/unchecked-items. */
+export interface ExcludedPath {
+    file: string;
+    reason: string;
+    /** The `PathExclusion.path` pattern that matched, for audit. */
+    pattern: string;
+}
+export type PathExclusionFindingRule = "path-exclusion-invalid" | "path-exclusion-unused";
+/** One problem with the `pathExclusions` CONFIGURATION itself — never about a scanned file's content. See this file's top doc comment for the fail-closed contract both rules implement. */
+export interface PathExclusionFinding {
+    rule: PathExclusionFindingRule;
+    /** `"error"` for a malformed entry (never applied); `"warning"` for a well-formed entry that matched nothing this run (applied as designed, just possibly stale). */
+    severity: "error" | "warning";
+    message: string;
+    /** The exclusion's own `path` pattern, when there is one to point at (absent only for a top-level shape error, e.g. `pathExclusions` itself not being an array). */
+    path?: string;
+}
+/** One validated `PathExclusion`, tagged with which of this file's three supported pattern shapes it is — computed once by `validatePathExclusions` so `matchesPathExclusion` never has to re-derive it (and never has to re-validate what was already validated). */
+export interface ValidatedPathExclusion extends PathExclusion {
+    kind: "exact" | "subtree" | "segment-wildcard";
+}
+/**
+ * Matches `relPath` (already `/`-joined, repo-relative — the same shape
+ * `scanCopySourceTree` produces for every `CopyCandidate.file`) against one
+ * already-classified exclusion. Never called with a pattern that failed
+ * `classifyPathExclusionPattern` — `validatePathExclusions` filters those
+ * out before anything reaches here, so this function does not re-validate.
+ */
+export declare function matchesPathExclusion(relPath: string, exclusion: ValidatedPathExclusion): boolean;
+export interface PathExclusionValidation {
+    /** Every exclusion that passed shape+pattern validation — safe to match files against. */
+    valid: ValidatedPathExclusion[];
+    /** Malformed entries, as `"error"`-severity findings. Never includes `"path-exclusion-unused"` — that rule is only ever added later, once the walk has actually run; see `scanCopySourceTree`. */
+    findings: PathExclusionFinding[];
+}
+/**
+ * Validates `value` (`ScanOptions.pathExclusions`, or any raw candidate list
+ * — this is called on a TYPED `PathExclusion[]` from a TypeScript caller,
+ * but re-validates every field anyway, the same defense-in-depth this
+ * repository's other schema functions apply to already-typed input: see
+ * `@clossys/writer/voice`'s `schema.ts` header comment for why a
+ * plain-JS caller, or a value that merely satisfies the type at compile
+ * time without conforming at runtime, is exactly the case this guards
+ * against). Never throws.
+ */
+export declare function validatePathExclusions(value: unknown): PathExclusionValidation;
+//# sourceMappingURL=path-exclusions.d.ts.map

package/dist/path-exclusions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path-exclusions.d.ts","sourceRoot":"","sources":["../src/path-exclusions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AAEH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,IAAI,EAAE,MAAM,CAAC;IACb,kNAAkN;IAClN,MAAM,EAAE,MAAM,CAAC;CAChB;AAED,4LAA4L;AAC5L,MAAM,WAAW,YAAY;IAC3B,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,MAAM,CAAC;IACf,gEAAgE;IAChE,OAAO,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,MAAM,wBAAwB,GAAG,wBAAwB,GAAG,uBAAuB,CAAC;AAE1F,4LAA4L;AAC5L,MAAM,WAAW,oBAAoB;IACnC,IAAI,EAAE,wBAAwB,CAAC;IAC/B,qKAAqK;IACrK,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAC;IAC9B,OAAO,EAAE,MAAM,CAAC;IAChB,oKAAoK;IACpK,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED,sQAAsQ;AACtQ,MAAM,WAAW,sBAAuB,SAAQ,aAAa;IAC3D,IAAI,EAAE,OAAO,GAAG,SAAS,GAAG,kBAAkB,CAAC;CAChD;AA4DD;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,SAAS,EAAE,sBAAsB,GAAG,OAAO,CAuBhG;AAED,MAAM,WAAW,uBAAuB;IACtC,0FAA0F;IAC1F,KAAK,EAAE,sBAAsB,EAAE,CAAC;IAChC,kMAAkM;IAClM,QAAQ,EAAE,oBAAoB,EAAE,CAAC;CAClC;AAED;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CA+D9E"}