vet-sdk-core-ts 0.4.0

package/README.md

@@ -0,0 +1,37 @@
+# VetChain Core SDK
+
+Browser-safe VetChain domain contracts. This repository is independent from
+UHC SDK packages and must not import them.
+
+The SDK consumes governed browser-safe values from `vet-data-utils-ts` and
+owns gateway request construction. GW VET remains the policy authority.
+
+The numeric animal identity and external evidence contract is documented in
+[`docs/ANIMAL_IDENTITY.md`](docs/ANIMAL_IDENTITY.md).
+
+## Animal species
+
+`VetChainDomesticAnimalSpecies` provides stable application keys, official
+NCBI Taxonomy identifiers, scientific names and broad animal groups for common
+domesticated, farmed and companion animals. User-facing common names remain in
+each portal's i18n catalogue.
+
+The catalogue is a governed starter set, not a closed biological universe.
+Callers may retain another verified positive non-human NCBI Taxonomy identifier.
+This matters because animal keeping varies by jurisdiction and taxonomy evolves.
+
+Current cards are issued with `issueVetChainAnimalCard`: five jurisdiction
+digits plus `animalNumericId15 + checkDigit1`, and the matching
+`did:web:{host}:card:vetchain:{jurisdiction5}:{animal16}`. Species is separate
+card context and participates in the Damm calculation as `speciesId7` without
+being repeated in the 21 printed digits.
+
+```ts
+import {
+  VetChainDomesticAnimalSpecies,
+  findVetChainSpeciesByTaxonomyId,
+} from "vet-sdk-core-ts/species";
+
+VetChainDomesticAnimalSpecies.DomesticFerret.ncbiTaxonomyId; // "9669"
+findVetChainSpeciesByTaxonomyId("9685")?.key; // "Cat"
+```

package/dist/animal-identity.d.ts

@@ -0,0 +1,109 @@
+export type SpeciesId7 = string;
+export type JurisdictionCode5 = string;
+export type AnimalNumericId15 = string;
+export type AnimalIdentifier16 = string;
+export type VetChainAnimalCardNumber21 = string;
+export type AnimalIndexCanonicalNumericId27 = string;
+export type AnimalIndexAssetId = string;
+export declare const AnimalIdentityEvidenceSystems: Readonly<{
+    readonly UsdaAin: "usda-ain";
+    readonly CfiaIso11784: "cfia-iso-11784";
+    readonly Iso11784_11785Microchip: "iso-11784-11785-microchip";
+    readonly HerdMark: "herd-mark";
+    readonly SlapTattoo: "slap-tattoo";
+    readonly Tattoo: "tattoo";
+    readonly Other: "other";
+}>;
+export type AnimalIdentityEvidenceSystem = typeof AnimalIdentityEvidenceSystems[keyof typeof AnimalIdentityEvidenceSystems];
+export type AnimalIdentityEvidenceScope = "individual" | "group" | "other";
+export type AnimalIdentityEvidence = Readonly<{
+    system: AnimalIdentityEvidenceSystem;
+    value: string;
+    scope: AnimalIdentityEvidenceScope;
+    /** True only when the evidence itself carries one individual 15-digit number. */
+    canSeedAnimalNumericId15: boolean;
+}>;
+/**
+ * Converts the canonical NCBI Taxonomy identifier to the seven telephone-safe
+ * digits used by the VetChain identity checksum. This is an NCBI taxonomy
+ * projection, never an organization fiscal identifier.
+ */
+export declare function buildSpeciesId7(ncbiTaxonomyId: string): SpeciesId7;
+/** Country3 plus immutable birth/initial-registration region2. */
+export declare function normalizeJurisdictionCode5(value: string): JurisdictionCode5;
+/** Exact telephone-safe individual number; never accepts letters or truncation. */
+export declare function normalizeAnimalNumericId15(value: string): AnimalNumericId15;
+/** Returns the Damm check digit that makes the complete sequence validate to zero. */
+export declare function computeDammCheckDigit(value: string): string;
+/** Validates a Damm-protected sequence including its final check digit. */
+export declare function validateDamm(value: string): boolean;
+/**
+ * Builds the spoken/printed 15+1 identifier.
+ *
+ * The check is deliberately calculated in the same order used by the passport
+ * and telephone assistant: species, initial jurisdiction, animal number.
+ * `speciesId7` and `jurisdictionCode5` are required validation context even
+ * though only `animalNumericId15 + checkDigit1` forms this 16-digit segment.
+ * The check digit detects inconsistent input; it does not create uniqueness.
+ */
+export declare function buildAnimalIdentifier16(input: Readonly<{
+    speciesId7: string;
+    jurisdictionCode5: string;
+    animalNumericId15: string;
+}>): AnimalIdentifier16;
+export declare function validateAnimalIdentifier16(input: Readonly<{
+    speciesId7: string;
+    jurisdictionCode5: string;
+    animalNumericId15: string;
+    animalIdentifier16: string;
+}>): boolean;
+/** Builds the 21 visible digits: jurisdiction5 + animalNumericId15 + check1. */
+export declare function buildVetChainAnimalCardNumber21(input: Readonly<{
+    speciesId7: string;
+    jurisdictionCode5: string;
+    animalNumericId15: string;
+}>): VetChainAnimalCardNumber21;
+export declare function validateVetChainAnimalCardNumber21(input: Readonly<{
+    speciesId7: string;
+    cardNumber21: string;
+}>): boolean;
+/**
+ * Builds the exact 27-digit Animal Index lookup preimage.
+ *
+ * The printed/telephone Damm digit is deliberately excluded: it detects input
+ * errors but is not identity material. Species and initial jurisdiction remain
+ * included so equal 15-digit animal numbers in different contexts do not map
+ * to the same index asset.
+ */
+export declare function buildAnimalIndexCanonicalNumericId27(input: Readonly<{
+    speciesId7: string;
+    jurisdictionCode5: string;
+    animalNumericId15: string;
+}>): AnimalIndexCanonicalNumericId27;
+/**
+ * Produces the lowercase SHA3-256 `assetId` stored by the permissioned Animal
+ * Index. Its asset may reveal only the currently active index-provider routing
+ * record; resolving it never authorizes access to the animal's data.
+ *
+ * This deterministic digest is a pseudonymous lookup key, not encryption. Do
+ * not publish the canonical 27 digits or treat the digest as confidential.
+ */
+export declare function buildAnimalIndexAssetId(input: Readonly<{
+    speciesId7: string;
+    jurisdictionCode5: string;
+    animalNumericId15: string;
+}>): Promise<AnimalIndexAssetId>;
+export declare function isAnimalIndexAssetId(value: string): value is AnimalIndexAssetId;
+/**
+ * Normalizes evidence without claiming verification.
+ *
+ * USDA AIN is a 15-digit individual number beginning `840`. Canadian CFIA
+ * individual indicators use ISO 11784 and begin `124`. ISO 11784/11785 animal
+ * transponders are global and are never classified by the animal's country.
+ * Herd marks and slaughter tattoos can identify a group/location rather than
+ * one animal and therefore never seed `animalNumericId15`.
+ */
+export declare function normalizeAnimalIdentityEvidence(input: Readonly<{
+    system: AnimalIdentityEvidenceSystem;
+    value: string;
+}>): AnimalIdentityEvidence;

package/dist/animal-identity.js

@@ -0,0 +1,207 @@
+// Copyright 2026 Connecting Solution & Applications Ltd under the Apache License, Version 2.0.
+import { sha3_256 } from "@noble/hashes/sha3.js";
+import { bytesToHex, utf8ToBytes } from "@noble/hashes/utils.js";
+export const AnimalIdentityEvidenceSystems = Object.freeze({
+    UsdaAin: "usda-ain",
+    CfiaIso11784: "cfia-iso-11784",
+    Iso11784_11785Microchip: "iso-11784-11785-microchip",
+    HerdMark: "herd-mark",
+    SlapTattoo: "slap-tattoo",
+    Tattoo: "tattoo",
+    Other: "other",
+});
+const DAMM_TABLE = Object.freeze([
+    Object.freeze([0, 3, 1, 7, 5, 9, 8, 6, 4, 2]),
+    Object.freeze([7, 0, 9, 2, 1, 5, 4, 8, 6, 3]),
+    Object.freeze([4, 2, 0, 6, 8, 7, 1, 3, 5, 9]),
+    Object.freeze([1, 7, 5, 0, 9, 8, 3, 4, 2, 6]),
+    Object.freeze([6, 1, 2, 3, 0, 4, 5, 9, 7, 8]),
+    Object.freeze([3, 6, 7, 4, 2, 0, 9, 5, 8, 1]),
+    Object.freeze([5, 8, 6, 9, 7, 2, 0, 1, 3, 4]),
+    Object.freeze([8, 9, 4, 5, 3, 6, 2, 0, 1, 7]),
+    Object.freeze([9, 4, 3, 8, 6, 1, 7, 2, 0, 5]),
+    Object.freeze([2, 5, 8, 1, 4, 3, 6, 7, 9, 0]),
+]);
+/**
+ * Converts the canonical NCBI Taxonomy identifier to the seven telephone-safe
+ * digits used by the VetChain identity checksum. This is an NCBI taxonomy
+ * projection, never an organization fiscal identifier.
+ */
+export function buildSpeciesId7(ncbiTaxonomyId) {
+    const source = String(ncbiTaxonomyId || "").trim();
+    if (!/^\d{1,7}$/.test(source)) {
+        throw new TypeError("NCBI Taxonomy identifier must contain at most seven digits.");
+    }
+    const normalized = source.replace(/^0+/, "") || "0";
+    if (normalized === "9606") {
+        throw new TypeError("Human NCBI Taxonomy identifier 9606 is not valid for a VetChain animal.");
+    }
+    if (normalized === "0")
+        throw new TypeError("NCBI Taxonomy identifier must be positive.");
+    return normalized.padStart(7, "0");
+}
+/** Country3 plus immutable birth/initial-registration region2. */
+export function normalizeJurisdictionCode5(value) {
+    return normalizeFixedDigits(value, 5, "jurisdictionCode5");
+}
+/** Exact telephone-safe individual number; never accepts letters or truncation. */
+export function normalizeAnimalNumericId15(value) {
+    return normalizeFixedDigits(value, 15, "animalNumericId15");
+}
+/** Returns the Damm check digit that makes the complete sequence validate to zero. */
+export function computeDammCheckDigit(value) {
+    const digits = normalizeDigits(value, "Damm input");
+    let interim = 0;
+    for (const character of digits)
+        interim = DAMM_TABLE[interim][Number(character)];
+    return String(interim);
+}
+/** Validates a Damm-protected sequence including its final check digit. */
+export function validateDamm(value) {
+    try {
+        const digits = normalizeDigits(value, "Damm input");
+        let interim = 0;
+        for (const character of digits)
+            interim = DAMM_TABLE[interim][Number(character)];
+        return interim === 0;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Builds the spoken/printed 15+1 identifier.
+ *
+ * The check is deliberately calculated in the same order used by the passport
+ * and telephone assistant: species, initial jurisdiction, animal number.
+ * `speciesId7` and `jurisdictionCode5` are required validation context even
+ * though only `animalNumericId15 + checkDigit1` forms this 16-digit segment.
+ * The check digit detects inconsistent input; it does not create uniqueness.
+ */
+export function buildAnimalIdentifier16(input) {
+    const speciesId7 = buildSpeciesId7(input.speciesId7);
+    const jurisdictionCode5 = normalizeJurisdictionCode5(input.jurisdictionCode5);
+    const animalNumericId15 = normalizeAnimalNumericId15(input.animalNumericId15);
+    const checkDigit1 = computeDammCheckDigit(`${speciesId7}${jurisdictionCode5}${animalNumericId15}`);
+    return `${animalNumericId15}${checkDigit1}`;
+}
+export function validateAnimalIdentifier16(input) {
+    try {
+        const animalNumericId15 = normalizeAnimalNumericId15(input.animalNumericId15);
+        const animalIdentifier16 = normalizeFixedDigits(input.animalIdentifier16, 16, "animalIdentifier16");
+        return animalIdentifier16.startsWith(animalNumericId15)
+            && animalIdentifier16 === buildAnimalIdentifier16({ ...input, animalNumericId15 });
+    }
+    catch {
+        return false;
+    }
+}
+/** Builds the 21 visible digits: jurisdiction5 + animalNumericId15 + check1. */
+export function buildVetChainAnimalCardNumber21(input) {
+    const jurisdictionCode5 = normalizeJurisdictionCode5(input.jurisdictionCode5);
+    return `${jurisdictionCode5}${buildAnimalIdentifier16({ ...input, jurisdictionCode5 })}`;
+}
+export function validateVetChainAnimalCardNumber21(input) {
+    try {
+        const cardNumber21 = normalizeFixedDigits(input.cardNumber21, 21, "cardNumber21");
+        const jurisdictionCode5 = cardNumber21.slice(0, 5);
+        const animalIdentifier16 = cardNumber21.slice(5);
+        const animalNumericId15 = animalIdentifier16.slice(0, 15);
+        return validateAnimalIdentifier16({
+            speciesId7: input.speciesId7,
+            jurisdictionCode5,
+            animalNumericId15,
+            animalIdentifier16,
+        });
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Builds the exact 27-digit Animal Index lookup preimage.
+ *
+ * The printed/telephone Damm digit is deliberately excluded: it detects input
+ * errors but is not identity material. Species and initial jurisdiction remain
+ * included so equal 15-digit animal numbers in different contexts do not map
+ * to the same index asset.
+ */
+export function buildAnimalIndexCanonicalNumericId27(input) {
+    return `${buildSpeciesId7(input.speciesId7)}${normalizeJurisdictionCode5(input.jurisdictionCode5)}${normalizeAnimalNumericId15(input.animalNumericId15)}`;
+}
+/**
+ * Produces the lowercase SHA3-256 `assetId` stored by the permissioned Animal
+ * Index. Its asset may reveal only the currently active index-provider routing
+ * record; resolving it never authorizes access to the animal's data.
+ *
+ * This deterministic digest is a pseudonymous lookup key, not encryption. Do
+ * not publish the canonical 27 digits or treat the digest as confidential.
+ */
+export async function buildAnimalIndexAssetId(input) {
+    const canonicalId27 = buildAnimalIndexCanonicalNumericId27(input);
+    return bytesToHex(sha3_256(utf8ToBytes(canonicalId27)));
+}
+export function isAnimalIndexAssetId(value) {
+    return /^[a-f0-9]{64}$/.test(String(value || ""));
+}
+/**
+ * Normalizes evidence without claiming verification.
+ *
+ * USDA AIN is a 15-digit individual number beginning `840`. Canadian CFIA
+ * individual indicators use ISO 11784 and begin `124`. ISO 11784/11785 animal
+ * transponders are global and are never classified by the animal's country.
+ * Herd marks and slaughter tattoos can identify a group/location rather than
+ * one animal and therefore never seed `animalNumericId15`.
+ */
+export function normalizeAnimalIdentityEvidence(input) {
+    const system = input.system;
+    if (!Object.values(AnimalIdentityEvidenceSystems).includes(system)) {
+        throw new TypeError("Unsupported animal identity evidence system.");
+    }
+    if (system === AnimalIdentityEvidenceSystems.UsdaAin) {
+        const value = normalizeAnimalNumericId15(input.value);
+        if (!value.startsWith("840"))
+            throw new TypeError("USDA AIN must begin with country code 840.");
+        return Object.freeze({ system, value, scope: "individual", canSeedAnimalNumericId15: true });
+    }
+    if (system === AnimalIdentityEvidenceSystems.CfiaIso11784) {
+        const value = normalizeAnimalNumericId15(input.value);
+        if (!value.startsWith("124"))
+            throw new TypeError("Canadian CFIA ISO 11784 identifier must begin with country code 124.");
+        return Object.freeze({ system, value, scope: "individual", canSeedAnimalNumericId15: true });
+    }
+    if (system === AnimalIdentityEvidenceSystems.Iso11784_11785Microchip) {
+        const value = normalizeAnimalNumericId15(input.value);
+        return Object.freeze({ system, value, scope: "individual", canSeedAnimalNumericId15: true });
+    }
+    if (system === AnimalIdentityEvidenceSystems.HerdMark) {
+        const value = normalizeEvidenceText(input.value);
+        return Object.freeze({ system, value, scope: "group", canSeedAnimalNumericId15: false });
+    }
+    if (system === AnimalIdentityEvidenceSystems.SlapTattoo) {
+        const value = normalizeEvidenceText(input.value);
+        return Object.freeze({ system, value, scope: "group", canSeedAnimalNumericId15: false });
+    }
+    const value = normalizeEvidenceText(input.value);
+    return Object.freeze({ system, value, scope: system === AnimalIdentityEvidenceSystems.Tattoo ? "individual" : "other", canSeedAnimalNumericId15: false });
+}
+function normalizeFixedDigits(value, length, name) {
+    const digits = normalizeDigits(value, name);
+    if (digits.length !== length)
+        throw new TypeError(`${name} must contain exactly ${length} digits.`);
+    return digits;
+}
+function normalizeDigits(value, name) {
+    const source = String(value || "").trim();
+    if (!source || !/^[0-9\s-]+$/.test(source))
+        throw new TypeError(`${name} must contain decimal digits only.`);
+    return source.replace(/[\s-]/g, "");
+}
+function normalizeEvidenceText(value) {
+    const normalized = String(value || "").trim().replace(/\s+/g, " ").toUpperCase();
+    if (!normalized)
+        throw new TypeError("Animal identity evidence value is required.");
+    if (normalized.length > 120)
+        throw new TypeError("Animal identity evidence value is too long.");
+    return normalized;
+}

package/dist/card-issuance.d.ts

@@ -0,0 +1,20 @@
+export type VetChainIssuedAnimalCard = Readonly<{
+    providerCode9: string;
+    jurisdictionCode5: string;
+    ncbiTaxonomyId: string;
+    speciesCode5: string;
+    animalNumericId15: string;
+    animalId16: string;
+    cardNumber21: string;
+    cardDidWeb: string;
+}>;
+/** Issues the current jurisdiction5 + animal15 + check1 card from server-held HMAC custody. */
+export declare function issueVetChainAnimalCard(input: Readonly<{
+    host: string;
+    providerCode9: string;
+    ncbiTaxonomyId: string;
+    subjectUuid: string;
+    hmacKeyBytes: Uint8Array;
+    collisionCounter?: number;
+}>): VetChainIssuedAnimalCard;
+export declare function normalizeVetChainNcbiTaxonomyId(value: string): string;

package/dist/card-issuance.js

@@ -0,0 +1,59 @@
+import { hmac } from '@noble/hashes/hmac.js';
+import { sha256 } from '@noble/hashes/sha2.js';
+import { utf8ToBytes } from '@noble/hashes/utils.js';
+import { parseVetChainAnimalCardDid } from 'vet-data-utils-ts';
+import { buildAnimalIdentifier16, buildSpeciesId7 } from './animal-identity.js';
+/** Issues the current jurisdiction5 + animal15 + check1 card from server-held HMAC custody. */
+export function issueVetChainAnimalCard(input) {
+    const providerCode9 = digits(input.providerCode9, 9, 'vet_card_provider_code_invalid');
+    const jurisdictionCode5 = providerCode9.slice(0, 5);
+    const ncbiTaxonomyId = taxonomy(input.ncbiTaxonomyId);
+    const speciesCode5 = ncbiTaxonomyId.padStart(5, '0');
+    const subjectUuid = String(input.subjectUuid || '').trim().toLowerCase().replace(/[{}]/g, '');
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/.test(subjectUuid)) {
+        throw new TypeError('vet_card_subject_uuid_invalid');
+    }
+    if (!(input.hmacKeyBytes instanceof Uint8Array) || input.hmacKeyBytes.length < 32) {
+        throw new TypeError('vet_card_hmac_key_invalid');
+    }
+    const collisionCounter = input.collisionCounter ?? 0;
+    if (!Number.isInteger(collisionCounter) || collisionCounter < 0)
+        throw new TypeError('vet_card_collision_counter_invalid');
+    const digest = hmac(sha256, input.hmacKeyBytes, utf8ToBytes([
+        'vetchain-animal-card:v3', providerCode9, ncbiTaxonomyId, subjectUuid, `cc:${collisionCounter}`,
+    ].join(':')));
+    const animalNumericId15 = `000${reduceDigestToDecimalDigits(digest, 12)}`;
+    const animalId16 = buildAnimalIdentifier16({
+        speciesId7: buildSpeciesId7(ncbiTaxonomyId),
+        jurisdictionCode5,
+        animalNumericId15,
+    });
+    const cardNumber21 = `${jurisdictionCode5}${animalId16}`;
+    const host = String(input.host || '').trim().toLowerCase();
+    if (!/^[a-z0-9.-]+(?::\d+)?$/.test(host))
+        throw new TypeError('vet_card_host_invalid');
+    const cardDidWeb = `did:web:${host.replace(':', '%3A')}:card:vetchain:${jurisdictionCode5}:${animalId16}`;
+    parseVetChainAnimalCardDid(cardDidWeb);
+    return Object.freeze({ providerCode9, jurisdictionCode5, ncbiTaxonomyId, speciesCode5, animalNumericId15, animalId16, cardNumber21, cardDidWeb });
+}
+export function normalizeVetChainNcbiTaxonomyId(value) {
+    return taxonomy(value);
+}
+function taxonomy(value) {
+    const normalized = String(value || '').trim();
+    if (!/^[1-9]\d{0,4}$/.test(normalized) || normalized === '9606')
+        throw new TypeError('vet_card_taxonomy_invalid');
+    return normalized;
+}
+function digits(value, width, error) {
+    const normalized = String(value || '').trim().replace(/[\s-]/g, '');
+    if (!new RegExp(`^\\d{${width}}$`).test(normalized))
+        throw new TypeError(error);
+    return normalized;
+}
+function reduceDigestToDecimalDigits(bytes, width) {
+    let value = 0n;
+    for (const byte of bytes)
+        value = (value << 8n) + BigInt(byte);
+    return (value % (10n ** BigInt(width))).toString().padStart(width, '0');
+}

package/dist/gateway-contract.d.ts

@@ -0,0 +1,60 @@
+import { type VeterinaryDigitalTwinFormat } from 'vet-data-utils-ts';
+export type VetGatewayRouteContext = Readonly<{
+    tenantId: string;
+    jurisdiction: string;
+    sector: 'animal-care' | 'animal-research';
+}>;
+export type VeterinaryBreakGlassSmartRequest = Readonly<{
+    thid: string;
+    iss: string;
+    aud: string;
+    body: Readonly<{
+        sub: string;
+        client_id: string;
+        client_assertion: string;
+        client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer';
+        vp_token: string;
+        acr_values: 'urn:antifraud:acr:openid4vp:employee';
+        purpose: 'EMERGENCY';
+        scope: string;
+        expires_in: number;
+        break_glass: Readonly<{
+            incidentId: string;
+            subjectKind: 'animal';
+            reasonCode: 'animal-emergency';
+            justification: string;
+        }>;
+    }>;
+}>;
+export type VeterinaryDigitalTwinSearchRequest = Readonly<{
+    format: VeterinaryDigitalTwinFormat;
+    resourceType: 'Composition';
+    payload: Readonly<{
+        thid: string;
+        body: Readonly<Record<string, unknown>>;
+    }>;
+}>;
+export declare function buildVetGatewayRoutePrefix(context: VetGatewayRouteContext): string;
+export declare function buildVeterinaryBreakGlassSmartRequest(input: Readonly<{
+    thid: string;
+    actorDid: string;
+    subjectDid: string;
+    requestedSections: readonly string[];
+    incidentId: string;
+    justification: string;
+    clientId: string;
+    clientAssertion: string;
+    vpToken: string;
+    audience: string;
+}>): VeterinaryBreakGlassSmartRequest;
+export declare function buildVeterinaryDigitalTwinSearchRequest(input: Readonly<{
+    thid: string;
+    format?: VeterinaryDigitalTwinFormat;
+    search: unknown;
+}>): VeterinaryDigitalTwinSearchRequest;
+export declare function buildExactAnimalResolution(input: Readonly<{
+    subjectDid: string;
+}>): Readonly<{
+    subjectDid: string;
+    cardNumber21: string;
+}>;

package/dist/gateway-contract.js

@@ -0,0 +1,73 @@
+import { VeterinaryBreakGlassMaxLifetimeSeconds, VeterinaryDigitalTwinFormats, parseVetChainAnimalCardDid, parseVeterinaryBreakGlassRequestData, parseVeterinaryDigitalTwinSearch, } from 'vet-data-utils-ts';
+export function buildVetGatewayRoutePrefix(context) {
+    const tenantId = bounded(context.tenantId, 'tenantId');
+    const jurisdiction = bounded(context.jurisdiction, 'jurisdiction').toUpperCase();
+    if (!/^[A-Z]{2}(?:-[A-Z0-9]{1,3})?$/.test(jurisdiction))
+        throw new TypeError('vet_gateway_jurisdiction_invalid');
+    return `/${tenantId}/cds-${jurisdiction}/v1/${context.sector}`;
+}
+export function buildVeterinaryBreakGlassSmartRequest(input) {
+    const emergency = parseVeterinaryBreakGlassRequestData(input);
+    const actorDid = did(input.actorDid, 'vet_break_glass_actor_invalid');
+    const section = emergency.requestedSections.join(',');
+    const scope = `organization/Composition.rs?subject=${encodeURIComponent(emergency.subjectDid)}&section=${encodeURIComponent(section)}`;
+    return Object.freeze({
+        thid: bounded(input.thid, 'thid'),
+        iss: actorDid,
+        aud: did(input.audience, 'vet_break_glass_audience_invalid'),
+        body: {
+            sub: actorDid,
+            client_id: did(input.clientId, 'vet_break_glass_client_invalid'),
+            client_assertion: bounded(input.clientAssertion, 'clientAssertion'),
+            client_assertion_type: 'urn:ietf:params:oauth:client-assertion-type:jwt-bearer',
+            vp_token: bounded(input.vpToken, 'vpToken'),
+            acr_values: 'urn:antifraud:acr:openid4vp:employee',
+            purpose: 'EMERGENCY',
+            scope,
+            expires_in: VeterinaryBreakGlassMaxLifetimeSeconds,
+            break_glass: {
+                incidentId: emergency.incidentId,
+                subjectKind: emergency.subjectKind,
+                reasonCode: emergency.reasonCode,
+                justification: emergency.justification,
+            },
+        },
+    });
+}
+export function buildVeterinaryDigitalTwinSearchRequest(input) {
+    const search = parseVeterinaryDigitalTwinSearch(input.search);
+    const format = input.format || VeterinaryDigitalTwinFormats.R4;
+    const parameter = [
+        { name: 'section', valueString: search.section },
+        { name: search.claim, valueString: search.value },
+    ];
+    return Object.freeze({
+        format,
+        // GW stores the pseudonymous twin as a Composition. `search.resourceType`
+        // names the nested clinical resource whose claim is being filtered; it is
+        // never the asynchronous route resource type.
+        resourceType: 'Composition',
+        payload: {
+            thid: bounded(input.thid, 'thid'),
+            body: format === VeterinaryDigitalTwinFormats.Api
+                ? { data: [{ type: 'Composition-search-request-v1.0', resource: { resourceType: 'Parameters', parameter } }] }
+                : { resourceType: 'Parameters', parameter },
+        },
+    });
+}
+export function buildExactAnimalResolution(input) {
+    const card = parseVetChainAnimalCardDid(input.subjectDid);
+    return Object.freeze({ subjectDid: card.did, cardNumber21: card.cardNumber21 });
+}
+function bounded(value, name) {
+    const normalized = String(value || '').trim();
+    if (!normalized || normalized.length > 4096)
+        throw new TypeError(`vet_gateway_${name}_invalid`);
+    return normalized;
+}
+function did(value, error) {
+    const normalized = bounded(value, 'did');
+    if (!normalized.startsWith('did:'))
+        throw new TypeError(error);
+    return normalized;
+}

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./species.js";
+export * from "./animal-identity.js";
+export * from "./gateway-contract.js";
+export * from "./card-issuance.js";
+export * from "vet-data-utils-ts";

package/dist/index.js

@@ -0,0 +1,5 @@
+export * from "./species.js";
+export * from "./animal-identity.js";
+export * from "./gateway-contract.js";
+export * from "./card-issuance.js";
+export * from "vet-data-utils-ts";