repo-contract 0.3.0 → 0.3.2

package/dist/.dts/execution/spawn-check.d.ts

@@ -0,0 +1,49 @@
+import type { CheckDefinition, CheckEvidence, Spawner, SyncSpawner } from "../types.js";
+/**
+ * The trusted execution capabilities a run supplies once (see
+ * specs/decisions/0011-process-spawning-and-ambient-environment-access-are-consumer-supplied-capabilities-not-package-owned.md)
+ * and every spawned check draws from -- `spawn`/`env` verbatim from
+ * `RepoContractConfig`, `shell` already resolved to its effective global
+ * default (`config.shell ?? false`). Internal only: not exported from
+ * `src/types.ts` or `src/index.ts`. Grouped into one object, rather than
+ * threaded as independent parameters through `run-repo-contract.ts` ->
+ * `run-checks.ts` -> `spawn-check.ts`, purely to keep related
+ * execution-capability concerns from drifting into unrelated positional
+ * parameters as more get added later.
+ */
+export interface ExecutionCapability {
+    readonly spawn: Spawner;
+    readonly env: NodeJS.ProcessEnv;
+    readonly shell: boolean;
+    readonly killProcessTree?: SyncSpawner;
+}
+export declare const SIGKILL_GRACE_PERIOD_MS = 2000;
+/** Handle a caller can use to forcibly terminate one in-flight check's process tree, independent of that check's own timeout/abort wiring -- used by run-checks.ts to clean up every active check when the host process itself receives SIGINT/SIGTERM. */
+export interface ActiveCheckHandle {
+    kill(signal: NodeJS.Signals): void;
+}
+/**
+ * Runs one configured check end to end: resolves its command, spawns it,
+ * enforces its timeout (if any), reacts to the run-level `AbortSignal` (if
+ * any), captures stdout/stderr, and resolves to a fully-formed
+ * `CheckEvidence` no matter how the process ended -- this function never
+ * rejects. `activeHandles` is a shared registry the caller (run-checks.ts)
+ * uses to kill every in-flight check on a host-process SIGINT/SIGTERM; this
+ * function adds its own handle once the process has a pid and removes it
+ * once the process has settled.
+ *
+ * A check whose `runSignal` is already aborted before this function is even
+ * invoked (queued behind the concurrency limit when the run was cancelled)
+ * never spawns at all, but still resolves to a well-formed `status:
+ * "aborted"` evidence entry -- every configured check gets evidence and a
+ * policy invocation regardless of whether it ever ran (see
+ * specs/architecture.md).
+ * @param checkId - the check's id, used for logging and passed through to `resolveCommand`
+ * @param check - the check definition to run (command, timeout, env, cwd, shell, etc.)
+ * @param runSignal - the whole run's abort signal, if any; already-aborted before this is called means the check never spawns
+ * @param activeHandles - the shared registry this check's kill handle is added to while running, so a host-process SIGINT/SIGTERM can terminate it
+ * @param execution - the run's trusted execution capabilities (`spawn`, `env`, resolved global `shell` default) -- see `ExecutionCapability`
+ * @returns a fully-formed `CheckEvidence` reflecting however the process ended; this function itself never rejects
+ */
+export declare function spawnCheck(checkId: string, check: CheckDefinition, runSignal: AbortSignal | undefined, activeHandles: Set<ActiveCheckHandle>, execution: ExecutionCapability): Promise<CheckEvidence>;
+//# sourceMappingURL=spawn-check.d.ts.map

package/dist/.dts/execution/spawn-check.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"spawn-check.d.ts","sourceRoot":"","sources":["../../../src/execution/spawn-check.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAe,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAA;AAIpG;;;;;;;;;;;GAWG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC,UAAU,CAAA;IAC/B,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;IACvB,QAAQ,CAAC,eAAe,CAAC,EAAE,WAAW,CAAA;CACvC;AA2BD,eAAO,MAAM,uBAAuB,OAAO,CAAA;AA6D3C,2PAA2P;AAC3P,MAAM,WAAW,iBAAiB;IAChC,IAAI,CAAC,MAAM,EAAE,MAAM,CAAC,OAAO,GAAG,IAAI,CAAA;CACnC;AAyHD;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,eAAe,EACtB,SAAS,EAAE,WAAW,GAAG,SAAS,EAClC,aAAa,EAAE,GAAG,CAAC,iBAAiB,CAAC,EACrC,SAAS,EAAE,mBAAmB,GAC7B,OAAO,CAAC,aAAa,CAAC,CA4QxB"}

package/dist/.dts/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Public API of repo-contract. Curated barrel -- internal implementation
+ * modules (src/execution/, src/parsing/, src/policy/, src/config/'s
+ * lower-level pieces) are not re-exported here even though they exist as
+ * real files; only the two functions and the types a consumer needs to
+ * author a config and interpret its result are part of the public surface.
+ * @packageDocumentation
+ */
+export { defineRepoContract } from "./config/define-repo-contract.js";
+export { runRepoContract } from "./run-repo-contract.js";
+export { DependencyDeclaredLaterError, InvalidCheckConfigError, InvalidRepoContractConfigError, ParserDependencyMissingError, PolicyReadFailedParseValueError, PolicyReadUnrequestedOutputError, PolicyThrewError, RepoContractError, StandardSchemaValidateThrewError, UnknownCheckIdError, } from "./errors.js";
+export type { StandardSchemaV1 } from "./standard-schema/types.js";
+export type { CheckDefinition, CheckDefinitionConfig, CheckEvidence, CheckSchema, CheckStatus, Evidence, OutputFormat, ParsedOutput, ParsedOutputFailure, ParsedOutputSuccess, Policy, PolicyContext, PolicyOutcome, PolicyResult, RepoContractConfig, RunRepoContractOptions, Spawner, SyncSpawner, ValidatedCheckSchema, Verdict, } from "./types.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/.dts/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,OAAO,EAAE,kBAAkB,EAAE,MAAM,kCAAkC,CAAA;AACrE,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAA;AAExD,OAAO,EACL,4BAA4B,EAC5B,uBAAuB,EACvB,8BAA8B,EAC9B,4BAA4B,EAC5B,+BAA+B,EAC/B,gCAAgC,EAChC,gBAAgB,EAChB,iBAAiB,EACjB,gCAAgC,EAChC,mBAAmB,GACpB,MAAM,aAAa,CAAA;AAEpB,YAAY,EAAE,gBAAgB,EAAE,MAAM,4BAA4B,CAAA;AAElE,YAAY,EACV,eAAe,EACf,qBAAqB,EACrB,aAAa,EACb,WAAW,EACX,WAAW,EACX,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,mBAAmB,EACnB,mBAAmB,EACnB,MAAM,EACN,aAAa,EACb,aAAa,EACb,YAAY,EACZ,kBAAkB,EAClB,sBAAsB,EACtB,OAAO,EACP,WAAW,EACX,oBAAoB,EACpB,OAAO,GACR,MAAM,YAAY,CAAA"}

package/dist/.dts/parsing/format-schema-issues.d.ts

@@ -0,0 +1,11 @@
+import type { StandardSchemaV1 } from "../standard-schema/types.js";
+/**
+ * Renders a failed `output.schema` validation's issues as a single, human-readable string for
+ * `ParsedOutputFailure.error` -- e.g. `Schema validation failed: foo.bar: Expected string;
+ * items[2].name: Required`. Kept as its own small module, independent of `parseOutput`, so its
+ * path-rendering logic (the only non-trivial part) can be unit-tested directly.
+ * @param issues - the failed `StandardSchemaV1.Result`'s `issues`.
+ * @returns the formatted error string.
+ */
+export declare function formatSchemaIssues(issues: readonly StandardSchemaV1.Issue[]): string;
+//# sourceMappingURL=format-schema-issues.d.ts.map

package/dist/.dts/parsing/format-schema-issues.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format-schema-issues.d.ts","sourceRoot":"","sources":["../../../src/parsing/format-schema-issues.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AAEnE;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,SAAS,gBAAgB,CAAC,KAAK,EAAE,GAAG,MAAM,CAEpF"}

package/dist/.dts/parsing/parse-json.d.ts

@@ -0,0 +1,8 @@
+import type { ParsedOutput } from "../types.js";
+/**
+ * Parses `stdout` as JSON. A malformed-JSON failure preserves the raw stdout on the caller's `CheckEvidence` unchanged and never throws -- the failure is reported as data, per repo-contract's "parsing failures are deterministic evidence, never a silent reinterpretation" contract.
+ * @param stdout - the check's raw stdout to parse as JSON.
+ * @returns the parsed value on success, or the unparsed failure with `stdout` preserved.
+ */
+export declare function parseJson(stdout: string): ParsedOutput<unknown>;
+//# sourceMappingURL=parse-json.d.ts.map

package/dist/.dts/parsing/parse-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-json.d.ts","sourceRoot":"","sources":["../../../src/parsing/parse-json.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC,OAAO,CAAC,CAU/D"}

package/dist/.dts/parsing/parse-output.d.ts

@@ -0,0 +1,25 @@
+import type { StandardSchemaV1 } from "../standard-schema/types.js";
+import type { OutputFormat, ParsedOutput } from "../types.js";
+/**
+ * Dispatches to the parser for `format`, then -- only on a successful parse, and only if `schema`
+ * is supplied -- runs `schema["~standard"].validate()` against the parsed value
+ * (https://standardschema.dev). `parse-json.ts`/`parse-yaml.ts`/`parse-text.ts` stay entirely
+ * unaware of `schema`; this is the sole orchestration point. `validate()` may return its `Result`
+ * synchronously or as a `Promise` -- `await`ing either uniformly is a no-op for the synchronous
+ * case, so this doesn't need its own reason to be async on top of the one this function already
+ * has (the dynamic `import("yaml")` for `format: "yaml"`). A successful `Result` (`issues ===
+ * undefined`) *replaces* `value` with the schema's own (possibly transformed) output; a failing
+ * `Result` becomes a `ParsedOutputFailure` whose `error` is built by `formatSchemaIssues`.
+ * `schema.validate()` itself throwing or rejecting is a bug in the consumer-supplied schema, not
+ * malformed output -- it throws `StandardSchemaValidateThrewError` rather than becoming a
+ * `ParsedOutputFailure`. Never throws for a malformed-output parse failure -- see each parser's
+ * own documentation. May throw `ParserDependencyMissingError` for `format: "yaml"` if the
+ * optional `yaml` peer dependency is unavailable.
+ * @param format - which parser to dispatch to.
+ * @param stdout - the check's raw stdout to parse.
+ * @param checkId - identifies which check's output is being parsed, used in a thrown `ParserDependencyMissingError`/`StandardSchemaValidateThrewError`.
+ * @param schema - an optional Standard Schema-compliant validator to run against a successful parse's value.
+ * @returns the parsed (and, if `schema` was supplied and validation succeeded, schema-transformed) output.
+ */
+export declare function parseOutput(format: OutputFormat, stdout: string, checkId: string, schema?: StandardSchemaV1): Promise<ParsedOutput<unknown>>;
+//# sourceMappingURL=parse-output.d.ts.map

package/dist/.dts/parsing/parse-output.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-output.d.ts","sourceRoot":"","sources":["../../../src/parsing/parse-output.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA;AACnE,OAAO,KAAK,EAAE,YAAY,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAM7D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAsB,WAAW,CAC/B,MAAM,EAAE,YAAY,EACpB,MAAM,EAAE,MAAM,EACd,OAAO,EAAE,MAAM,EACf,MAAM,CAAC,EAAE,gBAAgB,GACxB,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAkBhC"}

package/dist/.dts/parsing/parse-text.d.ts

@@ -0,0 +1,8 @@
+import type { ParsedOutput } from "../types.js";
+/**
+ * "Parses" `stdout` as text -- a trimmed passthrough that always succeeds. Exists as an explicit, self-documenting alternative to omitting `output` entirely: `format: "text"` gives a consumer `result.output.value` as a plain trimmed string, rather than needing to read `result.stdout` and trim it themselves every time.
+ * @param stdout - the check's raw stdout to trim.
+ * @returns the always-successful result wrapping the trimmed string.
+ */
+export declare function parseText(stdout: string): ParsedOutput<string>;
+//# sourceMappingURL=parse-text.d.ts.map

package/dist/.dts/parsing/parse-text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-text.d.ts","sourceRoot":"","sources":["../../../src/parsing/parse-text.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,YAAY,CAAC,MAAM,CAAC,CAE9D"}

package/dist/.dts/parsing/parse-yaml.d.ts

@@ -0,0 +1,21 @@
+import type { ParsedOutput } from "../types.js";
+/**
+ * Parses `stdout` as YAML using the optional `yaml` peer dependency, loaded
+ * via a dynamic `import()` only when a check actually requests
+ * `output.format: "yaml"` -- consumers who never use YAML never pay for it.
+ * If `yaml` cannot be loaded at all (not installed, or any other import-time
+ * failure), throws `ParserDependencyMissingError` with the original failure
+ * preserved as `cause`, rather than guessing at a specific module-resolution
+ * error code that could vary across Node versions and module systems (ESM
+ * vs. the package's own CJS build output).
+ *
+ * A malformed-YAML failure (the dependency loaded fine, but `stdout` isn't
+ * valid YAML) is a normal parse failure, not a missing-dependency error --
+ * it's returned as `{ success: false }`, following the same "preserve raw
+ * output, report failure as data" contract as `parseJson`.
+ * @param stdout - the check's raw stdout to parse as YAML.
+ * @param checkId - identifies which check's output is being parsed, used in the thrown `ParserDependencyMissingError`.
+ * @returns the parsed value on success, or the unparsed failure with `stdout` preserved.
+ */
+export declare function parseYaml(stdout: string, checkId: string): Promise<ParsedOutput<unknown>>;
+//# sourceMappingURL=parse-yaml.d.ts.map

package/dist/.dts/parsing/parse-yaml.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-yaml.d.ts","sourceRoot":"","sources":["../../../src/parsing/parse-yaml.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAE/C;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC,CAiB/F"}

package/dist/.dts/policy/run-policies.d.ts

@@ -0,0 +1,38 @@
+import type { ParsedCheckEntry } from "../evidence/build-evidence.js";
+import type { Evidence, Verdict } from "../types.js";
+/**
+ * Invokes every check's `policy` against the complete, already-assembled
+ * `evidence` and aggregates the results into a `Verdict`. Each check's
+ * `PolicyResult` is stored verbatim under `checks[checkId]`; `passed` is
+ * `true` only if every check's `outcome` is `"pass"` or `"warn"` -- no
+ * check's failure is ever collapsed into another's or into one generic
+ * message.
+ *
+ * Every `policy` call is isolated: the call itself is wrapped in `try/catch`
+ * (a policy doesn't have to be `async` to misbehave), and its returned
+ * value is `await`-ed inside that same `try`, so a promise that rejects
+ * later is caught identically to a synchronous throw. The resolved value is
+ * then validated against the `PolicyResult` contract itself (`outcome` is
+ * exactly `"pass"`, `"fail"`, or `"warn"`; `rationale` is a string) before
+ * it is trusted -- a malformed result is treated exactly like a throw
+ * rather than silently coerced into a pass. Every one of these failure
+ * modes is wrapped in `PolicyThrewError`, with the original thrown value
+ * (or a descriptive validation error, for a malformed result) preserved via
+ * `cause` -- never stringified or discarded. Two specific, common mistakes
+ * get a more actionable error instead, chosen by `wrapPolicyFailure` (see
+ * its own doc comment): reading a `result.output` property on a check that
+ * never requested a format (`PolicyReadUnrequestedOutputError`), and reading
+ * `result.output.value` on a check whose requested parse actually failed
+ * (`PolicyReadFailedParseValueError`) -- both still preserve the original
+ * `TypeError` via `cause`, exactly like the plain `PolicyThrewError` case.
+ * One policy failing this way never stops any other check's policy from
+ * running. If more than one policy fails this way in the same run, this
+ * function throws a native `AggregateError` whose `errors` holds one such
+ * error per failing check, rather than surfacing only the first one found;
+ * if exactly one policy fails, it throws that single error directly.
+ * @param entries - each check's id, definition, and final (possibly parsed-output) evidence to invoke its policy against
+ * @param evidence - the complete, already-assembled evidence for the whole run, passed to every policy call
+ * @returns the aggregated `Verdict` (throws instead if one or more policies failed to produce a valid `PolicyResult`)
+ */
+export declare function runPolicies(entries: readonly ParsedCheckEntry[], evidence: Evidence): Promise<Verdict>;
+//# sourceMappingURL=run-policies.d.ts.map

package/dist/.dts/policy/run-policies.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"run-policies.d.ts","sourceRoot":"","sources":["../../../src/policy/run-policies.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAA;AAMrE,OAAO,KAAK,EAEV,QAAQ,EAIR,OAAO,EACR,MAAM,aAAa,CAAA;AA4HpB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,wBAAsB,WAAW,CAC/B,OAAO,EAAE,SAAS,gBAAgB,EAAE,EACpC,QAAQ,EAAE,QAAQ,GACjB,OAAO,CAAC,OAAO,CAAC,CAsFlB"}

package/dist/.dts/presets/arethetypeswrong.d.ts

@@ -0,0 +1,39 @@
+import type { CheckDefinitionConfig, PolicyResult } from "../types.js";
+/**
+ * attw's own `--format json` contract -- not published as a TypeScript type
+ * by the tool. `problems` is a flat record keyed by problem kind (e.g.
+ * "FalseCJS", "NoResolution"), each entry carrying whichever context fields
+ * that kind of problem produces.
+ */
+export interface AttwReport {
+    readonly problems?: Record<string, readonly AttwProblem[]>;
+}
+export interface AttwProblem {
+    readonly kind: string;
+    readonly entrypoint?: string;
+    readonly resolutionKind?: string;
+    readonly typesFileName?: string;
+    readonly implementationFileName?: string;
+}
+/**
+ * Interprets an already-parsed attw JSON report -- exported (unlike this
+ * package's other internal evaluators) because a repository whose package
+ * has enough entrypoints to make attw's own `--format json` output exceed
+ * ~64KB can hit a real, reproducible upstream bug: attw truncates its own
+ * stdout when it's a pipe (confirmed independently of repo-contract, via
+ * plain shell piping) rather than a TTY or regular file. Redirecting attw's
+ * output to a file sidesteps that bug; a consumer doing so needs this same
+ * interpretation logic without re-deriving it. repo-contract's own
+ * `repo-contract.config.ts` does exactly this once it has more than one real
+ * entrypoint (see that file's `arethetypeswrong` override).
+ * Accepts `unknown` and validates the shape itself: its inputs are always
+ * untrusted parsed JSON (a tool's stdout, a report file), and valid JSON of an
+ * unexpected shape must produce a clean fail verdict here rather than a
+ * `TypeError` in the caller.
+ * @param report - the parsed attw JSON report to evaluate.
+ * @returns the pass/fail outcome and its rationale.
+ */
+export declare function evaluateAttwReport(report: unknown): PolicyResult;
+/** Published-package type-resolution correctness via `@arethetypeswrong/cli`. */
+export declare const arethetypeswrong: CheckDefinitionConfig;
+//# sourceMappingURL=arethetypeswrong.d.ts.map

package/dist/.dts/presets/arethetypeswrong.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arethetypeswrong.d.ts","sourceRoot":"","sources":["../../../src/presets/arethetypeswrong.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,YAAY,EAAE,MAAM,aAAa,CAAA;AAItE;;;;;GAKG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,SAAS,WAAW,EAAE,CAAC,CAAA;CAC3D;AAED,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;IACrB,QAAQ,CAAC,UAAU,CAAC,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,cAAc,CAAC,EAAE,MAAM,CAAA;IAChC,QAAQ,CAAC,aAAa,CAAC,EAAE,MAAM,CAAA;IAC/B,QAAQ,CAAC,sBAAsB,CAAC,EAAE,MAAM,CAAA;CACzC;AAkBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,OAAO,GAAG,YAAY,CA6BhE;AAUD,iFAAiF;AACjF,eAAO,MAAM,gBAAgB,EAAE,qBAmB9B,CAAA"}

package/dist/.dts/presets/broken-links.d.ts

@@ -0,0 +1,16 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Options accepted by {@link brokenLinks}. */
+interface BrokenLinksOptions {
+    /** File or directory passed straight through to linkinator as its positional target. Defaults to `"."`. */
+    readonly start?: string;
+}
+/**
+ * Broken-link detection via linkinator, recursing through local files and
+ * following both local and remote links. `--skip node_modules` avoids
+ * wasting the crawl on vendored files that were never authored content.
+ * @param options - configuration for this check; see {@link BrokenLinksOptions}.
+ * @returns the configured check.
+ */
+export declare function brokenLinks(options?: BrokenLinksOptions): CheckDefinitionConfig;
+export {};
+//# sourceMappingURL=broken-links.d.ts.map

package/dist/.dts/presets/broken-links.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"broken-links.d.ts","sourceRoot":"","sources":["../../../src/presets/broken-links.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAgBxD,+CAA+C;AAC/C,UAAU,kBAAkB;IAC1B,2GAA2G;IAC3G,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAA;CACxB;AAYD;;;;;;GAMG;AACH,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,qBAAqB,CAuDnF"}

package/dist/.dts/presets/commitlint.d.ts

@@ -0,0 +1,22 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Options accepted by {@link commitlint}. */
+interface CommitlintOptions {
+    /** The ref commitlint lints commits *from* (exclusive). Defaults to `"origin/main"`. */
+    readonly from?: string;
+    /** The ref commitlint lints commits *to* (inclusive). Defaults to `"HEAD"`. */
+    readonly to?: string;
+}
+/**
+ * Commit-message governance via commitlint, using whatever commitlint
+ * config the consumer's own repository already has (commitlint ships no
+ * rules of its own -- e.g. `@commitlint/config-conventional`). Exit-code
+ * based rather than `--format json`: commitlint has no broadly-documented,
+ * stable JSON CLI output, so this preset reads its plain-text report the
+ * same way the `format`/`typecheck` presets already do for their tools,
+ * rather than relying on an unconfirmed flag.
+ * @param options - configuration for this check; see {@link CommitlintOptions}.
+ * @returns the configured check.
+ */
+export declare function commitlint(options?: CommitlintOptions): CheckDefinitionConfig;
+export {};
+//# sourceMappingURL=commitlint.d.ts.map

package/dist/.dts/presets/commitlint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"commitlint.d.ts","sourceRoot":"","sources":["../../../src/presets/commitlint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAKxD,8CAA8C;AAC9C,UAAU,iBAAiB;IACzB,wFAAwF;IACxF,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;IACtB,+EAA+E;IAC/E,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAA;CACrB;AA2BD;;;;;;;;;;GAUG;AACH,wBAAgB,UAAU,CAAC,OAAO,GAAE,iBAAsB,GAAG,qBAAqB,CA2BjF"}

package/dist/.dts/presets/dead-code.d.ts

@@ -0,0 +1,23 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Options accepted by {@link deadCode}. */
+interface DeadCodeOptions {
+    /**
+     * devDependency names to exclude from the "unused devDependency" issue
+     * category -- e.g. CLI tools knip has no way to see are used, because
+     * nothing `import`s them. Round-tripped through knip's own
+     * `--reporter-options` flag (see `readReporterOptions`) rather than kept in
+     * a closure, so the exempt list this check actually ran with is visible on
+     * the recorded command line and in persisted evidence, not just in this
+     * file's source. Defaults to an empty list -- repo-contract ships no
+     * built-in exemptions; add your own repository's here.
+     */
+    readonly exemptUnusedDevDependencies?: readonly string[];
+}
+/**
+ * Dead/unused-code detection via knip.
+ * @param options - configuration for this check; see {@link DeadCodeOptions}.
+ * @returns the configured check.
+ */
+export declare function deadCode(options?: DeadCodeOptions): CheckDefinitionConfig;
+export {};
+//# sourceMappingURL=dead-code.d.ts.map

package/dist/.dts/presets/dead-code.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dead-code.d.ts","sourceRoot":"","sources":["../../../src/presets/dead-code.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA8CxD,4CAA4C;AAC5C,UAAU,eAAe;IACvB;;;;;;;;;OASG;IACH,QAAQ,CAAC,2BAA2B,CAAC,EAAE,SAAS,MAAM,EAAE,CAAA;CACzD;AA6DD;;;;GAIG;AACH,wBAAgB,QAAQ,CAAC,OAAO,GAAE,eAAoB,GAAG,qBAAqB,CAiG7E"}

package/dist/.dts/presets/duplication.d.ts

@@ -0,0 +1,14 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Options accepted by {@link duplication}. */
+interface DuplicationOptions {
+    /** Directory to scan for duplicated code, passed straight through to jscpd as its positional target. Defaults to `"."` -- narrow it (e.g. `"src"`) to scope the scan to your own source tree. */
+    readonly path?: string;
+}
+/**
+ * Duplicated-code detection via jscpd.
+ * @param options - configuration for this check; see {@link DuplicationOptions}.
+ * @returns the configured check.
+ */
+export declare function duplication(options?: DuplicationOptions): CheckDefinitionConfig;
+export {};
+//# sourceMappingURL=duplication.d.ts.map

package/dist/.dts/presets/duplication.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"duplication.d.ts","sourceRoot":"","sources":["../../../src/presets/duplication.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAkCxD,+CAA+C;AAC/C,UAAU,kBAAkB;IAC1B,iMAAiM;IACjM,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB;AAgBD;;;;GAIG;AACH,wBAAgB,WAAW,CAAC,OAAO,GAAE,kBAAuB,GAAG,qBAAqB,CA4EnF"}

package/dist/.dts/presets/e2e.d.ts

@@ -0,0 +1,4 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** End-to-end test execution via Playwright, reading its JSON reporter output. */
+export declare const e2e: CheckDefinitionConfig;
+//# sourceMappingURL=e2e.d.ts.map

package/dist/.dts/presets/e2e.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"e2e.d.ts","sourceRoot":"","sources":["../../../src/presets/e2e.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA+ExD,kFAAkF;AAClF,eAAO,MAAM,GAAG,EAAE,qBA+DjB,CAAA"}

package/dist/.dts/presets/format.d.ts

@@ -0,0 +1,4 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Code formatting via Prettier, applied in place. */
+export declare const format: CheckDefinitionConfig;
+//# sourceMappingURL=format.d.ts.map

package/dist/.dts/presets/format.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"format.d.ts","sourceRoot":"","sources":["../../../src/presets/format.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAKxD,sDAAsD;AACtD,eAAO,MAAM,MAAM,EAAE,qBAkBpB,CAAA"}

package/dist/.dts/presets/index.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Curated, growing catalog of preset checks for tools common across
+ * TypeScript/JavaScript repositories -- each preset encodes how to execute
+ * and interpret a common tool, never a repository's definition of quality
+ * (see specs/decisions/0004-public-surface-stays-narrow-no-cli-experimental-presets.md). Import a preset,
+ * spread it into your own `checks` record, and override whatever you need
+ * -- most often `policy`; a factory preset's options are the preferred way
+ * to change what it executes, a direct `run` override is an escape hatch.
+ * Never re-exported from the package root (`src/index.ts`) -- presets are
+ * an opt-in extra, not part of the core execution/evidence/policy surface
+ * those exports describe, and this barrel never re-exports anything from
+ * there either; the two stay independent.
+ * @packageDocumentation
+ */
+export { arethetypeswrong } from "./arethetypeswrong.js";
+export { brokenLinks } from "./broken-links.js";
+export { commitlint } from "./commitlint.js";
+export { deadCode } from "./dead-code.js";
+export { duplication } from "./duplication.js";
+export { e2e } from "./e2e.js";
+export { format } from "./format.js";
+export { license } from "./license.js";
+export { lint } from "./lint.js";
+export { markdownlint } from "./markdownlint.js";
+export { publint } from "./publint.js";
+export { securityDeps } from "./security-deps.js";
+export { securitySecrets } from "./security-secrets.js";
+export { stylelint } from "./stylelint.js";
+export { test } from "./test.js";
+export { typecheck } from "./typecheck.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/.dts/presets/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/presets/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAA;AACxD,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAC/C,OAAO,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AAC5C,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAA;AACzC,OAAO,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAA;AAC9C,OAAO,EAAE,GAAG,EAAE,MAAM,UAAU,CAAA;AAC9B,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AACpC,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AAChD,OAAO,EAAE,OAAO,EAAE,MAAM,cAAc,CAAA;AACtC,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAA;AACjD,OAAO,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAA;AACvD,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA;AAC1C,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAA;AAChC,OAAO,EAAE,SAAS,EAAE,MAAM,gBAAgB,CAAA"}

package/dist/.dts/presets/license.d.ts

@@ -0,0 +1,4 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Dependency license compliance via licensee. */
+export declare const license: CheckDefinitionConfig;
+//# sourceMappingURL=license.d.ts.map

package/dist/.dts/presets/license.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"license.d.ts","sourceRoot":"","sources":["../../../src/presets/license.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAuBxD,kDAAkD;AAClD,eAAO,MAAM,OAAO,EAAE,qBAiErB,CAAA"}

package/dist/.dts/presets/lint.d.ts

@@ -0,0 +1,20 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Options accepted by {@link lint}. */
+interface LintOptions {
+    /** Path (or glob) passed straight through to ESLint as its positional target. Defaults to `"."` -- narrow it (e.g. `"src"`) to scope linting to your own source tree. */
+    readonly path?: string;
+}
+/**
+ * Static analysis via ESLint, using whatever `eslint.config.js` the
+ * consumer's own repository already has -- this preset makes no assumption
+ * about rule configuration, only about how to run the tool and interpret
+ * its JSON output. Severity `2` (error) blocks; severity `1` (warning) is
+ * reported but never blocks -- ESLint's own severities already encode that
+ * distinction, so this preset just respects it rather than treating every
+ * finding as equally blocking.
+ * @param options - configuration for this check; see {@link LintOptions}.
+ * @returns the configured check.
+ */
+export declare function lint(options?: LintOptions): CheckDefinitionConfig;
+export {};
+//# sourceMappingURL=lint.d.ts.map

package/dist/.dts/presets/lint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint.d.ts","sourceRoot":"","sources":["../../../src/presets/lint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA0BxD,wCAAwC;AACxC,UAAU,WAAW;IACnB,yKAAyK;IACzK,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB;AAoBD;;;;;;;;;;GAUG;AACH,wBAAgB,IAAI,CAAC,OAAO,GAAE,WAAgB,GAAG,qBAAqB,CAsDrE"}

package/dist/.dts/presets/markdownlint.d.ts

@@ -0,0 +1,23 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Options accepted by {@link markdownlint}. */
+interface MarkdownlintOptions {
+    /** Glob passed straight through to markdownlint-cli2 as its positional target. Defaults to `"**\/*.md"`. */
+    readonly glob?: string;
+}
+/**
+ * Markdown structure/style lint via markdownlint-cli2. Unlike this
+ * package's other file-based-report presets, the report path is
+ * config-driven rather than a CLI flag -- markdownlint-cli2 only writes
+ * JSON when its own config file requests it. This preset assumes the
+ * consumer's `.markdownlint-cli2.jsonc` includes:
+ * ```jsonc
+ * "outputFormatters": [["markdownlint-cli2-formatter-json", { "name": "reports/markdownlint.json" }]]
+ * ```
+ * which also requires the `markdownlint-cli2-formatter-json` package
+ * alongside `markdownlint-cli2` itself.
+ * @param options - configuration for this check; see {@link MarkdownlintOptions}.
+ * @returns the configured check.
+ */
+export declare function markdownlint(options?: MarkdownlintOptions): CheckDefinitionConfig;
+export {};
+//# sourceMappingURL=markdownlint.d.ts.map

package/dist/.dts/presets/markdownlint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"markdownlint.d.ts","sourceRoot":"","sources":["../../../src/presets/markdownlint.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAmBxD,gDAAgD;AAChD,UAAU,mBAAmB;IAC3B,4GAA4G;IAC5G,QAAQ,CAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CACvB;AAeD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,YAAY,CAAC,OAAO,GAAE,mBAAwB,GAAG,qBAAqB,CAmDrF"}

package/dist/.dts/presets/publint.d.ts

@@ -0,0 +1,13 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/**
+ * publint has no machine-readable output mode -- only a plain-text CLI
+ * reporter (see its own `src/cli.js` `formatMessages`). Its process exit
+ * code reflects only 'error'-level findings; 'warning'/'suggestion'-level
+ * findings never affect it. This preset reads the same three section
+ * headers publint's own CLI writes ("Errors:", "Warnings:", "Suggestions:")
+ * to distinguish blocking findings from non-blocking ones, without
+ * depending on any per-message structure publint doesn't expose. Relevant
+ * only to repositories that publish an npm package.
+ */
+export declare const publint: CheckDefinitionConfig;
+//# sourceMappingURL=publint.d.ts.map

package/dist/.dts/presets/publint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"publint.d.ts","sourceRoot":"","sources":["../../../src/presets/publint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAKxD;;;;;;;;;GASG;AACH,eAAO,MAAM,OAAO,EAAE,qBAsBrB,CAAA"}

package/dist/.dts/presets/security-deps.d.ts

@@ -0,0 +1,4 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Dependency vulnerability scanning via `npm audit`. */
+export declare const securityDeps: CheckDefinitionConfig;
+//# sourceMappingURL=security-deps.d.ts.map

package/dist/.dts/presets/security-deps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-deps.d.ts","sourceRoot":"","sources":["../../../src/presets/security-deps.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AA0CxD,yDAAyD;AACzD,eAAO,MAAM,YAAY,EAAE,qBAkG1B,CAAA"}

package/dist/.dts/presets/security-secrets.d.ts

@@ -0,0 +1,4 @@
+import type { CheckDefinitionConfig } from "../types.js";
+/** Secret-leak scanning via secretlint. */
+export declare const securitySecrets: CheckDefinitionConfig;
+//# sourceMappingURL=security-secrets.d.ts.map

package/dist/.dts/presets/security-secrets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"security-secrets.d.ts","sourceRoot":"","sources":["../../../src/presets/security-secrets.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAA;AAsBxD,2CAA2C;AAC3C,eAAO,MAAM,eAAe,EAAE,qBAoE7B,CAAA"}

package/dist/.dts/presets/shared/error-warning-pass-policy.d.ts

@@ -0,0 +1,13 @@
+import type { PolicyResult } from "../../types.js";
+/**
+ * The shared three-branch shape behind every lint-style preset's pass/warn/fail decision: fail,
+ * listing every error, if there are any; else warn, listing every warning, if there are any; else
+ * pass -- shared by `lint` (ESLint) and `stylelint`, whose only difference was the tool name
+ * substituted into each rationale string.
+ * @param toolName - the tool's own display name, substituted into every rationale (e.g. "ESLint", "stylelint").
+ * @param errorDetails - one rendered line per error-severity finding.
+ * @param warningDetails - one rendered line per warning-severity finding.
+ * @returns the fail/warn/pass `PolicyResult`.
+ */
+export declare function errorWarningPassPolicy(toolName: string, errorDetails: readonly string[], warningDetails: readonly string[]): PolicyResult;
+//# sourceMappingURL=error-warning-pass-policy.d.ts.map

package/dist/.dts/presets/shared/error-warning-pass-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"error-warning-pass-policy.d.ts","sourceRoot":"","sources":["../../../../src/presets/shared/error-warning-pass-policy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAElD;;;;;;;;;GASG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,MAAM,EAChB,YAAY,EAAE,SAAS,MAAM,EAAE,EAC/B,cAAc,EAAE,SAAS,MAAM,EAAE,GAChC,YAAY,CAsBd"}

package/dist/.dts/presets/shared/exit-code-fail-rationale.d.ts

@@ -0,0 +1,23 @@
+import type { CheckEvidence } from "../../types.js";
+/**
+ * A check's captured stdout and stderr, trimmed and joined into one block -- either stream may be
+ * empty and is dropped rather than contributing a blank line. Shared by `exitCodeFailRationale`
+ * below and by `publint` (which needs the combined text itself, not just a rendered failure
+ * message, to detect its own "Warnings:"/"Suggestions:" section headers).
+ * @param result - the check's execution evidence (only `stdout`/`stderr` are read).
+ * @returns the combined, trimmed stdout+stderr text, or `""` if the tool produced neither.
+ */
+export declare function combinedOutput(result: CheckEvidence): string;
+/**
+ * Shared by every preset whose policy is a plain "exitCode 0 = pass, else
+ * render captured stdout/stderr (or fall back to an exit-code-only message
+ * if the tool produced neither)" -- `format`, `typecheck`, `commitlint`.
+ * Each preset still owns its own pass rationale and its own description of
+ * what failed; this only renders the shared "here's what the tool printed"
+ * half.
+ * @param result - the check's execution evidence (only `stdout`/`stderr`/`exitCode` are read).
+ * @param description - a present-tense description of the failure, e.g. "Prettier reported formatting failures".
+ * @returns `"{description}:\n{output}"` when the tool produced output, or `"{description} (exit code {N})."` otherwise.
+ */
+export declare function exitCodeFailRationale(result: CheckEvidence, description: string): string;
+//# sourceMappingURL=exit-code-fail-rationale.d.ts.map

package/dist/.dts/presets/shared/exit-code-fail-rationale.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"exit-code-fail-rationale.d.ts","sourceRoot":"","sources":["../../../../src/presets/shared/exit-code-fail-rationale.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAA;AAEnD;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAI5D;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAMxF"}

package/dist/.dts/presets/shared/missing-dependency.d.ts

@@ -0,0 +1,19 @@
+import type { CheckEvidence, PolicyResult } from "../../types.js";
+/**
+ * Every preset in `src/presets/*.ts` (except `securityDeps`, which shells out
+ * to `npm` itself -- something that cannot be "missing" in any environment
+ * capable of running `npm run <script>` at all) calls this first, before its
+ * own pass/fail/warn logic. `CheckEvidence.status === "spawn_error"` already
+ * distinguishes "the OS couldn't even launch the executable" from "the tool
+ * ran and exited non-zero" -- but not every spawn failure means the package
+ * is missing (a permission error or an invalid executable format lands here
+ * too), so this checks the structured `spawnErrorCode` for `"ENOENT"`
+ * specifically rather than treating every spawn error as "not installed."
+ * A non-ENOENT spawn error falls through to the preset's normal handling,
+ * unchanged, rather than getting a misleading "not installed" message.
+ * @param result - the check's raw execution evidence to inspect.
+ * @param packageName - the npm package a consumer would install to fix this (may differ from the binary name, e.g. `tsc` comes from `typescript`).
+ * @returns an actionable, package-manager-neutral `PolicyResult` if the tool appears to be missing, or `undefined` if the caller should proceed with its own interpretation.
+ */
+export declare function checkDependencyInstalled(result: CheckEvidence, packageName: string): PolicyResult | undefined;
+//# sourceMappingURL=missing-dependency.d.ts.map

package/dist/.dts/presets/shared/missing-dependency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"missing-dependency.d.ts","sourceRoot":"","sources":["../../../../src/presets/shared/missing-dependency.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,gBAAgB,CAAA;AAEjE;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,wBAAwB,CACtC,MAAM,EAAE,aAAa,EACrB,WAAW,EAAE,MAAM,GAClB,YAAY,GAAG,SAAS,CAS1B"}