code-auditor-mcp 4.1.0 → 5.0.1

package/dist/phase/runner.d.ts

@@ -0,0 +1,549 @@
+/**
+ * Spec 68 §3.2 vertical slice — the phase runner: Parse → Process → Analyze.
+ *
+ * This is the in-process proof of the phase model for ONE fact kind
+ * (`file-symbols`) and its SOLID rules. It is deliberately not the full §6
+ * distributed runner (bounded work queue, parent/worker, index-backed facts);
+ * that lands in §6. What this proves, once, is the contract the whole model
+ * turns on:
+ *
+ *   - Parse produces a `ParsedFile` whose `ast` lives only here (it is freed
+ *     after the processor runs and never crosses the Process→Analyze boundary).
+ *   - Process runs the `file-symbols` producer per file and concatenates the
+ *     fragments into the corpus-wide `file-symbols` fact.
+ *   - Analyze hands that fact — and nothing else — to each SOLID rule, whose
+ *     `analyze` is pure threshold comparison over plain data.
+ *
+ * §6 replaces the parse loop with fan-out and the `thresholds` literal with
+ * resolved config; the three-phase ordering and the "rules read facts, never
+ * ASTs" property are already fixed here.
+ */
+import type { Dialect } from '../mcp-tools/discoveryQueries.js';
+import type { ParsedFile, FileSymbols, ResolvedQuery, LoopQueryFact, DynamicSqlFact, SchemaUsageFact, SchemaDeclaration, SchemaObject, ResolutionFact, MigrationHistory, Entity, Format, ThresholdValues, Finding, StyleDeclarationsFile, FunctionIndexFact, MinedConvention, ExportFormFact, ImportFormFact, ImportFact, StringLiteralFact, SecretCandidate, SecurityCandidate, QuerySiteFact, ReactComponentScan, FileHeaderFact, CodeBlockFact, JsonDocumentFact, SchemaValidationFact } from './types.js';
+/** A file to parse, with its source already read (the CLI reads it in §11). */
+export type InputFile = {
+    readonly path: string;
+    readonly content: string;
+};
+/**
+ * The format a path declares, by extension (matches the liveness fixtures).
+ *
+ * @param path - The file path whose extension determines the format.
+ * @returns The `Format` the path declares.
+ */
+export declare function formatFor(path: string): Format;
+/**
+ * Parse one file into a `ParsedFile`. Uses `adapter.parse()` (not the sync
+ * bridge) so the adapter's source map is populated — `extractFunctions` /
+ * `extractClasses` read the real source through it. Returns `null` when no
+ * adapter resolves the path or the parse fails; the caller records the drop
+ * (§3.3 makes a per-file failure `incomplete`, which is §8's concern).
+ *
+ * @param input - The file to parse (path + already-read content).
+ * @param projectRoot - The optional project root threaded into the parsed file.
+ * @param sqlDialect - The corpus's named SQL dialect (null means cannot-fire for
+ *   the SQL-reading producers: `ddl-declarations` and `data-access-calls`).
+ * @returns The parsed file, or `null` when no adapter resolves or the parse fails.
+ */
+export declare function parseOne(input: InputFile, projectRoot?: string, sqlDialect?: Dialect | null): Promise<ParsedFile | null>;
+/**
+ * Parse → Process for the `file-symbols` fact. Returns the assembled corpus
+ * fact (every symbol from every file, files' ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `file-symbols` corpus fact.
+ */
+export declare function buildFileSymbols(files: readonly InputFile[]): Promise<FileSymbols[]>;
+/** Analyze the assembled `file-symbols` fact with the SOLID rules. The union
+ *  context carries the §9 Go facts as `[]` and widens `formats` to include `go`
+ *  so the Go arms (`interface-size`'s Go branch, `struct-size`, `function-size`,
+ *  `switch-size`, `liskov-substitution`) reduce an empty fact in this TS-only
+ *  slice rather than a missing one — they produce nothing because there are no
+ *  Go files here. `resolution` supplies the class-declaration chain
+ *  `solid/open-closed` walks (`isErrorSubclass`) for its `instanceof` guard.
+ *
+ *  @param symbols - The assembled `file-symbols` fact to analyze.
+ *  @param resolution - The one resolution fact (`solid/open-closed` reads its
+ *    `classes` for the extends-Error check).
+ *  @param thresholds - The SOLID rule thresholds (defaults to `{}`).
+ *  @returns The SOLID rules' findings over the fact.
+ */
+export declare function analyzeFileSymbols(symbols: FileSymbols[], resolution: ResolutionFact, thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The whole vertical slice: parse → file-symbols + resolution → SOLID rules →
+ *  findings.
+ *
+ * @param files the input files to parse and analyze
+ * @param thresholds the SOLID rule thresholds (defaults to `{}`)
+ * @returns the SOLID rules' findings over the whole file set
+ */
+export declare function runFileSymbolsSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Analyze the assembled `file-symbols` fact with the documentation rules.
+ *
+ * @param symbols - The assembled `file-symbols` fact to analyze.
+ * @param thresholds - The documentation rule thresholds (defaults to `{}`).
+ * @returns The documentation rules' findings over the fact.
+ */
+export declare function analyzeDocumentation(symbols: FileSymbols[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The documentation slice: parse → file-symbols → documentation rules → findings. */
+export declare function runDocumentationSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `data-access-calls` fact. Returns the assembled
+ * corpus fact (every resolved DB call from every file, ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @param sqlDialect - The corpus's named dialect for SQL parsing, or null/undefined.
+ * @returns The assembled `data-access-calls` corpus fact.
+ */
+export declare function buildDataAccessCalls(files: readonly InputFile[], sqlDialect?: Dialect | null): Promise<ResolvedQuery[]>;
+/** Analyze the assembled `data-access-calls` + `resolution` facts with the
+ *  data-access rules. `missing-org-filter` reads the resolution for Tier 3 (DDL)
+ *  tenancy; the other three rules ignore it (their `needs` declare only
+ *  `data-access-calls`, and the union context carries both).
+ *
+ *  @param calls - The assembled `data-access-calls` fact to analyze.
+ *  @param resolution - The one resolution fact (`missing-org-filter` reads it).
+ *  @param thresholds - The data-access rule thresholds (defaults to `{}`).
+ *  @returns The data-access rules' findings over the facts.
+ */
+export declare function analyzeDataAccessCalls(calls: ResolvedQuery[], resolution: ResolutionFact, thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * The data-access slice: parse → data-access-calls + resolution → rules → findings.
+ *
+ * @param files - The input files to parse and process.
+ * @param thresholds - The data-access rule thresholds (defaults to `{}`).
+ * @param sqlDialect - The corpus's named dialect (null means cannot-fire).
+ * @returns The data-access rules' findings over the assembled facts.
+ */
+export declare function runDataAccessSlice(files: readonly InputFile[], thresholds?: ThresholdValues, sqlDialect?: Dialect | null): Promise<Finding[]>;
+/**
+ * Parse → Process for the `loop-queries` fact. Returns the assembled corpus
+ * fact (every loop whose body issues a DB call, ASTs already freed). The fact
+ * carries no cross-file structure — the `loop-query` rule reduces each element
+ * in isolation, exactly as the legacy `checkLoopQueries` ran once per AST.
+ *
+ * @param files - The input files to parse and process.
+ * @param sqlDialect - The corpus's named dialect (null means cannot-fire).
+ * @returns The assembled `loop-queries` corpus fact.
+ */
+export declare function buildLoopQueries(files: readonly InputFile[], sqlDialect?: Dialect | null): Promise<LoopQueryFact[]>;
+/**
+ * Analyze the assembled `loop-queries` fact with the loop-query rule.
+ *
+ * @param facts - The assembled `loop-queries` fact to analyze.
+ * @param thresholds - The loop-query rule thresholds (defaults to `{}`).
+ * @returns The loop-query rule's findings over the fact.
+ */
+export declare function analyzeLoopQueries(facts: LoopQueryFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * The loop-queries slice: parse → loop-queries → loop-query → findings.
+ *
+ * @param files - The input files to parse and process.
+ * @param thresholds - The loop-query rule thresholds (defaults to `{}`).
+ * @param sqlDialect - The corpus's named dialect (null means cannot-fire).
+ * @returns The loop-query rule's findings over the assembled facts.
+ */
+export declare function runLoopQueriesSlice(files: readonly InputFile[], thresholds?: ThresholdValues, sqlDialect?: Dialect | null): Promise<Finding[]>;
+/**
+ * Parse → Process for the `dynamic-sql` fact. Returns the assembled corpus
+ * fact (every dangerous query/execute call site, ASTs already freed). The fact
+ * carries no cross-file structure — the `dynamic-sql-construction` rule reduces
+ * each element in isolation, exactly as the legacy `checkSQLInjection` ran once
+ * per AST.
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `dynamic-sql` corpus fact.
+ */
+export declare function buildDynamicSql(files: readonly InputFile[]): Promise<DynamicSqlFact[]>;
+/**
+ * Analyze the assembled `dynamic-sql` fact with the dynamic-sql-construction rule.
+ *
+ * @param facts - The assembled `dynamic-sql` fact to analyze.
+ * @param thresholds - The dynamic-sql rule thresholds (defaults to `{}`).
+ * @returns The dynamic-sql-construction rule's findings over the fact.
+ */
+export declare function analyzeDynamicSql(facts: DynamicSqlFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The dynamic-sql slice: parse → dynamic-sql → dynamic-sql-construction → findings. */
+export declare function runDynamicSqlSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `schema-usage` fact. Returns the assembled corpus
+ * fact (every table reference from every file, ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @param sqlDialect - The corpus's named dialect for SQL parsing, or null/undefined.
+ * @returns The assembled `schema-usage` corpus fact.
+ */
+export declare function buildSchemaUsage(files: readonly InputFile[], sqlDialect?: Dialect | null): Promise<SchemaUsageFact[]>;
+/**
+ * Parse → Process for the `ddl-declarations` fact (DDL in code and `.sql`
+ * migration files). Returns the raw declarations both corpus processors
+ * (`resolution`, `migration-history`) reduce — so the two derive from one
+ * parse pass rather than re-parsing the same files twice.
+ *
+ * @param files - The input files to parse and process.
+ * @param sqlDialect - The corpus's named dialect for SQL parsing, or null/undefined.
+ * @returns The raw `ddl-declarations` the corpus processors reduce.
+ */
+export declare function buildDdlDeclarations(files: readonly InputFile[], sqlDialect?: Dialect | null): Promise<SchemaDeclaration[]>;
+/**
+ * Parse → Process for the `schema-objects` fact (ORM `const <id> = pgTable(
+ * 'name', …)` bindings). Returns the identifier → SQL-name bindings the
+ * `resolution` corpus processor folds into its alias map.
+ *
+ * @param files - The input files to parse and process.
+ * @returns The raw `schema-objects` the corpus processor reduces.
+ */
+export declare function buildSchemaObjects(files: readonly InputFile[]): Promise<SchemaObject[]>;
+/**
+ * Reduce the `ddl-declarations` + `schema-objects` + `file-symbols` facts
+ * through the `resolution` corpus processor into the one resolution fact. The
+ * JSON-schema half of the old catalog is config-driven (§10) and not reachable
+ * from this simple runner, so it is dropped — this is the DDL-only slice of the
+ * resolution, the config-free half the corpus processor consumes.
+ *
+ * @param files The input files to parse and process.
+ * @param sqlDialect The corpus's named dialect (null means cannot-fire).
+ * @returns The reduced resolution fact.
+ */
+export declare function buildResolution(files: readonly InputFile[], sqlDialect?: Dialect | null): Promise<ResolutionFact>;
+/**
+ * Reduce the `ddl-declarations` fact through the `migration-history` corpus
+ * processor into the cross-file drop provenance (`stale-table-reference` reads
+ * it to partition dropped tables from never-existed tables).
+ *
+ * @param files The input files to parse and process.
+ * @param sqlDialect The corpus's named dialect (null means cannot-fire).
+ */
+export declare function buildMigrationHistory(files: readonly InputFile[], sqlDialect?: Dialect | null): Promise<MigrationHistory>;
+/** Analyze the `schema-usage` + `resolution` + `migration-history` facts with
+ *  the schema rules. `unknown-table` reads the resolution and migration-history
+ *  to hand dropped tables to `stale-table-reference`; `table-naming-convention`
+ *  reads `schema-usage` alone (its `needs` declares only that fact, and the
+ *  union context carries all three).
+ *
+ *  @param usages - The assembled `schema-usage` fact to analyze.
+ *  @param resolution - The one resolution fact (`unknown-table` reads it).
+ *  @param migrationHistory - The cross-file drop provenance.
+ *  @param thresholds - The schema rule thresholds (defaults to `{}`).
+ *  @returns The schema rules' findings over the facts.
+ */
+export declare function analyzeSchemaRules(usages: SchemaUsageFact[], resolution: ResolutionFact, migrationHistory: MigrationHistory, thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The schema slice: parse → schema-usage + resolution + migration-history →
+ *  schema rules → findings.
+ *
+ *  @param files - The input files to parse and process.
+ *  @param thresholds - The schema rule thresholds (defaults to `{}`).
+ *  @param sqlDialect - The corpus's named dialect (null means cannot-fire).
+ *  @returns The schema rules' findings over the assembled facts.
+ */
+export declare function runSchemaSlice(files: readonly InputFile[], thresholds?: ThresholdValues, sqlDialect?: Dialect | null): Promise<Finding[]>;
+/**
+ * Analyze the assembled `schema-usage` fact with the cross-domain lifecycle
+ * rules (`written-never-read`, `read-never-written`). Like the schema rules,
+ * these reduce the whole corpus at once; the two detectors are pure set
+ * differences over the flat usage list.
+ *
+ * @param usages - The assembled `schema-usage` fact to analyze.
+ * @param thresholds - The cross-domain rule thresholds (defaults to `{}`).
+ * @returns The cross-domain lifecycle rules' findings over the fact.
+ */
+export declare function analyzeCrossDomain(usages: SchemaUsageFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The cross-domain slice: parse → schema-usage → lifecycle rules → findings.
+ * @param files - The input files to parse and process.
+ * @param thresholds - The cross-domain rule thresholds.
+ * @param sqlDialect - The corpus's named dialect for SQL parsing, or null/undefined.
+ * @returns The cross-domain lifecycle rules' findings over the fact. */
+export declare function runCrossDomainSlice(files: readonly InputFile[], thresholds?: ThresholdValues, sqlDialect?: Dialect | null): Promise<Finding[]>;
+/**
+ * Parse → Process for the `cross-language-entities` fact. Returns the assembled
+ * corpus fact (every entity from every file, ASTs already freed). The
+ * dependency-graph rules read the *whole* corpus at once, so unlike the SOLID /
+ * data-access slices there is no per-file analysis arm — the fact is the input.
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `cross-language-entities` corpus fact.
+ */
+export declare function buildCrossLanguageEntities(files: readonly InputFile[]): Promise<Entity[]>;
+/**
+ * Analyze the assembled `cross-language-entities` fact with the dependency-graph rules.
+ *
+ * @param entities - The assembled `cross-language-entities` fact to analyze.
+ * @param thresholds - The dependency-graph rule thresholds (defaults to `{}`).
+ * @returns The dependency-graph rules' findings over the fact.
+ */
+export declare function analyzeDependencyGraph(entities: Entity[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The dependency-graph slice: parse → cross-language-entities → graph rules → findings. */
+export declare function runDependencyGraphSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Analyze the assembled `cross-language-entities` fact with the schema-validator
+ * rules. The dependency-graph and schema-validator slices share one producer;
+ * they differ only in which rules reduce the fact. Like the dependency-graph
+ * rules, the schema-validator rules read the *whole* corpus at once.
+ *
+ * @param entities - The assembled `cross-language-entities` fact to analyze.
+ * @param thresholds - The schema-validator rule thresholds (defaults to `{}`).
+ * @returns The schema-validator rules' findings over the fact.
+ */
+export declare function analyzeSchemaValidator(entities: Entity[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The schema-validator slice: parse → cross-language-entities → validator rules → findings. */
+export declare function runSchemaValidatorSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `style-declarations` fact. Returns the assembled
+ * corpus fact (every declaration/token/class-usage from every CSS/SCSS/TS/JS
+ * file, ASTs already freed). `projectRoot` threads through to the TS/JS producer
+ * so Tailwind utility expansion resolves the project's theme tokens.
+ *
+ * @param files - The input files to parse and process.
+ * @param projectRoot - The optional project root for Tailwind token resolution.
+ * @returns The assembled `style-declarations` corpus fact.
+ */
+export declare function buildStyleDeclarations(files: readonly InputFile[], projectRoot?: string): Promise<StyleDeclarationsFile[]>;
+/**
+ * Analyze the assembled `style-declarations` fact with the styles rules.
+ *
+ * @param facts - The assembled `style-declarations` fact to analyze.
+ * @param thresholds - The styles rule thresholds (defaults to `{}`).
+ * @returns The styles rules' findings over the fact.
+ */
+export declare function analyzeStyles(facts: StyleDeclarationsFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * The styles slice: parse → style-declarations → styles rules → findings.
+ *
+ * @param files - The input files to parse and process.
+ * @param projectRoot - The optional project root for Tailwind token resolution.
+ * @param thresholds - The styles rule thresholds (defaults to `{}`).
+ * @returns The styles rules' findings over the assembled fact.
+ */
+export declare function runStylesSlice(files: readonly InputFile[], projectRoot?: string, thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `function-index` fact. Returns the assembled corpus
+ * fact (every function/method/component from every file, ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `function-index` corpus fact.
+ */
+export declare function buildFunctionIndex(files: readonly InputFile[]): Promise<FunctionIndexFact[]>;
+/**
+ * Parse → Process for the `export-form` fact. Returns the assembled corpus fact
+ * (every exported `(name, isDefault)` pair from every file, ASTs already freed).
+ * The `conventions/export-shape` rule reads it to resolve a function's export
+ * form — the same AST-extracted exports the legacy reducer read as `exportsMap`.
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `export-form` corpus fact.
+ */
+export declare function buildExportForms(files: readonly InputFile[]): Promise<ExportFormFact[]>;
+/**
+ * Parse → Process for the `import-form` fact. Returns the assembled corpus fact
+ * (every import's classified form from every file). The producer reads
+ * `.source` (not the AST) via `parseFileImports`, so the AST is freed without
+ * being consumed by this producer — but the parse still validates the file.
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `import-form` corpus fact.
+ */
+export declare function buildImportForms(files: readonly InputFile[]): Promise<ImportFormFact[]>;
+/** Analyze the assembled `function-index` + `mined-conventions` + `export-form` +
+ *  `import-form` facts with the five function-index-servable conventions rules
+ *  (three `function-index`+`mined-conventions` rules plus the `export-form`-
+ *  reading export-shape rule and the `import-form`-reading import-form rule).
+ *
+ *  @param facts - The assembled `function-index` fact to analyze.
+ *  @param conventions - The assembled `mined-conventions` fact to analyze.
+ *  @param exportForms - The assembled `export-form` fact (`export-shape` reads it).
+ *  @param importForms - The assembled `import-form` fact (`import-form` reads it).
+ *  @param thresholds - The conventions rule thresholds (defaults to `{}`).
+ *  @returns The conventions rules' findings over the facts.
+ */
+export declare function analyzeConventions(facts: FunctionIndexFact[], conventions: MinedConvention[], exportForms: ExportFormFact[], importForms: ImportFormFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * The conventions slice: parse → function-index + export-form + import-form → mined-conventions → rules → findings.
+ *
+ * @param files - The input files to parse and process.
+ * @param thresholds - The conventions rule thresholds (defaults to `{}`).
+ * @returns The conventions rules' findings over the assembled facts.
+ */
+export declare function runConventionsSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `imports` fact. Returns the assembled corpus fact
+ * (every import statement from every file, ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `imports` corpus fact.
+ */
+export declare function buildImports(files: readonly InputFile[]): Promise<ImportFact[]>;
+/**
+ * Parse → Process for the `string-literals` fact. Returns the assembled corpus
+ * fact (every string/template-string literal from every file, ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `string-literals` corpus fact.
+ */
+export declare function buildStringLiterals(files: readonly InputFile[]): Promise<StringLiteralFact[]>;
+/**
+ * Parse → Process for the `code-block` fact. Returns the assembled corpus fact
+ * (every code block + shape fragment from every file, ASTs already freed). The
+ * producer projects the raw blocks/fragments with no threshold and no dedup;
+ * the three block rules re-apply `minLineThreshold`/`similarityThreshold`/
+ * `minShapeNames`/`excludePatterns`/check-gates over this plain data.
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `code-block` corpus fact.
+ */
+export declare function buildCodeBlocks(files: readonly InputFile[]): Promise<CodeBlockFact[]>;
+/**
+ * Analyze the assembled `imports` + `string-literals` + `code-block` facts with
+ * the six DRY rules. Each rule reads only the fact its `needs` declares; the
+ * union context carries all four. The three block rules partition `code-block`
+ * by file before their filter → dedupe → compare, because the legacy
+ * `analyzeAST` ran once per file (a block in file A is never compared against a
+ * block in file B). `diverging-clone` reads `clone-pair-history`, empty here
+ * (the slice test has no index), so it emits nothing.
+ *
+ * @param imports - The assembled `imports` fact to analyze.
+ * @param stringLiterals - The assembled `string-literals` fact to analyze.
+ * @param codeBlocks - The assembled `code-block` fact to analyze.
+ * @param thresholds - The DRY rule thresholds (defaults to `{}`).
+ * @returns The DRY rules' findings over the facts.
+ */
+export declare function analyzeDry(imports: ImportFact[], stringLiterals: StringLiteralFact[], codeBlocks: CodeBlockFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * The dry slice: parse → imports + string-literals + code-block → DRY rules → findings.
+ *
+ * @param files - The input files to parse and process.
+ * @param thresholds - The DRY rule thresholds (defaults to `{}`).
+ * @returns The DRY rules' findings over the assembled facts.
+ */
+export declare function runDrySlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Analyze the assembled `string-literals` fact with the hardcoded-connection
+ * rule. `hardcoded-secret` reads a different fact (`secret-candidates`) and is
+ * served by `analyzeSecrets` below, not this slice.
+ *
+ * @param stringLiterals - The assembled `string-literals` fact to analyze.
+ * @param thresholds - The security rule thresholds (defaults to `{}`).
+ * @returns The hardcoded-connection rule's findings over the fact.
+ */
+export declare function analyzeSecurity(stringLiterals: StringLiteralFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The security slice: parse → string-literals → hardcoded-credential rules → findings. */
+export declare function runSecuritySlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `secret-candidates` fact. Returns the assembled corpus
+ * fact (every credential-position string from every file, ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `secret-candidates` corpus fact.
+ */
+export declare function buildSecretCandidates(files: readonly InputFile[]): Promise<SecretCandidate[]>;
+/**
+ * Analyze the assembled `secret-candidates` fact with the hardcoded-secret rule.
+ *
+ * @param candidates - The assembled `secret-candidates` fact to analyze.
+ * @param thresholds - The hardcoded-secret rule thresholds (defaults to `{}`).
+ * @returns The hardcoded-secret rule's findings over the fact.
+ */
+export declare function analyzeSecrets(candidates: SecretCandidate[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The secret-candidates slice: parse → secret-candidates → hardcoded-secret → findings. */
+export declare function runSecretsSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `security-candidates` fact. Returns the assembled
+ * corpus fact (every command-injection/dynamic-require/unescaped-html candidate
+ * from every file, ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `security-candidates` corpus fact.
+ */
+export declare function buildSecurityCandidates(files: readonly InputFile[]): Promise<SecurityCandidate[]>;
+/**
+ * Analyze the assembled `security-candidates` fact with the three defect rules.
+ *
+ * @param candidates - The assembled `security-candidates` fact to analyze.
+ * @param thresholds - The security-defect rule thresholds (defaults to `{}`).
+ * @returns The three defect rules' findings over the fact.
+ */
+export declare function analyzeSecurityDefects(candidates: SecurityCandidate[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The security-candidates slice: parse → security-candidates → defect rules → findings. */
+export declare function runSecurityDefectsSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process → Reduce for the `query-sites` fact (Spec 70 Item 4, step 3).
+ * The legacy `query-sites` producer did two jobs — locate each DB-query site and
+ * gate the file on DB context — with a second parse of the file's provenance.
+ * The collapse splits them: `query-site-candidates` runs the location job
+ * un-gated while the AST lives, and the `query-sites` corpus producer re-derives
+ * each file's gate (`glob || dbProvenanced || dbActivity || hasSqlTag`) once the
+ * `receiver-provenance` fixed point supplies the cross-file seed, then emits the
+ * sites of the gated files. This helper builds the raw file facts + the fixed
+ * point and reduces through the two corpus producers, so the returned fact is
+ * byte-identical to the legacy gated extraction.
+ *
+ * @param files - The input files to parse and process.
+ * @param sqlDialect - The corpus's named dialect for SQL parsing, or null/undefined.
+ * @returns The assembled `query-sites` corpus fact.
+ */
+export declare function buildQuerySites(files: readonly InputFile[], sqlDialect?: Dialect | null): Promise<QuerySiteFact[]>;
+/**
+ * Analyze the assembled `query-sites` fact with the too-many-queries rule.
+ *
+ * @param facts - The assembled `query-sites` fact to analyze.
+ * @param thresholds - The too-many-queries rule thresholds (defaults to `{}`).
+ * @returns The too-many-queries rule's findings over the fact.
+ */
+export declare function analyzeQuerySites(facts: QuerySiteFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The query-sites slice: parse → query-sites → too-many-queries → findings. */
+export declare function runQuerySitesSlice(files: readonly InputFile[], thresholds?: ThresholdValues, sqlDialect?: Dialect | null): Promise<Finding[]>;
+/**
+ * Parse → Process for the `react-component` fact. Returns the assembled corpus
+ * fact (one scan per file, each a full component universe: metadata, imports,
+ * JSX elements, hooks, props, complexity), ASTs already freed.
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `react-component` corpus fact.
+ */
+export declare function buildReactComponents(files: readonly InputFile[]): Promise<ReactComponentScan[]>;
+/**
+ * Analyze the assembled `react-component` fact with the seven react rules.
+ *
+ * @param facts - The assembled `react-component` fact to analyze.
+ * @param thresholds - The react rule thresholds (defaults to `{}`).
+ * @returns The react rules' findings over the fact.
+ */
+export declare function analyzeReactComponents(facts: ReactComponentScan[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The react slice: parse → react-component → react rules → findings. */
+export declare function runReactComponentsSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `file-header` fact. Returns the assembled corpus
+ * fact (one leading comment projection per file, ASTs already freed).
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `file-header` corpus fact.
+ */
+export declare function buildFileHeaders(files: readonly InputFile[]): Promise<FileHeaderFact[]>;
+/**
+ * Analyze the assembled `file-header` fact with the file-documentation rule.
+ *
+ * @param facts - The assembled `file-header` fact to analyze.
+ * @param thresholds - The file-documentation rule thresholds (defaults to `{}`).
+ * @returns The file-documentation rule's findings over the fact.
+ */
+export declare function analyzeFileHeaders(facts: FileHeaderFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/** The file-header slice: parse → file-header → file-documentation → findings. */
+export declare function runFileHeadersSlice(files: readonly InputFile[], thresholds?: ThresholdValues): Promise<Finding[]>;
+/**
+ * Parse → Process for the `json-document` fact. Returns the assembled corpus
+ * fact (one parsed JSON document per `.json` file, ASTs already freed). The
+ * producer reads `.source` (the JsonAdapter has no code constructs), so the
+ * parse still validates the file but the fact is the `JSON.parse` value.
+ *
+ * @param files - The input files to parse and process.
+ * @returns The assembled `json-document` corpus fact.
+ */
+export declare function buildJsonDocuments(files: readonly InputFile[]): Promise<JsonDocumentFact[]>;
+/**
+ * Analyze the assembled `schema-validations` fact with the 17 schema-json rules.
+ *
+ * @param validations - The assembled `schema-validations` fact to analyze.
+ * @param thresholds - The schema-json rule thresholds (defaults to `{}`).
+ * @returns The 17 schema-json rules' findings over the fact.
+ */
+export declare function analyzeSchemaJson(validations: SchemaValidationFact[], thresholds?: ThresholdValues): Promise<Finding[]>;
+//# sourceMappingURL=runner.d.ts.map

package/dist/phase/runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"runner.d.ts","sourceRoot":"","sources":["../../src/phase/runner.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAIH,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAmBhE,OAAO,KAAK,EACV,UAAU,EACV,WAAW,EAGX,aAAa,EACb,aAAa,EACb,cAAc,EACd,eAAe,EACf,iBAAiB,EACjB,YAAY,EACZ,cAAc,EACd,gBAAgB,EAChB,MAAM,EACN,MAAM,EACN,eAAe,EACf,OAAO,EAEP,qBAAqB,EACrB,iBAAiB,EACjB,eAAe,EACf,cAAc,EACd,cAAc,EACd,UAAU,EACV,iBAAiB,EACjB,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,kBAAkB,EAClB,cAAc,EACd,aAAa,EACb,gBAAgB,EAChB,oBAAoB,EAIrB,MAAM,YAAY,CAAC;AAEpB,+EAA+E;AAC/E,MAAM,MAAM,SAAS,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAAC;AAE5E;;;;;GAKG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAW9C;AAED;;;;;;;;;;;;GAYG;AACH,wBAAsB,QAAQ,CAC5B,KAAK,EAAE,SAAS,EAChB,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAC1B,OAAO,CAAC,UAAU,GAAG,IAAI,CAAC,CA0B5B;AAiCD;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,WAAW,EAAE,CAAC,CAE1F;AA2BD;;;;;;;;;;;;;GAaG;AACH,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,UAAU,EAAE,cAAc,EAAE,UAAU,GAAE,eAAoB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAQjJ;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAMvH;AAID;;;;;;GAMG;AACH,wBAAsB,oBAAoB,CAAC,OAAO,EAAE,WAAW,EAAE,EAAE,UAAU,GAAE,eAAoB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAEvH;AAED,sFAAsF;AACtF,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAGzH;AA8CD;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAC1B,OAAO,CAAC,aAAa,EAAE,CAAC,CAE1B;AAED;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,aAAa,EAAE,EACtB,UAAU,EAAE,cAAc,EAC1B,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAMnJ;AAID;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAC1B,OAAO,CAAC,aAAa,EAAE,CAAC,CAE1B;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,aAAa,EAAE,EACtB,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,UAAU,CAAC,EAAE,eAAe,EAC5B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAC1B,OAAO,CAAC,OAAO,EAAE,CAAC,CAGpB;AAID;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAE5F;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,cAAc,EAAE,EACvB,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED,wFAAwF;AACxF,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAGtH;AAID;;;;;;;GAOG;AACH,wBAAsB,gBAAgB,CACpC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAC1B,OAAO,CAAC,eAAe,EAAE,CAAC,CAE5B;AAED;;;;;;;;;GASG;AACH,wBAAsB,oBAAoB,CACxC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAC1B,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAE9B;AAED;;;;;;;GAOG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,YAAY,EAAE,CAAC,CAE7F;AAED;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,cAAc,CAAC,CAOvH;AAED;;;;;;;GAOG;AACH,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,gBAAgB,CAAC,CAG/H;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,MAAM,EAAE,eAAe,EAAE,EACzB,UAAU,EAAE,cAAc,EAC1B,gBAAgB,EAAE,gBAAgB,EAClC,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAU/I;AAID;;;;;;;;;GASG;AACH,wBAAsB,kBAAkB,CAAC,MAAM,EAAE,eAAe,EAAE,EAAE,UAAU,GAAE,eAAoB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAExH;AAED;;;;wEAIwE;AACxE,wBAAsB,mBAAmB,CACvC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,UAAU,CAAC,EAAE,eAAe,EAC5B,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAC1B,OAAO,CAAC,OAAO,EAAE,CAAC,CAGpB;AAID;;;;;;;;GAQG;AACH,wBAAsB,0BAA0B,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAa/F;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,GAAE,eAAoB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAErH;AAED,4FAA4F;AAC5F,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAG3H;AAID;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,UAAU,GAAE,eAAoB,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAErH;AAED,gGAAgG;AAChG,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAG3H;AAID;;;;;;;;;GASG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,WAAW,CAAC,EAAE,MAAM,GACnB,OAAO,CAAC,qBAAqB,EAAE,CAAC,CAalC;AAED;;;;;;GAMG;AACH,wBAAsB,aAAa,CACjC,KAAK,EAAE,qBAAqB,EAAE,EAC9B,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAMpB;AAED;;;;;;;GAOG;AACH,wBAAsB,cAAc,CAClC,KAAK,EAAE,SAAS,SAAS,EAAE,EAC3B,WAAW,CAAC,EAAE,MAAM,EACpB,UAAU,CAAC,EAAE,eAAe,GAC3B,OAAO,CAAC,OAAO,EAAE,CAAC,CAGpB;AAID;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAalG;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAa7F;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAa7F;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,iBAAiB,EAAE,EAC1B,WAAW,EAAE,eAAe,EAAE,EAC9B,WAAW,EAAE,cAAc,EAAE,EAC7B,WAAW,EAAE,cAAc,EAAE,EAC7B,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAapB;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAYvH;AAID;;;;;;GAMG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,UAAU,EAAE,CAAC,CAarF;AAED;;;;;;GAMG;AACH,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAanG;AAED;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAa3F;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,UAAU,CAC9B,OAAO,EAAE,UAAU,EAAE,EACrB,cAAc,EAAE,iBAAiB,EAAE,EACnC,UAAU,EAAE,aAAa,EAAE,EAC3B,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED;;;;;;GAMG;AACH,wBAAsB,WAAW,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAO/G;AAID;;;;;;;;GAQG;AACH,wBAAsB,eAAe,CACnC,cAAc,EAAE,iBAAiB,EAAE,EACnC,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED,2FAA2F;AAC3F,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAGpH;AAID;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,eAAe,EAAE,CAAC,CAanG;AAED;;;;;;GAMG;AACH,wBAAsB,cAAc,CAClC,UAAU,EAAE,eAAe,EAAE,EAC7B,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED,4FAA4F;AAC5F,wBAAsB,eAAe,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAGnH;AAID;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC,CAavG;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,UAAU,EAAE,iBAAiB,EAAE,EAC/B,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED,4FAA4F;AAC5F,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAG3H;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,aAAa,EAAE,CAAC,CAwBxH;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,aAAa,EAAE,EACtB,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED,gFAAgF;AAChF,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,EAAE,UAAU,CAAC,EAAE,OAAO,GAAG,IAAI,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAGnJ;AAID;;;;;;;GAOG;AACH,wBAAsB,oBAAoB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,kBAAkB,EAAE,CAAC,CAarG;AAED;;;;;;GAMG;AACH,wBAAsB,sBAAsB,CAC1C,KAAK,EAAE,kBAAkB,EAAE,EAC3B,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED,yEAAyE;AACzE,wBAAsB,uBAAuB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAG3H;AAID;;;;;;GAMG;AACH,wBAAsB,gBAAgB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,cAAc,EAAE,CAAC,CAa7F;AAED;;;;;;GAMG;AACH,wBAAsB,kBAAkB,CACtC,KAAK,EAAE,cAAc,EAAE,EACvB,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB;AAED,kFAAkF;AAClF,wBAAsB,mBAAmB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,EAAE,UAAU,CAAC,EAAE,eAAe,GAAG,OAAO,CAAC,OAAO,EAAE,CAAC,CAGvH;AAID;;;;;;;;GAQG;AACH,wBAAsB,kBAAkB,CAAC,KAAK,EAAE,SAAS,SAAS,EAAE,GAAG,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAajG;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,WAAW,EAAE,oBAAoB,EAAE,EACnC,UAAU,GAAE,eAAoB,GAC/B,OAAO,CAAC,OAAO,EAAE,CAAC,CAEpB"}