@sourcey/catalog-verifier 1.0.0

package/dist/contracts/standards/src/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../contracts/standards/src/index.ts"],"names":[],"mappings":"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"}

package/dist/contracts/standards/src/index.js

@@ -0,0 +1,626 @@
+import { z } from "zod";
+import { DIGEST_PATTERN } from "../../../modules/primitives/src/index.js";
+const digestSchema = z.string().regex(DIGEST_PATTERN);
+const standardKeySchema = z.string().regex(/^[a-z0-9]+(?:[._-][a-z0-9]+)*$/);
+const standardVersionSchema = z.string().trim().min(1).max(160);
+const requirementIdSchema = z.string().trim().min(1).max(240);
+export const standardIdentitySchema = z
+    .object({
+    namespace: standardKeySchema,
+    version: standardVersionSchema,
+})
+    .strict();
+export const standardImplementationBindingSchema = standardIdentitySchema
+    .safeExtend({
+    relation: z.enum(["declares", "describes", "implements", "uses"]),
+})
+    .strict();
+export const standardRequirementReferenceSchema = standardIdentitySchema
+    .safeExtend({
+    requirement_id: requirementIdSchema,
+    relation: z.enum(["tests", "informational-reference"]),
+})
+    .strict();
+export const standardSourceProvenanceSchema = z
+    .object({
+    role: z.enum(["specification", "schema", "conformance-example"]),
+    source_uri: z.url({ protocol: /^https$/ }),
+    object_digest: digestSchema,
+    media_type: z.string().trim().min(1).max(160),
+    license: z
+        .object({
+        spdx_id: z.string().trim().min(1).max(80),
+        source_uri: z.url({ protocol: /^https$/ }),
+        object_digest: digestSchema,
+    })
+        .strict(),
+})
+    .strict();
+export const standardAdapterDependencySchema = z
+    .object({
+    name: standardKeySchema,
+    version: standardVersionSchema,
+    implementation_digest: digestSchema,
+})
+    .strict();
+export const standardAdapterExecutionSchema = z
+    .object({
+    network: z.literal("forbidden"),
+    external_effects: z.literal("forbidden"),
+})
+    .strict();
+const standardAdapterManifestFields = {
+    standard: standardIdentitySchema,
+    accepted_media_types: z.array(z.string().trim().min(1).max(160)).min(1),
+    implementation_digest: digestSchema,
+    official_sources: z.array(standardSourceProvenanceSchema).min(1),
+    dependencies: z.array(standardAdapterDependencySchema),
+    execution: standardAdapterExecutionSchema,
+};
+function validateAdapterManifest(value, context) {
+    assertUnique(value.accepted_media_types, context, ["accepted_media_types"]);
+    assertUnique(value.official_sources.map((source) => `${source.role}\u0000${source.object_digest}`), context, ["official_sources"]);
+    assertUnique(value.dependencies.map((dependency) => `${dependency.name}\u0000${dependency.version}`), context, ["dependencies"]);
+}
+export const standardEvidenceAdapterManifestCoreSchema = z
+    .object({
+    adapter_contract: z.literal("sourcey.standard-evidence-adapter/v1alpha1"),
+    ...standardAdapterManifestFields,
+    requirement_ids: z.array(requirementIdSchema).min(1),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.requirement_ids, context, ["requirement_ids"]);
+    validateAdapterManifest(value, context);
+});
+export const standardEvidenceAdapterManifestSchema = standardEvidenceAdapterManifestCoreSchema
+    .safeExtend({ adapter_digest: digestSchema })
+    .strict();
+export const standardResourceImportAdapterManifestCoreSchema = z
+    .object({
+    adapter_contract: z.literal("sourcey.standard-resource-import-adapter/v1alpha1"),
+    ...standardAdapterManifestFields,
+    resource_kinds: z.array(standardKeySchema).min(1),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.resource_kinds, context, ["resource_kinds"]);
+    validateAdapterManifest(value, context);
+});
+export const standardResourceImportAdapterManifestSchema = standardResourceImportAdapterManifestCoreSchema
+    .safeExtend({ adapter_digest: digestSchema })
+    .strict();
+export const standardEvidenceArtifactSchema = z
+    .object({
+    object_digest: digestSchema,
+    retention_receipt_digest: digestSchema,
+    media_type: z.string().trim().min(1).max(160),
+    bytes: z.number().int().positive(),
+    source_uri: z.url({ protocol: /^https$/ }),
+    role: z.enum([
+        "representation",
+        "transport_metadata",
+        "rendered_view",
+        "interaction_trace",
+        "manual_record",
+    ]),
+})
+    .strict();
+export const standardResourceImportRequestCoreSchema = z
+    .object({
+    request_contract: z.literal("sourcey.standard-resource-import-request/v1alpha1"),
+    adapter: z
+        .object({
+        namespace: standardKeySchema,
+        version: standardVersionSchema,
+        adapter_digest: digestSchema,
+    })
+        .strict(),
+    entrypoint_object_digests: z.array(digestSchema).min(1).max(64),
+    artifacts: z.array(standardEvidenceArtifactSchema).min(1).max(256),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.entrypoint_object_digests, context, ["entrypoint_object_digests"]);
+    assertUnique(value.artifacts.map((artifact) => artifact.object_digest), context, ["artifacts"]);
+    const artifacts = new Set(value.artifacts.map((artifact) => artifact.object_digest));
+    for (const [index, entrypoint] of value.entrypoint_object_digests.entries()) {
+        if (!artifacts.has(entrypoint)) {
+            context.addIssue({
+                code: "custom",
+                path: ["entrypoint_object_digests", index],
+                message: "Every resource-import entrypoint must name a retained request artifact.",
+            });
+        }
+    }
+});
+export const standardResourceImportRequestSchema = standardResourceImportRequestCoreSchema
+    .safeExtend({ request_digest: digestSchema })
+    .strict();
+export const standardEvidenceRequestCoreSchema = z
+    .object({
+    request_contract: z.literal("sourcey.standard-evidence-request/v1alpha1"),
+    adapter: z
+        .object({
+        namespace: standardKeySchema,
+        version: standardVersionSchema,
+        adapter_digest: digestSchema,
+    })
+        .strict(),
+    requirements: z.array(standardRequirementReferenceSchema).min(1).max(256),
+    artifacts: z.array(standardEvidenceArtifactSchema).min(1).max(64),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.requirements.map(requirementKey), context, ["requirements"]);
+    assertUnique(value.artifacts.map((artifact) => artifact.object_digest), context, ["artifacts"]);
+    for (const [index, requirement] of value.requirements.entries()) {
+        if (requirement.namespace !== value.adapter.namespace ||
+            requirement.version !== value.adapter.version ||
+            requirement.relation !== "tests") {
+            context.addIssue({
+                code: "custom",
+                path: ["requirements", index],
+                message: "Every requested requirement must test the exact adapter standard and version.",
+            });
+        }
+    }
+});
+export const standardEvidenceRequestSchema = standardEvidenceRequestCoreSchema
+    .safeExtend({ request_digest: digestSchema })
+    .strict();
+export const standardEvidenceLocatorSchema = z
+    .object({
+    object_digest: digestSchema,
+    kind: z.literal("utf8-range"),
+    start_byte: z.number().int().nonnegative(),
+    end_byte: z.number().int().positive(),
+    value_digest: digestSchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.end_byte <= value.start_byte) {
+        context.addIssue({
+            code: "custom",
+            path: ["end_byte"],
+            message: "A standards evidence locator must cover at least one byte.",
+        });
+    }
+});
+export const standardEvidenceResidueSchema = z
+    .object({
+    code: z.enum([
+        "resource_required",
+        "invalid_artifact",
+        "insufficient_artifacts",
+        "ambiguous_result",
+        "unsupported_version",
+        "cyclic_reference",
+        "unsupported_requirement",
+    ]),
+    resource_uri: z.url({ protocol: /^https$/ }).nullable(),
+    object_digest: digestSchema.nullable(),
+    detail: z.string().trim().min(1).max(2_000),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if ((value.code === "resource_required") !== (value.resource_uri !== null)) {
+        context.addIssue({
+            code: "custom",
+            path: ["resource_uri"],
+            message: "Only resource-required residue names the exact additional resource URI.",
+        });
+    }
+});
+export const standardImportedFactSchema = z
+    .object({
+    fact_id: standardKeySchema,
+    value: z.json(),
+    locators: z.array(standardEvidenceLocatorSchema).min(1).max(64),
+})
+    .strict();
+export const standardImportedResourceSchema = z
+    .object({
+    candidate_id: standardKeySchema,
+    resource_kind: standardKeySchema,
+    source_object_digest: digestSchema,
+    canonical_uri: z.url({ protocol: /^https$/ }).optional(),
+    facts: z.array(standardImportedFactSchema).max(256),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.facts.map((fact) => fact.fact_id), context, ["facts"]);
+    for (const [factIndex, fact] of value.facts.entries()) {
+        for (const [locatorIndex, locator] of fact.locators.entries()) {
+            if (locator.object_digest !== value.source_object_digest) {
+                context.addIssue({
+                    code: "custom",
+                    path: ["facts", factIndex, "locators", locatorIndex],
+                    message: "An imported fact locator must bind its exact source artifact.",
+                });
+            }
+        }
+    }
+});
+export const standardImportedResourceRelationSchema = z
+    .object({
+    relation_id: standardKeySchema,
+    relation_kind: standardKeySchema,
+    from_candidate_id: standardKeySchema,
+    target: z.union([
+        z.object({ candidate_id: standardKeySchema }).strict(),
+        z.object({ resource_uri: z.url({ protocol: /^https$/ }) }).strict(),
+    ]),
+    locators: z.array(standardEvidenceLocatorSchema).min(1).max(64),
+})
+    .strict();
+export const standardResourceImportResultCoreSchema = z
+    .object({
+    result_contract: z.literal("sourcey.standard-resource-import-result/v1alpha1"),
+    request_digest: digestSchema,
+    adapter_digest: digestSchema,
+    resources: z.array(standardImportedResourceSchema).max(512),
+    relations: z.array(standardImportedResourceRelationSchema).max(1_024),
+    residue: z.array(standardEvidenceResidueSchema).max(256),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.resources.map((resource) => resource.candidate_id), context, ["resources"]);
+    assertUnique(value.relations.map((relation) => relation.relation_id), context, ["relations"]);
+    const resources = new Set(value.resources.map((resource) => resource.candidate_id));
+    for (const [index, relation] of value.relations.entries()) {
+        if (!resources.has(relation.from_candidate_id) ||
+            ("candidate_id" in relation.target && !resources.has(relation.target.candidate_id))) {
+            context.addIssue({
+                code: "custom",
+                path: ["relations", index],
+                message: "Imported resource relations must close over exact candidates or unresolved URIs.",
+            });
+        }
+    }
+});
+export const standardResourceImportResultSchema = standardResourceImportResultCoreSchema
+    .safeExtend({ result_digest: digestSchema })
+    .strict();
+export const standardResourceImportRecordCoreSchema = z
+    .object({
+    record_contract: z.literal("sourcey.standard-resource-import-record/v1alpha1"),
+    request: standardResourceImportRequestSchema,
+    result: standardResourceImportResultSchema,
+    result_object_digest: digestSchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.result.request_digest !== value.request.request_digest ||
+        value.result.adapter_digest !== value.request.adapter.adapter_digest) {
+        context.addIssue({
+            code: "custom",
+            path: ["result"],
+            message: "A resource-import record must bind its exact request and adapter.",
+        });
+    }
+});
+export const standardResourceImportRecordSchema = standardResourceImportRecordCoreSchema
+    .safeExtend({ record_digest: digestSchema })
+    .strict();
+export const standardEvidenceRequirementResultSchema = z
+    .object({
+    requirement: standardRequirementReferenceSchema,
+    status: z.enum(["satisfied", "not_satisfied", "indeterminate"]),
+    locators: z.array(standardEvidenceLocatorSchema).max(64),
+    residue: z.array(standardEvidenceResidueSchema).max(32),
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.status === "indeterminate" && value.residue.length === 0) {
+        context.addIssue({
+            code: "custom",
+            path: ["residue"],
+            message: "An indeterminate standards result must preserve typed residue.",
+        });
+    }
+    if (value.status !== "indeterminate" && value.locators.length === 0) {
+        context.addIssue({
+            code: "custom",
+            path: ["locators"],
+            message: "A conclusive standards result requires exact retained-artifact locators.",
+        });
+    }
+});
+export const standardEvidenceResultCoreSchema = z
+    .object({
+    result_contract: z.literal("sourcey.standard-evidence-result/v1alpha1"),
+    request_digest: digestSchema,
+    adapter_digest: digestSchema,
+    requirements: z.array(standardEvidenceRequirementResultSchema).min(1).max(256),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.requirements.map((result) => requirementKey(result.requirement)), context, ["requirements"]);
+});
+export const standardEvidenceResultSchema = standardEvidenceResultCoreSchema
+    .safeExtend({ result_digest: digestSchema })
+    .strict();
+export const standardEvidenceRecordCoreSchema = z
+    .object({
+    record_contract: z.literal("sourcey.standard-evidence-record/v1alpha1"),
+    request: standardEvidenceRequestSchema,
+    result: standardEvidenceResultSchema,
+    result_object_digest: digestSchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.result.request_digest !== value.request.request_digest ||
+        value.result.adapter_digest !== value.request.adapter.adapter_digest) {
+        context.addIssue({
+            code: "custom",
+            path: ["result"],
+            message: "A standards evidence record must bind its exact request and adapter.",
+        });
+    }
+    const requested = value.request.requirements.map(requirementKey);
+    const returned = value.result.requirements.map(({ requirement }) => requirementKey(requirement));
+    if (requested.length !== returned.length ||
+        requested.some((requirement) => !returned.includes(requirement))) {
+        context.addIssue({
+            code: "custom",
+            path: ["result", "requirements"],
+            message: "A standards evidence record must return its exact requested requirement set.",
+        });
+    }
+    const artifacts = new Map(value.request.artifacts.map((artifact) => [artifact.object_digest, artifact]));
+    for (const [resultIndex, result] of value.result.requirements.entries()) {
+        for (const [locatorIndex, locator] of result.locators.entries()) {
+            const artifact = artifacts.get(locator.object_digest);
+            if (!artifact) {
+                context.addIssue({
+                    code: "custom",
+                    path: ["result", "requirements", resultIndex, "locators", locatorIndex],
+                    message: "A standards result locator must bind an artifact in its exact request.",
+                });
+            }
+            else if (locator.end_byte > artifact.bytes) {
+                context.addIssue({
+                    code: "custom",
+                    path: ["result", "requirements", resultIndex, "locators", locatorIndex],
+                    message: "A standards result locator cannot exceed its retained artifact.",
+                });
+            }
+        }
+        for (const [residueIndex, residue] of result.residue.entries()) {
+            if (residue.object_digest !== null && !artifacts.has(residue.object_digest)) {
+                context.addIssue({
+                    code: "custom",
+                    path: ["result", "requirements", resultIndex, "residue", residueIndex],
+                    message: "Standards residue must bind an artifact in its exact request.",
+                });
+            }
+        }
+    }
+});
+export const standardEvidenceRecordSchema = standardEvidenceRecordCoreSchema
+    .safeExtend({ record_digest: digestSchema })
+    .strict();
+export const externalStandardSuiteDefinitionCoreSchema = z
+    .object({
+    suite_contract: z.literal("sourcey.external-standard-suite/v1alpha1"),
+    suite: standardIdentitySchema,
+    official_sources: z.array(standardSourceProvenanceSchema).min(1),
+    assertions: z
+        .array(z
+        .object({
+        assertion_id: requirementIdSchema,
+        title: z.string().trim().min(1).max(240),
+        metadata: z.record(standardKeySchema, z.json()),
+        operator: z.enum(["all", "any"]),
+        requirements: z.array(standardRequirementReferenceSchema).max(256),
+        mapping_residue: z.array(standardEvidenceResidueSchema).max(32),
+    })
+        .strict()
+        .superRefine((value, context) => {
+        assertUnique(value.requirements.map(requirementKey), context, ["requirements"]);
+        for (const [index, requirement] of value.requirements.entries()) {
+            if (requirement.relation !== "tests") {
+                context.addIssue({
+                    code: "custom",
+                    path: ["requirements", index, "relation"],
+                    message: "An external suite assertion can evaluate only tested leaf requirements.",
+                });
+            }
+        }
+        if ((value.requirements.length === 0) !== value.mapping_residue.length > 0) {
+            context.addIssue({
+                code: "custom",
+                path: ["mapping_residue"],
+                message: "An unmapped suite assertion requires explicit residue; a mapped assertion must omit it.",
+            });
+        }
+    }))
+        .min(1)
+        .max(512),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.assertions.map((assertion) => assertion.assertion_id), context, ["assertions"]);
+    assertUnique(value.official_sources.map((source) => `${source.role}\u0000${source.object_digest}`), context, ["official_sources"]);
+});
+export const externalStandardSuiteDefinitionSchema = externalStandardSuiteDefinitionCoreSchema
+    .safeExtend({ suite_digest: digestSchema })
+    .strict();
+export const externalStandardSuiteEvaluationCoreSchema = z
+    .object({
+    evaluation_contract: z.literal("sourcey.external-standard-suite-evaluation/v1alpha1"),
+    suite_digest: digestSchema,
+    evidence_result_digests: z.array(digestSchema).max(512),
+    assertions: z
+        .array(z
+        .object({
+        assertion_id: requirementIdSchema,
+        status: z.enum(["passed", "failed", "indeterminate"]),
+        leaf_requirements: z
+            .array(z
+            .object({
+            requirement: standardRequirementReferenceSchema,
+            evidence_result_digest: digestSchema,
+            status: z.enum(["satisfied", "not_satisfied", "indeterminate"]),
+        })
+            .strict())
+            .max(256),
+        residue: z.array(standardEvidenceResidueSchema).max(256),
+    })
+        .strict()
+        .superRefine((value, context) => {
+        if (value.status === "indeterminate" && value.residue.length === 0) {
+            context.addIssue({
+                code: "custom",
+                path: ["residue"],
+                message: "An indeterminate suite assertion must preserve typed residue.",
+            });
+        }
+    }))
+        .min(1),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.evidence_result_digests, context, ["evidence_result_digests"]);
+    assertUnique(value.assertions.map((assertion) => assertion.assertion_id), context, ["assertions"]);
+});
+export const externalStandardSuiteEvaluationSchema = externalStandardSuiteEvaluationCoreSchema
+    .safeExtend({ evaluation_digest: digestSchema })
+    .strict();
+export const externalAssessmentAdapterManifestCoreSchema = z
+    .object({
+    adapter_contract: z.literal("sourcey.external-assessment-adapter/v1alpha1"),
+    assessment: standardIdentitySchema,
+    assertion_ids: z.array(requirementIdSchema).min(1),
+    accepted_media_types: standardAdapterManifestFields.accepted_media_types,
+    implementation_digest: digestSchema,
+    official_sources: standardAdapterManifestFields.official_sources,
+    dependencies: standardAdapterManifestFields.dependencies,
+    execution: standardAdapterExecutionSchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.assertion_ids, context, ["assertion_ids"]);
+    validateAdapterManifest(value, context);
+});
+export const externalAssessmentAdapterManifestSchema = externalAssessmentAdapterManifestCoreSchema
+    .safeExtend({ adapter_digest: digestSchema })
+    .strict();
+export const externalAssessmentRequestCoreSchema = z
+    .object({
+    request_contract: z.literal("sourcey.external-assessment-request/v1alpha1"),
+    adapter: z
+        .object({
+        namespace: standardKeySchema,
+        version: standardVersionSchema,
+        adapter_digest: digestSchema,
+    })
+        .strict(),
+    assertion_ids: z.array(requirementIdSchema).min(1).max(512),
+    artifacts: z.array(standardEvidenceArtifactSchema).min(1).max(256),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.assertion_ids, context, ["assertion_ids"]);
+    assertUnique(value.artifacts.map((artifact) => artifact.object_digest), context, ["artifacts"]);
+});
+export const externalAssessmentRequestSchema = externalAssessmentRequestCoreSchema
+    .safeExtend({ request_digest: digestSchema })
+    .strict();
+export const externalAssessmentResultCoreSchema = z
+    .object({
+    result_contract: z.literal("sourcey.external-assessment-result/v1alpha1"),
+    request_digest: digestSchema,
+    adapter_digest: digestSchema,
+    assertions: z
+        .array(z
+        .object({
+        assertion_id: requirementIdSchema,
+        reported_status: z.enum(["passed", "failed", "indeterminate"]),
+        reported_score: z
+            .object({
+            value: z.number().finite(),
+            scale_minimum: z.number().finite(),
+            scale_maximum: z.number().finite(),
+        })
+            .strict()
+            .superRefine((value, context) => {
+            if (value.scale_minimum >= value.scale_maximum ||
+                value.value < value.scale_minimum ||
+                value.value > value.scale_maximum) {
+                context.addIssue({
+                    code: "custom",
+                    message: "A reported assessment score must fall inside its exact scale.",
+                });
+            }
+        })
+            .optional(),
+        locators: z.array(standardEvidenceLocatorSchema).max(64),
+        residue: z.array(standardEvidenceResidueSchema).max(64),
+    })
+        .strict()
+        .superRefine((value, context) => {
+        if (value.reported_status === "indeterminate" && value.residue.length === 0) {
+            context.addIssue({
+                code: "custom",
+                path: ["residue"],
+                message: "An indeterminate external assessment must preserve typed residue.",
+            });
+        }
+        if (value.reported_status !== "indeterminate" && value.locators.length === 0) {
+            context.addIssue({
+                code: "custom",
+                path: ["locators"],
+                message: "A conclusive external assessment requires retained-artifact locators.",
+            });
+        }
+    }))
+        .min(1),
+})
+    .strict()
+    .superRefine((value, context) => {
+    assertUnique(value.assertions.map((assertion) => assertion.assertion_id), context, ["assertions"]);
+});
+export const externalAssessmentResultSchema = externalAssessmentResultCoreSchema
+    .safeExtend({ result_digest: digestSchema })
+    .strict();
+export const externalAssessmentRecordCoreSchema = z
+    .object({
+    record_contract: z.literal("sourcey.external-assessment-record/v1alpha1"),
+    request: externalAssessmentRequestSchema,
+    result: externalAssessmentResultSchema,
+    result_object_digest: digestSchema,
+})
+    .strict()
+    .superRefine((value, context) => {
+    if (value.result.request_digest !== value.request.request_digest ||
+        value.result.adapter_digest !== value.request.adapter.adapter_digest) {
+        context.addIssue({
+            code: "custom",
+            path: ["result"],
+            message: "An external-assessment record must bind its exact request and adapter.",
+        });
+    }
+    const requested = new Set(value.request.assertion_ids);
+    if (requested.size !== value.result.assertions.length ||
+        value.result.assertions.some((assertion) => !requested.has(assertion.assertion_id))) {
+        context.addIssue({
+            code: "custom",
+            path: ["result", "assertions"],
+            message: "An external-assessment record must return its exact requested assertions.",
+        });
+    }
+});
+export const externalAssessmentRecordSchema = externalAssessmentRecordCoreSchema
+    .safeExtend({ record_digest: digestSchema })
+    .strict();
+function requirementKey(value) {
+    return `${value.namespace}\u0000${value.version}\u0000${value.requirement_id}\u0000${value.relation}`;
+}
+function assertUnique(values, context, path) {
+    if (new Set(values).size !== values.length) {
+        context.addIssue({ code: "custom", path, message: "Values must be unique." });
+    }
+}
+//# sourceMappingURL=index.js.map