codictator 0.0.0 → 0.1.3

package/dist/kernel/redact.js

@@ -0,0 +1,206 @@
+// SPEC §4.7.1 detectors, implemented here in the kernel so engine, audit,
+// adapters and generator can redact without importing security (§3.3).
+// Every match is replaced by its first 4 characters plus its length;
+// env references, placeholders and fixture paths are left unchanged.
+const KNOWN_FORMATS = [
+    /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----[\s\S]*?-----END [A-Z0-9 ]*PRIVATE KEY-----/g,
+    /\bAKIA[0-9A-Z]{16}\b/g,
+    /\bghp_[A-Za-z0-9]{36,}\b/g,
+    /\bgho_[A-Za-z0-9]{36,}\b/g,
+    /\bghs_[A-Za-z0-9]{36,}\b/g,
+    /\bghu_[A-Za-z0-9]{36,}\b/g,
+    /\bghr_[A-Za-z0-9]{36,}\b/g,
+    /\bgithub_pat_[A-Za-z0-9_]{22,}\b/g,
+    /\bglpat-[A-Za-z0-9_-]{20,}/g,
+    /\bxox[abposr]-[A-Za-z0-9-]{8,}/g,
+    /\b[rs]k_live_[A-Za-z0-9]{16,}/g,
+    /\bAIza[A-Za-z0-9_-]{35}\b/g,
+    /\bnpm_[A-Za-z0-9]{36}\b/g,
+    /\bsk-(?:ant-|proj-)?[A-Za-z0-9_-]{20,}/g,
+    /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}/g,
+];
+// Keyword-first half of the assignment detector (SPEC §4.7.1): the same
+// keyword alternation the old `["']?([A-Za-z0-9_.$-]*...)` pattern used,
+// run alone so the engine can use a literal search instead of backtracking
+// the leading name-character run at every position.
+const KEYWORD_PATTERN = /secret|token|passw(?:or)?d|api[_-]?key|private[_-]?key|client[_-]?secret/gi;
+// Sticky tail of an assignment match, anchored at the end of the keyword:
+// the optional quote, separator and value run of the original pattern,
+// split so the value (group 2) stays available for the entropy check.
+const ASSIGNMENT_MID = /["']?\s*[:=]\s*["']?/y;
+const ASSIGNMENT_VALUE = /[^\s"'`;,]+/y;
+const ALLOW_PATTERNS = [
+    /process\.env\.[A-Za-z_][A-Za-z0-9_]*/g,
+    /\$\{[A-Za-z_][A-Za-z0-9_]*\}/g,
+    /\$[A-Za-z_][A-Za-z0-9_]*/g,
+    /os\.environ\s*\[[^\]\n]*\]/g,
+];
+const PLACEHOLDER_PATTERN = /^(?:x+|changeme|example|your[-_].*|<.*>)$/i;
+function allowSpans(text) {
+    const spans = [];
+    for (const pattern of ALLOW_PATTERNS) {
+        pattern.lastIndex = 0;
+        let match = pattern.exec(text);
+        while (match !== null) {
+            spans.push({
+                start: match.index,
+                end: match.index + match[0].length,
+                replacement: match[0],
+            });
+            match = pattern.exec(text);
+        }
+    }
+    return spans;
+}
+// The `[A-Za-z0-9_.$-]` name class of the assignment detector as char
+// codes, for the backward scan to the start of the name run.
+function isNameChar(code) {
+    return ((code >= 0x30 && code <= 0x39) ||
+        (code >= 0x41 && code <= 0x5a) ||
+        (code >= 0x61 && code <= 0x7a) ||
+        code === 0x24 ||
+        code === 0x2e ||
+        code === 0x2d ||
+        code === 0x5f);
+}
+function isQuote(value) {
+    return value === '"' || value === "'";
+}
+function redact(match) {
+    return `${match.slice(0, 4)}…(${match.length})`;
+}
+function shannonPerChar(value) {
+    const counts = new Map();
+    for (const char of value) {
+        counts.set(char, (counts.get(char) ?? 0) + 1);
+    }
+    let entropy = 0;
+    for (const count of counts.values()) {
+        const probability = count / value.length;
+        entropy -= probability * Math.log2(probability);
+    }
+    return entropy;
+}
+function isAllowedSecret(candidate) {
+    return PLACEHOLDER_PATTERN.test(candidate);
+}
+function assignmentSpans(text) {
+    const spans = [];
+    // Keyword-first scan: the original leading `[A-Za-z0-9_.$-]*` made the
+    // engine backtrack over every long run of name characters (quadratic on
+    // inputs like 65KB of `a`). Anchoring each attempt at a keyword keeps
+    // every scan over disjoint input. The original pattern also allowed
+    // trailing name characters after the keyword (`aws_secret_access_key`),
+    // so the separator check runs at the end of the name run; the floor
+    // advances past every examined run, keeping the scan linear.
+    KEYWORD_PATTERN.lastIndex = 0;
+    let keyword = KEYWORD_PATTERN.exec(text);
+    let floor = 0;
+    while (keyword !== null) {
+        const keywordStart = keyword.index;
+        const keywordEnd = keywordStart + keyword[0].length;
+        if (keywordStart >= floor) {
+            let nameEnd = keywordEnd;
+            while (nameEnd < text.length && isNameChar(text.charCodeAt(nameEnd))) {
+                nameEnd += 1;
+            }
+            floor = nameEnd;
+            ASSIGNMENT_MID.lastIndex = nameEnd;
+            const mid = ASSIGNMENT_MID.exec(text);
+            if (mid !== null) {
+                ASSIGNMENT_VALUE.lastIndex = ASSIGNMENT_MID.lastIndex;
+                const value = ASSIGNMENT_VALUE.exec(text);
+                if (value !== null) {
+                    let end = ASSIGNMENT_VALUE.lastIndex;
+                    if (isQuote(text[end])) {
+                        end += 1;
+                    }
+                    let start = keywordStart;
+                    while (start > 0 && isNameChar(text.charCodeAt(start - 1))) {
+                        start -= 1;
+                    }
+                    if (start > 0 && isQuote(text[start - 1])) {
+                        start -= 1;
+                    }
+                    const candidate = value[0];
+                    const full = text.slice(start, end);
+                    if (candidate.length >= 20 &&
+                        shannonPerChar(candidate) >= 4 &&
+                        !isAllowedSecret(candidate)) {
+                        spans.push({
+                            start,
+                            end,
+                            replacement: redact(full),
+                        });
+                    }
+                    floor = end;
+                }
+            }
+        }
+        keyword = KEYWORD_PATTERN.exec(text);
+    }
+    return spans;
+}
+function formatSpans(text) {
+    const spans = [];
+    for (const pattern of KNOWN_FORMATS) {
+        pattern.lastIndex = 0;
+        let match = pattern.exec(text);
+        while (match !== null) {
+            const found = match[0];
+            if (!isAllowedSecret(found)) {
+                spans.push({
+                    start: match.index,
+                    end: match.index + found.length,
+                    replacement: redact(found),
+                });
+            }
+            match = pattern.exec(text);
+        }
+    }
+    return spans;
+}
+function mergeSpans(spans) {
+    const sorted = [...spans].sort((a, b) => a.start - b.start || b.end - a.end);
+    const merged = [];
+    for (const span of sorted) {
+        const last = merged[merged.length - 1];
+        if (last === undefined || span.start >= last.end) {
+            merged.push(span);
+        }
+        else if (span.end > last.end) {
+            merged[merged.length - 1] = { ...last, end: span.end };
+        }
+    }
+    return merged;
+}
+export function redactSecrets(text) {
+    // Both lists are sorted and non-overlapping after merging, so one sweep
+    // each replaces the per-candidate overlap scans (SPEC §4.7.1: the sort
+    // keeps the widest of overlapping candidates first, so the survivor is
+    // unchanged).
+    const allowed = mergeSpans(allowSpans(text));
+    const candidates = [...formatSpans(text), ...assignmentSpans(text)];
+    candidates.sort((a, b) => a.start - b.start || b.end - a.end);
+    const parts = [];
+    let cursor = 0;
+    let allowedIndex = 0;
+    for (const span of candidates) {
+        if (span.start < cursor) {
+            continue;
+        }
+        while (allowedIndex < allowed.length &&
+            (allowed[allowedIndex]?.end ?? 0) <= span.start) {
+            allowedIndex += 1;
+        }
+        const blocker = allowed[allowedIndex];
+        if (blocker !== undefined && blocker.start < span.end) {
+            continue;
+        }
+        parts.push(text.slice(cursor, span.start));
+        parts.push(span.replacement);
+        cursor = span.end;
+    }
+    parts.push(text.slice(cursor));
+    return parts.join("");
+}

package/dist/kernel/repo-root.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from "./result.ts";
+export declare function pathExists(target: string): Promise<boolean>;
+export declare function resolveRepoRoot(startDir: string): Promise<Result<string>>;

package/dist/kernel/repo-root.js

@@ -0,0 +1,29 @@
+// SPEC §4.1.1: repo-root resolution for the Fs port. Walks up from a start
+// directory to the nearest ancestor holding a `.git` entry and returns its
+// canonical (symlink-resolved) path. Anything else is CDX-E703, never a guess.
+import { promises as fsp } from "node:fs";
+import path from "node:path";
+import { makeError } from "./errors.js";
+import { err, ok } from "./result.js";
+export async function pathExists(target) {
+    try {
+        await fsp.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function resolveRepoRoot(startDir) {
+    let dir = path.resolve(startDir);
+    while (true) {
+        if (await pathExists(path.join(dir, ".git"))) {
+            return ok(await fsp.realpath(dir));
+        }
+        const parent = path.dirname(dir);
+        if (parent === dir) {
+            return err(makeError("CDX-E703", `no git repository above ${startDir}`, "Run inside a git repository so paths resolve against its root."));
+        }
+        dir = parent;
+    }
+}

package/dist/kernel/result.d.ts

@@ -0,0 +1,10 @@
+import type { CdxError } from "./errors.ts";
+export type Result<T> = {
+    readonly ok: true;
+    readonly value: T;
+} | {
+    readonly ok: false;
+    readonly error: CdxError;
+};
+export declare function ok<T>(value: T): Result<T>;
+export declare function err<T>(error: CdxError): Result<T>;

package/dist/kernel/result.js

@@ -0,0 +1,6 @@
+export function ok(value) {
+    return { ok: true, value };
+}
+export function err(error) {
+    return { ok: false, error };
+}

package/dist/kernel/schema-helpers.d.ts

@@ -0,0 +1,11 @@
+import { type Result } from "./result.ts";
+export declare const SUPPORTED_KEYWORDS: ReadonlySet<string>;
+export declare const MAX_REF_DEPTH: number;
+export declare function isObjectRecord(value: unknown): value is Record<string, unknown>;
+export declare function field(schema: Record<string, unknown>, name: string): unknown;
+export declare function jsonType(value: unknown): string;
+export declare function mismatch(path: string, expected: string, detail?: string): Result<void>;
+export declare function unsupported(keyword: string): Result<void>;
+export declare function resolvePointer(root: unknown, pointer: string): unknown;
+export declare function checkType(expected: unknown, value: unknown, path: string): Result<void> | undefined;
+export declare function checkRange(schema: Record<string, unknown>, value: number, path: string): Result<void> | undefined;

package/dist/kernel/schema-helpers.js

@@ -0,0 +1,101 @@
+// SPEC §4.1.2: primitives for the JSON Schema 2020-12 subset validator.
+// Keyword policy, JSON typing, diagnostics, $ref pointer resolution and the
+// non-recursive scalar checks live here. Nothing here recurses into
+// validateAgainst, so schema.ts can import this file without a cycle.
+import { makeError } from "./errors.js";
+import { err } from "./result.js";
+export const SUPPORTED_KEYWORDS = new Set([
+    "type",
+    "properties",
+    "required",
+    "additionalProperties",
+    "items",
+    "enum",
+    "const",
+    "pattern",
+    "minimum",
+    "maximum",
+    "minLength",
+    "maxLength",
+    "minItems",
+    "maxItems",
+    "oneOf",
+    "$ref",
+    "$defs",
+    "definitions",
+]);
+export const MAX_REF_DEPTH = 32;
+export function isObjectRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+// Bracket access through a variable keeps noPropertyAccessFromIndexSignature
+// (tsconfig.base.json) satisfied without tripping useLiteralKeys.
+export function field(schema, name) {
+    return schema[name];
+}
+export function jsonType(value) {
+    if (value === null) {
+        return "null";
+    }
+    if (Array.isArray(value)) {
+        return "array";
+    }
+    if (typeof value === "number") {
+        return Number.isInteger(value) ? "integer" : "number";
+    }
+    return typeof value;
+}
+export function mismatch(path, expected, detail) {
+    return err(makeError("CDX-E101", `value at ${path} is invalid: expected ${expected}`, "Fix the value so it matches the schema, then retry.", detail));
+}
+export function unsupported(keyword) {
+    return err(makeError("CDX-E201", `schema uses unsupported keyword "${keyword}"`, "Remove the keyword or teach the kernel validator about it (SPEC §4.1.2)."));
+}
+export function resolvePointer(root, pointer) {
+    if (pointer === "#") {
+        return root;
+    }
+    if (!pointer.startsWith("#/")) {
+        return undefined;
+    }
+    let current = root;
+    for (const raw of pointer.slice(2).split("/")) {
+        const part = raw.replace(/~1/g, "/").replace(/~0/g, "~");
+        if (isObjectRecord(current)) {
+            current = current[part];
+        }
+        else if (Array.isArray(current)) {
+            const index = Number.parseInt(part, 10);
+            current = Number.isSafeInteger(index) ? current[index] : undefined;
+        }
+        else {
+            return undefined;
+        }
+        if (current === undefined) {
+            return undefined;
+        }
+    }
+    return current;
+}
+export function checkType(expected, value, path) {
+    if (typeof expected !== "string") {
+        return unsupported("type");
+    }
+    const actual = jsonType(value);
+    const matches = actual === expected || (expected === "number" && actual === "integer");
+    if (!matches) {
+        return mismatch(path, `type ${expected}`);
+    }
+    return undefined;
+}
+export function checkRange(schema, value, path) {
+    const minimum = field(schema, "minimum");
+    if (typeof minimum === "number" && value < minimum) {
+        return mismatch(path, `minimum ${minimum}`);
+    }
+    const maximum = field(schema, "maximum");
+    if (typeof maximum === "number" && value > maximum) {
+        return mismatch(path, `maximum ${maximum}`);
+    }
+    return undefined;
+}

package/dist/kernel/schema.d.ts

@@ -0,0 +1,2 @@
+import { type Result } from "./result.ts";
+export declare function validateSchema(schemaText: string, value: unknown): Result<void>;

package/dist/kernel/schema.js

@@ -0,0 +1,203 @@
+// SPEC §4.1.2: JSON Schema 2020-12 subset validator. Unsupported keywords
+// in a schema are a load error (CDX-E201), never ignored (EC-10). Value
+// mismatches fail with CDX-E101 naming the JSON-pointer path, never the
+// value itself. Primitives and scalar checks live in schema-helpers.ts;
+// the composite checks, $ref orchestration and entry live here.
+import { makeError } from "./errors.js";
+import { parseJson, stableStringify } from "./json.js";
+import { checkPattern } from "./pattern.js";
+import { err, ok } from "./result.js";
+import { checkRange, checkType, field, isObjectRecord, MAX_REF_DEPTH, mismatch, resolvePointer, SUPPORTED_KEYWORDS, unsupported, } from "./schema-helpers.js";
+function checkString(schema, value, path) {
+    const minLength = field(schema, "minLength");
+    if (typeof minLength === "number" && value.length < minLength) {
+        return mismatch(path, `minLength ${minLength}`);
+    }
+    const maxLength = field(schema, "maxLength");
+    if (typeof maxLength === "number" && value.length > maxLength) {
+        return mismatch(path, `maxLength ${maxLength}`);
+    }
+    const pattern = field(schema, "pattern");
+    if (typeof pattern === "string") {
+        const safe = checkPattern(pattern);
+        if (!safe.ok) {
+            return err(safe.error);
+        }
+        let expression;
+        try {
+            expression = new RegExp(pattern);
+        }
+        catch {
+            return unsupported("pattern");
+        }
+        if (!expression.test(value)) {
+            return mismatch(path, `pattern ${pattern}`);
+        }
+    }
+    return undefined;
+}
+function checkArray(schema, root, value, path, depth) {
+    const minItems = field(schema, "minItems");
+    if (typeof minItems === "number" && value.length < minItems) {
+        return mismatch(path, `minItems ${minItems}`);
+    }
+    const maxItems = field(schema, "maxItems");
+    if (typeof maxItems === "number" && value.length > maxItems) {
+        return mismatch(path, `maxItems ${maxItems}`);
+    }
+    const items = field(schema, "items");
+    if (items !== undefined) {
+        if (Array.isArray(items)) {
+            return unsupported("prefixItems");
+        }
+        for (let index = 0; index < value.length; index += 1) {
+            const checked = validateAgainst(items, value[index], root, `${path}/${index}`, depth + 1);
+            if (!checked.ok) {
+                return checked;
+            }
+        }
+    }
+    return undefined;
+}
+function checkObject(schema, root, value, path, depth) {
+    const required = field(schema, "required");
+    if (Array.isArray(required)) {
+        for (const name of required) {
+            if (typeof name !== "string") {
+                return unsupported("required");
+            }
+            if (value[name] === undefined) {
+                return mismatch(path, `required property "${name}"`);
+            }
+        }
+    }
+    const properties = field(schema, "properties");
+    if (isObjectRecord(properties)) {
+        for (const key of Object.keys(properties)) {
+            if (value[key] !== undefined) {
+                const checked = validateAgainst(properties[key], value[key], root, `${path}/${key}`, depth + 1);
+                if (!checked.ok) {
+                    return checked;
+                }
+            }
+        }
+    }
+    const additional = field(schema, "additionalProperties");
+    const declared = properties !== undefined && isObjectRecord(properties)
+        ? new Set(Object.keys(properties))
+        : new Set();
+    if (additional === false) {
+        for (const key of Object.keys(value)) {
+            if (!declared.has(key)) {
+                return mismatch(path, `no additional property "${key}"`);
+            }
+        }
+    }
+    else if (additional !== undefined && additional !== true) {
+        for (const key of Object.keys(value)) {
+            if (!declared.has(key)) {
+                const checked = validateAgainst(additional, value[key], root, `${path}/${key}`, depth + 1);
+                if (!checked.ok) {
+                    return checked;
+                }
+            }
+        }
+    }
+    return undefined;
+}
+function validateAgainst(schema, value, root, path, depth) {
+    if (depth > MAX_REF_DEPTH) {
+        return err(makeError("CDX-E902", "schema $ref nesting exceeds the validator budget", "Flatten the schema so $ref chains stay shallow, then retry."));
+    }
+    if (typeof schema === "boolean") {
+        return schema ? ok(undefined) : mismatch(path, "a value the schema allows");
+    }
+    if (!isObjectRecord(schema)) {
+        return unsupported("$ref");
+    }
+    for (const keyword of Object.keys(schema)) {
+        if (!SUPPORTED_KEYWORDS.has(keyword)) {
+            return unsupported(keyword);
+        }
+    }
+    const reference = field(schema, "$ref");
+    if (typeof reference === "string") {
+        const target = resolvePointer(root, reference);
+        if (target === undefined) {
+            return unsupported("$ref");
+        }
+        const resolved = validateAgainst(target, value, root, path, depth + 1);
+        if (!resolved.ok) {
+            return resolved;
+        }
+    }
+    const enumeration = field(schema, "enum");
+    if (Array.isArray(enumeration)) {
+        const wanted = stableStringify(value);
+        const found = enumeration.some((candidate) => stableStringify(candidate) === wanted);
+        if (!found) {
+            return mismatch(path, "one of the enum values");
+        }
+    }
+    if ("const" in schema) {
+        if (stableStringify(field(schema, "const")) !== stableStringify(value)) {
+            return mismatch(path, "the const value");
+        }
+    }
+    const expectedType = field(schema, "type");
+    if (expectedType !== undefined) {
+        const checked = checkType(expectedType, value, path);
+        if (checked !== undefined) {
+            return checked;
+        }
+    }
+    if (typeof value === "number") {
+        const checked = checkRange(schema, value, path);
+        if (checked !== undefined) {
+            return checked;
+        }
+    }
+    if (typeof value === "string") {
+        const checked = checkString(schema, value, path);
+        if (checked !== undefined) {
+            return checked;
+        }
+    }
+    if (Array.isArray(value)) {
+        const checked = checkArray(schema, root, value, path, depth);
+        if (checked !== undefined) {
+            return checked;
+        }
+    }
+    if (isObjectRecord(value)) {
+        const checked = checkObject(schema, root, value, path, depth);
+        if (checked !== undefined) {
+            return checked;
+        }
+    }
+    const branches = field(schema, "oneOf");
+    if (Array.isArray(branches)) {
+        let matches = 0;
+        let firstFailure;
+        for (const branch of branches) {
+            const checked = validateAgainst(branch, value, root, path, depth + 1);
+            if (checked.ok) {
+                matches += 1;
+            }
+            else if (firstFailure === undefined) {
+                firstFailure = checked;
+            }
+        }
+        if (matches !== 1) {
+            return firstFailure ?? mismatch(path, "exactly one oneOf branch");
+        }
+    }
+    return ok(undefined);
+}
+export function validateSchema(schemaText, value) {
+    const parsed = parseJson(schemaText);
+    if (!parsed.ok) {
+        return err(parsed.error);
+    }
+    return validateAgainst(parsed.value, value, parsed.value, "#", 0);
+}

package/dist/kernel/secret-paths.d.ts

@@ -0,0 +1,3 @@
+export declare const DEFAULT_FIXTURE_GLOBS: ReadonlyArray<string>;
+export declare function isSecretReadPath(path: string): boolean;
+export declare function isFixturePath(path: string, globs?: ReadonlyArray<string>): boolean;

package/dist/kernel/secret-paths.js

@@ -0,0 +1,70 @@
+// SPEC §4.7.1 secret-read guard: the paths that must never reach the
+// agent context (tool.pre.read and shell commands that print files). The
+// .env family exempts .env.example; dotfiles with auth lines (.npmrc,
+// .pypirc, nuget.config) block as whole files; home-relative secret dirs
+// match lexically. Also owns the default fixture-glob exemption: values
+// under fixture dirs are test vectors, never live credentials.
+import { globMatch } from "./glob.js";
+const SECRET_BASENAMES = new Set([".npmrc", ".pypirc", "nuget.config"]);
+const SECRET_DIR_SEGMENTS = new Set([".ssh", ".aws", ".gnupg"]);
+export const DEFAULT_FIXTURE_GLOBS = [
+    "**/fixtures/**",
+    "**/fixture/**",
+    "**/__fixtures__/**",
+    "**/testdata/**",
+    "**/test-data/**",
+    "**/*.fixture.*",
+];
+// The home-prefix patterns live at module scope so their quantifiers
+// never count as branches of the function that applies them.
+const HOME_PREFIX_PATTERNS = [
+    /^~[/\\]?/,
+    /^\$home[/\\]?/,
+    /^\$\{home\}[/\\]?/,
+    /^%userprofile%[/\\]?/,
+];
+function isEnvSecretFile(base) {
+    return (base === ".env" || (base.startsWith(".env.") && base !== ".env.example"));
+}
+function isKeyMaterialFile(base) {
+    return (base.endsWith(".pem") ||
+        base.endsWith(".key") ||
+        base.endsWith(".p12") ||
+        base.endsWith(".pfx") ||
+        base.startsWith("id_rsa") ||
+        base.startsWith("id_ed25519"));
+}
+function homeRelativePath(slashed) {
+    let relative = slashed.toLowerCase();
+    for (const pattern of HOME_PREFIX_PATTERNS) {
+        relative = relative.replace(pattern, "");
+    }
+    return relative;
+}
+function isSecretDirPath(slashed) {
+    const segments = homeRelativePath(slashed).split("/");
+    return (segments.some((segment) => SECRET_DIR_SEGMENTS.has(segment)) ||
+        (segments[0] === ".config" && segments[1] === "gh"));
+}
+// SPEC §4.7.1: the secret-read guard paths.
+export function isSecretReadPath(path) {
+    const slashed = path.replace(/\\/g, "/");
+    const base = slashed.split("/").pop() ?? "";
+    if (isEnvSecretFile(base)) {
+        return true;
+    }
+    if (isKeyMaterialFile(base)) {
+        return true;
+    }
+    if (SECRET_BASENAMES.has(base)) {
+        return true;
+    }
+    return isSecretDirPath(slashed);
+}
+// SPEC §4.7.1: placeholder credentials and test vectors under a declared
+// fixture glob are allowlisted. The kernel default covers the common
+// fixture layouts; the check takes configured globs when the caller has
+// them (phase 4 config), so the default never silently widens.
+export function isFixturePath(path, globs = DEFAULT_FIXTURE_GLOBS) {
+    return globs.some((glob) => globMatch(glob, path));
+}

package/dist/kernel/shell-bypass.d.ts

@@ -0,0 +1,4 @@
+import type { SimpleCommand } from "./shell.ts";
+export declare function isProtectedPath(path: string): boolean;
+export declare function matchBypassCommand(cmd: SimpleCommand): string | undefined;
+export declare function scanBypassRawText(text: string): string | undefined;