@velum-labs/routekit-eval-setup 1.3.2 → 1.5.0

package/dist/services/pipeline-oracle/service.js

@@ -0,0 +1,256 @@
+import { Clock, Effect, Schema } from "effect";
+import { checkpointDigestV1, PipelineStageError, pipelineStageToProgressStageV1 } from "../../case-pipeline-protocol.js";
+import { RepositoryFoundryError } from "../../errors.js";
+import { assertRepositoryHiddenFixtureSuiteV1, RepositoryHiddenFixtureSuiteV1 } from "../../repository-fixture-protocol.js";
+import { repositoryFoundryRoleOutputCeilingV1 } from "../../repository-foundry-plan-protocol.js";
+import { repositoryFoundryModelAssignmentV1 } from "../../repository-language-model-protocol.js";
+import { normalizePipelineFailureV1 } from "../budgeted-model/service.js";
+import { repositoryFixturePreflightFeedbackV1, validateRepositoryFixturesV1 } from "../fixture-validation/service.js";
+import { reportFoundryStageV1 } from "../foundry-progress/service.js";
+import { groundedStructuredGenerationV1 } from "../grounded-authoring/service.js";
+import { RepositoryFoundryLanguageModel } from "../language-model/service.js";
+const OracleAuthorSubmissionV1 = Schema.Struct({
+    suite: RepositoryHiddenFixtureSuiteV1,
+    scopeCoverage: Schema.Array(Schema.Struct({
+        scopeId: Schema.String,
+        outcome: Schema.Literals(["covered", "unsupported", "contradictory", "uncertain"]),
+        fixtureIds: Schema.Array(Schema.String),
+        detail: Schema.String
+    }))
+});
+const ORACLE_AUTHOR_INSTRUCTIONS = `You are the grounded hidden-oracle author for a repository coding benchmark.
+Use the complete dimension contract, visible task, grounded scope, and the two pinned Git trees. Read and search the trees instead of guessing APIs. Build a suite of isolated hidden test overlays for user-observable behavior. Each fixture must have one complete independently executable overlay at a reviewed test path. Include boundary behavior and at least one counterfactual or metamorphic fixture. Do not inspect or prescribe a solution implementation.
+
+Before submitting, call run_fixture separately for EVERY overlay exactly as it will appear in the submitted suite. Repair compile, setup, API, assertion, and execution failures using those observations. A model claim is not evidence: the host will independently execute every submitted overlay against the pinned reference. Never weaken an expectation merely to make the reference pass. Do not use source-text inspection, patch identity, filenames, implementation style, timing guesses, or another test's result as an assertion.
+
+Return scopeCoverage as an advisory assessment against every grounded scope clause. Be honest about unsupported, contradictory, or uncertain clauses. A short proposal, missing field, invalid action, or failed execution is feedback for this same role, not a reason to abandon the case. Submit only {suite, scopeCoverage}.`;
+const STAGE = "oracle";
+const failure = (detail, cause) => new RepositoryFoundryError({
+    operation: "run-pipeline-stage",
+    detail,
+    ...(cause === undefined ? {} : { cause })
+});
+const stageFailure = (detail, terminal, cause) => new RepositoryFoundryError({
+    operation: "run-pipeline-stage",
+    detail,
+    cause: new PipelineStageError({ stage: STAGE, detail, terminal, cause })
+});
+const describe = (cause) => cause instanceof Error && cause.message.trim().length > 0 ? cause.message : String(cause);
+const allowedTestPathsOf = (seed) => new Set(seed.capabilityEvidence
+    .filter((evidence) => evidence.kind === "test" && evidence.path !== undefined)
+    .map((evidence) => evidence.path)
+    .filter((path) => !seed.environment.protectedControlPaths.includes(path)));
+const preflightFindings = (error) => {
+    const detail = repositoryFixturePreflightFeedbackV1(error);
+    if (error.detail.startsWith("fixture preflight input failed validation") ||
+        error.detail.startsWith("fixture preflight has no independently executable")) {
+        return [{ kind: "contract", message: detail }];
+    }
+    return [{ kind: "execution", message: detail }];
+};
+const validateCoverageSubmission = (value, scopeIds) => {
+    const expectedScopeIds = new Set(scopeIds);
+    const submittedScopeIds = value.scopeCoverage.map((coverage) => coverage.scopeId);
+    const fixtureIds = new Set(value.suite.fixtures.map((fixture) => fixture.id));
+    const findings = [];
+    if (submittedScopeIds.length !== scopeIds.length ||
+        new Set(submittedScopeIds).size !== submittedScopeIds.length ||
+        submittedScopeIds.some((scopeId) => !expectedScopeIds.has(scopeId))) {
+        findings.push({
+            kind: "contract",
+            message: "scopeCoverage must contain every grounded scope clause exactly once"
+        });
+    }
+    for (const coverage of value.scopeCoverage) {
+        if (coverage.detail.trim().length === 0) {
+            findings.push({
+                kind: "contract",
+                message: `scopeCoverage ${JSON.stringify(coverage.scopeId)} requires a non-empty assessment`
+            });
+        }
+        if (coverage.fixtureIds.some((fixtureId) => !fixtureIds.has(fixtureId))) {
+            findings.push({
+                kind: "contract",
+                message: `scopeCoverage ${JSON.stringify(coverage.scopeId)} refers to a fixture that is not in the submitted suite`
+            });
+        }
+    }
+    return findings;
+};
+/**
+ * Reference execution proves fixture executability, not behavioral coverage.
+ * Until a later tournament measures an escape against a solution, every scope
+ * remains explicitly uncertain regardless of author self-report.
+ */
+const PREFLIGHT_COVERAGE_ADVISORY = "Reference preflight established executability only; behavioral coverage awaits measured tournament observations.";
+const uncertainScopeCoverage = (input) => input.scopeIds.map((scopeId) => {
+    const proposed = input.proposed.find((coverage) => coverage.scopeId === scopeId);
+    let detail = proposed?.detail ?? "The oracle author supplied no additional assessment.";
+    while (detail.startsWith(PREFLIGHT_COVERAGE_ADVISORY))
+        detail = detail.slice(PREFLIGHT_COVERAGE_ADVISORY.length).trimStart();
+    return {
+        scopeId,
+        outcome: "uncertain",
+        fixtureIds: [...new Set(proposed?.fixtureIds ?? [])],
+        detail: `${PREFLIGHT_COVERAGE_ADVISORY} ${detail}`
+    };
+});
+const checkpointOf = (input) => ({
+    version: 1,
+    stage: STAGE,
+    parentDigest: input.parentDigest,
+    createdAt: input.createdAt,
+    suite: input.suite,
+    fixtureMetadata: input.suite.fixtures.map((fixture) => ({
+        id: fixture.id,
+        kind: fixture.kind,
+        expectationMode: fixture.expectationMode,
+        description: fixture.description,
+        expectedBehavior: fixture.expectedBehavior,
+        testPath: fixture.testPath
+    })),
+    scopeCoverage: [...input.scopeCoverage],
+    preflight: { passed: true, repairs: 0 },
+    witnesses: [],
+    coverageRounds: 0
+});
+/**
+ * Authors and reference-preflights the initial oracle. Proactive coverage
+ * criticism and speculative witness generation are intentionally deferred to
+ * the tournament, where actual correct and wrong solutions provide measured
+ * escapes. Only executed observations can later establish admission evidence.
+ */
+export const runPipelineOracleStageV1 = (input) => Effect.gen(function* () {
+    const seedCheckpoint = input.checkpoints.seed;
+    const spec = input.checkpoints.spec;
+    if (seedCheckpoint === undefined || spec === undefined) {
+        return yield* failure("oracle requires accepted seed and specification checkpoints");
+    }
+    const seed = seedCheckpoint.seed;
+    const referenceCommit = seed.referenceCommit;
+    if (seed.status !== "qualified" || referenceCommit === undefined) {
+        return yield* failure("oracle requires a replay-qualified pinned reference");
+    }
+    const parentDigest = checkpointDigestV1(spec);
+    const resumed = input.checkpoints.oracle;
+    if (resumed !== undefined && resumed.parentDigest === parentDigest) {
+        const needsMigration = resumed.witnesses.length > 0 ||
+            resumed.coverageRounds > 0 ||
+            resumed.scopeCoverage.length !== spec.scope.length ||
+            spec.scope.some((entry) => {
+                const coverage = resumed.scopeCoverage.filter((value) => value.scopeId === entry.id);
+                return coverage.length !== 1 || coverage[0]?.outcome !== "uncertain";
+            });
+        // Resume is not new science. Preserve the exact accepted checkpoint,
+        // including its advisory text and preflight metadata, unless migrating
+        // a legacy speculative-coverage checkpoint.
+        const checkpoint = needsMigration
+            ? checkpointOf({
+                parentDigest,
+                createdAt: resumed.createdAt,
+                suite: resumed.suite,
+                scopeCoverage: uncertainScopeCoverage({
+                    scopeIds: spec.scope.map((entry) => entry.id),
+                    proposed: resumed.scopeCoverage
+                })
+            })
+            : resumed;
+        if (needsMigration)
+            yield* input.checkpoint(checkpoint);
+        yield* reportFoundryStageV1(pipelineStageToProgressStageV1(STAGE), `using checkpointed reference-preflight oracle; fixtures=${String(resumed.suite.fixtures.length)}`);
+        return checkpoint;
+    }
+    const allowedTestPaths = allowedTestPathsOf(seed);
+    if (allowedTestPaths.size === 0) {
+        return yield* stageFailure("qualified seed exposes no reviewed, unprotected test path", true, { referenceCommit });
+    }
+    yield* reportFoundryStageV1(pipelineStageToProgressStageV1(STAGE), "grounded oracle authoring with reference execution");
+    const languageModel = yield* RepositoryFoundryLanguageModel;
+    const scopeIds = spec.scope.map((entry) => entry.id);
+    let acceptedSuite;
+    const authored = yield* groundedStructuredGenerationV1({
+        checkpointStore: input.workCheckpointStore,
+        languageModel,
+        assignment: repositoryFoundryModelAssignmentV1(input.context.modelPlan, "oracle-designer"),
+        operationId: `${input.context.caseId}:pipeline:oracle:author`,
+        instructions: ORACLE_AUTHOR_INSTRUCTIONS,
+        task: {
+            dimension: input.context.dimension,
+            visibleTask: spec.visible,
+            analysis: spec.analysis,
+            groundedScope: spec.scope,
+            targetBehavior: seed.targetBehavior,
+            initialCommit: seed.initialState.commit,
+            referenceCommit,
+            gradeRecipes: seed.environment.gradeRecipes,
+            allowedTestPaths: [...allowedTestPaths]
+        },
+        outputSchema: OracleAuthorSubmissionV1,
+        schemaName: "routekit_pipeline_oracle_submission_v1",
+        tools: {
+            repositoryRoot: input.context.repositoryRoot,
+            commits: { initial: seed.initialState.commit, reference: referenceCommit },
+            allowedTestPaths,
+            seed,
+            runFixture: true
+        },
+        validateSubmission: (submission) => Effect.gen(function* () {
+            const contractFindings = yield* Effect.sync(() => {
+                try {
+                    assertRepositoryHiddenFixtureSuiteV1(submission.suite);
+                    return validateCoverageSubmission(submission, scopeIds);
+                }
+                catch (cause) {
+                    return [
+                        { kind: "contract", message: describe(cause) }
+                    ];
+                }
+            });
+            if (contractFindings.length > 0)
+                return contractFindings;
+            const preflight = yield* Effect.result(validateRepositoryFixturesV1({
+                checkpointStore: input.workCheckpointStore,
+                repositoryRoot: input.context.repositoryRoot,
+                operationId: `${input.context.caseId}:pipeline:oracle:author-preflight`,
+                seed,
+                suite: submission.suite,
+                allowedTestPaths,
+                context: {
+                    dimension: input.context.dimension,
+                    visibleTask: spec.visible,
+                    groundedScope: spec.scope
+                },
+                modelPlan: input.context.modelPlan,
+                maximumRepairAttempts: 0,
+                oracleCoverageWitnessVersion: 2,
+                oracleRepairFeedbackVersion: 1
+            }).pipe(Effect.provideService(RepositoryFoundryLanguageModel, languageModel)));
+            if (preflight._tag === "Success") {
+                acceptedSuite = preflight.success.suite;
+                return [];
+            }
+            const normalized = normalizePipelineFailureV1(preflight.failure);
+            if (normalized._tag === "PipelineBudgetExhaustedError")
+                return yield* normalized;
+            if (normalized.detail.startsWith("fixture preflight stopped on infrastructure")) {
+                return yield* normalized;
+            }
+            return preflightFindings(normalized);
+        }),
+        maximumOutputTokens: repositoryFoundryRoleOutputCeilingV1("oracle-designer"),
+        maxTurns: Math.max(1, Math.trunc(input.context.budget.maxModelCalls) + 1)
+    });
+    const suite = acceptedSuite ?? authored.value.suite;
+    const checkpoint = checkpointOf({
+        parentDigest,
+        createdAt: new Date(yield* Clock.currentTimeMillis).toISOString(),
+        suite,
+        scopeCoverage: uncertainScopeCoverage({
+            scopeIds,
+            proposed: authored.value.scopeCoverage
+        })
+    });
+    yield* input.checkpoint(checkpoint);
+    yield* reportFoundryStageV1(pipelineStageToProgressStageV1(STAGE), `reference-preflight oracle ready; fixtures=${String(suite.fixtures.length)}; measured coverage deferred to tournament`);
+    return checkpoint;
+}).pipe(Effect.mapError(normalizePipelineFailureV1));

package/dist/services/pipeline-seed/service.d.ts

@@ -0,0 +1,298 @@
+import { Schema } from "effect";
+import { type PipelineStageRunV1, type SeedCheckpointV1 } from "../../case-pipeline-protocol.js";
+/**
+ * The ranker may return a useful prefix. Omitting candidates is not a terminal
+ * exact-count failure: omitted candidates retain their lexical prefilter order
+ * and are still replay-qualified.
+ */
+export declare const PipelineSeedRankingV1: Schema.Struct<{
+    readonly candidates: Schema.$Array<Schema.Struct<{
+        readonly commit: Schema.String;
+        readonly score: Schema.Finite;
+        readonly rationale: Schema.String;
+    }>>;
+}>;
+export type PipelineSeedRankingV1 = typeof PipelineSeedRankingV1.Type;
+/** Rank history once, then let repeated pinned execution select the first viable seed. */
+export declare const runPipelineSeedStageV1: PipelineStageRunV1<SeedCheckpointV1>;
+/** Short name used by the orchestrator. */
+export declare const runPipelineSeedV1: PipelineStageRunV1<{
+    readonly seed: {
+        readonly id: string;
+        readonly source: {
+            readonly kind: "historical-fix";
+            readonly changeEpisodeId: string;
+        } | {
+            readonly kind: "historical-feature";
+            readonly changeEpisodeId: string;
+        } | {
+            readonly kind: "historical-refactor";
+            readonly changeEpisodeId: string;
+        } | {
+            readonly kind: "existing-test";
+            readonly testIds: readonly string[];
+        } | {
+            readonly kind: "public-api";
+            readonly surfaceIds: readonly string[];
+        } | {
+            readonly kind: "schema-contract";
+            readonly protocolIds: readonly string[];
+        } | {
+            readonly kind: "production-request";
+            readonly requestId: string;
+        } | {
+            readonly kind: "reviewed-synthetic-gap";
+            readonly reviewId: string;
+        };
+        readonly version: 1;
+        readonly rejectionReasons: readonly string[];
+        readonly confidence: "high" | "medium" | "review-required";
+        readonly status: "candidate" | "qualified" | "rejected";
+        readonly capabilityEvidence: readonly {
+            readonly kind: "symbol" | "package" | "public-surface" | "protocol" | "schema" | "test" | "command" | "history-episode" | "workload-signal" | "documentation";
+            readonly id: string;
+            readonly path?: string | undefined;
+        }[];
+        readonly initialState: {
+            readonly commit: string;
+            readonly parentCommit?: string | undefined;
+        };
+        readonly targetBehavior: readonly {
+            readonly id: string;
+            readonly description: string;
+            readonly critical: boolean;
+            readonly evidence: readonly {
+                readonly kind: "symbol" | "package" | "public-surface" | "protocol" | "schema" | "test" | "command" | "history-episode" | "workload-signal" | "documentation";
+                readonly id: string;
+                readonly path?: string | undefined;
+            }[];
+        }[];
+        readonly baselineObservations: readonly {
+            readonly id: string;
+            readonly kind: "test-command" | "property" | "schema" | "event-trace" | "structural";
+            readonly subjectId: string;
+            readonly outcome: "pass" | "fail" | "unknown";
+            readonly detail: string;
+        }[];
+        readonly preChangeObservations: readonly {
+            readonly id: string;
+            readonly kind: "test-command" | "property" | "schema" | "event-trace" | "structural";
+            readonly subjectId: string;
+            readonly outcome: "pass" | "fail" | "unknown";
+            readonly detail: string;
+        }[];
+        readonly postChangeObservations: readonly {
+            readonly id: string;
+            readonly kind: "test-command" | "property" | "schema" | "event-trace" | "structural";
+            readonly subjectId: string;
+            readonly outcome: "pass" | "fail" | "unknown";
+            readonly detail: string;
+        }[];
+        readonly candidateTestIds: readonly string[];
+        readonly risks: readonly ("review-required" | "external-service" | "ambiguous-intent" | "bundled-change" | "flaky-baseline" | "reference-only-oracle" | "weak-test-delta" | "unrealistic-mutation" | "private-context" | "cross-batch-instability")[];
+        readonly summary: string;
+        readonly environment: {
+            readonly protectedControlPaths: readonly string[];
+            readonly trustedPreparationRecipes: readonly {
+                readonly id: string;
+                readonly kind: "schema" | "test" | "build" | "check" | "custom";
+                readonly cwd: string;
+                readonly executable: string;
+                readonly args: readonly string[];
+                readonly timeoutMs: number;
+            }[];
+            readonly candidateValidationRecipes: readonly {
+                readonly id: string;
+                readonly kind: "schema" | "test" | "build" | "check" | "custom";
+                readonly cwd: string;
+                readonly executable: string;
+                readonly args: readonly string[];
+                readonly timeoutMs: number;
+            }[];
+            readonly baselineGradeRecipes: readonly {
+                readonly id: string;
+                readonly kind: "schema" | "test" | "build" | "check" | "custom";
+                readonly cwd: string;
+                readonly executable: string;
+                readonly args: readonly string[];
+                readonly timeoutMs: number;
+            }[];
+            readonly gradeRecipes: readonly {
+                readonly id: string;
+                readonly kind: "schema" | "test" | "build" | "check" | "custom";
+                readonly cwd: string;
+                readonly executable: string;
+                readonly args: readonly string[];
+                readonly timeoutMs: number;
+            }[];
+            readonly packageManager?: {
+                readonly name: "pnpm";
+                readonly version: string;
+            } | undefined;
+            readonly lockfilePath?: string | undefined;
+        };
+        readonly referenceCommit?: string | undefined;
+    };
+    readonly qualification: {
+        readonly seed: {
+            readonly id: string;
+            readonly source: {
+                readonly kind: "historical-fix";
+                readonly changeEpisodeId: string;
+            } | {
+                readonly kind: "historical-feature";
+                readonly changeEpisodeId: string;
+            } | {
+                readonly kind: "historical-refactor";
+                readonly changeEpisodeId: string;
+            } | {
+                readonly kind: "existing-test";
+                readonly testIds: readonly string[];
+            } | {
+                readonly kind: "public-api";
+                readonly surfaceIds: readonly string[];
+            } | {
+                readonly kind: "schema-contract";
+                readonly protocolIds: readonly string[];
+            } | {
+                readonly kind: "production-request";
+                readonly requestId: string;
+            } | {
+                readonly kind: "reviewed-synthetic-gap";
+                readonly reviewId: string;
+            };
+            readonly version: 1;
+            readonly rejectionReasons: readonly string[];
+            readonly confidence: "high" | "medium" | "review-required";
+            readonly status: "candidate" | "qualified" | "rejected";
+            readonly capabilityEvidence: readonly {
+                readonly kind: "symbol" | "package" | "public-surface" | "protocol" | "schema" | "test" | "command" | "history-episode" | "workload-signal" | "documentation";
+                readonly id: string;
+                readonly path?: string | undefined;
+            }[];
+            readonly initialState: {
+                readonly commit: string;
+                readonly parentCommit?: string | undefined;
+            };
+            readonly targetBehavior: readonly {
+                readonly id: string;
+                readonly description: string;
+                readonly critical: boolean;
+                readonly evidence: readonly {
+                    readonly kind: "symbol" | "package" | "public-surface" | "protocol" | "schema" | "test" | "command" | "history-episode" | "workload-signal" | "documentation";
+                    readonly id: string;
+                    readonly path?: string | undefined;
+                }[];
+            }[];
+            readonly baselineObservations: readonly {
+                readonly id: string;
+                readonly kind: "test-command" | "property" | "schema" | "event-trace" | "structural";
+                readonly subjectId: string;
+                readonly outcome: "pass" | "fail" | "unknown";
+                readonly detail: string;
+            }[];
+            readonly preChangeObservations: readonly {
+                readonly id: string;
+                readonly kind: "test-command" | "property" | "schema" | "event-trace" | "structural";
+                readonly subjectId: string;
+                readonly outcome: "pass" | "fail" | "unknown";
+                readonly detail: string;
+            }[];
+            readonly postChangeObservations: readonly {
+                readonly id: string;
+                readonly kind: "test-command" | "property" | "schema" | "event-trace" | "structural";
+                readonly subjectId: string;
+                readonly outcome: "pass" | "fail" | "unknown";
+                readonly detail: string;
+            }[];
+            readonly candidateTestIds: readonly string[];
+            readonly risks: readonly ("review-required" | "external-service" | "ambiguous-intent" | "bundled-change" | "flaky-baseline" | "reference-only-oracle" | "weak-test-delta" | "unrealistic-mutation" | "private-context" | "cross-batch-instability")[];
+            readonly summary: string;
+            readonly environment: {
+                readonly protectedControlPaths: readonly string[];
+                readonly trustedPreparationRecipes: readonly {
+                    readonly id: string;
+                    readonly kind: "schema" | "test" | "build" | "check" | "custom";
+                    readonly cwd: string;
+                    readonly executable: string;
+                    readonly args: readonly string[];
+                    readonly timeoutMs: number;
+                }[];
+                readonly candidateValidationRecipes: readonly {
+                    readonly id: string;
+                    readonly kind: "schema" | "test" | "build" | "check" | "custom";
+                    readonly cwd: string;
+                    readonly executable: string;
+                    readonly args: readonly string[];
+                    readonly timeoutMs: number;
+                }[];
+                readonly baselineGradeRecipes: readonly {
+                    readonly id: string;
+                    readonly kind: "schema" | "test" | "build" | "check" | "custom";
+                    readonly cwd: string;
+                    readonly executable: string;
+                    readonly args: readonly string[];
+                    readonly timeoutMs: number;
+                }[];
+                readonly gradeRecipes: readonly {
+                    readonly id: string;
+                    readonly kind: "schema" | "test" | "build" | "check" | "custom";
+                    readonly cwd: string;
+                    readonly executable: string;
+                    readonly args: readonly string[];
+                    readonly timeoutMs: number;
+                }[];
+                readonly packageManager?: {
+                    readonly name: "pnpm";
+                    readonly version: string;
+                } | undefined;
+                readonly lockfilePath?: string | undefined;
+            };
+            readonly referenceCommit?: string | undefined;
+        };
+        readonly stability: {
+            readonly version: 1;
+            readonly seedId: string;
+            readonly batchesRequired: number;
+            readonly repetitionsPerBatch: number;
+            readonly stable: boolean;
+            readonly batches: readonly {
+                readonly batch: number;
+                readonly status: "qualified" | "rejected";
+                readonly phaseSignatures: readonly {
+                    readonly phase: "baseline" | "pre-change" | "post-change";
+                    readonly signatures: readonly string[];
+                }[];
+                readonly rejectionReasons: readonly string[];
+            }[];
+            readonly divergentPhases: readonly ("baseline" | "pre-change" | "post-change")[];
+            readonly failureSignatures: readonly {
+                readonly signature: string;
+                readonly count: number;
+            }[];
+            readonly rejectionReasons: readonly string[];
+        };
+    };
+    readonly repository: {
+        readonly root: string;
+        readonly commit: string;
+        readonly tree: string;
+    };
+    readonly selection: {
+        readonly candidates: readonly {
+            readonly commit: string;
+            readonly subject: string;
+            readonly score: number;
+            readonly rationale: string;
+        }[];
+        readonly selectedCommit: string;
+        readonly rejected: readonly {
+            readonly commit: string;
+            readonly reason: string;
+        }[];
+    };
+    readonly version: 1;
+    readonly stage: "seed";
+    readonly parentDigest: string;
+    readonly createdAt: string;
+}>;