codictator 0.0.0 → 0.1.3

package/dist/features/packs/enforcers/py-pins.js

@@ -0,0 +1,184 @@
+// SPEC §6.3 driver `pypi`: manifest-side supplies for the pack enforcers.
+// The requirements*.txt pin mirror and the pyproject dependency scan live
+// here (rather than in py-lex.ts) so every supply file stays review-sized;
+// like py-lex.ts this mirrors the drivers locally because §3.3 forbids the
+// packs module from importing the pack supplies or features/deps.
+import { makeError } from "../../../kernel/index.js";
+import { findingFor, readErrorFinding } from "./binding.js";
+// SPEC §6.3: lock `uv.lock` or fully pinned `requirements*.txt`.
+export function isRequirementsFile(path) {
+    const slash = path.replaceAll("\\", "/").lastIndexOf("/");
+    const base = slash < 0 ? path : path.slice(slash + 1);
+    return (base === "requirements.txt" ||
+        (base.startsWith("requirements") && base.endsWith(".txt")));
+}
+// Join backslash continuations the way pip does, keeping the start line of
+// each logical line. A trailing lone continuation still flushes.
+function joinContinuedLines(text) {
+    const logical = [];
+    let current = "";
+    let start = 1;
+    let line = 1;
+    const flush = () => {
+        logical.push({ line: current, number: start });
+        current = "";
+    };
+    for (const raw of text.split("\n")) {
+        const stripped = raw.endsWith("\r") ? raw.slice(0, -1) : raw;
+        if (current === "") {
+            start = line;
+        }
+        if (stripped.endsWith("\\")) {
+            current += `${stripped.slice(0, -1)} `;
+        }
+        else {
+            current += stripped;
+            flush();
+        }
+        line += 1;
+    }
+    if (current !== "") {
+        flush();
+    }
+    return logical;
+}
+const REQUIREMENT_NAME = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?/;
+// Parse one logical requirements line: comments and `-` directives stay
+// quiet, `--hash` pin rows and non-requirement lines report their line,
+// otherwise the PEP 508 name plus the marker-stripped spec lands.
+function parseRequirementEntry(entry, reqs) {
+    const uncommented = stripPyComment(entry.line).trim();
+    if (uncommented === "") {
+        return undefined;
+    }
+    if (uncommented.startsWith("--hash")) {
+        return entry.number;
+    }
+    if (uncommented.startsWith("-")) {
+        return undefined;
+    }
+    const name = REQUIREMENT_NAME.exec(uncommented)?.[0];
+    if (name === undefined) {
+        return entry.number;
+    }
+    const rest = uncommented
+        .slice(name.length)
+        .replace(/^\[[^\]]*\]/, "")
+        .split(";", 1)[0]
+        ?.trim()
+        .replace(/\s+--hash=\S+/g, "")
+        .trim();
+    reqs.push({ name, spec: rest ?? "", line: entry.number });
+    return undefined;
+}
+// Join backslash continuations the way pip does, keeping the start line,
+// then parse each logical line as a PEP 508 requirement. Local mirror of
+// the features/deps/pypi.ts line handling (§3.3).
+export function parsePythonRequirements(text) {
+    const reqs = [];
+    let brokenLine;
+    for (const entry of joinContinuedLines(text)) {
+        const broken = parseRequirementEntry(entry, reqs);
+        if (broken !== undefined) {
+            brokenLine = broken;
+        }
+    }
+    return { reqs, brokenLine };
+}
+function stripPyComment(line) {
+    for (let index = 0; index < line.length; index += 1) {
+        if (line[index] === "#" &&
+            (index === 0 || line[index - 1] === " " || line[index - 1] === "\t")) {
+            return line.slice(0, index);
+        }
+    }
+    return line;
+}
+// SPEC §6.3: exact pin is `name==x.y.z`; a bare name, comparisons, `~=`,
+// `===` and `.*` prefixes are ranges. Local mirror of isExactPyPiPin (§3.3).
+export function isExactPythonPin(spec) {
+    return /^==\d+\.\d+\.\d+(?:[-+_.][0-9A-Za-z.+-]+)?$/.test(spec.trim());
+}
+// SPEC §6.3 driver `pypi`: the `[project] dependencies` names plus the
+// `[dependency-groups]` (and `[project.optional-dependencies]`) members,
+// read as a static approximation over the manifest text: quoted literals
+// inside each `name = [` array, skipping `{include-group}` rows, which name
+// a group rather than a package.
+export function collectPyprojectNames(text) {
+    const names = new Set();
+    const lines = text.split("\n");
+    let section = "";
+    let collecting = false;
+    let depth = 0;
+    const flushChunk = (chunk) => {
+        for (const match of chunk.matchAll(/"([^"]*)"|'([^']*)'/g)) {
+            const literal = (match[1] ?? match[2] ?? "").trim();
+            if (literal === "" ||
+                literal.startsWith("{") ||
+                literal.includes("include-group")) {
+                continue;
+            }
+            const name = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?/.exec(literal)?.[0];
+            if (name !== undefined) {
+                names.add(name);
+            }
+        }
+    };
+    for (const line of lines) {
+        const header = /^[ \t]*\[([^\][\s]+)\][ \t]*(?:#.*)?$/.exec(line);
+        if (header !== null) {
+            collecting = false;
+            section = (header[1] ?? "").toLowerCase();
+            continue;
+        }
+        if (line.includes("include-group")) {
+            continue;
+        }
+        const opensArray = (section === "project" &&
+            /^[ \t]*dependencies[ \t]*=[ \t]*\[/.test(line)) ||
+            ((section === "dependency-groups" ||
+                section === "project.optional-dependencies") &&
+                /^[ \t]*[A-Za-z0-9_.-]+[ \t]*=[ \t]*\[/.test(line));
+        if (!collecting && opensArray) {
+            collecting = true;
+            depth = 0;
+        }
+        if (!collecting) {
+            continue;
+        }
+        for (const char of line) {
+            if (char === "[") {
+                depth += 1;
+            }
+            else if (char === "]") {
+                depth -= 1;
+            }
+        }
+        flushChunk(line);
+        if (depth <= 0) {
+            collecting = false;
+        }
+    }
+    return names;
+}
+// SPEC §6.4 EC-7: a `requirements*.txt` line judges the core/dep-exact-pin
+// verdict through the PyPI pin mirror above: only `name==x.y.z` pins, so a
+// `requests>=2` line blocks while a fully pinned line stays clean. A line
+// that is neither a directive nor a requirement fails closed (CDX-E903)
+// instead of silently dropping a dependency the verdicts cannot see.
+export function checkPythonPins(binding, file, text, findings) {
+    const parsed = parsePythonRequirements(text);
+    if (parsed.brokenLine !== undefined) {
+        findings.push(readErrorFinding(binding, file, makeError("CDX-E903", `${file} line ${String(parsed.brokenLine)} is not a requirement string`, "Write the line as a PEP 508 requirement string."), "read"));
+        return;
+    }
+    for (const req of parsed.reqs) {
+        if (!isExactPythonPin(req.spec)) {
+            findings.push(findingFor(binding, {
+                path: file,
+                message: `${req.name}@${req.spec} in ${file} is not an exact pin`,
+                vars: { path: file, value: `${req.name}@${req.spec}` },
+            }));
+        }
+    }
+}

package/dist/features/packs/enforcers/py-security-patterns.d.ts

@@ -0,0 +1,18 @@
+import { type Ports } from "../../../kernel/index.ts";
+import type { CheckContext, Finding } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+export declare function resolvePythonSecurityPatterns(decl: EnforcerDecl, rule: PackRule, ports: Ports): {
+    ok: false;
+    error: import("../../../kernel/errors.ts").CdxError;
+    value?: never;
+} | {
+    error?: never;
+    ok: true;
+    value: {
+        id: string;
+        kinds: readonly ("compact" | "post-tool" | "pre-tool" | "prompt" | "review" | "scheduled" | "startup")[];
+        budgetMs: number;
+        check: (ctx: CheckContext) => Promise<Array<Finding>>;
+    };
+};

package/dist/features/packs/enforcers/py-security-patterns.js

@@ -0,0 +1,70 @@
+// SPEC §6.3 python/security-patterns: dangerous Python patterns over
+// source files. Dynamic evaluation sinks, shell-spawning subprocess calls,
+// unsafe deserialization and loading calls, and disabled TLS verification
+// all block. Only language files are scanned, line by line like the
+// parametric patterns.
+import { checkPattern } from "../../../kernel/index.js";
+import { bindRule, findingFor, readErrorFinding, readLossyText, selectFiles, } from "./binding.js";
+import { isPythonFile } from "./py-lex.js";
+const RAW_PATTERNS = [
+    { id: "eval", pattern: "\\beval\\s*\\(" },
+    { id: "exec", pattern: "\\bexec\\s*\\(" },
+    { id: "shell-true", pattern: "\\bshell\\s*=\\s*True\\b" },
+    { id: "pickle-loads", pattern: "\\bpickle\\s*\\.\\s*loads\\s*\\(" },
+    { id: "yaml-load", pattern: "\\byaml\\s*\\.\\s*load\\s*\\(" },
+    { id: "verify-false", pattern: "\\bverify\\s*=\\s*False\\b" },
+];
+export function resolvePythonSecurityPatterns(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const compiled = [];
+    for (const entry of RAW_PATTERNS) {
+        const safe = checkPattern(entry.pattern);
+        if (!safe.ok) {
+            return { ok: false, error: safe.error };
+        }
+        compiled.push({ id: entry.id, pattern: new RegExp(entry.pattern) });
+    }
+    return {
+        ok: true,
+        value: {
+            id: rule.id,
+            kinds: binding.triggers,
+            budgetMs: decl.budgetMs,
+            check: async (ctx) => {
+                const findings = [];
+                for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+                    if (!isPythonFile(file)) {
+                        continue;
+                    }
+                    const loaded = await readLossyText(ports.fs, file);
+                    if (!loaded.ok) {
+                        findings.push(readErrorFinding(binding, file, loaded.error, "read"));
+                        continue;
+                    }
+                    let line = 0;
+                    for (const content of loaded.value.text.split("\n")) {
+                        line += 1;
+                        for (const entry of compiled) {
+                            if (!entry.pattern.test(content)) {
+                                continue;
+                            }
+                            // A SafeLoader riding the yaml.load call line is
+                            // the sanctioned sink; anything else blocks.
+                            if (entry.id === "yaml-load" && content.includes("SafeLoader")) {
+                                continue;
+                            }
+                            findings.push(findingFor(binding, {
+                                path: file,
+                                line,
+                                message: `dangerous pattern ${entry.id} in ${file}:${String(line)}`,
+                                vars: { path: file, line: String(line) },
+                            }));
+                            break;
+                        }
+                    }
+                }
+                return findings;
+            },
+        },
+    };
+}

package/dist/features/packs/enforcers/records-guards.d.ts

@@ -0,0 +1,12 @@
+import type { Ports } from "../../../kernel/index.ts";
+import { type Result } from "../../../kernel/index.ts";
+import type { Enforcer } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+export declare function resolveHistoryEntry(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveHistoryAppendOnly(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveHistoryEntryComplete(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveBugRegistry(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveBugRowsImmutable(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveDiagnoseBeforeFix(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveFileNaming(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;

package/dist/features/packs/enforcers/records-guards.js

@@ -0,0 +1,178 @@
+import { ok } from "../../../kernel/index.js";
+import { bindRule, findingFor, selectFiles } from "./binding.js";
+import { baseEnforcer, loadScopeText, parseMarkers, scopeMarkerTexts, } from "./health-measures.js";
+// SPEC §5.8 core/history-entry: a commit with no history entry flags.
+export function resolveHistoryEntry(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined) {
+                continue;
+            }
+            if ((parseMarkers(text).get("history") ?? "") === "none") {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `commit with no history entry in ${file}`,
+                    vars: { path: file },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §5.8 core/history-append-only: an edit to a history file flags;
+// appending stays clean. The marker is a report line (`edited:` at the
+// line start), never a substring, so the guard's own source never flags.
+export function resolveHistoryAppendOnly(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined || !/^[ \t]*edited:/m.test(text)) {
+                continue;
+            }
+            findings.push(findingFor(binding, {
+                path: file,
+                message: `history file edited in ${file}`,
+                vars: { path: file },
+            }));
+        }
+        return findings;
+    }));
+}
+// SPEC §5.8 core/history-entry-complete: an entry missing a required field
+// flags.
+export function resolveHistoryEntryComplete(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined) {
+                continue;
+            }
+            if ((parseMarkers(text).get("spec") ?? "") === "missing") {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `history entry missing a field in ${file}`,
+                    vars: { path: file },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §5.8 core/bug-registry: a fix with no bug row flags.
+export function resolveBugRegistry(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined) {
+                continue;
+            }
+            if ((parseMarkers(text).get("bug-row") ?? "") === "none") {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `fix with no bug row in ${file}`,
+                    vars: { path: file },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §5.8 core/bug-rows-immutable: an edit to a closed bug row flags;
+// appending a note stays clean. The marker is a report line (`edited:`
+// at the line start), never a substring, so the guard's own source never
+// flags.
+export function resolveBugRowsImmutable(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined || !/^[ \t]*edited:/m.test(text)) {
+                continue;
+            }
+            findings.push(findingFor(binding, {
+                path: file,
+                message: `closed bug row edited in ${file}`,
+                vars: { path: file },
+            }));
+        }
+        return findings;
+    }));
+}
+// SPEC §5.8 core/diagnose-before-fix: a fix with no recorded diagnosis
+// flags.
+export function resolveDiagnoseBeforeFix(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined) {
+                continue;
+            }
+            if ((parseMarkers(text).get("diagnosis") ?? "") === "none") {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `fix with no diagnosis in ${file}`,
+                    vars: { path: file },
+                }));
+            }
+        }
+        return findings;
+    }));
+}
+// SPEC §5.11 + §6.1 core/file-naming: TypeScript sources are kebab-case,
+// tests are *.test.<ext>; framework-reserved names ([id], +page, _layout)
+// stay allowed. Lexer-light mirror of builtin-packs/typescript/naming.ts:
+// packs cannot import the pack supplies (§3.3). Markdown names per §4.9.2
+// stay with the records doc reads.
+function isKebabStem(stem) {
+    return /^[a-z0-9]+(-[a-z0-9]+)*$/.test(stem);
+}
+// Test files judge the stem before `.test.`; other files judge the stem
+// before the last dot; a dotless name judges whole.
+function judgedStem(base) {
+    const testAt = base.toLowerCase().indexOf(".test.");
+    if (testAt >= 0) {
+        return base.slice(0, testAt);
+    }
+    const dot = base.lastIndexOf(".");
+    return dot < 0 ? base : base.slice(0, dot);
+}
+export function resolveFileNaming(decl, rule, ports) {
+    const binding = bindRule(rule);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const { file, markers } of await scopeMarkerTexts(ports, binding, ctx, findings)) {
+            const name = markers.get("file") ?? "";
+            if (name === "") {
+                continue;
+            }
+            const base = name.split("/").pop() ?? name;
+            if (base.startsWith("[") ||
+                base.startsWith("+") ||
+                base.startsWith("_")) {
+                continue;
+            }
+            const stem = judgedStem(base);
+            if (isKebabStem(stem)) {
+                continue;
+            }
+            findings.push(findingFor(binding, {
+                path: file,
+                message: `file stem "${stem}" is not kebab-case`,
+                vars: { path: file },
+            }));
+        }
+        return findings;
+    }));
+}

package/dist/features/packs/enforcers/remediation-guards.d.ts

@@ -0,0 +1,6 @@
+import type { Ports } from "../../../kernel/index.ts";
+import { type Result } from "../../../kernel/index.ts";
+import type { Enforcer } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+export declare function resolveRemediationStepSize(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;

package/dist/features/packs/enforcers/remediation-guards.js

@@ -0,0 +1,42 @@
+import { ok } from "../../../kernel/index.js";
+import { bindRule, findingFor, selectFiles } from "./binding.js";
+import { baseEnforcer, isMarkerFile, limitOf, loadScopeText, parseMarkerInt, parseMarkers, } from "./health-measures.js";
+// SPEC §5.6 defaults: 10 files, 300 lines.
+export function resolveRemediationStepSize(decl, rule, ports) {
+    const binding = bindRule(rule);
+    const maxFiles = limitOf(binding, "maxFiles", 10);
+    const maxChangedLines = limitOf(binding, "maxChangedLines", 300);
+    return ok(baseEnforcer(rule, binding, decl, async (ctx) => {
+        const findings = [];
+        for (const file of selectFiles(ctx.scope.files, binding.scopeGlobs)) {
+            const text = await loadScopeText(ports, binding, file, findings);
+            if (text === undefined || !isMarkerFile(file)) {
+                continue;
+            }
+            const markers = parseMarkers(text);
+            const files = parseMarkerInt(markers, "files");
+            const lines = parseMarkerInt(markers, "changed-lines");
+            if (files !== undefined && files > maxFiles) {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `remediation step touches ${String(files)} files, above the ${String(maxFiles)} file budget`,
+                    vars: {
+                        path: file,
+                        limit: `${String(maxFiles)}/${String(maxChangedLines)}`,
+                    },
+                }));
+            }
+            if (lines !== undefined && lines > maxChangedLines) {
+                findings.push(findingFor(binding, {
+                    path: file,
+                    message: `remediation step touches ${String(lines)} lines, above the ${String(maxChangedLines)} line budget`,
+                    vars: {
+                        path: file,
+                        limit: `${String(maxFiles)}/${String(maxChangedLines)}`,
+                    },
+                }));
+            }
+        }
+        return findings;
+    }));
+}

package/dist/features/packs/enforcers/required.d.ts

@@ -0,0 +1,10 @@
+import type { Ports } from "../../../kernel/index.ts";
+import { type Result } from "../../../kernel/index.ts";
+import type { Finding } from "../../engine/index.ts";
+import { type RuleBinding } from "./binding.ts";
+export interface RequiredConfig {
+    readonly files: ReadonlyArray<string>;
+    readonly contains: Readonly<Record<string, string>>;
+}
+export declare function narrowRequiredArgs(declId: string, args: unknown): Result<RequiredConfig>;
+export declare function checkRequired(ports: Ports, binding: RuleBinding, config: RequiredConfig): Promise<Array<Finding>>;

package/dist/features/packs/enforcers/required.js

@@ -0,0 +1,65 @@
+// SPEC §4.4.6 file-required: required files exist, and required content is
+// present inside them. Missing files and absent content each fail closed
+// with their own finding; the scope never restricts the check because the
+// requirement is about the tree, not the trigger.
+import { err, ok } from "../../../kernel/index.js";
+import { field, isRecord } from "../manifest.js";
+import { argsRecord, bindingError, findingFor, readErrorFinding, readLossyText, stringList, } from "./binding.js";
+export function narrowRequiredArgs(declId, args) {
+    const record = argsRecord(declId, args);
+    if (!record.ok) {
+        return err(record.error);
+    }
+    const files = stringList(field(record.value, "files")) ?? [];
+    if (files.length === 0 || files.some((file) => file.length === 0)) {
+        return bindingError(declId, "needs a non-empty files list in args");
+    }
+    const rawContains = field(record.value, "contains") ?? {};
+    if (!isRecord(rawContains)) {
+        return bindingError(declId, "needs a contains object in args");
+    }
+    const contains = {};
+    for (const key of Object.keys(rawContains)) {
+        const need = rawContains[key];
+        if (typeof need !== "string") {
+            return bindingError(declId, "needs string values in contains");
+        }
+        contains[key] = need;
+    }
+    return ok({ files: [...files].sort(), contains });
+}
+export async function checkRequired(ports, binding, config) {
+    const findings = [];
+    for (const file of config.files) {
+        const seen = await ports.fs.exists(file);
+        if (!seen.ok) {
+            findings.push(readErrorFinding(binding, file, seen.error, "stat"));
+            continue;
+        }
+        if (!seen.value) {
+            findings.push(findingFor(binding, {
+                path: file,
+                message: `required file missing: ${file}`,
+                vars: { path: file },
+            }));
+            continue;
+        }
+        const need = config.contains[file];
+        if (typeof need !== "string") {
+            continue;
+        }
+        const loaded = await readLossyText(ports.fs, file);
+        if (!loaded.ok) {
+            findings.push(readErrorFinding(binding, file, loaded.error, "read"));
+            continue;
+        }
+        if (!loaded.value.text.includes(need)) {
+            findings.push(findingFor(binding, {
+                path: file,
+                message: `required content absent from ${file}`,
+                vars: { path: file },
+            }));
+        }
+    }
+    return findings;
+}

package/dist/features/packs/enforcers/secret-scan.d.ts

@@ -0,0 +1,6 @@
+import { type Ports, type Result } from "../../../kernel/index.ts";
+import type { Enforcer } from "../../engine/index.ts";
+import type { PackRule } from "../index.ts";
+import type { EnforcerDecl } from "../manifest.ts";
+export declare function resolveNoSecrets(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;
+export declare function resolveNoSecretReads(decl: EnforcerDecl, rule: PackRule, ports: Ports): Result<Enforcer>;