@nexalink/coding-contracts 0.1.0

package/dist/cjs/index.cjs

@@ -0,0 +1,1613 @@
+"use strict";
+// GENERATED FILE. DO NOT EDIT.
+// Source: nexalink-cloud contracts/ (run: npm run contracts:gen)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RcmWorkflowCatalogSchemaJson = exports.validRcmWorkflowCatalog = exports.rcmWorkflowCatalogSchema = exports.RcmRuntimeEventSchemaJson = exports.validRcmRuntimeEvent = exports.rcmRuntimeEventSchema = exports.RcmRetrievalMetadataSchemaJson = exports.validRcmRetrievalMetadata = exports.rcmRetrievalMetadataSchema = exports.RcmModelPromptSchemaJson = exports.validRcmModelPrompt = exports.rcmModelPromptSchema = exports.RcmCodingOutputSchemaJson = exports.validRcmCodingOutput = exports.rcmCodingOutputSchema = exports.RcmCodingInputSchemaJson = exports.validRcmCodingInput = exports.rcmCodingInputSchema = exports.RcmSupportingReferenceSchemaJson = exports.validRcmSupportingReference = exports.rcmSupportingReferenceSchema = exports.RCM_WORKFLOW_CATALOG_SCHEMA_VERSION = exports.RCM_RUNTIME_EVENT_SCHEMA_VERSION = exports.RCM_RETRIEVAL_SCHEMA_VERSION = exports.RCM_MODEL_PROMPT_SCHEMA_VERSION = exports.RCM_OUTPUT_SCHEMA_VERSION = exports.RCM_INPUT_SCHEMA_VERSION = exports.RCM_REFERENCE_SCHEMA_VERSION = exports.RCM_HUMAN_REVIEW_INSTRUCTION = exports.RCM_OUTPUT_SCHEMA_NAME = exports.RCM_HUMAN_REVIEW_POLICY_ID = exports.RCM_MODEL_POLICY_ID = exports.RCM_WORKFLOW_ID = void 0;
+exports.rcmSupportingReferenceValidationError = rcmSupportingReferenceValidationError;
+exports.rcmCodingInputValidationError = rcmCodingInputValidationError;
+exports.rcmCodingOutputValidationError = rcmCodingOutputValidationError;
+exports.rcmModelPromptValidationError = rcmModelPromptValidationError;
+exports.rcmRetrievalMetadataValidationError = rcmRetrievalMetadataValidationError;
+exports.rcmRuntimeEventValidationError = rcmRuntimeEventValidationError;
+exports.rcmWorkflowCatalogValidationError = rcmWorkflowCatalogValidationError;
+const zod_1 = require("zod");
+const escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+// Canonical workflow constants (source: contracts/workflow-constants.json).
+exports.RCM_WORKFLOW_ID = "rcm-coding-assistance";
+exports.RCM_MODEL_POLICY_ID = "carecompass-rcm-review-v1";
+exports.RCM_HUMAN_REVIEW_POLICY_ID = "qualified-coder-review-v1";
+exports.RCM_OUTPUT_SCHEMA_NAME = "carecompass_rcm_grounded_review";
+exports.RCM_HUMAN_REVIEW_INSTRUCTION = "Qualified human coder review is required before billing, coding, or claim submission.";
+// Schema wire versions (source: contracts/schemas/*.schema.json).
+exports.RCM_REFERENCE_SCHEMA_VERSION = "rcm-supporting-reference-v1";
+exports.RCM_INPUT_SCHEMA_VERSION = "rcm-coding-input-v1";
+exports.RCM_OUTPUT_SCHEMA_VERSION = "rcm-grounded-human-review-v2";
+exports.RCM_MODEL_PROMPT_SCHEMA_VERSION = "rcm-model-prompt-v1";
+exports.RCM_RETRIEVAL_SCHEMA_VERSION = "rcm-retrieval-metadata-v1";
+exports.RCM_RUNTIME_EVENT_SCHEMA_VERSION = "rcm-runtime-event-v1";
+exports.RCM_WORKFLOW_CATALOG_SCHEMA_VERSION = "rcm-workflow-catalog-v1";
+// --------------------------------------------------------------------
+// RcmSupportingReference (schema 1.0.0, wire rcm-supporting-reference-v1)
+// --------------------------------------------------------------------
+exports.rcmSupportingReferenceSchema = zod_1.z
+    .object({
+    referenceId: zod_1.z
+        .string()
+        .regex(new RegExp("^reference-[1-9][0-9]*$"))
+        .max(32),
+    documentId: zod_1.z.string().min(1).max(240).optional(),
+    title: zod_1.z.string().min(1).max(240),
+    excerpt: zod_1.z.string().min(1).max(2000),
+    version: zod_1.z.string().min(1).max(80).optional(),
+    corpusScope: zod_1.z.enum(["base", "tenant"]).optional(),
+    publisher: zod_1.z.string().max(240).optional(),
+    effectiveDate: zod_1.z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+        .optional(),
+    retrievalDate: zod_1.z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+        .optional(),
+    coveredPayerProgram: zod_1.z.string().max(240).optional(),
+    sourceUrl: zod_1.z.string().max(2048).optional(),
+    humanReviewRequired: zod_1.z.literal(true).optional(),
+})
+    .strict();
+function rcmSupportingReferenceValidationError(value) {
+    if (!isRecord(value))
+        return "reference";
+    if (!Object.keys(value).every((key) => [
+        "referenceId",
+        "documentId",
+        "title",
+        "excerpt",
+        "version",
+        "corpusScope",
+        "publisher",
+        "effectiveDate",
+        "retrievalDate",
+        "coveredPayerProgram",
+        "sourceUrl",
+        "humanReviewRequired",
+    ].includes(key)) ||
+        !["referenceId", "title", "excerpt"].every((key) => key in value))
+        return "reference_keys";
+    const value_referenceId = value["referenceId"];
+    if (typeof value_referenceId !== "string" ||
+        value_referenceId.length > 32 ||
+        !new RegExp("^reference-[1-9][0-9]*$").test(value_referenceId))
+        return "reference_id";
+    if (value["documentId"] !== undefined) {
+        const value_documentId = value["documentId"];
+        if (typeof value_documentId !== "string" ||
+            value_documentId.length < 1 ||
+            value_documentId.length > 240)
+            return "reference_document_id";
+    }
+    const value_title = value["title"];
+    if (typeof value_title !== "string" ||
+        value_title.length < 1 ||
+        value_title.length > 240)
+        return "reference_title";
+    const value_excerpt = value["excerpt"];
+    if (typeof value_excerpt !== "string" ||
+        value_excerpt.length < 1 ||
+        value_excerpt.length > 2000)
+        return "reference_excerpt";
+    if (value["version"] !== undefined) {
+        const value_version = value["version"];
+        if (typeof value_version !== "string" ||
+            value_version.length < 1 ||
+            value_version.length > 80)
+            return "reference_version";
+    }
+    if (value["corpusScope"] !== undefined) {
+        const value_corpusScope = value["corpusScope"];
+        if (typeof value_corpusScope !== "string" ||
+            !["base", "tenant"].includes(value_corpusScope))
+            return "reference_corpus_scope";
+    }
+    if (value["publisher"] !== undefined) {
+        const value_publisher = value["publisher"];
+        if (typeof value_publisher !== "string" || value_publisher.length > 240)
+            return "reference_publisher";
+    }
+    if (value["effectiveDate"] !== undefined) {
+        const value_effectiveDate = value["effectiveDate"];
+        if (typeof value_effectiveDate !== "string" ||
+            !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_effectiveDate))
+            return "reference_effective_date";
+    }
+    if (value["retrievalDate"] !== undefined) {
+        const value_retrievalDate = value["retrievalDate"];
+        if (typeof value_retrievalDate !== "string" ||
+            !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_retrievalDate))
+            return "reference_retrieval_date";
+    }
+    if (value["coveredPayerProgram"] !== undefined) {
+        const value_coveredPayerProgram = value["coveredPayerProgram"];
+        if (typeof value_coveredPayerProgram !== "string" ||
+            value_coveredPayerProgram.length > 240)
+            return "reference_covered_payer_program";
+    }
+    if (value["sourceUrl"] !== undefined) {
+        const value_sourceUrl = value["sourceUrl"];
+        if (typeof value_sourceUrl !== "string" || value_sourceUrl.length > 2048)
+            return "reference_source_url";
+    }
+    if (value["humanReviewRequired"] !== undefined) {
+        const value_humanReviewRequired = value["humanReviewRequired"];
+        if (typeof value_humanReviewRequired !== "boolean" ||
+            value_humanReviewRequired !== true)
+            return "reference_human_review_required";
+    }
+    return null;
+}
+const validRcmSupportingReference = (value) => rcmSupportingReferenceValidationError(value) === null;
+exports.validRcmSupportingReference = validRcmSupportingReference;
+exports.RcmSupportingReferenceSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/rcm-supporting-reference.schema.json",
+    title: "RcmSupportingReference",
+    description: "One policy/evidence reference attached to an RCM coding request or returned by the tenant-scoped hosted retrieval. Core fields are the portable minimum; the remaining fields are populated by the hosted runtime and may be absent for customer-injected development references.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["referenceId", "title", "excerpt"],
+    properties: {
+        referenceId: {
+            type: "string",
+            pattern: "^reference-[1-9][0-9]*$",
+            maxLength: 32,
+        },
+        documentId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 240,
+        },
+        title: {
+            type: "string",
+            minLength: 1,
+            maxLength: 240,
+        },
+        excerpt: {
+            type: "string",
+            minLength: 1,
+            maxLength: 2000,
+        },
+        version: {
+            type: "string",
+            minLength: 1,
+            maxLength: 80,
+        },
+        corpusScope: {
+            type: "string",
+            enum: ["base", "tenant"],
+        },
+        publisher: {
+            type: "string",
+            maxLength: 240,
+        },
+        effectiveDate: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+        },
+        retrievalDate: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+        },
+        coveredPayerProgram: {
+            type: "string",
+            maxLength: 240,
+        },
+        sourceUrl: {
+            type: "string",
+            maxLength: 2048,
+        },
+        humanReviewRequired: {
+            type: "boolean",
+            const: true,
+        },
+    },
+};
+// --------------------------------------------------------------------
+// RcmCodingInput (schema 1.0.0, wire rcm-coding-input-v1)
+// --------------------------------------------------------------------
+exports.rcmCodingInputSchema = zod_1.z
+    .object({
+    encounterId: zod_1.z.string().min(1).max(160),
+    diagnosisNarrative: zod_1.z.string().min(1).max(2000),
+    procedureNarrative: zod_1.z.string().max(2000).optional(),
+    serviceDate: zod_1.z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+        .optional(),
+    placeOfService: zod_1.z.string().min(1).max(20).optional(),
+    claimContext: zod_1.z
+        .object({
+        stage: zod_1.z.enum(["development", "staging", "production"]).optional(),
+        payerName: zod_1.z.string().min(1).max(160).optional(),
+        submittedCodes: zod_1.z.array(zod_1.z.string().min(1).max(20)).max(20).optional(),
+    })
+        .strict()
+        .optional(),
+    supportingReferences: zod_1.z
+        .array(exports.rcmSupportingReferenceSchema)
+        .max(10)
+        .optional(),
+})
+    .strict();
+function rcmCodingInputValidationError(value) {
+    if (!isRecord(value))
+        return "coding_input";
+    if (!Object.keys(value).every((key) => [
+        "encounterId",
+        "diagnosisNarrative",
+        "procedureNarrative",
+        "serviceDate",
+        "placeOfService",
+        "claimContext",
+        "supportingReferences",
+    ].includes(key)) ||
+        !["encounterId", "diagnosisNarrative"].every((key) => key in value))
+        return "coding_input_keys";
+    const value_encounterId = value["encounterId"];
+    if (typeof value_encounterId !== "string" ||
+        value_encounterId.length < 1 ||
+        value_encounterId.length > 160)
+        return "encounter_id";
+    const value_diagnosisNarrative = value["diagnosisNarrative"];
+    if (typeof value_diagnosisNarrative !== "string" ||
+        value_diagnosisNarrative.length < 1 ||
+        value_diagnosisNarrative.length > 2000)
+        return "diagnosis_narrative";
+    if (value["procedureNarrative"] !== undefined) {
+        const value_procedureNarrative = value["procedureNarrative"];
+        if (typeof value_procedureNarrative !== "string" ||
+            value_procedureNarrative.length > 2000)
+            return "procedure_narrative";
+    }
+    if (value["serviceDate"] !== undefined) {
+        const value_serviceDate = value["serviceDate"];
+        if (typeof value_serviceDate !== "string" ||
+            !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_serviceDate))
+            return "service_date";
+    }
+    if (value["placeOfService"] !== undefined) {
+        const value_placeOfService = value["placeOfService"];
+        if (typeof value_placeOfService !== "string" ||
+            value_placeOfService.length < 1 ||
+            value_placeOfService.length > 20)
+            return "place_of_service";
+    }
+    if (value["claimContext"] !== undefined) {
+        const value_claimContext = value["claimContext"];
+        if (!isRecord(value_claimContext))
+            return "claim_context";
+        if (!Object.keys(value_claimContext).every((key) => ["stage", "payerName", "submittedCodes"].includes(key)))
+            return "claim_context";
+        if (value_claimContext["stage"] !== undefined) {
+            const value_claimContext_stage = value_claimContext["stage"];
+            if (typeof value_claimContext_stage !== "string" ||
+                !["development", "staging", "production"].includes(value_claimContext_stage))
+                return "claim_context_stage";
+        }
+        if (value_claimContext["payerName"] !== undefined) {
+            const value_claimContext_payerName = value_claimContext["payerName"];
+            if (typeof value_claimContext_payerName !== "string" ||
+                value_claimContext_payerName.length < 1 ||
+                value_claimContext_payerName.length > 160)
+                return "claim_context_payer_name";
+        }
+        if (value_claimContext["submittedCodes"] !== undefined) {
+            const value_claimContext_submittedCodes = value_claimContext["submittedCodes"];
+            if (!Array.isArray(value_claimContext_submittedCodes) ||
+                value_claimContext_submittedCodes.length > 20)
+                return "claim_context_submitted_codes";
+            for (const item of value_claimContext_submittedCodes) {
+                if (typeof item !== "string" || item.length < 1 || item.length > 20)
+                    return "claim_context_submitted_codes";
+            }
+        }
+    }
+    if (value["supportingReferences"] !== undefined) {
+        const value_supportingReferences = value["supportingReferences"];
+        if (!Array.isArray(value_supportingReferences) ||
+            value_supportingReferences.length > 10)
+            return "supporting_references";
+        for (const item of value_supportingReferences) {
+            const itemError = rcmSupportingReferenceValidationError(item);
+            if (itemError !== null)
+                return itemError;
+        }
+    }
+    return null;
+}
+const validRcmCodingInput = (value) => rcmCodingInputValidationError(value) === null;
+exports.validRcmCodingInput = validRcmCodingInput;
+exports.RcmCodingInputSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/rcm-coding-input.schema.json",
+    title: "RcmCodingInput",
+    description: "Structured coding-case context for a single encounter-based RCM coding-review request. Canonical source for the SDK input shape, the portal request context, and the cloud-hosted encounter payload.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["encounterId", "diagnosisNarrative"],
+    properties: {
+        encounterId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 160,
+        },
+        diagnosisNarrative: {
+            type: "string",
+            minLength: 1,
+            maxLength: 2000,
+        },
+        procedureNarrative: {
+            type: "string",
+            maxLength: 2000,
+        },
+        serviceDate: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+        },
+        placeOfService: {
+            type: "string",
+            minLength: 1,
+            maxLength: 20,
+        },
+        claimContext: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                stage: {
+                    type: "string",
+                    enum: ["development", "staging", "production"],
+                },
+                payerName: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 160,
+                },
+                submittedCodes: {
+                    type: "array",
+                    maxItems: 20,
+                    items: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 20,
+                    },
+                },
+            },
+        },
+        supportingReferences: {
+            type: "array",
+            maxItems: 10,
+            items: {
+                $ref: "rcm-supporting-reference.schema.json",
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// RcmCodingOutput (schema 1.0.0, wire rcm-grounded-human-review-v2)
+// --------------------------------------------------------------------
+exports.rcmCodingOutputSchema = zod_1.z
+    .object({
+    disposition: zod_1.z.enum(["review_required", "abstain", "escalate"]),
+    humanReviewRequired: zod_1.z.literal(true),
+    rationale: zod_1.z
+        .string()
+        .min(1)
+        .max(4000)
+        .refine((value) => value.trim().length > 0),
+    recommendations: zod_1.z
+        .array(zod_1.z
+        .object({
+        code: zod_1.z
+            .string()
+            .min(1)
+            .max(64)
+            .refine((value) => value.trim().length > 0),
+        codeSystem: zod_1.z.enum(["ICD-10-CM", "CPT", "HCPCS"]),
+        confidence: zod_1.z.enum(["low", "medium", "high"]),
+        rationale: zod_1.z
+            .string()
+            .min(1)
+            .max(2000)
+            .refine((value) => value.trim().length > 0),
+        evidenceIds: zod_1.z
+            .array(zod_1.z
+            .string()
+            .min(1)
+            .max(128)
+            .refine((value) => value.trim().length > 0))
+            .min(1)
+            .max(5),
+    })
+        .strict())
+        .max(20),
+    documentationGaps: zod_1.z
+        .array(zod_1.z
+        .string()
+        .min(1)
+        .max(1000)
+        .refine((value) => value.trim().length > 0))
+        .max(20),
+})
+    .strict()
+    .superRefine((value, ctx) => {
+    if (value["disposition"] === "review_required") {
+        if (!Array.isArray(value["recommendations"]) ||
+            value["recommendations"].length === 0) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["recommendations"],
+                message: "review_required_recommendations",
+            });
+        }
+    }
+    else {
+        if (Array.isArray(value["recommendations"]) &&
+            value["recommendations"].length > 0) {
+            ctx.addIssue({
+                code: "custom",
+                path: ["recommendations"],
+                message: "disposition_recommendations",
+            });
+        }
+    }
+});
+function rcmCodingOutputValidationError(value, options) {
+    if (!isRecord(value))
+        return "not_object";
+    if (!Object.keys(value).every((key) => [
+        "disposition",
+        "humanReviewRequired",
+        "rationale",
+        "recommendations",
+        "documentationGaps",
+    ].includes(key)) ||
+        ![
+            "disposition",
+            "humanReviewRequired",
+            "recommendations",
+            "documentationGaps",
+            "rationale",
+        ].every((key) => key in value))
+        return "top_level_keys";
+    const value_disposition = value["disposition"];
+    if (typeof value_disposition !== "string" ||
+        !["review_required", "abstain", "escalate"].includes(value_disposition))
+        return "disposition";
+    const value_humanReviewRequired = value["humanReviewRequired"];
+    if (typeof value_humanReviewRequired !== "boolean" ||
+        value_humanReviewRequired !== true)
+        return "human_review_required";
+    const value_rationale = value["rationale"];
+    if (typeof value_rationale !== "string" ||
+        value_rationale.length < 1 ||
+        value_rationale.length > 4000 ||
+        value_rationale.trim().length === 0)
+        return "rationale";
+    const value_recommendations = value["recommendations"];
+    if (!Array.isArray(value_recommendations) ||
+        value_recommendations.length > 20)
+        return "recommendations";
+    for (const item of value_recommendations) {
+        if (!isRecord(item))
+            return "recommendation_keys";
+        if (!Object.keys(item).every((key) => [
+            "code",
+            "codeSystem",
+            "confidence",
+            "rationale",
+            "evidenceIds",
+        ].includes(key)) ||
+            !["code", "codeSystem", "confidence", "rationale", "evidenceIds"].every((key) => key in item))
+            return "recommendation_keys";
+        const item_code = item["code"];
+        if (typeof item_code !== "string" ||
+            item_code.length < 1 ||
+            item_code.length > 64 ||
+            item_code.trim().length === 0)
+            return "recommendation_code";
+        const item_codeSystem = item["codeSystem"];
+        if (typeof item_codeSystem !== "string" ||
+            !["ICD-10-CM", "CPT", "HCPCS"].includes(item_codeSystem))
+            return "recommendation_code_system";
+        const item_confidence = item["confidence"];
+        if (typeof item_confidence !== "string" ||
+            !["low", "medium", "high"].includes(item_confidence))
+            return "recommendation_confidence";
+        const item_rationale = item["rationale"];
+        if (typeof item_rationale !== "string" ||
+            item_rationale.length < 1 ||
+            item_rationale.length > 2000 ||
+            item_rationale.trim().length === 0)
+            return "recommendation_rationale";
+        const item_evidenceIds = item["evidenceIds"];
+        if (!Array.isArray(item_evidenceIds) ||
+            item_evidenceIds.length < 1 ||
+            item_evidenceIds.length > 5)
+            return "recommendation_evidence_ids";
+        for (const item of item_evidenceIds) {
+            if (typeof item !== "string" ||
+                item.length < 1 ||
+                item.length > 128 ||
+                item.trim().length === 0)
+                return "recommendation_evidence_ids";
+        }
+    }
+    const value_documentationGaps = value["documentationGaps"];
+    if (!Array.isArray(value_documentationGaps) ||
+        value_documentationGaps.length > 20)
+        return "documentation_gaps";
+    for (const item of value_documentationGaps) {
+        if (typeof item !== "string" ||
+            item.length < 1 ||
+            item.length > 1000 ||
+            item.trim().length === 0)
+            return "documentation_gaps";
+    }
+    if (value["disposition"] === "review_required") {
+        if (!Array.isArray(value["recommendations"]) ||
+            value["recommendations"].length === 0)
+            return "review_required_recommendations";
+    }
+    else {
+        if (Array.isArray(value["recommendations"]) &&
+            value["recommendations"].length > 0)
+            return "disposition_recommendations";
+    }
+    if (options?.allowedReferenceIds) {
+        for (const recommendation of value["recommendations"] ?? []) {
+            const rec = isRecord(recommendation) ? recommendation : {};
+            const ids = Array.isArray(rec["evidenceIds"])
+                ? rec["evidenceIds"]
+                : [];
+            for (const id of ids) {
+                if (!options.allowedReferenceIds.has(String(id)))
+                    return "recommendation_unapproved_evidence";
+            }
+        }
+    }
+    if (options?.referenceTextById) {
+        for (const recommendation of value["recommendations"] ?? []) {
+            const rec = isRecord(recommendation) ? recommendation : {};
+            const ids = Array.isArray(rec["evidenceIds"])
+                ? rec["evidenceIds"]
+                : [];
+            if (ids.length === 0)
+                continue;
+            const code = String(rec["code"] ?? "");
+            const codePattern = new RegExp("(?<![A-Za-z0-9.])" +
+                escapeRegExp(code) +
+                "(?![A-Za-z0-9]|\\.[A-Za-z0-9])", "i");
+            if (!ids.some((id) => codePattern.test(options.referenceTextById?.[String(id)] ?? "")))
+                return "recommendation_code_not_in_evidence";
+        }
+    }
+    return null;
+}
+const validRcmCodingOutput = (value) => rcmCodingOutputValidationError(value) === null;
+exports.validRcmCodingOutput = validRcmCodingOutput;
+exports.RcmCodingOutputSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/rcm-coding-output.schema.json",
+    title: "RcmCodingOutput",
+    description: "Grounded RCM coding-review result returned by the hosted runtime. This is the stable compatibility contract behind the legacy rcm-grounded-human-review-v2 output schema version. The runtime postcondition fails closed: any structural or grounding violation is replaced with an escalate response carrying rcm_validation_error.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "disposition",
+        "humanReviewRequired",
+        "recommendations",
+        "documentationGaps",
+        "rationale",
+    ],
+    properties: {
+        disposition: {
+            type: "string",
+            enum: ["review_required", "abstain", "escalate"],
+        },
+        humanReviewRequired: {
+            type: "boolean",
+            const: true,
+        },
+        rationale: {
+            type: "string",
+            minLength: 1,
+            maxLength: 4000,
+        },
+        recommendations: {
+            type: "array",
+            maxItems: 20,
+            items: {
+                type: "object",
+                additionalProperties: false,
+                required: [
+                    "code",
+                    "codeSystem",
+                    "confidence",
+                    "rationale",
+                    "evidenceIds",
+                ],
+                properties: {
+                    code: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 64,
+                    },
+                    codeSystem: {
+                        type: "string",
+                        enum: ["ICD-10-CM", "CPT", "HCPCS"],
+                    },
+                    confidence: {
+                        type: "string",
+                        enum: ["low", "medium", "high"],
+                    },
+                    rationale: {
+                        type: "string",
+                        minLength: 1,
+                        maxLength: 2000,
+                    },
+                    evidenceIds: {
+                        type: "array",
+                        minItems: 1,
+                        maxItems: 5,
+                        items: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 128,
+                        },
+                    },
+                },
+            },
+        },
+        documentationGaps: {
+            type: "array",
+            maxItems: 20,
+            items: {
+                type: "string",
+                minLength: 1,
+                maxLength: 1000,
+            },
+        },
+    },
+    if: {
+        properties: {
+            disposition: {
+                const: "review_required",
+            },
+        },
+        required: ["disposition"],
+    },
+    then: {
+        properties: {
+            recommendations: {
+                minItems: 1,
+            },
+        },
+    },
+    else: {
+        properties: {
+            recommendations: {
+                maxItems: 0,
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// RcmModelPrompt (schema 1.0.0, wire rcm-model-prompt-v1)
+// --------------------------------------------------------------------
+exports.rcmModelPromptSchema = zod_1.z
+    .object({
+    encounter: zod_1.z
+        .object({
+        encounterId: zod_1.z.string().min(1).max(160),
+        diagnosisNarrative: zod_1.z.string().min(1).max(2000),
+        procedureNarrative: zod_1.z.string().max(2000).optional(),
+        serviceDate: zod_1.z
+            .string()
+            .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}$"))
+            .optional(),
+        placeOfService: zod_1.z.string().min(1).max(20).optional(),
+        claimContext: zod_1.z
+            .object({
+            stage: zod_1.z.enum(["development", "staging", "production"]).optional(),
+            payerName: zod_1.z.string().min(1).max(160).optional(),
+            submittedCodes: zod_1.z
+                .array(zod_1.z.string().min(1).max(20))
+                .max(20)
+                .optional(),
+        })
+            .strict()
+            .optional(),
+    })
+        .strict(),
+    supportingReferences: zod_1.z.array(exports.rcmSupportingReferenceSchema).max(5),
+})
+    .strict();
+function rcmModelPromptValidationError(value) {
+    if (!isRecord(value))
+        return "model_prompt";
+    if (!Object.keys(value).every((key) => ["encounter", "supportingReferences"].includes(key)) ||
+        !["encounter", "supportingReferences"].every((key) => key in value))
+        return "model_prompt_keys";
+    const value_encounter = value["encounter"];
+    if (!isRecord(value_encounter))
+        return "encounter";
+    if (!Object.keys(value_encounter).every((key) => [
+        "encounterId",
+        "diagnosisNarrative",
+        "procedureNarrative",
+        "serviceDate",
+        "placeOfService",
+        "claimContext",
+    ].includes(key)) ||
+        !["encounterId", "diagnosisNarrative"].every((key) => key in value_encounter))
+        return "encounter_keys";
+    const value_encounter_encounterId = value_encounter["encounterId"];
+    if (typeof value_encounter_encounterId !== "string" ||
+        value_encounter_encounterId.length < 1 ||
+        value_encounter_encounterId.length > 160)
+        return "encounter_id";
+    const value_encounter_diagnosisNarrative = value_encounter["diagnosisNarrative"];
+    if (typeof value_encounter_diagnosisNarrative !== "string" ||
+        value_encounter_diagnosisNarrative.length < 1 ||
+        value_encounter_diagnosisNarrative.length > 2000)
+        return "diagnosis_narrative";
+    if (value_encounter["procedureNarrative"] !== undefined) {
+        const value_encounter_procedureNarrative = value_encounter["procedureNarrative"];
+        if (typeof value_encounter_procedureNarrative !== "string" ||
+            value_encounter_procedureNarrative.length > 2000)
+            return "procedure_narrative";
+    }
+    if (value_encounter["serviceDate"] !== undefined) {
+        const value_encounter_serviceDate = value_encounter["serviceDate"];
+        if (typeof value_encounter_serviceDate !== "string" ||
+            !new RegExp("^\\d{4}-\\d{2}-\\d{2}$").test(value_encounter_serviceDate))
+            return "service_date";
+    }
+    if (value_encounter["placeOfService"] !== undefined) {
+        const value_encounter_placeOfService = value_encounter["placeOfService"];
+        if (typeof value_encounter_placeOfService !== "string" ||
+            value_encounter_placeOfService.length < 1 ||
+            value_encounter_placeOfService.length > 20)
+            return "place_of_service";
+    }
+    if (value_encounter["claimContext"] !== undefined) {
+        const value_encounter_claimContext = value_encounter["claimContext"];
+        if (!isRecord(value_encounter_claimContext))
+            return "claim_context";
+        if (!Object.keys(value_encounter_claimContext).every((key) => ["stage", "payerName", "submittedCodes"].includes(key)))
+            return "claim_context";
+        if (value_encounter_claimContext["stage"] !== undefined) {
+            const value_encounter_claimContext_stage = value_encounter_claimContext["stage"];
+            if (typeof value_encounter_claimContext_stage !== "string" ||
+                !["development", "staging", "production"].includes(value_encounter_claimContext_stage))
+                return "claim_context_stage";
+        }
+        if (value_encounter_claimContext["payerName"] !== undefined) {
+            const value_encounter_claimContext_payerName = value_encounter_claimContext["payerName"];
+            if (typeof value_encounter_claimContext_payerName !== "string" ||
+                value_encounter_claimContext_payerName.length < 1 ||
+                value_encounter_claimContext_payerName.length > 160)
+                return "claim_context_payer_name";
+        }
+        if (value_encounter_claimContext["submittedCodes"] !== undefined) {
+            const value_encounter_claimContext_submittedCodes = value_encounter_claimContext["submittedCodes"];
+            if (!Array.isArray(value_encounter_claimContext_submittedCodes) ||
+                value_encounter_claimContext_submittedCodes.length > 20)
+                return "claim_context_submitted_codes";
+            for (const item of value_encounter_claimContext_submittedCodes) {
+                if (typeof item !== "string" || item.length < 1 || item.length > 20)
+                    return "claim_context_submitted_codes";
+            }
+        }
+    }
+    const value_supportingReferences = value["supportingReferences"];
+    if (!Array.isArray(value_supportingReferences) ||
+        value_supportingReferences.length > 5)
+        return "model_prompt_references";
+    for (const item of value_supportingReferences) {
+        const itemError = rcmSupportingReferenceValidationError(item);
+        if (itemError !== null)
+            return itemError;
+    }
+    return null;
+}
+const validRcmModelPrompt = (value) => rcmModelPromptValidationError(value) === null;
+exports.validRcmModelPrompt = validRcmModelPrompt;
+exports.RcmModelPromptSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/rcm-model-prompt.schema.json",
+    title: "RcmModelPrompt",
+    description: "Structured JSON presented to the coding model. The encounter carries the request case fields and supportingReferences carry server-resolved or development-approved evidence. The hosted runtime builds this itself from retrieval and never accepts caller-supplied references outside development.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["encounter", "supportingReferences"],
+    properties: {
+        encounter: {
+            type: "object",
+            additionalProperties: false,
+            required: ["encounterId", "diagnosisNarrative"],
+            properties: {
+                encounterId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 160,
+                },
+                diagnosisNarrative: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 2000,
+                },
+                procedureNarrative: {
+                    type: "string",
+                    maxLength: 2000,
+                },
+                serviceDate: {
+                    type: "string",
+                    pattern: "^\\d{4}-\\d{2}-\\d{2}$",
+                },
+                placeOfService: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 20,
+                },
+                claimContext: {
+                    type: "object",
+                    additionalProperties: false,
+                    properties: {
+                        stage: {
+                            type: "string",
+                            enum: ["development", "staging", "production"],
+                        },
+                        payerName: {
+                            type: "string",
+                            minLength: 1,
+                            maxLength: 160,
+                        },
+                        submittedCodes: {
+                            type: "array",
+                            maxItems: 20,
+                            items: {
+                                type: "string",
+                                minLength: 1,
+                                maxLength: 20,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        supportingReferences: {
+            type: "array",
+            maxItems: 5,
+            items: {
+                $ref: "rcm-supporting-reference.schema.json",
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// RcmRetrievalMetadata (schema 1.0.0, wire rcm-retrieval-metadata-v1)
+// --------------------------------------------------------------------
+exports.rcmRetrievalMetadataSchema = zod_1.z
+    .object({
+    corpusId: zod_1.z.string().min(1).max(128),
+    corpusVersion: zod_1.z.string().min(1).max(128),
+    outcome: zod_1.z.enum(["completed", "empty", "failed"]),
+    latencyMs: zod_1.z.number().int().min(0),
+    knowledgeBaseId: zod_1.z.string().max(128).optional(),
+    tenantId: zod_1.z.string().max(128).optional(),
+    references: zod_1.z.array(exports.rcmSupportingReferenceSchema),
+})
+    .strict();
+function rcmRetrievalMetadataValidationError(value) {
+    if (!isRecord(value))
+        return "retrieval_metadata";
+    if (!Object.keys(value).every((key) => [
+        "corpusId",
+        "corpusVersion",
+        "outcome",
+        "latencyMs",
+        "knowledgeBaseId",
+        "tenantId",
+        "references",
+    ].includes(key)) ||
+        !["corpusId", "corpusVersion", "outcome", "latencyMs", "references"].every((key) => key in value))
+        return "retrieval_metadata_keys";
+    const value_corpusId = value["corpusId"];
+    if (typeof value_corpusId !== "string" ||
+        value_corpusId.length < 1 ||
+        value_corpusId.length > 128)
+        return "corpus_id";
+    const value_corpusVersion = value["corpusVersion"];
+    if (typeof value_corpusVersion !== "string" ||
+        value_corpusVersion.length < 1 ||
+        value_corpusVersion.length > 128)
+        return "corpus_version";
+    const value_outcome = value["outcome"];
+    if (typeof value_outcome !== "string" ||
+        !["completed", "empty", "failed"].includes(value_outcome))
+        return "retrieval_outcome";
+    const value_latencyMs = value["latencyMs"];
+    if (typeof value_latencyMs !== "number" ||
+        Number.isNaN(value_latencyMs) ||
+        !Number.isInteger(value_latencyMs) ||
+        value_latencyMs < 0)
+        return "retrieval_latency_ms";
+    if (value["knowledgeBaseId"] !== undefined) {
+        const value_knowledgeBaseId = value["knowledgeBaseId"];
+        if (typeof value_knowledgeBaseId !== "string" ||
+            value_knowledgeBaseId.length > 128)
+            return "knowledge_base_id";
+    }
+    if (value["tenantId"] !== undefined) {
+        const value_tenantId = value["tenantId"];
+        if (typeof value_tenantId !== "string" || value_tenantId.length > 128)
+            return "retrieval_tenant_id";
+    }
+    const value_references = value["references"];
+    if (!Array.isArray(value_references))
+        return "retrieval_references";
+    for (const item of value_references) {
+        const itemError = rcmSupportingReferenceValidationError(item);
+        if (itemError !== null)
+            return itemError;
+    }
+    return null;
+}
+const validRcmRetrievalMetadata = (value) => rcmRetrievalMetadataValidationError(value) === null;
+exports.validRcmRetrievalMetadata = validRcmRetrievalMetadata;
+exports.RcmRetrievalMetadataSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/rcm-retrieval-metadata.schema.json",
+    title: "RcmRetrievalMetadata",
+    description: "Bounded metadata attached to a hosted RCM retrieval outcome. The client-visible shape omits tenantId and knowledgeBaseId; both are included here as optional so the full runtime envelope and the persisted client-facing metadata validate against the same contract.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["corpusId", "corpusVersion", "outcome", "latencyMs", "references"],
+    properties: {
+        corpusId: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        corpusVersion: {
+            type: "string",
+            minLength: 1,
+            maxLength: 128,
+        },
+        outcome: {
+            type: "string",
+            enum: ["completed", "empty", "failed"],
+        },
+        latencyMs: {
+            type: "integer",
+            minimum: 0,
+        },
+        knowledgeBaseId: {
+            type: "string",
+            maxLength: 128,
+        },
+        tenantId: {
+            type: "string",
+            maxLength: 128,
+        },
+        references: {
+            type: "array",
+            items: {
+                $ref: "rcm-supporting-reference.schema.json",
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// RcmRuntimeEvent (schema 1.0.0, wire rcm-runtime-event-v1)
+// --------------------------------------------------------------------
+exports.rcmRuntimeEventSchema = zod_1.z
+    .object({
+    type: zod_1.z.enum(["audit", "safety"]),
+    outcome: zod_1.z.enum(["authorized", "validated", "escalated"]),
+    reason: zod_1.z.enum([
+        "workflow_authorized",
+        "output_validated",
+        "output_invalid",
+        "workflow_escalated",
+        "guardrail_blocked",
+        "retrieval_completed",
+        "retrieval_failed",
+    ]),
+    occurredAt: zod_1.z
+        .string()
+        .regex(new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}"))
+        .max(64),
+    workflowId: zod_1.z.enum(["rcm-coding-assistance"]),
+    guardrail: zod_1.z
+        .object({
+        stopReason: zod_1.z.string().max(64).optional(),
+        actions: zod_1.z
+            .array(zod_1.z
+            .object({
+            scope: zod_1.z.string().max(64),
+            policyType: zod_1.z.string().max(64),
+            rule: zod_1.z.string().max(128),
+            action: zod_1.z.string().max(64),
+        })
+            .strict())
+            .optional(),
+    })
+        .strict()
+        .optional(),
+    retrieval: zod_1.z
+        .object({
+        corpusId: zod_1.z.string().min(1).max(128),
+        corpusVersion: zod_1.z.string().min(1).max(128),
+        outcome: zod_1.z.string().max(64),
+        referenceCount: zod_1.z.number().int().min(0),
+        latencyMs: zod_1.z.number().int().min(0),
+        references: zod_1.z.array(zod_1.z
+            .object({
+            referenceId: zod_1.z
+                .string()
+                .regex(new RegExp("^reference-[1-9][0-9]*$"))
+                .max(32),
+            documentId: zod_1.z.string().min(1).max(240),
+            version: zod_1.z.string().min(1).max(80),
+        })
+            .strict()),
+    })
+        .strict()
+        .optional(),
+})
+    .strict();
+function rcmRuntimeEventValidationError(value) {
+    if (!isRecord(value))
+        return "runtime_event";
+    if (!Object.keys(value).every((key) => [
+        "type",
+        "outcome",
+        "reason",
+        "occurredAt",
+        "workflowId",
+        "guardrail",
+        "retrieval",
+    ].includes(key)) ||
+        !["type", "outcome", "reason", "occurredAt", "workflowId"].every((key) => key in value))
+        return "runtime_event_keys";
+    const value_type = value["type"];
+    if (typeof value_type !== "string" ||
+        !["audit", "safety"].includes(value_type))
+        return "runtime_event_type";
+    const value_outcome = value["outcome"];
+    if (typeof value_outcome !== "string" ||
+        !["authorized", "validated", "escalated"].includes(value_outcome))
+        return "runtime_event_outcome";
+    const value_reason = value["reason"];
+    if (typeof value_reason !== "string" ||
+        ![
+            "workflow_authorized",
+            "output_validated",
+            "output_invalid",
+            "workflow_escalated",
+            "guardrail_blocked",
+            "retrieval_completed",
+            "retrieval_failed",
+        ].includes(value_reason))
+        return "runtime_event_reason";
+    const value_occurredAt = value["occurredAt"];
+    if (typeof value_occurredAt !== "string" ||
+        value_occurredAt.length > 64 ||
+        !new RegExp("^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}").test(value_occurredAt))
+        return "runtime_event_occurred_at";
+    const value_workflowId = value["workflowId"];
+    if (typeof value_workflowId !== "string" ||
+        !["rcm-coding-assistance"].includes(value_workflowId))
+        return "runtime_event_workflow_id";
+    if (value["guardrail"] !== undefined) {
+        const value_guardrail = value["guardrail"];
+        if (!isRecord(value_guardrail))
+            return "runtime_event_guardrail";
+        if (!Object.keys(value_guardrail).every((key) => ["stopReason", "actions"].includes(key)))
+            return "runtime_event_guardrail_keys";
+        if (value_guardrail["stopReason"] !== undefined) {
+            const value_guardrail_stopReason = value_guardrail["stopReason"];
+            if (typeof value_guardrail_stopReason !== "string" ||
+                value_guardrail_stopReason.length > 64)
+                return "runtime_event_guardrail_stop_reason";
+        }
+        if (value_guardrail["actions"] !== undefined) {
+            const value_guardrail_actions = value_guardrail["actions"];
+            if (!Array.isArray(value_guardrail_actions))
+                return "runtime_event_guardrail_actions";
+            for (const item of value_guardrail_actions) {
+                if (!isRecord(item))
+                    return "runtime_event_guardrail_action";
+                if (!Object.keys(item).every((key) => ["scope", "policyType", "rule", "action"].includes(key)) ||
+                    !["scope", "policyType", "rule", "action"].every((key) => key in item))
+                    return "runtime_event_guardrail_action_keys";
+                const item_scope = item["scope"];
+                if (typeof item_scope !== "string" || item_scope.length > 64)
+                    return "runtime_event_guardrail_action_scope";
+                const item_policyType = item["policyType"];
+                if (typeof item_policyType !== "string" || item_policyType.length > 64)
+                    return "runtime_event_guardrail_action_policy_type";
+                const item_rule = item["rule"];
+                if (typeof item_rule !== "string" || item_rule.length > 128)
+                    return "runtime_event_guardrail_action_rule";
+                const item_action = item["action"];
+                if (typeof item_action !== "string" || item_action.length > 64)
+                    return "runtime_event_guardrail_action_type";
+            }
+        }
+    }
+    if (value["retrieval"] !== undefined) {
+        const value_retrieval = value["retrieval"];
+        if (!isRecord(value_retrieval))
+            return "runtime_event_retrieval";
+        if (!Object.keys(value_retrieval).every((key) => [
+            "corpusId",
+            "corpusVersion",
+            "outcome",
+            "referenceCount",
+            "latencyMs",
+            "references",
+        ].includes(key)) ||
+            ![
+                "corpusId",
+                "corpusVersion",
+                "outcome",
+                "referenceCount",
+                "latencyMs",
+                "references",
+            ].every((key) => key in value_retrieval))
+            return "runtime_event_retrieval_keys";
+        const value_retrieval_corpusId = value_retrieval["corpusId"];
+        if (typeof value_retrieval_corpusId !== "string" ||
+            value_retrieval_corpusId.length < 1 ||
+            value_retrieval_corpusId.length > 128)
+            return "runtime_event_retrieval_corpus_id";
+        const value_retrieval_corpusVersion = value_retrieval["corpusVersion"];
+        if (typeof value_retrieval_corpusVersion !== "string" ||
+            value_retrieval_corpusVersion.length < 1 ||
+            value_retrieval_corpusVersion.length > 128)
+            return "runtime_event_retrieval_corpus_version";
+        const value_retrieval_outcome = value_retrieval["outcome"];
+        if (typeof value_retrieval_outcome !== "string" ||
+            value_retrieval_outcome.length > 64)
+            return "runtime_event_retrieval_outcome";
+        const value_retrieval_referenceCount = value_retrieval["referenceCount"];
+        if (typeof value_retrieval_referenceCount !== "number" ||
+            Number.isNaN(value_retrieval_referenceCount) ||
+            !Number.isInteger(value_retrieval_referenceCount) ||
+            value_retrieval_referenceCount < 0)
+            return "runtime_event_retrieval_reference_count";
+        const value_retrieval_latencyMs = value_retrieval["latencyMs"];
+        if (typeof value_retrieval_latencyMs !== "number" ||
+            Number.isNaN(value_retrieval_latencyMs) ||
+            !Number.isInteger(value_retrieval_latencyMs) ||
+            value_retrieval_latencyMs < 0)
+            return "runtime_event_retrieval_latency_ms";
+        const value_retrieval_references = value_retrieval["references"];
+        if (!Array.isArray(value_retrieval_references))
+            return "runtime_event_retrieval_references";
+        for (const item of value_retrieval_references) {
+            if (!isRecord(item))
+                return "runtime_event_retrieval_reference";
+            if (!Object.keys(item).every((key) => ["referenceId", "documentId", "version"].includes(key)) ||
+                !["referenceId", "documentId", "version"].every((key) => key in item))
+                return "runtime_event_retrieval_reference_keys";
+            const item_referenceId = item["referenceId"];
+            if (typeof item_referenceId !== "string" ||
+                item_referenceId.length > 32 ||
+                !new RegExp("^reference-[1-9][0-9]*$").test(item_referenceId))
+                return "runtime_event_retrieval_reference_id";
+            const item_documentId = item["documentId"];
+            if (typeof item_documentId !== "string" ||
+                item_documentId.length < 1 ||
+                item_documentId.length > 240)
+                return "runtime_event_retrieval_document_id";
+            const item_version = item["version"];
+            if (typeof item_version !== "string" ||
+                item_version.length < 1 ||
+                item_version.length > 80)
+                return "runtime_event_retrieval_reference_version";
+        }
+    }
+    return null;
+}
+const validRcmRuntimeEvent = (value) => rcmRuntimeEventValidationError(value) === null;
+exports.validRcmRuntimeEvent = validRcmRuntimeEvent;
+exports.RcmRuntimeEventSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/rcm-runtime-event.schema.json",
+    title: "RcmRuntimeEvent",
+    description: "Sanitized audit or safety event emitted along a workflow runtime lifecycle. Events never carry prompts, raw PHI, or unrestricted guardrail trace content.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: ["type", "outcome", "reason", "occurredAt", "workflowId"],
+    properties: {
+        type: {
+            type: "string",
+            enum: ["audit", "safety"],
+        },
+        outcome: {
+            type: "string",
+            enum: ["authorized", "validated", "escalated"],
+        },
+        reason: {
+            type: "string",
+            enum: [
+                "workflow_authorized",
+                "output_validated",
+                "output_invalid",
+                "workflow_escalated",
+                "guardrail_blocked",
+                "retrieval_completed",
+                "retrieval_failed",
+            ],
+        },
+        occurredAt: {
+            type: "string",
+            pattern: "^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}",
+            maxLength: 64,
+        },
+        workflowId: {
+            type: "string",
+            enum: ["rcm-coding-assistance"],
+        },
+        guardrail: {
+            type: "object",
+            additionalProperties: false,
+            properties: {
+                stopReason: {
+                    type: "string",
+                    maxLength: 64,
+                },
+                actions: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["scope", "policyType", "rule", "action"],
+                        properties: {
+                            scope: {
+                                type: "string",
+                                maxLength: 64,
+                            },
+                            policyType: {
+                                type: "string",
+                                maxLength: 64,
+                            },
+                            rule: {
+                                type: "string",
+                                maxLength: 128,
+                            },
+                            action: {
+                                type: "string",
+                                maxLength: 64,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+        retrieval: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+                "corpusId",
+                "corpusVersion",
+                "outcome",
+                "referenceCount",
+                "latencyMs",
+                "references",
+            ],
+            properties: {
+                corpusId: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 128,
+                },
+                corpusVersion: {
+                    type: "string",
+                    minLength: 1,
+                    maxLength: 128,
+                },
+                outcome: {
+                    type: "string",
+                    maxLength: 64,
+                },
+                referenceCount: {
+                    type: "integer",
+                    minimum: 0,
+                },
+                latencyMs: {
+                    type: "integer",
+                    minimum: 0,
+                },
+                references: {
+                    type: "array",
+                    items: {
+                        type: "object",
+                        additionalProperties: false,
+                        required: ["referenceId", "documentId", "version"],
+                        properties: {
+                            referenceId: {
+                                type: "string",
+                                pattern: "^reference-[1-9][0-9]*$",
+                                maxLength: 32,
+                            },
+                            documentId: {
+                                type: "string",
+                                minLength: 1,
+                                maxLength: 240,
+                            },
+                            version: {
+                                type: "string",
+                                minLength: 1,
+                                maxLength: 80,
+                            },
+                        },
+                    },
+                },
+            },
+        },
+    },
+};
+// --------------------------------------------------------------------
+// RcmWorkflowCatalog (schema 1.0.0, wire rcm-workflow-catalog-v1)
+// --------------------------------------------------------------------
+exports.rcmWorkflowCatalogSchema = zod_1.z
+    .object({
+    id: zod_1.z.enum(["rcm-coding-assistance"]),
+    name: zod_1.z.string().min(1).max(120),
+    description: zod_1.z.string().min(1).max(400),
+    environments: zod_1.z.array(zod_1.z.enum(["development", "production"])).min(1),
+    modelPolicy: zod_1.z
+        .object({
+        policyId: zod_1.z.literal("carecompass-rcm-review-v1"),
+        inferencePath: zod_1.z.string().max(64),
+        maxNewTokens: zod_1.z.number().int().min(1).max(2048),
+        temperature: zod_1.z.number().min(0).max(2),
+        outputSchemaVersion: zod_1.z.literal("rcm-grounded-human-review-v2"),
+        requireHumanReview: zod_1.z.literal(true),
+    })
+        .strict(),
+    humanReviewPolicy: zod_1.z
+        .object({
+        policyId: zod_1.z.literal("qualified-coder-review-v1"),
+        humanReviewRequired: zod_1.z.literal(true),
+    })
+        .strict(),
+    outputSchemaVersion: zod_1.z.literal("rcm-grounded-human-review-v2"),
+})
+    .strict();
+function rcmWorkflowCatalogValidationError(value) {
+    if (!isRecord(value))
+        return "workflow_catalog";
+    if (!Object.keys(value).every((key) => [
+        "id",
+        "name",
+        "description",
+        "environments",
+        "modelPolicy",
+        "humanReviewPolicy",
+        "outputSchemaVersion",
+    ].includes(key)) ||
+        ![
+            "id",
+            "name",
+            "description",
+            "environments",
+            "modelPolicy",
+            "humanReviewPolicy",
+            "outputSchemaVersion",
+        ].every((key) => key in value))
+        return "workflow_catalog_keys";
+    const value_id = value["id"];
+    if (typeof value_id !== "string" ||
+        !["rcm-coding-assistance"].includes(value_id))
+        return "workflow_id";
+    const value_name = value["name"];
+    if (typeof value_name !== "string" ||
+        value_name.length < 1 ||
+        value_name.length > 120)
+        return "workflow_name";
+    const value_description = value["description"];
+    if (typeof value_description !== "string" ||
+        value_description.length < 1 ||
+        value_description.length > 400)
+        return "workflow_description";
+    const value_environments = value["environments"];
+    if (!Array.isArray(value_environments) || value_environments.length < 1)
+        return "workflow_environments";
+    for (const item of value_environments) {
+        if (typeof item !== "string" ||
+            !["development", "production"].includes(item))
+            return "workflow_environment";
+    }
+    const value_modelPolicy = value["modelPolicy"];
+    if (!isRecord(value_modelPolicy))
+        return "model_policy";
+    if (!Object.keys(value_modelPolicy).every((key) => [
+        "policyId",
+        "inferencePath",
+        "maxNewTokens",
+        "temperature",
+        "outputSchemaVersion",
+        "requireHumanReview",
+    ].includes(key)) ||
+        ![
+            "policyId",
+            "inferencePath",
+            "maxNewTokens",
+            "temperature",
+            "outputSchemaVersion",
+            "requireHumanReview",
+        ].every((key) => key in value_modelPolicy))
+        return "model_policy_keys";
+    const value_modelPolicy_policyId = value_modelPolicy["policyId"];
+    if (typeof value_modelPolicy_policyId !== "string" ||
+        value_modelPolicy_policyId !== "carecompass-rcm-review-v1")
+        return "model_policy_id";
+    const value_modelPolicy_inferencePath = value_modelPolicy["inferencePath"];
+    if (typeof value_modelPolicy_inferencePath !== "string" ||
+        value_modelPolicy_inferencePath.length > 64)
+        return "model_policy_inference_path";
+    const value_modelPolicy_maxNewTokens = value_modelPolicy["maxNewTokens"];
+    if (typeof value_modelPolicy_maxNewTokens !== "number" ||
+        Number.isNaN(value_modelPolicy_maxNewTokens) ||
+        !Number.isInteger(value_modelPolicy_maxNewTokens) ||
+        value_modelPolicy_maxNewTokens < 1 ||
+        value_modelPolicy_maxNewTokens > 2048)
+        return "model_policy_max_new_tokens";
+    const value_modelPolicy_temperature = value_modelPolicy["temperature"];
+    if (typeof value_modelPolicy_temperature !== "number" ||
+        Number.isNaN(value_modelPolicy_temperature) ||
+        value_modelPolicy_temperature < 0 ||
+        value_modelPolicy_temperature > 2)
+        return "model_policy_temperature";
+    const value_modelPolicy_outputSchemaVersion = value_modelPolicy["outputSchemaVersion"];
+    if (typeof value_modelPolicy_outputSchemaVersion !== "string" ||
+        value_modelPolicy_outputSchemaVersion !== "rcm-grounded-human-review-v2")
+        return "model_policy_output_schema_version";
+    const value_modelPolicy_requireHumanReview = value_modelPolicy["requireHumanReview"];
+    if (typeof value_modelPolicy_requireHumanReview !== "boolean" ||
+        value_modelPolicy_requireHumanReview !== true)
+        return "model_policy_require_human_review";
+    const value_humanReviewPolicy = value["humanReviewPolicy"];
+    if (!isRecord(value_humanReviewPolicy))
+        return "human_review_policy";
+    if (!Object.keys(value_humanReviewPolicy).every((key) => ["policyId", "humanReviewRequired"].includes(key)) ||
+        !["policyId", "humanReviewRequired"].every((key) => key in value_humanReviewPolicy))
+        return "human_review_policy_keys";
+    const value_humanReviewPolicy_policyId = value_humanReviewPolicy["policyId"];
+    if (typeof value_humanReviewPolicy_policyId !== "string" ||
+        value_humanReviewPolicy_policyId !== "qualified-coder-review-v1")
+        return "human_review_policy_id";
+    const value_humanReviewPolicy_humanReviewRequired = value_humanReviewPolicy["humanReviewRequired"];
+    if (typeof value_humanReviewPolicy_humanReviewRequired !== "boolean" ||
+        value_humanReviewPolicy_humanReviewRequired !== true)
+        return "human_review_policy_required";
+    const value_outputSchemaVersion = value["outputSchemaVersion"];
+    if (typeof value_outputSchemaVersion !== "string" ||
+        value_outputSchemaVersion !== "rcm-grounded-human-review-v2")
+        return "workflow_output_schema_version";
+    return null;
+}
+const validRcmWorkflowCatalog = (value) => rcmWorkflowCatalogValidationError(value) === null;
+exports.validRcmWorkflowCatalog = validRcmWorkflowCatalog;
+exports.RcmWorkflowCatalogSchemaJson = {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    $id: "https://nexalink.care/contracts/rcm-workflow-catalog.schema.json",
+    title: "RcmWorkflowCatalog",
+    description: "A single authorized workflow entry. The catalog pins the workflow identifier, model policy, human-review policy, and output schema version that the runtime and portal may offer for the RCM coding-assistance workflow. Customer configuration can never redefine these immutable server-side values.",
+    version: "1.0.0",
+    type: "object",
+    additionalProperties: false,
+    required: [
+        "id",
+        "name",
+        "description",
+        "environments",
+        "modelPolicy",
+        "humanReviewPolicy",
+        "outputSchemaVersion",
+    ],
+    properties: {
+        id: {
+            type: "string",
+            enum: ["rcm-coding-assistance"],
+        },
+        name: {
+            type: "string",
+            minLength: 1,
+            maxLength: 120,
+        },
+        description: {
+            type: "string",
+            minLength: 1,
+            maxLength: 400,
+        },
+        environments: {
+            type: "array",
+            minItems: 1,
+            items: {
+                type: "string",
+                enum: ["development", "production"],
+            },
+        },
+        modelPolicy: {
+            type: "object",
+            additionalProperties: false,
+            required: [
+                "policyId",
+                "inferencePath",
+                "maxNewTokens",
+                "temperature",
+                "outputSchemaVersion",
+                "requireHumanReview",
+            ],
+            properties: {
+                policyId: {
+                    type: "string",
+                    const: "carecompass-rcm-review-v1",
+                },
+                inferencePath: {
+                    type: "string",
+                    maxLength: 64,
+                },
+                maxNewTokens: {
+                    type: "integer",
+                    minimum: 1,
+                    maximum: 2048,
+                },
+                temperature: {
+                    type: "number",
+                    minimum: 0,
+                    maximum: 2,
+                },
+                outputSchemaVersion: {
+                    type: "string",
+                    const: "rcm-grounded-human-review-v2",
+                },
+                requireHumanReview: {
+                    type: "boolean",
+                    const: true,
+                },
+            },
+        },
+        humanReviewPolicy: {
+            type: "object",
+            additionalProperties: false,
+            required: ["policyId", "humanReviewRequired"],
+            properties: {
+                policyId: {
+                    type: "string",
+                    const: "qualified-coder-review-v1",
+                },
+                humanReviewRequired: {
+                    type: "boolean",
+                    const: true,
+                },
+            },
+        },
+        outputSchemaVersion: {
+            type: "string",
+            const: "rcm-grounded-human-review-v2",
+        },
+    },
+};