import { observedComparisonCapabilities } from "./observedComparisonCapabilities.js";
import { reviewEvidenceGraphSchema, parseReviewEvidenceGraph } from "./reviewEvidenceGraphContracts.js";
import { REVIEW_EVIDENCE_GRAPH_CONTRACT_VERSION, REVIEW_EVIDENCE_GRAPH_CONTRACT_VERSION_V2, REVIEW_EVIDENCE_GRAPH_LIMITS, REVIEW_EVIDENCE_GRAPH_V2_MAXIMUM_WIRE_NODES, REVIEW_EVIDENCE_GRAPH_V2_EXPANSION_CEILING, MAX_DIAGNOSTIC_JSON_NODES } from "@actuarial-ts/core";
import { boundedGroupedDevelopmentRequestSchema, parseBoundedGroupedDevelopmentRequest, BOUNDED_GROUPED_HISTORY_WORK_LIMITS } from "./boundedGroupedHistory.js";
import { boundedGroupedProjectionRequestSchema, projectBoundedGroupedDevelopmentFromInput } from "./reviewContracts.js";
import { BOUNDED_GROUPED_DEVELOPMENT_CONTRACT_VERSION, BOUNDED_GROUPED_MAXIMUM_OUTPUT_CELLS, BOUNDED_GROUPED_PROJECTION_CONTRACT_VERSION } from "@actuarial-ts/core";
import type { z } from "zod";
import { HISTORICAL_PREPARATION_CONTRACT_VERSION, HISTORICAL_PREPARATION_LIMITS, HISTORICAL_FOLD_CONTRACT_VERSION, HISTORICAL_FOLD_LIMITS, HISTORICAL_STUDY_CONTRACT_VERSION, HISTORICAL_STUDY_LIMITS, ANALYSIS_RESULT_CONTRACT_VERSION, REVIEW_PREPARATION_CONTRACT_VERSION, REVIEW_PREPARATION_LIMITS, RECIPE_DEVELOPMENT_CONTRACT_VERSION, RECIPE_DEVELOPMENT_LIMITS, RECIPE_EXPOSURE_CONTRACT_VERSION, RECIPE_EXPOSURE_LIMITS, snapshotDiagnosticJson, type AnalysisCapability, type AnalysisEligibility, type AnalysisReviewFinding, type CustomizationCapabilityFinding } from "@actuarial-ts/core";
import { DATA_PACKAGE_VERSION } from "./version.js";
import { reviewPreparationRequestSchema, runAnalysisRecipeFromInput, reviewPreparationExecutionRequestSchema, recipeDevelopmentProjectionRequestSchema, runReviewPreparationFromInput, projectRecipeDevelopmentFromInput } from "./recipeDevelopmentContracts.js";
import { recipeExposureProjectionRequestSchema, attachRecipeExposureRequestSchema, projectRecipeExposureFromInput, attachRecipeExposureFromInput, parseAttachRecipeExposureRequest } from "./recipeExposureContracts.js";
import { ANALYSIS_STATISTIC_INPUT_LIMITS, analysisStatisticRequestSchema, calculateAnalysisStatisticFromInput } from "./analysisStatisticContracts.js";

import { historicalPreparationRequestSchema, prepareHistoricalReviewFromInput } from "./historicalPreparationContracts.js";
import { historicalFoldRequestSchema, historicalStudyRequestSchema, validateHistoricalFoldFromInput, validateHistoricalStudyFromInput } from "./historicalValidationContracts.js";
import { ANALYSIS_SCENARIO_INPUT_LIMITS, analysisScenariosRequestSchema, analysisScenarioGridRequestSchema, analysisScenarioAttributionRequestSchema, analysisScenarioBridgeRequestSchema, runAnalysisScenariosFromInput, runAnalysisScenarioGridFromInput, runAnalysisScenarioAttributionFromInput, runAnalysisScenarioBridgeFromInput } from "./analysisScenarioContracts.js";
import type { AnalysisResult, AnalysisScenarioDifference, AnalysisScenarioRun } from "@actuarial-ts/core";
import { nativeDevelopmentCapabilities } from "./nativeDevelopmentCapabilities.js";
import { diagnosticSuiteCapabilities } from "./diagnosticSuiteCapabilities.js";
import { observedDiagnosticCapabilities } from "./observedDiagnosticsCapabilities.js";
import { generalizedDiagnosticCapabilities } from "./generalizedDiagnosticCapabilities.js";
import { reviewStudyCapabilities } from "./reviewStudyCapabilities.js";

export interface DataOperation {
  id: string; native: string; entry: string; validator?: string; parser: string; schemaName: string; schema: z.ZodTypeAny;
  input: string; output: string; contract: string | null; kind: AnalysisCapability["kind"];
  fields: readonly string[]; limits: Readonly<Record<string, number>>; work: NonNullable<AnalysisCapability["preflight"]>["work"];
  checked: readonly string[]; deferred: readonly string[]; coordinates: readonly string[]; source: string; replay: readonly string[];
  unitRule: string; populationRule: string; financialRule: string; limitations: readonly string[]; options: AnalysisCapability["options"];
  originKinds?: readonly string[]; temporalStructures?: readonly string[];
  nativePackage?: AnalysisCapability["native"]["package"];
  replayPackage?: NonNullable<AnalysisCapability["preflight"]>["replayPackage"];
  costQualification?: string;
  evaluate(input: unknown): { findings: readonly AnalysisReviewFinding[]; requiresInput?: boolean; status?: "supported-with-warnings" | "requires-input" | "unsupported" };
}
const nativeFindings = (findings: readonly CustomizationCapabilityFinding[], coordinates?: AnalysisReviewFinding["coordinates"]): AnalysisReviewFinding[] => findings.map((finding) => ({ code: finding.code, path: finding.path, message: finding.message,
  ...(coordinates ? { coordinates } : {}), remedies: finding.requiredFields?.length ? [`Supply ${finding.requiredFields.join(", ")} under the declared native contract`] : ["Resolve the native preparation/statistic finding before treating the result as complete"] }));
const explicit = (path: string, choices: readonly string[], description: string) => ({ path, choices, description, default: null });
const projection = { work: "preparation-replay" as const, kind: "transformation" as const, source: "retained-recipe-preparation", replay: ["replayReviewPlanRun"],
  unitRule: "Output dimensions and scale must match the actual prepared measure or allocated exposure",
  populationRule: "Exact or explicitly declared subset coordinates; retained population meaning is required",
  financialRule: "Loss projection checks its declared basis against applied pipeline stages; exposure remains a separately declared denominator",
};
const historical = { kind: "workflow" as const, work: "source-preparation" as const, source: "dated-revision-archive-and-selected-policy",
  unitRule: "Recipe projection preserves actual loss and exposure units; eligible resolved model inputs use the shared dimensional checks",
  populationRule: "Selected historical recipe scopes and explicit loss/exposure relationships define each fold population",
  financialRule: "Prepared financial stages, selected assumptions and source bindings remain exact; future corrections require an explicit restated view",
  options: [explicit("view.kind", ["as-known", "restated"], "Preparation must explicitly distinguish original and later revision cutoffs")],
};
const historicalDeferred = ["fit-convergence-and-complete-output-coverage", "derived-prior-and-dependent-model-eligibility", "fitted-forecast-pattern-and-numerical-availability", "scoring-vintage-compatibility-and-maturity", "source-availability-authenticity", "independent-validation"];
function scenarioValueFindings(result: AnalysisResult, scenarioId: string, outputPath: string): AnalysisReviewFinding[] {
  return result.values.flatMap((value, index) => nativeFindings(value.findings, { ...value.coordinates, measureId: value.measureId, scenarioId, nativeOutputPath: `${outputPath}.values[${index}]` }));
}
function scenarioDifferenceFindings(differences: readonly AnalysisScenarioDifference[], scenarioId: string, outputPath: string): AnalysisReviewFinding[] {
  return differences.flatMap((difference, index) => difference.absoluteDifference === null || difference.percentageDifference === null ? [{
    code: difference.absoluteDifference === null ? "SCENARIO_EFFECT_UNAVAILABLE" : "SCENARIO_PERCENTAGE_UNAVAILABLE", path: "$",
    message: difference.absoluteDifference === null ? "A native coordinate or required marginal effect is unavailable; no missing contribution is replaced by zero" : "A percentage requires a positive baseline and finite arithmetic; the absolute effect is retained",
    coordinates: { ...difference.coordinates, measureId: difference.measureId, scenarioId, nativeOutputPath: `${outputPath}[${index}]` }, remedies: ["Inspect the native values, denominators and all required coalition coordinates before interpreting the effect"],
  }] : []);
}
function scenarioRunFindings(runs: readonly AnalysisScenarioRun[], outputPath = "$"): AnalysisReviewFinding[] {
  return runs.flatMap((run, index) => [...scenarioValueFindings(run.result, run.scenarioId, `${outputPath}[${index}].result`), ...scenarioDifferenceFindings(run.differences, run.scenarioId, `${outputPath}[${index}].differences`)]);
}
const scenario = { kind: "workflow" as const, contract: ANALYSIS_RESULT_CONTRACT_VERSION, limits: ANALYSIS_SCENARIO_INPUT_LIMITS, work: "source-preparation" as const,
  checked: ["safe-json-and-exact-recipe-scenario-schema", "bounded-recipe-expansion", "native-financial-and-population-change-validation", "native-recipe-calculation", "exact-coordinate-effect-availability"],
  deferred: ["source-and-revision-authenticity", "actuarial-scenario-plausibility", "causal-interpretation", "independent-validation", "uncertainty", "measured-execution-cost"], coordinates: ["scenarioId", "measureId", "originId", "evaluationDate"], source: "historical-records-recipe-and-declared-scenario-changes", replay: [],
  unitRule: "Effects retain native measure units; percentages require a positive baseline. No implicit unit conversion is performed",
  populationRule: "Declared reporting-predicate changes can change the selected population; effect sizes are descriptive counterfactuals, not causal estimates",
  financialRule: "Only declared term limits, attachments and named scale adjustments are varied through the existing recipe",
  options: [explicit("scenarios[].changes[].kind", ["financial-term-limit", "financial-term-attachment", "financial-adjustment-factor", "reporting-predicate"], "Exact changes are supplied; no scenario or fallback is inferred")],
};
const entries: readonly DataOperation[] = [
  { ...projection, id: "review.evidence-graph", native: "decodeReviewEvidence", nativePackage: "@actuarial-ts/core", entry: "parseReviewEvidenceGraph", parser: "parseReviewEvidenceGraph", schemaName: "reviewEvidenceGraphSchema", schema: reviewEvidenceGraphSchema,
    input: "ReviewEvidenceTransport", output: "ReviewEvidenceTransport", contract: REVIEW_EVIDENCE_GRAPH_CONTRACT_VERSION_V2,
    fields: ["contractVersion", "root", "vertices", "limits"], limits: { ...REVIEW_EVIDENCE_GRAPH_LIMITS, maximumWireJsonNodesV1: MAX_DIAGNOSTIC_JSON_NODES, maximumWireJsonNodesV2: REVIEW_EVIDENCE_GRAPH_V2_MAXIMUM_WIRE_NODES, maximumConfigurableExpandedCharactersV2: REVIEW_EVIDENCE_GRAPH_V2_EXPANSION_CEILING.maximumExpandedCharacters, maximumConfigurableExpandedOccurrencesV2: REVIEW_EVIDENCE_GRAPH_V2_EXPANSION_CEILING.maximumExpandedOccurrences, maximumPhysicalTraversalAndAllocationV2: REVIEW_EVIDENCE_GRAPH_LIMITS.maximumExpandedOccurrences }, work: "request-validation", validator: "parseReviewEvidenceGraph", source: "exact-shared-review-evidence", replay: ["replayReviewSnapshotEvidenceGraph"], replayPackage: "@actuarial-ts/compliance",
    checked: ["safe-json", "version-discriminated-exact-v1-and-v2", "canonical-postorder-dependencies", "unique-reachable-subtrees", "logical-and-storage-reachability", "bounded-expanded-work-and-characters", "bounded-aggregate-allocation-and-canonical-keys"], deferred: ["current-sdk-calculation-authority", "complete-original-file-replay", "source-authenticity", "joint-uncertainty", "persistence"],
    coordinates: ["node", "port", "origin", "valuationDate"], options: [explicit("contractVersion", [REVIEW_EVIDENCE_GRAPH_CONTRACT_VERSION, REVIEW_EVIDENCE_GRAPH_CONTRACT_VERSION_V2], "Exact /1 retains its limits; compact /2 supports explicit bounded logical expansion while physical budgets remain fixed; decoding grants no execution authority")], limitations: ["Decoding owns immutable JSON; serialized evidence never authorizes its own calculations", "All models retain their native semantic eligibility and missingness; this format supplies no joint selection uncertainty"],
    evaluate(input) { parseReviewEvidenceGraph(input); return { findings: [] }; } },
  { ...projection, id: "history.grouped-development", native: "createBoundedGroupedDevelopmentAccumulator", entry: "projectStreamedHistoricalDevelopment", parser: "parseBoundedGroupedDevelopmentRequest", schemaName: "boundedGroupedDevelopmentRequestSchema", schema: boundedGroupedDevelopmentRequestSchema,
    input: "BoundedGroupedDevelopmentRequest", output: "BoundedGroupedDevelopmentResult", contract: BOUNDED_GROUPED_DEVELOPMENT_CONTRACT_VERSION,
    fields: ["definition", "recipe", "origins", "ages", "ageConvention", "evaluationDates", "knowledgeDate", "coverage", "measures", "maximumObservations"],
    limits: { ...BOUNDED_GROUPED_HISTORY_WORK_LIMITS, maximumOutputCells: BOUNDED_GROUPED_MAXIMUM_OUTPUT_CELLS },
    work: "request-validation", validator: "parseBoundedGroupedDevelopmentRequest", source: "full-original-mapped-record-stream", replay: ["verifyBoundedGroupedHistoryReplay"], replayPackage: "@actuarial-ts/compliance",
    checked: ["exact-native-claim-sums", "origin-universe", "elapsed-calendar-ages", "bounded-output-dimensions", "source-measure-units", "supported-financial-stages"],
    deferred: ["original-bytes-and-mapping-authenticity", "full-stream-revision-selection", "adapter-resource-accounting", "independent-replay", "historical-knowledge-authenticity"],
    coordinates: ["origin", "ageMonths", "valuationDate", "measureId"],
    limitations: ["Structural preflight validates only grouping configuration; execution requires trusted host records, header, resource-accounted external state and limits", "Only exact unfiltered observed cumulative paid/incurred sums are supported; no policy terms are inferred from cohort lengths", "Cancellation and elapsed deadlines are cooperative between records and adapter operations; host I/O must honor AbortSignal"],
    options: [explicit("coverage", ["exact-universe", "declared-subset"], "Excluded observations remain in evidence"), explicit("ageConvention", ["calendar-period-end", "elapsed-months"], "Real date coordinates must match the declared month clock")],
    evaluate(input) { parseBoundedGroupedDevelopmentRequest(input); return { findings: [] }; } },
  { ...projection, id: "history.grouped-projection", native: "projectBoundedGroupedDevelopment", entry: "projectBoundedGroupedDevelopmentFromInput", parser: "parseBoundedGroupedProjectionRequest", schemaName: "boundedGroupedProjectionRequestSchema", schema: boundedGroupedProjectionRequestSchema,
    input: "BoundedGroupedProjectionRequest", output: "BoundedGroupedProjection", contract: BOUNDED_GROUPED_PROJECTION_CONTRACT_VERSION,
    fields: ["id", "version", "grouping", "grouped", "measureId", "valuationDate", "accountingDate", "sourceReplay", "meaning"], limits: { maximumOutputCells: BOUNDED_GROUPED_MAXIMUM_OUTPUT_CELLS },
    checked: ["grouping-result-identity", "dated-cells-and-missingness", "structural-origin-boundary", "financial-currency-scale", "typed-source-context-populations"],
    deferred: ["current-original-replay-authority", "actuarial-suitability", "historical-knowledge-authenticity"], coordinates: ["origin", "ageMonths", "valuationDate"],
    replay: ["verifyBoundedGroupedHistoryReplay"], replayPackage: "@actuarial-ts/compliance",
    limitations: ["Serialized projection bytes cannot authenticate original inputs; use projectVerifiedBoundedGroupedDevelopment with a current independent replay receipt", "Restated history remains qualified through models and snapshots"], options: [],
    evaluate(input) { return projectBoundedGroupedDevelopmentFromInput(input); } },
  ...nativeDevelopmentCapabilities(),
  ...diagnosticSuiteCapabilities(),
  ...observedDiagnosticCapabilities(),
  ...observedComparisonCapabilities(),
  ...generalizedDiagnosticCapabilities(),
  ...reviewStudyCapabilities(),
  { ...scenario, id: "analysis.scenarios", native: "runAnalysisScenarios", entry: "runAnalysisScenariosFromInput", parser: "parseAnalysisScenariosRequest", schemaName: "analysisScenariosRequestSchema", schema: analysisScenariosRequestSchema,
    input: "Parameters<typeof runAnalysisScenarios>[0]", output: "readonly AnalysisScenarioRun[]", fields: ["history", "definition", "recipe", "scenarios", "limits"],
    limitations: ["Preflight executes baseline plus each independent declared scenario; missing coordinates remain unavailable", "An empty scenario list returns no comparisons after calculating the baseline; omitted evaluationDate retains the native latest-observation convention", "Result identities retain calculation/lineage evidence, but no immutable review replay receipt is supplied"], evaluate(input) { return { findings: scenarioRunFindings(runAnalysisScenariosFromInput(input)) }; } },
  { ...scenario, id: "analysis.scenario-grid", native: "runAnalysisScenarioGrid", entry: "runAnalysisScenarioGridFromInput", parser: "parseAnalysisScenarioGridRequest", schemaName: "analysisScenarioGridRequestSchema", schema: analysisScenarioGridRequestSchema,
    input: "Parameters<typeof runAnalysisScenarioGrid>[0]", output: "readonly AnalysisScenarioRun[]", fields: ["history", "definition", "recipe", "grid", "limits"],
    options: [explicit("grid.axes[].options[].change", ["null", "declared-change"], "Null explicitly retains the baseline choice; each axis changes one distinct parameter")],
    limitations: ["The Cartesian product is bounded before execution; baseline plus every expanded scenario is calculated", "Expanded IDs and parameter targets must be unambiguous; a baseline grid cell is an explicit no-change scenario", "No immutable review replay receipt or causal attribution is supplied"], evaluate(input) { return { findings: scenarioRunFindings(runAnalysisScenarioGridFromInput(input)) }; } },
  { ...scenario, id: "analysis.scenario-attribution", native: "runAnalysisScenarioAttribution", entry: "runAnalysisScenarioAttributionFromInput", parser: "parseAnalysisScenarioAttributionRequest", schemaName: "analysisScenarioAttributionRequestSchema", schema: analysisScenarioAttributionRequestSchema,
    input: "Parameters<typeof runAnalysisScenarioAttribution>[0]", output: "AnalysisScenarioAttribution", fields: ["history", "definition", "recipe", "scenarios", "limits"],
    limitations: ["Symmetric attribution evaluates every coalition: 2^n recipe runs for n one-change scenarios; the caller limit includes the baseline coalition", "Conflicting overrides of one parameter are refused; identical declared changes remain eligible for equal shares", "An unavailable marginal makes that attribution unavailable. Native step scenarioValue retains the joint endpoint; absoluteDifference is the attributed share", "Attribution is a deterministic allocation of declared changes, not causal proof, uncertainty or an immutable review replay receipt"],
    evaluate(input) { const result = runAnalysisScenarioAttributionFromInput(input); return { findings: [...scenarioValueFindings(result.baseline, "baseline", "$.baseline"), ...scenarioValueFindings(result.joint, "joint", "$.joint"), ...result.steps.flatMap((step, index) => scenarioDifferenceFindings(step.differences, step.scenarioId, `$.steps[${index}].differences`))] }; } },
  { ...scenario, id: "analysis.scenario-bridge", native: "runAnalysisScenarioBridge", entry: "runAnalysisScenarioBridgeFromInput", parser: "parseAnalysisScenarioBridgeRequest", schemaName: "analysisScenarioBridgeRequestSchema", schema: analysisScenarioBridgeRequestSchema,
    input: "Parameters<typeof runAnalysisScenarioBridge>[0]", output: "ReturnType<typeof runAnalysisScenarioBridge>", fields: ["history", "definition", "recipe", "scenarios", "limits"],
    limitations: ["Baseline plus each ordered one-change step is calculated; later overrides apply to the preceding effective definition", "Bridge allocations depend on order. Native repeated labels remain distinguishable by array position and fromCalculationIdentity", "No symmetric attribution, causal interpretation or immutable review replay receipt is implied"], evaluate(input) { const result = runAnalysisScenarioBridgeFromInput(input); return { findings: [...scenarioValueFindings(result.baseline, "baseline", "$.baseline"), ...scenarioRunFindings(result.steps, "$.steps")] }; } },
  { ...historical, id: "review.historical-preparation", native: "prepareHistoricalReview", entry: "prepareHistoricalReviewFromInput", parser: "parseHistoricalPreparationRequest", schemaName: "historicalPreparationRequestSchema", schema: historicalPreparationRequestSchema,
    input: "HistoricalPreparationRequest", output: "HistoricalPreparation", contract: HISTORICAL_PREPARATION_CONTRACT_VERSION, fields: ["id", "version", "information", "bindings", "history", "exposure", "evaluationDates", "view", "unknownRecordAvailability", "limits"], limits: HISTORICAL_PREPARATION_LIMITS,
    checked: ["exact-zod-boundary-and-selected-configuration", "historical-information-resolution", "record-and-exposure-revision-cutoffs", "mapping-and-opening-bindings", "dated-recipe-frame-preparation"], deferred: ["complete-native-values", "source-availability-authenticity", "downstream-model-eligibility", "independent-validation"], coordinates: ["valuationDate", "record", "revision", "originId", "measure"], replay: ["replayHistoricalPreparation", "replayReviewPlanRun"],
    limitations: ["Preflight performs bounded revision selection and recipe preparation; mapping identity is checked but source normalization is not reexecuted", "Unknown availability, restated corrections and native missingness remain visible"],
    evaluate(input) { const result = prepareHistoricalReviewFromInput(input); return { findings: result.findings, requiresInput: result.status === "requires-input" }; } },
  { ...historical, id: "review.historical-fold", native: "runHistoricalFold", entry: "runHistoricalFoldFromInput", validator: "validateHistoricalFoldFromInput", parser: "parseHistoricalFoldRequest", schemaName: "historicalFoldRequestSchema", schema: historicalFoldRequestSchema,
    input: "HistoricalFoldRequest", output: "HistoricalFold", contract: HISTORICAL_FOLD_CONTRACT_VERSION, fields: ["id", "version", "preparation", "policySlot", "scoring", "limits"], limits: HISTORICAL_FOLD_LIMITS,
    checked: ["exact-zod-boundary-and-selected-policy", "historical-preparation-and-projections", "selected-assumption-dates-and-ancestry", "calibration-window-and-refit-policy", "available-model-input-eligibility", "explicit-pending-fold-prior", "forecast-target-clock-and-declared-pattern"], deferred: historicalDeferred, coordinates: ["origin", "ageMonths", "valuationDate", "modelUse"], replay: ["replayHistoricalFold", "replayReviewPlanRun"],
    options: [explicit("preparation.view.kind", ["as-known", "restated"], "Configuration retains its original cutoff even when records are restated"), explicit("scoring", ["null", "declared-vintage"], "A forecast can be created before later truth exists")],
    limitations: ["Preflight reconstructs sources and resolves available model inputs without fitting; a fold-derived prior remains an explicit pending dependency", "Fitted forecast-pattern applicability, scoring applicability and actual performance require execution; reconstruction does not prove contemporaneous model use"], evaluate: validateHistoricalFoldFromInput },
  { ...historical, id: "review.historical-study", native: "runHistoricalStudy", entry: "runHistoricalStudyFromInput", validator: "validateHistoricalStudyFromInput", parser: "parseHistoricalStudyRequest", schemaName: "historicalStudyRequestSchema", schema: historicalStudyRequestSchema,
    input: "HistoricalStudyRequest", output: "HistoricalStudy", contract: HISTORICAL_STUDY_CONTRACT_VERSION, fields: ["id", "version", "refit", "folds", "decisionUses", "limits"], limits: HISTORICAL_STUDY_LIMITS,
    checked: ["exact-zod-boundary-and-bounded-fold-expansion", "unique-folds-and-decision-references", "every-fold-input-preflight", "selected-fixed-assumption-consistency", "declared-refit-policy-consistency"], deferred: [...historicalDeferred, "realized-decision-information-leakage", "derived-assumption-consistency", "cross-fold-score-comparability"], coordinates: ["fold", "decision", "origin", "valuationDate"], replay: ["replayHistoricalStudy", "replayReviewPlanRun"],
    options: [explicit("refit", ["fixed-assumptions", "recalibrated-per-fold"], "Fixed supplied assumptions do not freeze native fitted parameters"), explicit("folds[].role", ["exploratory", "tuning", "validation"], "Labels do not establish independent holdout evidence")],
    limitations: ["Every declared fold input is checked without fitting; successful input checks do not certify scored coverage or tuning independence", "Scores retain native units; this operation does not pool incompatible errors or combine uncertainty"], evaluate: validateHistoricalStudyFromInput },
  { id: "analysis.recipe", native: "runAnalysisRecipe", entry: "runAnalysisRecipeFromInput", parser: "parseAnalysisRecipeRequest", schemaName: "reviewPreparationRequestSchema", schema: reviewPreparationRequestSchema,
    input: "Parameters<typeof runAnalysisRecipe>[0]", output: "AnalysisResult", contract: ANALYSIS_RESULT_CONTRACT_VERSION, kind: "workflow", fields: ["history", "definition", "recipe"], limits: REVIEW_PREPARATION_LIMITS, work: "source-preparation",
    checked: ["safe-json-and-exact-zod-boundary", "recipe-references-and-step-order", "definition-units-and-expressions", "source-revision-selection", "native-preparation-and-statistics"], deferred: ["complete-output-coverage", "historical-availability-authenticity", "downstream-model-eligibility", "actuarial-suitability"], coordinates: ["measure", "originId", "evaluationDate"], source: "historical-records-and-analysis-recipe", replay: [],
    unitRule: "Recipe expressions and financial stages resolve actual output units", populationRule: "Uses explicit financial/reporting/exposure scopes and source revision policies", financialRule: "Financial stages require the actual claim/occurrence/policy population",
    limitations: ["Preflight executes preparation and statistics; use review.preparation to retain a replayable request/result artifact", "Omitted evaluationDate uses the native latest-prepared-observation convention and does not establish a historical cutoff"], options: [explicit("history.revisionView.kind", ["restated", "as-known"], "The native revision policy is retained")],
    evaluate(input) { const result = runAnalysisRecipeFromInput(input); return { findings: result.values.flatMap((value) => nativeFindings(value.findings, { measureId: value.measureId, ...value.coordinates })) }; } },
  { id: "review.preparation", native: "runReviewPreparation", entry: "runReviewPreparationFromInput", parser: "parseReviewPreparationRequest", schemaName: "reviewPreparationExecutionRequestSchema", schema: reviewPreparationExecutionRequestSchema,
    input: "Parameters<typeof runReviewPreparation>[0]", output: "ReviewRecipePreparation", contract: REVIEW_PREPARATION_CONTRACT_VERSION, kind: "workflow", fields: ["id", "version", "request"], limits: REVIEW_PREPARATION_LIMITS, work: "source-preparation",
    checked: ["safe-json-and-exact-zod-boundary", "recipe-references-and-step-order", "definition-units-and-expressions", "source-revision-selection", "native-preparation-and-statistics"], deferred: ["complete-output-coverage", "historical-availability-authenticity", "downstream-model-eligibility", "actuarial-suitability"], coordinates: ["measure", "originId", "evaluationDate"], source: "historical-records-and-analysis-recipe", replay: ["replayReviewPreparation", "replayReviewPlanRun"],
    unitRule: "Recipe expressions and financial stages resolve native output units; no undeclared conversion is inferred", populationRule: "Uses explicit financial/reporting/exposure scopes and source revision policies", financialRule: "Native financial stages require their actual claim/occurrence/policy data and population completeness",
    limitations: ["Preflight executes the bounded preparation and statistics; source authenticity and later model eligibility remain separate", "An omitted recipe evaluation date retains the existing latest-prepared-observation convention; it does not establish a historical cutoff"], options: [explicit("request.history.revisionView.kind", ["restated", "as-known"], "The native revision policy is retained" )],
    evaluate(input) { const result = runReviewPreparationFromInput(input); return { findings: result.result.values.flatMap((value) => nativeFindings(value.findings, { measureId: value.measureId, ...value.coordinates })) }; } },
  { ...projection, id: "recipe.development", native: "projectRecipeDevelopment", entry: "projectRecipeDevelopmentFromInput", parser: "parseRecipeDevelopmentProjectionRequest", schemaName: "recipeDevelopmentProjectionRequestSchema", schema: recipeDevelopmentProjectionRequestSchema,
    input: "RecipeDevelopmentProjectionRequest", output: "RecipeDevelopmentProjection", contract: RECIPE_DEVELOPMENT_CONTRACT_VERSION, fields: ["id", "version", "preparations", "measureId", "kind", "origins", "ages", "ageConvention", "coverage", "valuationDate", "knowledgeDate", "accountingDate", "meaning", "limits"], limits: RECIPE_DEVELOPMENT_LIMITS,
    checked: ["exact-preparation-replay", "common-recipe-definition", "cumulative-sum-measure", "dated-coordinate-projection", "source-knowledge-cutoffs", "financial-pipeline-and-unit-binding"], deferred: ["source-authenticity", "complete-coordinate-values", "downstream-model-eligibility", "actuarial-suitability"], coordinates: ["origin", "ageMonths", "valuationDate", "resultIndex"],
    limitations: ["Only actual dated cumulative sum cells are projected; absent rows remain unavailable and true origin zero remains zero"], options: [explicit("coverage", ["exact-universe", "declared-subset"], "Excluded prepared coordinates remain evidence")], evaluate(input) { return projectRecipeDevelopmentFromInput(input); } },
  { ...projection, id: "recipe.exposure", native: "projectRecipeExposure", entry: "projectRecipeExposureFromInput", parser: "parseRecipeExposureProjectionRequest", schemaName: "recipeExposureProjectionRequestSchema", schema: recipeExposureProjectionRequestSchema,
    input: "RecipeExposureProjectionRequest", output: "RecipeExposureProjection", contract: RECIPE_EXPOSURE_CONTRACT_VERSION, fields: ["id", "version", "preparation", "measureId", "origins", "coverage", "knownDate", "meaning", "limits"], limits: RECIPE_EXPOSURE_LIMITS,
    checked: ["exact-preparation-replay", "actual-earned-exposure-measure", "interval-basis-and-unit-compatibility", "bounded-native-allocation", "exact-target-boundaries", "source-knowledge-cutoffs"], deferred: ["source-authenticity", "complete-exposure-values", "loss-population-relationship", "downstream-model-eligibility"], coordinates: ["origin", "allocationIndex", "targetIndex"],
    limitations: ["Point-in-time stocks cannot be relabeled as interval exposure; missing or partial allocated amounts remain unavailable"], options: [explicit("coverage", ["exact-universe", "declared-subset"], "Excluded allocation targets remain evidence")], evaluate(input) { return projectRecipeExposureFromInput(input); } },
  { ...projection, id: "recipe.exposure-attachment", native: "attachRecipeExposure", entry: "attachRecipeExposureFromInput", parser: "parseAttachRecipeExposureRequest", schemaName: "attachRecipeExposureRequestSchema", schema: attachRecipeExposureRequestSchema,
    input: "AttachRecipeExposureRequest", output: "AttachedRecipeExposure", contract: RECIPE_EXPOSURE_CONTRACT_VERSION, fields: ["id", "version", "context", "snapshots", "projection", "relationship"], limits: { maximumInputCharacters: RECIPE_EXPOSURE_LIMITS.maximumInputCharacters },
    checked: ["exact-exposure-projection-replay", "origin-and-valuation-alignment", "available-population-relationship-declaration", "semantic-reference-binding"], deferred: ["source-authenticity", "population-declaration-authenticity", "complete-exposure-values", "downstream-model-eligibility"], coordinates: ["origin"],
    limitations: ["The retained relationship is a caller declaration; matching origins do not prove equivalent loss and exposure populations", "Nested exposure projection retains its own declared origin, observation and allocation ceilings"], options: [],
    evaluate(input) { const request = parseAttachRecipeExposureRequest(input); attachRecipeExposureFromInput(request); return { findings: request.projection.findings }; } },
  { id: "statistics.descriptive", native: "calculateAnalysisStatistic", entry: "calculateAnalysisStatisticFromInput", parser: "parseAnalysisStatisticRequest", schemaName: "analysisStatisticRequestSchema", schema: analysisStatisticRequestSchema,
    input: "Parameters<typeof calculateAnalysisStatistic>[0]", output: "AnalysisStatisticResult", contract: ANALYSIS_RESULT_CONTRACT_VERSION, kind: "statistic", fields: ["measure", "observations", "selection"], limits: ANALYSIS_STATISTIC_INPUT_LIMITS, work: "statistic-calculation",
    checked: ["safe-json-and-exact-zod-boundary", "revision-resolved-observation-keys", "explicit-observation-selection", "native-statistic-availability", "native-positive-denominator-and-weight-rules"], deferred: ["source-authenticity", "declared-population-membership", "declared-output-unit-correctness", "sampling-representativeness", "predictive-uncertainty"], coordinates: ["measureId"], source: "caller-selected-prepared-observations", replay: [],
    unitRule: "The output unit and optional dimensions are caller declarations; this low-level statistic does not infer source measure units", populationRule: "Supply an already selected population; scope IDs are labels and conditions must be applied by a recipe before this boundary", financialRule: "Observations must already be on the declared financial basis; this statistic does not apply or reconcile financial terms",
    limitations: ["This boundary recalculates the native statistic; it provides no immutable review receipt or independent model validation", "All-observations retains repeated claim observations across dates; cumulative measures require an evaluation-date selection", "No source revision or population completeness claim is established by a supplied prepared observation"],
    options: [explicit("measure.statistic.kind", ["sum", "ratio", "distinct-count", "weighted-mean", "minimum", "maximum", "quantile", "duration", "survival-quantile"], "The existing native estimator and its missingness rules are retained"), explicit("selection.kind", ["all-observations", "evaluation-date"], "Explicit selection; no valuation date is invented")],
    evaluate(input) { const result = calculateAnalysisStatisticFromInput(input); return { requiresInput: result.status === "unavailable", findings: nativeFindings(result.findings, { measureId: result.measureId }) }; } },
];

export function dataOperationSchema(id: string): z.ZodTypeAny | null { return entries.find((entry) => entry.id === id)?.schema ?? null; }
export function dataOperationCapabilities(): readonly AnalysisCapability[] {
  return entries.map((entry) => ({ id: entry.id, kind: entry.kind, sdkVersion: DATA_PACKAGE_VERSION, native: { available: true, entryPoints: [entry.native], ...(entry.nativePackage ? { package: entry.nativePackage } : {}) },
    connected: { available: true, package: "@actuarial-ts/data", entryPoint: entry.entry, inputParser: entry.parser, inputType: entry.input, outputType: entry.output, contractVersion: entry.contract },
    preflight: { validator: entry.validator ?? entry.entry, inputSchema: { package: "@actuarial-ts/data", export: entry.schemaName }, work: entry.work, modelFitting: false, modelFittingScope: "reserve-model-estimators", retainedCalculations: "may-be-recomputed-by-shared-validation", checked: entry.checked, deferred: entry.deferred, hardLimits: entry.limits, replayEntryPoints: entry.replay, ...(entry.replayPackage ? { replayPackage: entry.replayPackage } : {}) },
    assurance: { connectedReplay: entry.replay.length ? "current-sdk-operation-replay" : "unavailable", independentNativeExecution: "not-advertised", independentConnectedExecution: "unavailable" },
    input: { requiredFields: entry.fields, sourceKinds: [entry.source], originKinds: entry.originKinds ?? ["declared-by-native-subject"], temporalStructures: entry.temporalStructures ?? ["explicit-record-dates-and-native-selection-policy"], quantityRoles: ["declared-by-native-subject"], unitRule: entry.unitRule, populationRule: entry.populationRule, financialRule: entry.financialRule, minimum: { origins: null, positiveAgeObservations: null, pairedCalibrationOrigins: null } },
    options: entry.options, output: { coordinateDimensions: entry.coordinates, quantityKeys: [], quantityAvailability: [], missingValues: "native-contract", uncertainty: [] },
    cost: { basis: "native-contract", order: null, measured: false, maximumOrigins: entry.limits.maximumOrigins ?? null, maximumCells: entry.limits.maximumCells ?? null, maximumSimulations: null, maximumSimulationCells: null, maximumParameters: null, maximumLikelihoodCellEvaluations: null, qualification: entry.costQualification ?? "Preflight executes native preparation/projection/statistic work; listed ceilings and nested request limits apply. No latency or memory measurement is implied" },
    limitations: entry.limitations,
  }));
}

/** Package-owned execution boundaries reuse their own parsers and native calculations. */
export function assessDataOperationEligibility(id: string, input: unknown): AnalysisEligibility | null {
  const entry = entries.find((item) => item.id === id);
  if (!entry) return null;
  const result = entry.evaluate(input);
  const findings = result.findings.map((finding) => finding.remedies.length ? finding : { ...finding, remedies: [`Use ${entry.parser} and resolve the evidence identified at ${finding.path} before execution`] });
  return snapshotDiagnosticJson({ method: id, status: result.status ?? (result.requiresInput ? "requires-input" : "supported-with-warnings"), coverage: { eligibleOrigins: [], unavailableOrigins: [] }, assurance: "structural-eligibility-only",
    preflight: { work: entry.work, completed: true, modelFitting: false, modelFittingScope: "reserve-model-estimators", retainedCalculations: "may-be-recomputed-by-shared-validation", originCoverage: "not-assessed", checkedScope: entry.checked, deferred: entry.deferred },
    findings: [...findings, { code: "CAPABILITY_PREFLIGHT_DEFERRED", path: "$", message: `Executed ${entry.work}; deferred checks: ${entry.deferred.join(", ")}`, remedies: ["Inspect native coordinates, missingness and qualifications before downstream use"] }],
  });
}