depcurfew 1.3.0 → 1.4.0

package/dist/index.d.ts

@@ -1,8 +1,8 @@
 import { Readable, Writable } from "node:stream";
-type ToolId = 'npm' | 'pnpm' | 'yarn' | 'bun' | 'deno' | 'uv' | 'pip' | 'poetry' | 'pdm' | 'pipenv' | 'renovate' | 'dependabot';
+type ToolId = 'npm' | 'pnpm' | 'yarn' | 'bun' | 'deno' | 'uv' | 'pip' | 'poetry' | 'pdm' | 'pipenv' | 'composer' | 'renovate' | 'dependabot';
 type ToolKind = 'package-manager' | 'update-bot';
 /** The registry a package manager installs from; package names in the policy are compared per ecosystem. */
-type Ecosystem = 'npm' | 'pypi';
+type Ecosystem = 'npm' | 'pypi' | 'packagist';
 interface Evidence$1<T> {
   value: T;
   /** URL of official documentation or changelog. */
@@ -250,9 +250,19 @@ type OverrideValues = 'delay' | 'any' | readonly string[] | {
 interface OverrideSwitch {
   /** The option as the scanner resolves it (--name) or the variable, compared without regard to case. */
   name: string;
-  /** The release-age delay, or the rule on dependency install scripts. */
-  weakens: 'delay' | 'scripts';
+  /**
+   * The release-age delay, the rule on dependency install scripts, or a protection of the package manager that the
+   * policy does not manage (Composer's blocking of versions flagged as malware), which always counts (decision D-133).
+   */
+  weakens: 'delay' | 'scripts' | 'protection';
   values: OverrideValues;
+  /** protection: what it turns off, for messages ("turns off the blocking of versions flagged as malware"). */
+  effect?: string;
+  /**
+   * protection: what that protection does, as a clause of its own, when it covers less than every package the command
+   * fetches ("secure-http lets Composer download only over HTTPS, …"; decision D-142).
+   */
+  protects?: string;
 }
 /** A tool that environment facts refer to: Node.js, Python or a package manager. */
 type RuntimeOrTool = 'node' | 'python' | ToolId;
@@ -386,6 +396,71 @@ interface ProjectStatusKnowledge {
   /** Installers may warn about the project. */
   warned: readonly string[];
 }
+/** The batch query of the OSV.dev API (decision D-129): where to send it, how its JSON is spelled, and its limit. */
+interface OsvApiKnowledge {
+  /** Base URL of the API. */
+  url: string;
+  queryBatchPath: string;
+  /** GET: one record by id ({id}). */
+  vulnerabilityPath: string;
+  /** The web page of a record ({id}). */
+  recordPage: string;
+  queriesField: string;
+  resultsField: string;
+  vulnsField: string;
+  idField: string;
+  /** A result with more pages carries this token; the next request sends it back as pageTokenField of that query. */
+  nextPageTokenField: string;
+  pageTokenField: string;
+  /** Most queries in one batch request. */
+  maxQueriesPerBatch: number;
+}
+/** When a batch result is paged: more vulnerabilities than these for one query, or for the whole batch. */
+interface OsvPagingKnowledge {
+  perQuery: number;
+  perBatch: number;
+}
+/** What OSV.dev promises about its service: no rate limit (null), how fresh the data is, the largest response over HTTP/1.1. */
+interface OsvServiceKnowledge {
+  rateLimit: number | null;
+  freshnessMinutes: number;
+  freshnessShare: number;
+  responseLimitBytes: number;
+}
+/** Withdrawn records: the field that marks them, and which responses still carry them. */
+interface OsvWithdrawnKnowledge {
+  field: string;
+  inQueryResponses: boolean;
+  inRecordResponses: boolean;
+}
+/** The records of known malicious packages in OSV.dev: their id prefix and where they come from. */
+interface OsvMaliciousKnowledge {
+  idPrefix: string;
+  database: string;
+  license: string;
+}
+/** The characters a record id may have (a regular expression for the whole id), from the OSV schema (decision D-135). */
+interface OsvIdKnowledge {
+  pattern: string;
+}
+/** OSV.dev, asked about known malicious package versions with --osv (decision D-129). */
+interface OsvKnowledge {
+  api: Fact<OsvApiKnowledge>;
+  paging: Fact<OsvPagingKnowledge>;
+  ids: Fact<OsvIdKnowledge>;
+  service: Fact<OsvServiceKnowledge>;
+  withdrawn: Fact<OsvWithdrawnKnowledge>;
+  malicious: Fact<OsvMaliciousKnowledge>;
+  /** The OSV ecosystem name of each ecosystem of depcurfew (npm, pypi, ...). */
+  ecosystems: Fact<Readonly<Record<string, string>>>;
+  /** How the API compares the version of a query with the versions of a record, by depcurfew's ecosystem (decision D-142). */
+  versionMatching: Fact<Readonly<Record<string, OsvVersionMatchingKnowledge>>>;
+}
+/** What OSV.dev leaves out of a version before it compares it. */
+interface OsvVersionMatchingKnowledge {
+  /** A leading character left out of both versions (Packagist: v and V). */
+  ignoredPrefixes: readonly string[];
+}
 /** Claude Code hooks that run before a tool call and can block it (used by depcurfew check --hook claude-code). */
 interface ClaudeCodeHooksKnowledge {
   /** Project settings file that can be committed. */
@@ -775,6 +850,36 @@ interface RuntimeImageKnowledge {
 interface MovingTagsKnowledge {
   tags: Readonly<Record<string, string>>;
 }
+/**
+ * An npm package with install scripts whose effect is known (decision D-127), read in its source at the releases in
+ * `versions`: `not-needed` when the package works without the script, `project-task` when the script does a task of
+ * the project (installing git hooks) that the project can run in its own lifecycle script (`projectScript`).
+ */
+interface InstallScriptPackageKnowledge {
+  name: string;
+  /** The releases the source was read at. */
+  versions: readonly string[];
+  /** The install script, as the package declares it or as npm adds it, for messages. */
+  script: string;
+  kind: 'not-needed' | 'project-task';
+  /** What the script does, as a clause for messages ("it runs lefthook install, which installs the git hooks"). */
+  does: string;
+  /** What changes when the script does not run, as a clause for messages ("nothing changes"). */
+  withoutScript: string;
+  /**
+   * Without its install script the package can take its binary only from an optional dependency for the platform (the
+   * script fetches it otherwise), so a denied one fails where optional dependencies are left out.
+   */
+  needsOptionalDependencies: boolean;
+  /**
+   * project-task: how the project does the same task without the install script, as the package documents it for
+   * projects that do not use that script: a command to run after each clone of the repository (decision D-135).
+   */
+  projectStep?: {
+    command: string;
+    after: 'clone';
+  };
+}
 interface EnvironmentKnowledge {
   corepack: {
     packageManagerField: Fact<PackageManagerFieldKnowledge>;
@@ -792,7 +897,18 @@ interface EnvironmentKnowledge {
       command: string;
       npmOnlyWhenNamed: boolean;
     }>;
+    /**
+     * Installing Corepack where Node.js does not come with it (decision D-128): the npm package and the command; then
+     * corepack enable puts the shims on the path.
+     */
+    manualInstall: Fact<{
+      package: string;
+      command: string;
+      enable: string;
+    }>;
   };
+  /** npm packages whose install scripts are known to be unneeded or to do a task of the project (decision D-127). */
+  installScriptPackages: Readonly<Record<string, Fact<InstallScriptPackageKnowledge>>>;
   node: {
     /** The npm each Node.js release bundles, per release line. */
     bundledNpm: Fact<readonly BundledVersionsLine[]>;
@@ -853,6 +969,10 @@ interface EnvironmentKnowledge {
   };
   githubActions: {
     workflows: Fact<WorkflowsKnowledge>;
+    /** The ids GitHub accepts as keys of jobs, as a regular expression (decision D-135). */
+    jobId: Fact<{
+      pattern: string;
+    }>;
     setupNode: Fact<SetupActionKnowledge>;
     /** The versions node-version accepts besides semver ranges. */
     setupNodeVersions: Fact<NodeVersionNamesKnowledge>;
@@ -871,6 +991,10 @@ interface EnvironmentKnowledge {
       key: string;
       levels: readonly ('workflow' | 'job' | 'step')[];
     }>;
+    /** Whether workflows may use YAML anchors and aliases, which GitHub expands (decision D-141). */
+    yamlAliases: Fact<{
+      accepted: boolean;
+    }>;
     pnpmActionSetup: Fact<SetupActionKnowledge>;
     pnpmSetup: Fact<SetupActionKnowledge>;
     setupBun: Fact<SetupActionKnowledge>;
@@ -943,6 +1067,8 @@ interface EnvironmentKnowledge {
       extensions: readonly string[];
     }>;
   };
+  /** OSV.dev, for --osv (decision D-129). */
+  osv: OsvKnowledge;
   python: {
     /** How Python package names are compared: lowercased, with every run of these characters replaced by `replacement`. */
     nameNormalization: Fact<{
@@ -969,7 +1095,7 @@ interface EnvironmentKnowledge {
     }>;
   };
 }
-type PackageManagerId = Extract<ToolId, 'npm' | 'pnpm' | 'yarn' | 'bun' | 'deno' | 'uv' | 'pip' | 'poetry' | 'pdm' | 'pipenv'>;
+type PackageManagerId = Extract<ToolId, 'npm' | 'pnpm' | 'yarn' | 'bun' | 'deno' | 'uv' | 'pip' | 'poetry' | 'pdm' | 'pipenv' | 'composer'>;
 type BotId = Extract<ToolId, 'renovate' | 'dependabot'>;
 /** Why a package manager is considered in use. Ordered from the strongest signal. */
 type EvidenceKind = 'lockfile' | 'packageManager' | 'devEngines' | 'config' | 'ci' | 'default';
@@ -1032,11 +1158,22 @@ interface ToolCommand {
   lockfile?: true;
   /** npm runs it with dependency install scripts off (--ignore-scripts, npm_config_ignore_scripts=true; decision D-115). */
   scriptsOff?: true;
+  /**
+   * npm install: its command line and variables leave out optional dependencies (--omit=optional, --no-optional,
+   * npm_config_omit=optional) or keep them whatever .npmrc says (--include=optional); absent when they do not say
+   * (decision D-127).
+   */
+  optionalDependencies?: 'omitted' | 'kept';
   /** pip install: the release-age delay it gets, as written (--uploaded-prior-to, PIP_UPLOADED_PRIOR_TO; decision D-115). */
   delay?: string;
   /** pip install: PIP_CONFIG_FILE names a file that may set the delay, or the value is a variable depcurfew does not read. */
   delayUnknown?: true;
   line: number;
+  /**
+   * A command that installs or runs Corepack comes before it in the same job (an earlier run step, or earlier in its
+   * own) or Dockerfile stage (an earlier RUN, or earlier in its own), also on the same line (decision D-141).
+   */
+  afterCorepack?: true;
   /**
    * github-actions: the working directory of the run step as written (working-directory of the step, or
    * defaults.run.working-directory of the job or the workflow), without ./ and a trailing /, joined with the literal
@@ -1061,6 +1198,8 @@ interface WorkflowJob {
    * release-age delay of its pip installs cannot be told (decision D-115).
    */
   pipConfig?: true;
+  /** The line of the first run step command that installs Corepack (npm install -g corepack) or runs it (decision D-128). */
+  corepack?: number;
 }
 /** The official runtime image a build stage starts from. */
 interface StageRuntime {
@@ -1086,6 +1225,8 @@ interface DockerStage {
   commands: ToolCommand[];
   /** A RUN may change pip's configuration (pip config set, a pip.conf it writes), as for jobs (decision D-115). */
   pipConfig?: true;
+  /** The line of the first RUN command that installs Corepack (npm install -g corepack) or runs it (decision D-128). */
+  corepack?: number;
   /**
    * The source paths of the stage's COPY and ADD instructions that copy from the build context (not --from), as
    * written; absent when there are none. A root Dockerfile whose stage copies only files of one directory listed in
@@ -1129,6 +1270,13 @@ interface DetectionWarning {
 }
 interface Detection {
   packageManagers: PackageManagerInfo[];
+  /**
+   * Detected with the directories listed in projects (decision D-137): package managers only CI setup steps of the root
+   * show, while the root holds no manifest of their registry, or every install with them in its workflows runs in a
+   * listed directory and no Dockerfile of the root installs with them. The steps set them up for the projects, so they
+   * are no package managers of the root; the versions the steps install are still checked. Absent when there are none.
+   */
+  ciForProjects?: PackageManagerInfo[];
   node: {
     versions: VersionDeclaration[];
   };
@@ -1154,10 +1302,13 @@ interface UserEnvironment {
   /** Whether a directory exists; replaceable in tests. */
   isDirectory?: (path: string) => boolean;
 }
+/** fetch as depcurfew calls it: a GET of a registry or index, or the POST of a batch query to OSV.dev (--osv, decision D-129). */
 type FetchLike = (url: string, init: {
   headers: Record<string, string>;
   signal: AbortSignal;
   redirect?: 'manual';
+  method?: 'POST';
+  body?: string;
 }) => Promise<Response>;
 /**
  * Lookups shared by the checks of one run, by registry or index and name: a command checked against two policies
@@ -1178,9 +1329,9 @@ interface McpLimits {
   /** How long calls may still run after stdin ends before they are stopped. */
   graceMs: number;
 }
-declare const EXIT_OK = 0;
-declare const EXIT_FAILURE = 1;
-declare const EXIT_USAGE = 2;
+export declare const EXIT_OK = 0;
+export declare const EXIT_FAILURE = 1;
+export declare const EXIT_USAGE = 2;
 interface CliIo {
   stdout(text: string): void;
   stderr(text: string): void;
@@ -1243,8 +1394,8 @@ type DurationResult = {
   message: string;
 };
 /** Writes minutes with the largest unit that represents them exactly, e.g. 2160 → "36h". */
-declare function formatDuration(minutes: number): string;
-declare function parseDuration(input: string): DurationResult;
+export declare function formatDuration(minutes: number): string;
+export declare function parseDuration(input: string): DurationResult;
 interface Issue {
   /** Path to the field, e.g. `cooldown.exclude[2]`; `(root)` for the document itself. */
   path: string;
@@ -1293,12 +1444,6 @@ type Output<S> = S extends Shape<unknown, infer Out> ? Out : never;
 declare const FAIL_ON_LEVELS: readonly ["error", "warning"];
 declare const policyShape: Shape<{
   version: 1;
-  $schema?: string;
-  cooldown?: {
-    minimum: string;
-    exclude?: readonly string[];
-    securityUpdates?: "bypass" | "delay";
-  };
   installScripts?: {
     default: "allow" | "deny";
     allow?: readonly string[];
@@ -1310,6 +1455,12 @@ declare const policyShape: Shape<{
     file?: "allow" | "deny";
     directory?: "allow" | "deny";
   };
+  $schema?: string;
+  cooldown?: {
+    minimum: string;
+    exclude?: readonly string[];
+    securityUpdates?: "bypass" | "delay";
+  };
   targets?: "auto" | readonly ToolId[];
   projects?: readonly string[];
   doctor?: {
@@ -1319,12 +1470,6 @@ declare const policyShape: Shape<{
   version: 1;
   targets: "auto" | readonly ToolId[];
   projects: readonly string[];
-  $schema?: string;
-  cooldown?: {
-    minimum: Duration;
-    exclude: readonly string[];
-    securityUpdates: "bypass" | "delay";
-  };
   installScripts?: {
     default: "allow" | "deny";
     allow: readonly string[];
@@ -1336,6 +1481,12 @@ declare const policyShape: Shape<{
     file?: "allow" | "deny";
     directory?: "allow" | "deny";
   };
+  $schema?: string;
+  cooldown?: {
+    minimum: Duration;
+    exclude: readonly string[];
+    securityUpdates: "bypass" | "delay";
+  };
   doctor?: {
     failOn?: "error" | "warning";
   };
@@ -1344,6 +1495,159 @@ declare const policyShape: Shape<{
 type Policy = Input<typeof policyShape>;
 /** The policy after validation: defaults filled in, durations parsed. */
 type ResolvedPolicy = Output<typeof policyShape>;
+interface SimilarName {
+  /** The popular package the name resembles. */
+  match: string;
+  /** edit: a letter or two differ; separators: only -, _ or . differ. */
+  reason: 'edit' | 'separators';
+}
+export declare class PopularNames {
+  #private;
+  constructor(names: readonly string[]);
+  has(name: string): boolean;
+  /** The popular package `name` resembles, or undefined (also when `name` is itself popular). */
+  similar(name: string): SimilarName | undefined;
+}
+type SpecKind = 'registry' | 'git' | 'remoteTarball' | 'file' | 'directory' | 'workspace' | 'other';
+type FindingCode = 'invalid-spec' | 'forbidden-source' | 'unchecked-source' | 'unverified' | 'not-found' | 'no-version' | 'too-young' | 'install-scripts' | 'similar-name' | 'deprecated' | 'yanked' | 'archived' | 'quarantined' | 'insecure-registry' |
+/** --osv: OSV.dev has a record of the OpenSSF malicious-packages database for the version (decision D-129). */
+'known-malicious';
+interface CheckFinding {
+  level: 'error' | 'warning';
+  code: FindingCode;
+  message: string;
+  /** What to do about it. */
+  fix: string;
+}
+interface PackageReport {
+  spec: string;
+  kind: SpecKind | 'invalid';
+  name?: string;
+  version?: string;
+  publishedAt?: string;
+  latest?: {
+    version: string;
+    publishedAt?: string;
+  };
+  /** npm: the dist-tag the version was picked by, when it is not the default one (--tag, npm_config_tag, tag in .npmrc). */
+  tag?: string;
+  /** Python: pre-releases allowed or forbidden by the command. */
+  prereleases?: 'allow' | 'deny';
+  /** Python: the command builds the package from source (true) or installs wheels only (false). */
+  buildFromSource?: boolean;
+  findings: CheckFinding[];
+}
+/** A spec with what the install command changes about the version or the build. */
+interface CheckRequest {
+  spec: string;
+  /** The package manager of the command, when a command names one (the hook): its own registry settings apply. */
+  tool?: ToolId;
+  /** npm: the dist-tag npm prefers for a name without a version or with a range; the registry's default when left out. */
+  tag?: string;
+  /** The package manager is not npm, so tag= in .npmrc (CheckOptions.defaultTag) does not choose its version. */
+  ignoresConfigTag?: boolean;
+  /** Python: pre-releases allowed or forbidden; PEP 440's default when left out. */
+  prereleases?: 'allow' | 'deny';
+  /** Python: the package is built from source even when it has wheels (true), or only wheels are used (false). */
+  buildFromSource?: boolean;
+  /**
+   * npm: the command line has an option that may set workspaces (--no-workspaces, --workspaces=false), with which npm
+   * reads the .npmrc of a workspace package as its project configuration (decision D-124).
+   */
+  workspacesOption?: boolean;
+  /**
+   * Composer (decision D-133): the command does not read the composer.json of the directory it runs in (create-project,
+   * global), so the repositories declared there do not apply to it.
+   */
+  readsManifest?: false;
+  /**
+   * Composer: composer update names the package without a constraint, so the constraint the root composer.json
+   * requires applies; a package that composer.json does not require is not checked.
+   */
+  fromManifest?: true;
+  /**
+   * Composer (decision D-136): the command word as written and the command of Composer it stands for, when it is not
+   * that command's exact name (an alias, an abbreviation, another case), so that the scripts of the composer.json the
+   * command runs with, which Composer then registers as commands, may make it stand for a script or for nothing.
+   */
+  composerCommand?: {
+    word: string;
+    command: string;
+  };
+  /**
+   * Composer: picks the version at the minimum stability stable, without the minimum-stability and prefer-stable of
+   * the root composer.json, for a file of a parent directory that Composer may not use (decision D-142).
+   */
+  rootStability?: false;
+}
+interface CheckOptions {
+  policy: ResolvedPolicy;
+  fetch: FetchLike;
+  now: Date;
+  registry: string;
+  popular: PopularNames;
+  /** Registries the project assigns to scopes (@scope:registry in .npmrc); those packages are not looked up. */
+  scopeRegistries?: ReadonlyMap<string, string>;
+  /** The Python package index pypi: packages are looked up in; PyPI when not given. */
+  index?: string;
+  /** Popular Python projects, by normalized name, for look-alike names. */
+  popularPython?: PopularNames;
+  /** npm: the dist-tag npm prefers when a request names none (tag in .npmrc); the registry's default when left out. */
+  defaultTag?: string;
+  /**
+   * Whether a finding about install scripts quotes them (the default) or names them only, for the hook: their body is
+   * written by the package's publisher and should not reach the model as part of depcurfew's reason.
+   */
+  scriptBodies?: boolean;
+  /** Stops the lookups: checkSpecs then rejects with the signal's reason (a cancelled call of depcurfew mcp). */
+  signal?: AbortSignal;
+  /** Lookups shared with other checks of the same run (the two policies of the hook), by registry and name. */
+  lookups?: LookupCache;
+  /**
+   * npm packages not to look up: their scope's registry is set in a file depcurfew does not take (decision D-113), so
+   * the name may be private and the public registry may hold a look-alike. The package is reported as unverified.
+   */
+  skipLookup?: (name: string, tool: ToolId | undefined, request?: Omit<CheckRequest, 'spec'>) => boolean;
+  /**
+   * Composer: minimum-stability and prefer-stable of the root composer.json (decision D-136), for the requests that read
+   * it; without them, the defaults (stable, prefer-stable off).
+   */
+  composerStability?: {
+    minimum?: string;
+    preferStable: boolean;
+    file: string;
+  };
+}
+/** A package version to look up; `ecosystem` is depcurfew's (npm, pypi, packagist), whose names the policy writes without a prefix, with pypi: and with composer:. */
+interface OsvPackage {
+  ecosystem: string;
+  name: string;
+  version: string;
+}
+/** What OSV.dev says about one version: the ids of its MAL- records (none: no known malware), or why it was not checked. */
+type OsvVerdict = {
+  status: 'checked';
+  malicious: string[];
+} | {
+  status: 'unchecked';
+  reason: string;
+};
+interface OsvOptions {
+  fetch: FetchLike;
+  signal?: AbortSignal | undefined;
+  /** Per request; OSV_TIMEOUT_MS when left out. */
+  timeoutMs?: number;
+  /** Largest answer read; the response limit of OSV.dev over HTTP/1.1 when left out. */
+  maxBytes?: number;
+  /** Most distinct versions looked up in one run; the others stay unchecked. MAX_OSV_PACKAGES when left out. */
+  limit?: number;
+}
+/**
+ * What OSV.dev says about each package version, in the order given. Each distinct version is asked about once; the
+ * batches go one after the other, and once one fails the rest is not asked (OSV.dev is out of reach, or answers
+ * wrong), so every version left is unchecked with that reason. When `options.signal` aborts, the promise rejects.
+ */
+export declare function queryOsv(packages: readonly OsvPackage[], options: OsvOptions): Promise<OsvVerdict[]>;
 /** The SARIF levels: an error fails `doctor`, warnings and notes do not. */
 type Level = 'error' | 'warning' | 'note';
 interface Location {
@@ -1406,7 +1710,18 @@ interface RuleContext {
   projects?: readonly ProjectView[];
   /** How apply plans this directory, for the rules that compare with that plan (config-drift). */
   plan?: PlanOptions;
+  /** doctor --osv (decision D-129): absent without it; see OsvDoctor. */
+  osv?: OsvDoctor;
 }
+/**
+ * What known-malicious gets with --osv: a list to fill with the locked versions (the first run, before OSV.dev is
+ * asked), or the answers of OSV.dev by osvKey (the second run, which reports).
+ */
+type OsvDoctor = {
+  collect: OsvPackage[];
+} | {
+  answers: ReadonlyMap<string, OsvVerdict>;
+};
 /** A directory listed in projects, as the rules at the repository root see it. */
 interface ProjectView {
   /** Relative to the repository root, as listed. */
@@ -1452,6 +1767,8 @@ interface CheckedTool {
   versionFrom?: string;
   /** A bot configuration in a directory listed in projects, which the bot does not read (it reads the root's, decision D-109). */
   unread?: true;
+  /** A package manager that a CI setup step of the root sets up for the directories listed in projects (decisions D-137 and D-141). */
+  setUpInCi?: true;
 }
 /** One check of the list of what doctor checked: a rule and what came of it. */
 interface RuleResult {
@@ -1501,7 +1818,7 @@ interface RootPlaces {
     stages: readonly number[];
   }[];
 }
-declare const APPLY_WARNINGS: {
+export declare const APPLY_WARNINGS: {
   readonly 'nothing-to-configure': "depcurfew found no supported package manager or bot, so nothing is configured.";
   readonly 'environment-overrides': "apply --user: an environment variable makes a tool read another user file or none, or overrides a value apply writes there.";
   readonly 'depcurfew-outdated': "The project installs a newer depcurfew than the one running, which may not know settings that version writes.";
@@ -1523,12 +1840,15 @@ declare const APPLY_WARNINGS: {
   readonly 'cooldown-environment-only': "pip reads no project configuration, so the release-age delay has to be set in the environment where pip runs.";
   readonly 'exclude-pattern-unsupported': "A cooldown exception uses a wildcard the tool does not support, so it is not written.";
   readonly 'exclude-unsupported': "The tool has no setting for cooldown exceptions, so the release-age delay applies to every package.";
+  readonly 'exclude-not-written': "The setting that holds the cooldown exceptions (Composer's config.policy.cooldown.ignore) has a value of a type the tool does not accept there, so apply leaves it as it is and does not add the exceptions; the release-age delay is written.";
+  readonly 'exclude-entry-outside-policy': "A cooldown exception in a file without depcurfew's markers (Composer's config.policy.cooldown.ignore) exempts a package that cooldown.exclude does not; apply removes only the entries it wrote, recognised by their reason, and leaves this one.";
   readonly 'allow-pattern-unsupported': "An installScripts.allow entry is a pattern, but the tool takes package names only, so it is not written.";
   readonly 'deny-pattern-unsupported': "An installScripts.deny entry is a pattern, but the tool records denials by package name only, so it is not written.";
   readonly 'allow-all-unsupported': "The tool has no setting that allows every install script, so installScripts \"allow\" is not written.";
-  readonly 'allow-all-replaced': "A setting that allowed every install script (with any value the tool reads as true, also one that a YAML merge key brings in, or pnpm 10's dangerously-allow-all-builds in .npmrc) was set to false, because the policy denies install scripts.";
+  readonly 'allow-all-replaced': "A setting that allowed every install script (with any value the tool reads as true, also one that a YAML merge key brings in, or pnpm 10's dangerously-allow-all-builds in .npmrc) was set to false, or replaced with the policy's allow-list where the setting is the list itself (Deno's allowScripts, Composer's allow-plugins, which then may be {}), because the policy denies install scripts.";
   readonly 'allow-list-entry-outside-policy': "An install-script allow-list in the repository (with apply --user, in a user file) lets a package run scripts the policy does not allow; apply does not remove it.";
   readonly 'deny-conflicts-with-file': "An entry in a tool's own list lets a package of installScripts.deny run its install scripts, or blocks a package of installScripts.allow; apply does not change entries it did not write.";
+  readonly 'deny-needs-optional-dependencies': "A package of installScripts.deny takes its binary from an optional dependency (esbuild), but npm leaves optional dependencies out (omit=optional or optional=false in .npmrc, --omit=optional or --no-optional on an install of a CI job or Dockerfile, NPM_CONFIG_OMIT=optional), so the package cannot find its binary after that install.";
   readonly 'unexpected-value': "A setting apply adds to has a value of a type the tool does not accept there, so apply leaves it as it is and writes nothing into it.";
   readonly 'built-in-list-replaced': "Bun's built-in list of trusted packages is replaced by the policy's allow-list.";
   readonly 'scripts-not-enforceable': "The pinned (with apply --user, the installed) npm or pnpm, or another npm the repository runs (one a declared Node.js comes with, or a CI job or Dockerfile installs), runs every install script and has no allow-list, so \"deny\" cannot be enforced; also given for an npm the repository runs whose version depcurfew cannot tell, which counts as one that runs them.";
@@ -1543,16 +1863,17 @@ declare const APPLY_WARNINGS: {
   readonly 'build-switch-install-only': "Poetry applies its build switch when installing; poetry lock may still build source distributions.";
   readonly 'build-switch-environment-only': "The tool has no project setting that forbids building from source, so it has to be set in the environment where the tool runs.";
   readonly 'requirements-file-missing': "There is no requirements file to write pip options into.";
-  readonly 'manifest-missing': "A setting belongs in a project manifest (package.json, deno.json, pyproject.toml, Pipfile) that does not exist, and apply does not create manifests.";
+  readonly 'manifest-missing': "A setting belongs in a project manifest (package.json, deno.json, pyproject.toml, Pipfile, composer.json) that does not exist, and apply does not create manifests.";
   readonly 'lockfile-out-of-date': "The lockfile records, or is checked against, a setting apply changed, so it has to be locked again.";
   readonly 'file-ignored-by-git': "A file apply writes matches a .gitignore rule, so the change may never reach the repository.";
   readonly 'bot-config-missing': "A bot has no configuration file, and depcurfew does not create one.";
   readonly 'bot-config-not-edited': "A bot configuration file is in a place or format depcurfew does not edit; a snippet shows what to add.";
   readonly 'bot-entries-missing': "The Dependabot configuration has no entries for the package managers in use.";
-  readonly 'bot-rule-shortens-delay': "A Renovate packageRules entry apply does not manage gives every package of a registry, or some update types, a shorter release-age delay than the one apply writes; Renovate uses it, and apply does not change it.";
+  readonly 'bot-config-unreadable': "The Dependabot configuration uses a YAML alias, which Dependabot does not accept, so it reads no configuration from the file (the cooldown apply writes included), and depcurfew does not read the delays the file sets.";
+  readonly 'bot-rule-shortens-delay': "A Renovate packageRules entry apply does not manage gives every package of a registry, Renovate manager or category in use, or the actions of the workflows, or some update types of them, a shorter release-age delay than the one apply writes; Renovate uses it, and apply does not change it.";
   readonly 'security-delay-unsupported': "Dependabot cannot delay security updates, so securityUpdates \"delay\" is not applied.";
 };
-declare const APPLY_ERRORS: {
+export declare const APPLY_ERRORS: {
   readonly 'cannot-edit': "A file cannot be read or edited safely (invalid syntax, a symlink, a style depcurfew does not edit), so nothing is written.";
   readonly 'cannot-write': "A file cannot be written (no permission, a read-only file system, a full disk, a directory or symlink in its place); the files already written are put back, so nothing changes.";
   readonly 'policy-missing': "The directory has no depcurfew.json.";
@@ -1589,7 +1910,7 @@ interface ApplyWarning {
   fix?: string;
 }
 /** A warning as one line of text, as ApplyReport.warnings has it. */
-declare function warningText(warning: ApplyWarning): string;
+export declare function warningText(warning: ApplyWarning): string;
 interface FileChange {
   /** Repository-relative path with `/` separators. */
   file: string;
@@ -1631,6 +1952,8 @@ interface EditFailure {
   tool: ToolId;
   file: string;
   message: string;
+  /** What to do, when the generic fix of cannot-edit does not say it. */
+  fix?: string;
 }
 /** Why a directory listed in projects cannot be used; nothing is written and doctor reports it (invalid-project). */
 interface ProjectProblem {
@@ -1696,12 +2019,12 @@ interface PlanOptions {
   root?: RootPlaces;
 }
 /** The bots' delay: the policy's, or longer if a package manager rounded its delay up further. */
-declare function botDuration(policy: Duration, managerMinutes: readonly number[]): Duration;
+export declare function botDuration(policy: Duration, managerMinutes: readonly number[]): Duration;
 /**
  * Computes every change of one directory without writing anything. With projects in the policy, `options` says which
  * part of the repository this directory is (planRepository plans them all).
  */
-declare function planApply(root: string, policy: ResolvedPolicy, detection: Detection, tools?: readonly ToolKnowledge[], options?: PlanOptions): ApplyReport;
+export declare function planApply(root: string, policy: ResolvedPolicy, detection: Detection, tools?: readonly ToolKnowledge[], options?: PlanOptions): ApplyReport;
 /**
  * Plans the whole repository: the root as planApply does, and each directory listed in projects as a project of its
  * own with the same policy (decision D-100). Bots are configured only from the root, with a delay at least as long
@@ -1709,8 +2032,8 @@ declare function planApply(root: string, policy: ResolvedPolicy, detection: Dete
  * used is an error (`problems`), so that nothing is written; the other directories are still planned, so one run
  * reports everything.
  */
-declare function planRepository(root: string, policy: ResolvedPolicy, tools?: readonly ToolKnowledge[], rootDetection?: Detection): ApplyReport;
-declare class PolicyError extends Error {
+export declare function planRepository(root: string, policy: ResolvedPolicy, tools?: readonly ToolKnowledge[], rootDetection?: Detection): ApplyReport;
+export declare class PolicyError extends Error {
   readonly issues: string[];
   readonly code: ApplyErrorCode;
   /** What to do, when the message does not say it. */
@@ -1721,12 +2044,12 @@ declare class PolicyError extends Error {
   /** The message and what to do, as one line of text. */
   get text(): string;
 }
-declare function loadPolicy(root: string): ResolvedPolicy;
+export declare function loadPolicy(root: string): ResolvedPolicy;
 /**
  * A file could not be written (code cannot-write). The files apply had already replaced were put back, so the
  * repository is as it was, unless `unrestored` lists files. `report` is the plan that was being written.
  */
-declare class ApplyWriteError extends Error {
+export declare class ApplyWriteError extends Error {
   readonly code: "cannot-write";
   /** The file that could not be written, relative to the repository. */
   readonly file: string;
@@ -1749,104 +2072,16 @@ declare class ApplyWriteError extends Error {
  * could not be edited, nothing is written, so a run either applies the whole policy or leaves the repository as it was.
  * A file that cannot be written throws ApplyWriteError after the files already written are put back.
  */
-declare function applyProject(root: string, options?: {
+export declare function applyProject(root: string, options?: {
   write?: boolean;
   beforeWrite?: () => void;
 }): ApplyReport;
-interface SimilarName {
-  /** The popular package the name resembles. */
-  match: string;
-  /** edit: a letter or two differ; separators: only -, _ or . differ. */
-  reason: 'edit' | 'separators';
-}
-declare class PopularNames {
-  #private;
-  constructor(names: readonly string[]);
-  has(name: string): boolean;
-  /** The popular package `name` resembles, or undefined (also when `name` is itself popular). */
-  similar(name: string): SimilarName | undefined;
-}
-type SpecKind = 'registry' | 'git' | 'remoteTarball' | 'file' | 'directory' | 'workspace' | 'other';
-type FindingCode = 'invalid-spec' | 'forbidden-source' | 'unchecked-source' | 'unverified' | 'not-found' | 'no-version' | 'too-young' | 'install-scripts' | 'similar-name' | 'deprecated' | 'yanked' | 'archived' | 'quarantined' | 'insecure-registry';
-interface CheckFinding {
-  level: 'error' | 'warning';
-  code: FindingCode;
-  message: string;
-  /** What to do about it. */
-  fix: string;
-}
-interface PackageReport {
-  spec: string;
-  kind: SpecKind | 'invalid';
-  name?: string;
-  version?: string;
-  publishedAt?: string;
-  latest?: {
-    version: string;
-    publishedAt?: string;
-  };
-  /** npm: the dist-tag the version was picked by, when it is not the default one (--tag, npm_config_tag, tag in .npmrc). */
-  tag?: string;
-  /** Python: pre-releases allowed or forbidden by the command. */
-  prereleases?: 'allow' | 'deny';
-  /** Python: the command builds the package from source (true) or installs wheels only (false). */
-  buildFromSource?: boolean;
-  findings: CheckFinding[];
-}
-/** A spec with what the install command changes about the version or the build. */
-interface CheckRequest {
-  spec: string;
-  /** The package manager of the command, when a command names one (the hook): its own registry settings apply. */
-  tool?: ToolId;
-  /** npm: the dist-tag npm prefers for a name without a version or with a range; the registry's default when left out. */
-  tag?: string;
-  /** The package manager is not npm, so tag= in .npmrc (CheckOptions.defaultTag) does not choose its version. */
-  ignoresConfigTag?: boolean;
-  /** Python: pre-releases allowed or forbidden; PEP 440's default when left out. */
-  prereleases?: 'allow' | 'deny';
-  /** Python: the package is built from source even when it has wheels (true), or only wheels are used (false). */
-  buildFromSource?: boolean;
-  /**
-   * npm: the command line has an option that may set workspaces (--no-workspaces, --workspaces=false), with which npm
-   * reads the .npmrc of a workspace package as its project configuration (decision D-124).
-   */
-  workspacesOption?: boolean;
-}
-interface CheckOptions {
-  policy: ResolvedPolicy;
-  fetch: FetchLike;
-  now: Date;
-  registry: string;
-  popular: PopularNames;
-  /** Registries the project assigns to scopes (@scope:registry in .npmrc); those packages are not looked up. */
-  scopeRegistries?: ReadonlyMap<string, string>;
-  /** The Python package index pypi: packages are looked up in; PyPI when not given. */
-  index?: string;
-  /** Popular Python projects, by normalized name, for look-alike names. */
-  popularPython?: PopularNames;
-  /** npm: the dist-tag npm prefers when a request names none (tag in .npmrc); the registry's default when left out. */
-  defaultTag?: string;
-  /**
-   * Whether a finding about install scripts quotes them (the default) or names them only, for the hook: their body is
-   * written by the package's publisher and should not reach the model as part of depcurfew's reason.
-   */
-  scriptBodies?: boolean;
-  /** Stops the lookups: checkSpecs then rejects with the signal's reason (a cancelled call of depcurfew mcp). */
-  signal?: AbortSignal;
-  /** Lookups shared with other checks of the same run (the two policies of the hook), by registry and name. */
-  lookups?: LookupCache;
-  /**
-   * npm packages not to look up: their scope's registry is set in a file depcurfew does not take (decision D-113), so
-   * the name may be private and the public registry may hold a look-alike. The package is reported as unverified.
-   */
-  skipLookup?: (name: string, tool: ToolId | undefined, request?: Omit<CheckRequest, 'spec'>) => boolean;
-}
-declare function checkSpec(request: string | CheckRequest, options: CheckOptions): Promise<PackageReport>;
+export declare function checkSpec(request: string | CheckRequest, options: CheckOptions): Promise<PackageReport>;
 /**
  * Checks the specs a few at a time; the reports keep the order of the specs. When `options.signal` aborts, no further
  * spec is looked up and the promise rejects with the signal's reason.
  */
-declare function checkSpecs(specs: readonly (string | CheckRequest)[], options: CheckOptions): Promise<PackageReport[]>;
+export declare function checkSpecs(specs: readonly (string | CheckRequest)[], options: CheckOptions): Promise<PackageReport[]>;
 interface Paint {
   red(text: string): string;
   yellow(text: string): string;
@@ -1866,11 +2101,16 @@ interface CheckDependencies {
   projectDir?: () => string | undefined;
   /** --user: platform, home directory and environment variables (tests replace them). */
   userEnvironment?: () => UserEnvironment;
+  /**
+   * The platform the hook runs on: on Windows a POSIX shell (Git Bash) hands its variables to programs that do not tell
+   * their names apart by case (decision D-143); tests replace it.
+   */
+  platform?: () => NodeJS.Platform;
   /** depcurfew mcp: the streams the server talks over, its environment and signals (tests replace them). */
   mcpProcess?: () => McpProcess;
 }
-declare function run(argv: readonly string[], output: CliIo, dependencies?: CheckDependencies): Promise<number>;
-declare function getVersion(): string;
+export declare function run(argv: readonly string[], output: CliIo, dependencies?: CheckDependencies): Promise<number>;
+export declare function getVersion(): string;
 interface DiffOptions {
   /** Shows the values of secrets as <redacted> in every line (redactSecrets), for a diff that people or logs see. */
   redact?: boolean;
@@ -1881,7 +2121,7 @@ interface DiffOptions {
  * and forge a header or a hunk. A file with an absolute path (a user file outside the home directory) is named as it
  * is, without the a/ and b/ of repository paths.
  */
-declare function unifiedDiff(file: string, before: string | null, after: string, context?: number, options?: DiffOptions): string;
+export declare function unifiedDiff(file: string, before: string | null, after: string, context?: number, options?: DiffOptions): string;
 /**
  * Where a command runs, relative to the directory the command line starts in: the directories it changes to, in order
  * (an absolute one starts over). `localPrefix`: npm --prefix names npm's local prefix, whose .npmrc npm reads without
@@ -1993,6 +2233,15 @@ interface InstallRequest {
   buildFromSource?: boolean;
   /** Where the install runs, when the command changes directory before it or moves it with an option (decision D-118). */
   directory?: CommandDirectory;
+  /** Composer: the command does not read the composer.json of the directory it runs in (create-project, global; decision D-133). */
+  readsManifest?: false;
+  /** Composer: composer update names the package without a constraint, so the one of the root composer.json applies. */
+  fromManifest?: true;
+  /** Composer: the command word, when the scripts of composer.json may change the command it stands for (decision D-136). */
+  composerCommand?: {
+    word: string;
+    command: string;
+  };
 }
 /** An option or variable of a command that weakens the release-age delay or the rule on install scripts (installOverrides). */
 interface Override {
@@ -2002,10 +2251,16 @@ interface Override {
   /** As written: --min-release-age=0, npm_config_ignore_scripts=false. */
   written: string;
   weakens: OverrideSwitch['weakens'];
+  /** protection: what it turns off (OverrideSwitch.effect). */
+  effect?: string;
+  /** protection: what that protection does, when it covers less than every package the command fetches (OverrideSwitch.protects). */
+  protects?: string;
   /** The delay it sets, to compare with the policy; left out when any value weakens it. */
   delay?: string;
   /** The shell expands its value. */
   expanded?: boolean;
+  /** A shell builtin or another form sets it, whose value depcurfew does not read (decision D-143); written is the name. */
+  unread?: true;
   /** Where its command runs, when that is not where the command line starts (decision D-118). */
   directory?: CommandDirectory;
 }
@@ -2025,16 +2280,21 @@ interface CommandScan {
 interface ScanOptions {
   /** The shell that runs the line: a POSIX shell (the default; also Git Bash) or PowerShell. */
   shell?: 'posix' | 'powershell';
+  /**
+   * The line runs on Windows (by default where depcurfew runs), whose programs do not tell the names of environment
+   * variables apart by case, so a POSIX shell's Composer=… sets COMPOSER there too (decision D-143).
+   */
+  windows?: boolean;
 }
 /** The packages a command line installs or downloads to run with npm, pnpm, Yarn, Bun, Deno, pip, uv, Poetry, PDM, Pipenv or pipx. */
-declare function scanCommandLine(line: string, options?: ScanOptions): CommandScan;
-/**
- * Describes the repository at `root`. Never executes anything from the repository and never leaves it;
- * problems with individual files become warnings.
- */
-declare function detectProject(root: string, tools?: readonly ToolKnowledge[], environment?: EnvironmentKnowledge): Detection;
+export declare function scanCommandLine(line: string, options?: ScanOptions): CommandScan;
+interface DetectOptions {
+  /** The directories listed in projects in depcurfew.json, relative to the root (decision D-137). */
+  projects?: readonly string[];
+}
+export declare function detectProject(root: string, tools?: readonly ToolKnowledge[], environment?: EnvironmentKnowledge, options?: DetectOptions): Detection;
 /** Every doctor rule, in the order they are documented. unreadable-config runs last, after every other rule has read its files. */
-declare const RULES: readonly Rule[];
+export declare const RULES: readonly Rule[];
 type FailOn = (typeof FAIL_ON_LEVELS)[number];
 /** Where the setting came from: the command line (or the Action input), doctor.failOn of the policy, or neither. */
 type FailOnFrom = 'option' | 'policy' | 'default';
@@ -2046,12 +2306,12 @@ interface FailOnSetting {
   /** from policy: the policy file as messages show it, e.g. depcurfew.json. */
   file?: string;
 }
-declare function countLevels(findings: readonly Finding[]): Record<'error' | 'warning' | 'note', number>;
+export declare function countLevels(findings: readonly Finding[]): Record<'error' | 'warning' | 'note', number>;
 /**
  * `failOn`: which findings fail doctor and where that was set (decision D-112); when warnings make it fail, a line under
  * the counts says why, with how to fail on errors only. `strict` alone (before D-112) adds STRICT_NOTE.
  */
-declare function renderText(report: DoctorReport, rules: readonly Rule[], colors?: Paint, options?: {
+export declare function renderText(report: DoctorReport, rules: readonly Rule[], colors?: Paint, options?: {
   strict?: boolean;
   failOn?: FailOnSetting;
 }): string;
@@ -2063,7 +2323,7 @@ interface SarifError {
   message: string;
   fix?: string;
 }
-declare function toSarif(report: DoctorReport, rules: readonly Rule[], version: string, readLine?: LineReader, errors?: readonly SarifError[]): object;
+export declare function toSarif(report: DoctorReport, rules: readonly Rule[], version: string, readLine?: LineReader, errors?: readonly SarifError[]): object;
 /**
  * Runs the rules on a repository. When depcurfew.json exists but is invalid, it throws PolicyError, or with
  * invalidPolicy: 'report' runs the rules that need no policy and reports the problems as an invalid-policy finding.
@@ -2071,12 +2331,18 @@ declare function toSarif(report: DoctorReport, rules: readonly Rule[], version:
  * policy, the rules also run on every listed directory with the same policy, and the report covers them all, with
  * paths relative to the root (decision D-100).
  */
-declare function runDoctor(root: string, options?: {
+export declare function runDoctor(root: string, options?: {
   rules?: readonly Rule[];
   tools?: readonly ToolKnowledge[];
   invalidPolicy?: 'throw' | 'report';
   policy?: ResolvedPolicy | null;
+  osv?: OsvDoctor;
 }): DoctorReport;
+/**
+ * runDoctor with known-malicious: the locked versions are looked up in OSV.dev first. Throws PolicyError as runDoctor
+ * does for an invalid depcurfew.json, unless asked to report it.
+ */
+export declare function runDoctorWithOsv(root: string, options: Omit<Parameters<typeof runDoctor>[1] & object, 'osv'>, osv: OsvOptions): Promise<DoctorReport>;
 type NumericDelayUnit = Exclude<DelayUnit, 'duration-string'>;
 declare const DURATION_STRING_UNITS: readonly ["minutes", "hours", "days", "weeks"];
 type DurationStringUnit = (typeof DURATION_STRING_UNITS)[number];
@@ -2097,19 +2363,19 @@ type CooldownConversion = {
   reason: string;
   fix: string;
 };
-declare function convertMinutes(minutes: number, unit: NumericDelayUnit): Converted<number>;
+export declare function convertMinutes(minutes: number, unit: NumericDelayUnit): Converted<number>;
 /** Writes minutes as a duration string such as `36 hours` or `3 days`. */
-declare function toDurationString(minutes: number, units: readonly DurationStringUnit[]): Converted<string>;
+export declare function toDurationString(minutes: number, units: readonly DurationStringUnit[]): Converted<string>;
 /**
  * Converts the policy's minimum release age into the value for one tool. When official sources disagree on the
  * unit, the smallest unit wins: its larger number is long enough under every reading.
  */
-declare function convertCooldown(tool: ToolKnowledge, duration: Duration): CooldownConversion;
-declare const POLICY_FILE = "depcurfew.json";
+export declare function convertCooldown(tool: ToolKnowledge, duration: Duration): CooldownConversion;
+export declare const POLICY_FILE = "depcurfew.json";
 /** Where the published package serves schema.json; init writes it into `$schema`. */
-declare const SCHEMA_URL = "https://unpkg.com/depcurfew/schema.json";
+export declare const SCHEMA_URL = "https://unpkg.com/depcurfew/schema.json";
 /** What `depcurfew init` writes. Every section is explicit, so the file shows what can be configured. */
-declare const DEFAULT_POLICY: {
+export declare const DEFAULT_POLICY: {
   readonly $schema: "https://unpkg.com/depcurfew/schema.json";
   readonly version: 1;
   readonly cooldown: {
@@ -2133,7 +2399,7 @@ declare const DEFAULT_POLICY: {
     readonly failOn: "warning";
   };
 };
-declare function renderPolicy(policy: Policy): string;
+export declare function renderPolicy(policy: Policy): string;
 type PolicyIssue = Issue;
 type PolicyResult = {
   ok: true;
@@ -2143,8 +2409,8 @@ type PolicyResult = {
   issues: PolicyIssue[];
 };
 /** Validates a parsed policy document and fills in defaults. Reports every problem, each with the path to its field. */
-declare function validatePolicy(document: unknown, tools?: readonly ToolKnowledge[]): PolicyResult;
+export declare function validatePolicy(document: unknown, tools?: readonly ToolKnowledge[]): PolicyResult;
 /** Parses and validates the text of a policy file. */
-declare function parsePolicy(source: string, tools?: readonly ToolKnowledge[]): PolicyResult;
-declare function formatIssue(issue: PolicyIssue): string;
-export { APPLY_ERRORS, APPLY_WARNINGS, type ApplyErrorCode, type ApplyProblem, type ApplyReport, type ApplyWarning, type ApplyWarningCode, ApplyWriteError, type CheckFinding, type CheckOptions, type CliIo, type CommandDirectory, type CommandScan, type Converted, type CooldownConversion, DEFAULT_POLICY, type Detection, type DetectionWarning, type DoctorReport, type Duration, type DurationResult, type DurationStringUnit, EXIT_FAILURE, EXIT_OK, EXIT_USAGE, type FileChange, type Finding, type FindingCode, type InstallRequest, type KnownDirectory, type Level, type Location, type Notice, type NumericDelayUnit, POLICY_FILE, type PackageManagerInfo, type PackageReport, type PlanOptions, type Policy, PolicyError, type PolicyIssue, type PolicyResult, PopularNames, type ProjectProblem, RULES, type ResolvedPolicy, type Rule, SCHEMA_URL, type ScanOptions, type Snippet, type VersionDeclaration, applyProject, botDuration, checkSpec, checkSpecs, convertCooldown, convertMinutes, countLevels, detectProject, formatDuration, formatIssue, getVersion, loadPolicy, parseDuration, parsePolicy, planApply, planRepository, renderPolicy, renderText, run, runDoctor, scanCommandLine, toDurationString, toSarif, unifiedDiff, validatePolicy, warningText };
+export declare function parsePolicy(source: string, tools?: readonly ToolKnowledge[]): PolicyResult;
+export declare function formatIssue(issue: PolicyIssue): string;
+export type { ApplyErrorCode, ApplyProblem, ApplyReport, ApplyWarning, ApplyWarningCode, CheckFinding, CheckOptions, CliIo, CommandDirectory, CommandScan, Converted, CooldownConversion, DetectOptions, Detection, DetectionWarning, DoctorReport, Duration, DurationResult, DurationStringUnit, FileChange, Finding, FindingCode, InstallRequest, KnownDirectory, Level, Location, Notice, NumericDelayUnit, OsvOptions, OsvPackage, OsvVerdict, PackageManagerInfo, PackageReport, PlanOptions, Policy, PolicyIssue, PolicyResult, ProjectProblem, ResolvedPolicy, Rule, ScanOptions, Snippet, VersionDeclaration };