@voyantjs/bookings 0.119.1 → 0.119.3

package/dist/pricing-assignment.js

@@ -1,558 +1,4 @@
-/**
- * Pure, transport-agnostic logic for mapping travelers onto option_units
- * at booking-create time. Lives in `@voyantjs/bookings` so the
- * booking-create dialog (preview + submit) is the only call site today,
- * but the server can import the same module to validate or re-resolve
- * submit payloads in a follow-up — that wiring is not yet in place.
- *
- * Vocabulary:
- *   - A **pricing tier** (`unit_type='person'`) is a per-pax price band
- *     a traveler is billed as (Adult / Child 6-12 / Infant 0-5 / …).
- *   - An **inventory unit** (`'room' | 'vehicle' | 'seat'`) is a finite
- *     container a traveler is placed into (one DBL room holds 2 pax).
- *   - "Person-priced options" are options that only have pricing tiers
- *     (no inventory). Excursions. For these, line-item quantities
- *     **derive from the traveler list** (1 adult + 1 child + 1 infant).
- *   - "Accommodation options" have inventory units (and usually a
- *     paired person unit for per-pax fees). For these, line-item
- *     quantities **stay as the operator picked them** (1 DBL room is
- *     still 1 line, not 2).
- *
- * The `pricingUnitSource` and `inventoryUnitSource` enums on the
- * traveler track operator intent so the resolver knows when to
- * re-derive ("auto") versus respect an explicit choice ("manual" /
- * "none" for No room).
- *
- * No React, no DB, no HTTP — just the assignment math.
- *
- * Tracking: voyantjs/voyant#1267.
- */
-/**
- * Compute integer age in full years from an ISO date-of-birth string.
- * Returns null when the DOB is missing or unparseable.
- */
-export function computeAgeYears(dob, now = new Date()) {
-    if (!dob)
-        return null;
-    const birth = new Date(dob);
-    if (Number.isNaN(birth.getTime()))
-        return null;
-    let age = now.getFullYear() - birth.getFullYear();
-    const beforeBirthday = now.getMonth() < birth.getMonth() ||
-        (now.getMonth() === birth.getMonth() && now.getDate() < birth.getDate());
-    if (beforeBirthday)
-        age -= 1;
-    return age >= 0 ? age : null;
-}
-/**
- * Derive the age-banded traveler category from DOB + role hint.
- * DOB-derived age wins; role hint is the fallback for travelers
- * added before the operator filled in a birthday.
- */
-export function deriveDraftPaxBand(traveler, now = new Date()) {
-    const age = computeAgeYears(traveler.dateOfBirth, now);
-    if (age == null) {
-        return traveler.role === "adult" || traveler.role === "child" || traveler.role === "infant"
-            ? traveler.role
-            : null;
-    }
-    if (age < 2)
-        return "infant";
-    if (age < 18)
-        return "child";
-    return "adult";
-}
-/**
- * Pick the unit for a traveler pricing band. Priorities:
- *   1. DOB-derived age that falls into a unit's `[minAge, maxAge]`
- *   2. Role hint mapped to a representative age (infant→1, child→8,
- *      adult→30) matched against bands. Works for products coded
- *      `child_0_5` / `child_6_12` (not just literal `INFANT`/`CHILD`).
- *   3. Code/name matching for legacy products with no min/max set.
- */
-export function pickUnitForAge(units, age, roleHint = null) {
-    if (units.length === 0)
-        return undefined;
-    const personUnits = units.filter((u) => u.unitType == null || u.unitType === "person");
-    const pool = personUnits.length > 0 ? personUnits : units;
-    const sorted = [...pool].sort((a, b) => (a.minAge ?? 0) - (b.minAge ?? 0));
-    const matchByAge = (target) => sorted.find((u) => (u.minAge == null || target >= u.minAge) && (u.maxAge == null || target <= u.maxAge));
-    if (age != null) {
-        const match = matchByAge(age);
-        if (match)
-            return match;
-    }
-    if (roleHint) {
-        const HINT_AGE = { adult: 30, child: 8, infant: 1 };
-        const hintAge = HINT_AGE[roleHint];
-        // Only consider units with at least one explicit age bound.
-        // Without this, legacy units with null min/max (just bare
-        // ADULT/CHILD codes) would all match every hint age and collapse
-        // onto the first sorted entry. Code-matching below handles those.
-        const banded = sorted.filter((u) => u.minAge != null || u.maxAge != null);
-        const match = banded.find((u) => (u.minAge == null || hintAge >= u.minAge) && (u.maxAge == null || hintAge <= u.maxAge));
-        if (match)
-            return match;
-    }
-    const findByCode = (code) => sorted.find((u) => (u.unitCode ?? "").toUpperCase() === code) ??
-        sorted.find((u) => new RegExp(`\\b${code}\\b`, "i").test(u.unitName));
-    if (roleHint === "child")
-        return findByCode("CHILD") ?? sorted[0];
-    if (roleHint === "infant")
-        return findByCode("INFANT") ?? sorted[0];
-    return findByCode("ADULT") ?? sorted[sorted.length - 1] ?? sorted[0];
-}
-/**
- * Find the unit whose `[minAge, maxAge]` contains the DOB-derived
- * age. Used by the UI to pre-pick a unit when a traveler attaches.
- */
-export function matchUnitByDob(units, dob) {
-    if (!dob)
-        return null;
-    const age = computeAgeYears(dob);
-    if (age == null)
-        return null;
-    const personUnits = units.filter((u) => u.unitType == null || u.unitType === "person");
-    const match = personUnits.find((u) => (u.minAge == null || age >= u.minAge) && (u.maxAge == null || age <= u.maxAge));
-    return match?.optionUnitId ?? null;
-}
-/**
- * Find the unit matching a role hint when DOB is missing. Same
- * HINT_AGE mapping as `pickUnitForAge`. Returns null when the role
- * carries no age signal (e.g. `lead`).
- */
-export function matchUnitByRoleHint(units, role) {
-    if (!role || role === "lead")
-        return null;
-    const HINT_AGE = {
-        adult: 30,
-        child: 8,
-        infant: 1,
-    };
-    const hintAge = HINT_AGE[role];
-    if (hintAge == null)
-        return null;
-    const banded = units.filter((u) => (u.unitType == null || u.unitType === "person") && (u.minAge != null || u.maxAge != null));
-    const match = banded.find((u) => (u.minAge == null || hintAge >= u.minAge) && (u.maxAge == null || hintAge <= u.maxAge));
-    return match?.optionUnitId ?? null;
-}
-function optionKey(unit) {
-    return unit.optionId ?? unit.optionUnitId;
-}
-function isPersonUnit(unit) {
-    return unit.unitType == null || unit.unitType === "person";
-}
-/**
- * Inventory units are finite containers a traveler is placed into.
- * Rooms (hotels), vehicles (transfers), seats (where modeled
- * explicitly). Distinct from pricing tiers (`person`).
- */
-function isInventoryUnit(unit) {
-    return unit.unitType === "room" || unit.unitType === "vehicle";
-}
-function roleHintForTraveler(traveler) {
-    return traveler.role === "adult" || traveler.role === "child" || traveler.role === "infant"
-        ? traveler.role
-        : null;
-}
-/**
- * Resolve a booking-create draft into the per-unit quantities and
- * per-traveler unit assignments the submit pipeline + price preview
- * both need. Single source of truth for traveler→unit mapping.
- *
- * Shape branching:
- *   - **Person-priced options** (only `person` units, no `room`):
- *     quantities are derived from traveler assignments (1 adult + 1
- *     child + 1 infant = 3 line items, not "3 x Adult"). Auto-source
- *     travelers are re-derived against the current option's bands.
- *   - **Accommodation options** (any `room` unit): operator-picked
- *     stepper quantities are preserved (1 DBL room is 1 line). Per-
- *     traveler room assignments still update `travelerIndexesByUnitId`
- *     so `booking_item_travelers` rows can be created.
- *
- * Respects assignment sources:
- *   - `none` → the corresponding field stays null
- *   - `manual` → the existing unit is kept when valid for the chosen option
- *   - `auto` → re-derived against current options
- */
-export function resolveBookingDraft(options) {
-    const { quantities, travelers, now = new Date() } = options;
-    const units = [...options.units];
-    if (units.length === 0) {
-        return { quantities, travelers: [...travelers], travelerIndexesByUnitId: {} };
-    }
-    const unitsByOption = new Map();
-    const unitById = new Map();
-    const unitToOption = new Map();
-    for (const unit of units) {
-        const key = optionKey(unit);
-        unitById.set(unit.optionUnitId, unit);
-        unitToOption.set(unit.optionUnitId, key);
-        const list = unitsByOption.get(key);
-        if (list)
-            list.push(unit);
-        else
-            unitsByOption.set(key, [unit]);
-    }
-    const primaryInventoryByOption = new Map();
-    for (const [key, optionUnits] of unitsByOption) {
-        const inventoryUnit = optionUnits.find(isInventoryUnit);
-        if (inventoryUnit)
-            primaryInventoryByOption.set(key, inventoryUnit);
-    }
-    // An option is "person-priced" when it has at least one person unit
-    // and no inventory unit (room/vehicle). That's the excursion shape:
-    // line quantities derive from travelers, not from the stepper's
-    // primary-unit count. Multi-day packages with both a room AND a
-    // person-typed adult fee fall outside this set — the room
-    // quantity passes through unchanged.
-    const personPricedOptions = new Set();
-    for (const [key, optionUnits] of unitsByOption) {
-        const hasPerson = optionUnits.some(isPersonUnit);
-        const hasInventory = optionUnits.some(isInventoryUnit);
-        if (hasPerson && !hasInventory)
-            personPricedOptions.add(key);
-    }
-    const totalByOption = new Map();
-    for (const [unitId, quantity] of Object.entries(quantities)) {
-        if (quantity <= 0)
-            continue;
-        const key = unitToOption.get(unitId);
-        if (!key)
-            continue;
-        totalByOption.set(key, (totalByOption.get(key) ?? 0) + quantity);
-    }
-    const assignedForDefaulting = new Map();
-    for (const traveler of travelers) {
-        const inventorySource = traveler.inventoryUnitSource ?? "auto";
-        const pricingSource = traveler.pricingUnitSource ?? "auto";
-        const assignedUnitId = inventorySource !== "none" && traveler.inventoryUnitId
-            ? traveler.inventoryUnitId
-            : pricingSource !== "none"
-                ? traveler.pricingUnitId
-                : null;
-        if (!assignedUnitId)
-            continue;
-        const key = unitToOption.get(assignedUnitId);
-        if (!key)
-            continue;
-        assignedForDefaulting.set(key, (assignedForDefaulting.get(key) ?? 0) + 1);
-    }
-    const optionDemand = Array.from(totalByOption.entries());
-    const pickOptionWithDemand = () => optionDemand.find(([candidate, total]) => (assignedForDefaulting.get(candidate) ?? 0) < total)?.[0] ?? optionDemand[0]?.[0];
-    const resolvePricingUnitForTraveler = (traveler, key) => pickUnitForAge((unitsByOption.get(key) ?? []).filter(isPersonUnit), computeAgeYears(traveler.dateOfBirth, now), roleHintForTraveler(traveler));
-    const resolveTargetOption = (traveler) => {
-        const inventorySource = traveler.inventoryUnitSource ?? "auto";
-        if (inventorySource !== "none" && traveler.inventoryUnitId) {
-            const inventoryUnit = unitById.get(traveler.inventoryUnitId);
-            const key = unitToOption.get(traveler.inventoryUnitId);
-            if (key && inventoryUnit && isInventoryUnit(inventoryUnit))
-                return { key, fromDemand: false };
-        }
-        const pricingSource = traveler.pricingUnitSource ?? "auto";
-        if (pricingSource !== "none" && traveler.pricingUnitId) {
-            const pricingUnit = unitById.get(traveler.pricingUnitId);
-            const key = unitToOption.get(traveler.pricingUnitId);
-            if (key && pricingUnit && isPersonUnit(pricingUnit))
-                return { key, fromDemand: false };
-        }
-        const key = pickOptionWithDemand();
-        return key ? { key, fromDemand: true } : null;
-    };
-    const nextTravelers = travelers.map((traveler) => {
-        const target = resolveTargetOption(traveler);
-        const pricingSource = traveler.pricingUnitSource ?? "auto";
-        const inventorySource = traveler.inventoryUnitSource ?? "auto";
-        if (!target) {
-            return {
-                ...traveler,
-                pricingUnitId: null,
-                inventoryUnitId: null,
-                pricingUnitSource: pricingSource === "none" ? "none" : "auto",
-                inventoryUnitSource: inventorySource === "none" ? "none" : "auto",
-            };
-        }
-        const targetKey = target.key;
-        const currentPricingUnit = traveler.pricingUnitId
-            ? unitById.get(traveler.pricingUnitId)
-            : undefined;
-        const currentPricingKey = traveler.pricingUnitId
-            ? unitToOption.get(traveler.pricingUnitId)
-            : undefined;
-        const keepManualPricing = pricingSource === "manual" &&
-            currentPricingUnit &&
-            isPersonUnit(currentPricingUnit) &&
-            currentPricingKey === targetKey;
-        const nextPricingUnit = pricingSource === "none"
-            ? null
-            : keepManualPricing
-                ? currentPricingUnit
-                : (resolvePricingUnitForTraveler(traveler, targetKey) ?? null);
-        const currentInventoryUnit = traveler.inventoryUnitId
-            ? unitById.get(traveler.inventoryUnitId)
-            : undefined;
-        const currentInventoryKey = traveler.inventoryUnitId
-            ? unitToOption.get(traveler.inventoryUnitId)
-            : undefined;
-        const keepManualInventory = inventorySource === "manual" &&
-            currentInventoryUnit &&
-            isInventoryUnit(currentInventoryUnit) &&
-            currentInventoryKey === targetKey;
-        const targetInventoryUnit = primaryInventoryByOption.get(targetKey) ?? null;
-        const nextInventoryUnit = inventorySource === "none"
-            ? null
-            : keepManualInventory
-                ? currentInventoryUnit
-                : targetInventoryUnit;
-        if (target.fromDemand && (nextPricingUnit || nextInventoryUnit)) {
-            assignedForDefaulting.set(targetKey, (assignedForDefaulting.get(targetKey) ?? 0) + 1);
-        }
-        return {
-            ...traveler,
-            pricingUnitId: nextPricingUnit?.optionUnitId ?? null,
-            inventoryUnitId: nextInventoryUnit?.optionUnitId ?? null,
-            pricingUnitSource: pricingSource === "none" ? "none" : keepManualPricing ? "manual" : "auto",
-            inventoryUnitSource: inventorySource === "none" ? "none" : keepManualInventory ? "manual" : "auto",
-        };
-    });
-    const next = {};
-    const travelerIndexesByUnitId = {};
-    // Accommodation quantities pass through unchanged — 1 DBL room
-    // stays 1 line. Person-priced quantities are rebuilt from traveler
-    // assignments below.
-    for (const [unitId, quantity] of Object.entries(quantities)) {
-        if (quantity <= 0)
-            continue;
-        const key = unitToOption.get(unitId);
-        if (!key || personPricedOptions.has(key))
-            continue;
-        const submittedUnit = unitById.get(unitId);
-        const targetUnitId = submittedUnit && isInventoryUnit(submittedUnit)
-            ? unitId
-            : (primaryInventoryByOption.get(key)?.optionUnitId ?? unitId);
-        next[targetUnitId] = (next[targetUnitId] ?? 0) + quantity;
-    }
-    const assignedByOption = new Map();
-    for (const [index, traveler] of nextTravelers.entries()) {
-        const pricingSource = traveler.pricingUnitSource ?? "auto";
-        const inventorySource = traveler.inventoryUnitSource ?? "auto";
-        const pricingKey = pricingSource !== "none" && traveler.pricingUnitId
-            ? unitToOption.get(traveler.pricingUnitId)
-            : undefined;
-        const inventoryKey = inventorySource !== "none" && traveler.inventoryUnitId
-            ? unitToOption.get(traveler.inventoryUnitId)
-            : undefined;
-        const key = inventoryKey ?? pricingKey;
-        if (!key)
-            continue;
-        if (personPricedOptions.has(key)) {
-            if (!traveler.pricingUnitId || pricingSource === "none")
-                continue;
-            const unitIndexes = travelerIndexesByUnitId[traveler.pricingUnitId] ?? [];
-            unitIndexes.push(index);
-            travelerIndexesByUnitId[traveler.pricingUnitId] = unitIndexes;
-            next[traveler.pricingUnitId] = (next[traveler.pricingUnitId] ?? 0) + 1;
-            assignedByOption.set(key, (assignedByOption.get(key) ?? 0) + 1);
-        }
-        else if (traveler.inventoryUnitId && inventorySource !== "none") {
-            const unitIndexes = travelerIndexesByUnitId[traveler.inventoryUnitId] ?? [];
-            unitIndexes.push(index);
-            travelerIndexesByUnitId[traveler.inventoryUnitId] = unitIndexes;
-        }
-    }
-    // Person-priced residual: operator picked N seats but only added M
-    // travelers (M < N) → put the leftover on the option's adult unit
-    // so the line-item total matches the stepper.
-    for (const [key, total] of totalByOption) {
-        if (!personPricedOptions.has(key))
-            continue;
-        const assigned = assignedByOption.get(key) ?? 0;
-        const residual = Math.max(0, total - assigned);
-        if (residual === 0)
-            continue;
-        const adult = pickUnitForAge(unitsByOption.get(key) ?? [], null, "adult");
-        if (!adult)
-            continue;
-        next[adult.optionUnitId] = (next[adult.optionUnitId] ?? 0) + residual;
-    }
-    return { quantities: next, travelers: nextTravelers, travelerIndexesByUnitId };
-}
-/**
- * Normalize per-person extras to charged traveler quantity and
- * stamp traveler links + `clientLineKey` so the server can link
- * each extra line to the travelers it applies to via
- * `booking_item_travelers`.
- *
- * Per-person mode (`pricingMode === "per_person"` or
- * `pricedPerPerson === true`): quantity multiplied by travelerCount,
- * `travelerKeys` set to all travelers when stable keys are supplied;
- * otherwise `travelerIndexes` is set as a deprecated fallback.
- * Non-per-person lines pass through with `clientLineKey` only.
- */
-export function resolveBookingExtraLines(options) {
-    const travelerIndexes = Array.from({ length: options.travelerCount }, (_, index) => index);
-    const travelerKeys = (options.travelerKeys ?? []).filter((key) => typeof key === "string" && key.trim().length > 0);
-    const useTravelerKeys = travelerKeys.length === options.travelerCount;
-    return options.extraLines.map((line) => {
-        const perPerson = line.pricingMode === "per_person" || line.pricedPerPerson === true;
-        if (!perPerson) {
-            return {
-                ...line,
-                clientLineKey: line.clientLineKey ?? `extra:${line.productExtraId}`,
-            };
-        }
-        const quantity = Math.max(1, options.travelerCount) * line.quantity;
-        return {
-            ...line,
-            clientLineKey: line.clientLineKey ?? `extra:${line.productExtraId}`,
-            quantity,
-            totalSellAmountCents: line.unitSellAmountCents == null
-                ? line.totalSellAmountCents
-                : line.unitSellAmountCents * quantity,
-            ...(useTravelerKeys ? { travelerKeys } : { travelerIndexes }),
-        };
-    });
-}
-/**
- * Project a resolved draft's traveler list into the wire-format
- * `BookingCreateTravelerInput[]` shape the dialog submits. Derives
- * the `travelerCategory` from DOB / role.
- *
- * `roomUnitId` is a deprecated compatibility alias for the pricing tier
- * option unit. Inventory placement is expressed only by item lines and their
- * `travelerKeys`; the server accepts this field but does not persist it.
- */
-export function travelersToRows(value, now = new Date()) {
-    return value.travelers.map((traveler) => ({
-        clientTravelerKey: traveler.clientTravelerKey?.trim() || null,
-        personId: traveler.personId,
-        firstName: traveler.firstName.trim(),
-        lastName: traveler.lastName.trim(),
-        email: traveler.email.trim() || null,
-        phone: traveler.phone.trim() || null,
-        preferredLanguage: traveler.preferredLanguage.trim() || null,
-        participantType: "traveler",
-        travelerCategory: deriveDraftPaxBand(traveler, now),
-        isPrimary: traveler.role === "lead",
-        roomUnitId: traveler.pricingUnitSource === "none" ? null : traveler.pricingUnitId,
-    }));
-}
-/**
- * Re-derive what `resolveBookingDraft` would have produced from the
- * submitted wire-format payload and compare against the submitted
- * itemLines. Used server-side as a sanity check on the client's
- * draft resolution. Returns `ok: true` when the submitted lines
- * match the resolver, else lists per-unit mismatches.
- *
- * Behavior of this helper is *non-rejecting* — callers decide
- * whether to log, warn, or fail. The orchestrator currently logs;
- * a follow-up will flip to rejection once observability confirms
- * no legitimate clients trip the warning.
- *
- * Notes on the reconstruction:
- *   - The wire format doesn't carry split per-traveler assignment
- *     fields (the join-table model encodes them through
- *     `itemLines[].travelerKeys`), so we reconstruct the relevant
- *     pricing or inventory unit by walking item lines and matching
- *     them to traveler keys. Deprecated `travelerIndexes` remain a
- *     fallback for older clients.
- *   - DOB doesn't round-trip on the wire today either; we feed the
- *     resolver the `travelerCategory` as a role hint so age-banded
- *     options can still be re-derived.
- */
-export function verifyBookingDraft(input) {
-    if (input.itemLines.length === 0 || input.units.length === 0) {
-        return { ok: true, mismatches: [] };
-    }
-    // Walk the submitted itemLines to recover the per-traveler unit
-    // assignment the client intended. Prefer stable `travelerKeys`
-    // when present; fall back to deprecated `travelerIndexes` for
-    // legacy clients. If neither is present, we can't verify
-    // per-traveler assignment — just compare aggregate quantities.
-    // Booking-create schema validation rejects unknown traveler keys
-    // before this verifier runs.
-    const unitById = new Map(input.units.map((unit) => [unit.optionUnitId, unit]));
-    const travelerIndexByKey = new Map();
-    for (const [index, traveler] of input.travelers.entries()) {
-        const key = traveler.clientTravelerKey?.trim();
-        if (key && !travelerIndexByKey.has(key))
-            travelerIndexByKey.set(key, index);
-    }
-    const unitByTravelerIndex = new Map();
-    for (const line of input.itemLines) {
-        const travelerKeys = (line.travelerKeys ?? []).filter((key) => key.trim().length > 0);
-        const keyedIndexes = travelerKeys
-            .map((key) => travelerIndexByKey.get(key.trim()))
-            .filter((index) => typeof index === "number");
-        const indexes = travelerKeys.length > 0 ? keyedIndexes : (line.travelerIndexes ?? []);
-        for (const idx of indexes) {
-            unitByTravelerIndex.set(idx, line.optionUnitId);
-        }
-    }
-    const travelerDrafts = input.travelers.map((t, i) => {
-        const cat = t.travelerCategory;
-        const role = t.isPrimary === true
-            ? "lead"
-            : cat === "child" || cat === "infant" || cat === "adult"
-                ? cat
-                : "adult";
-        const assigned = unitByTravelerIndex.get(i);
-        const assignedUnit = assigned ? unitById.get(assigned) : undefined;
-        return {
-            personId: null,
-            firstName: "",
-            lastName: "",
-            email: "",
-            phone: "",
-            preferredLanguage: "",
-            role,
-            dateOfBirth: null,
-            // We deliberately use `auto` (not `manual`) here even though
-            // the client effectively committed to an assignment when it
-            // serialized the line. The point of verification is to ask
-            // "would a fresh resolver, given the same role/category
-            // signals, produce these quantities?" — i.e. allow the
-            // resolver to re-derive instead of treating the submitted
-            // value as ground truth. Otherwise the day-tour bug shape
-            // (3 travelers all manually frozen to Adult) would round-trip
-            // through the verifier unchanged.
-            pricingUnitId: assigned && assignedUnit && isPersonUnit(assignedUnit) ? assigned : null,
-            inventoryUnitId: assigned && assignedUnit && isInventoryUnit(assignedUnit) ? assigned : null,
-            pricingUnitSource: "auto",
-            inventoryUnitSource: "auto",
-        };
-    });
-    // Aggregate submitted quantities for resolver input. For
-    // accommodation options the resolver passes these through
-    // unchanged; for person-priced options it rebuilds them from
-    // traveler assignments.
-    const submittedQuantities = {};
-    for (const line of input.itemLines) {
-        submittedQuantities[line.optionUnitId] =
-            (submittedQuantities[line.optionUnitId] ?? 0) + line.quantity;
-    }
-    const resolved = resolveBookingDraft({
-        quantities: submittedQuantities,
-        travelers: travelerDrafts,
-        units: input.units,
-    });
-    const mismatches = [];
-    const allUnitIds = new Set([
-        ...Object.keys(submittedQuantities),
-        ...Object.keys(resolved.quantities),
-    ]);
-    for (const unitId of allUnitIds) {
-        const submitted = submittedQuantities[unitId] ?? 0;
-        const resolvedQty = resolved.quantities[unitId] ?? 0;
-        if (submitted === resolvedQty)
-            continue;
-        const kind = submitted === 0 ? "missing" : resolvedQty === 0 ? "extra" : "qty";
-        mismatches.push({
-            kind,
-            optionUnitId: unitId,
-            submittedQuantity: submitted,
-            resolvedQuantity: resolvedQty,
-        });
-    }
-    return { ok: mismatches.length === 0, mismatches };
-}
+export * from "./pricing-assignment/age.js";
+export * from "./pricing-assignment/draft.js";
+export * from "./pricing-assignment/types.js";
+export * from "./pricing-assignment/verify.js";