@crvouga/mockingbird-service-junction 3.6.1 → 3.7.0

package/dist/server.d.ts

@@ -133,6 +133,12 @@ interface SqliteClient$2 {
     transaction<T>(fn: () => T): T;
 }
 
+/**
+ * What names an id base: a non-negative safe integer (or its decimal string) or `"boot"`,
+ * which derives the base from the wall clock when the runtime is created.
+ */
+type IdBase$1 = number | string;
+
 /**
  * The single source of time for a service.
  *
@@ -215,6 +221,15 @@ type FaultRule$1 = {
     requestHeaders?: Record<string, string>;
     /** Fault only requests carrying these query parameters. `"*"` matches any value. */
     query?: Record<string, string>;
+    /**
+     * Fault only requests whose JSON body carries these fields. Each key is a dotted path into
+     * the parsed body (`"patient_details.email"`; a number steps into an array, `"items.0.sku"`)
+     * and each value is what the field must equal: a string, number, boolean or `null`, compared
+     * strictly (`3` is not `"3"`). `"*"` matches any value that is present. A request whose body
+     * is missing, is not JSON, or is not a JSON object never matches. Not `body`, which is the
+     * response a rule injects.
+     */
+    requestBody?: Record<string, RequestBodyValue$1>;
     /**
      * Fault only this namespace. Omit (or `"*"`) to fault every namespace — which is what
      * an in-process caller usually wants, and what a parallel worker usually does not:
@@ -281,6 +296,8 @@ type FaultRule$1 = {
     /** The preset this rule was expanded from, if any. */
     fromPreset?: string;
 };
+/** What a field of the request body must equal in {@link FaultRule.requestBody}. */
+type RequestBodyValue$1 = string | number | boolean | null;
 /** A fault that fired for one request. */
 type FaultHit$1 = {
     id: string;
@@ -305,6 +322,11 @@ type FaultCandidate$1 = {
     /** Request headers and query, for rules that match on them. */
     headers?: Headers;
     query?: URLSearchParams;
+    /**
+     * The request body parsed as JSON, read only when a rule matches on `requestBody`. Resolve
+     * `undefined` for a body that is missing or not JSON. It must leave the request readable.
+     */
+    readJson?: () => Promise<unknown>;
     /** The namespace clock, for `from` / `until`. Rules with a window are skipped without it. */
     now?: number;
     /** How to spend a delay for this request. Default: the registry's own sleep. */
@@ -827,6 +849,12 @@ type ServiceRuntime$1<T extends ServiceInstance$1> = FetchAPI$2 & {
     mount(prefix: string): MountedAPI$1;
     readonly sqlite: SqliteClient$2;
     readonly clock: Clock$1;
+    /**
+     * Change the id base ({@link RuntimeOptions.idBase}) for ids generated from now on, and
+     * return the number it resolved to. Set it before the first request so a boot's ids stay
+     * one run.
+     */
+    setIdBase(base: IdBase$1): number;
     readonly faults: FaultRegistry$1;
     /** Baseline response time per namespace. */
     readonly latency: LatencyRegistry$1;
@@ -932,6 +960,12 @@ type CommonServeOptions = {
     /** Synthetic provider fixture objects supplied by a fleet entry. */
     fixtures?: Record<string, unknown>;
     baseUrl?: string;
+    /**
+     * Boot settings from `--settings`, `MOCKINGBIRD_SETTINGS` or a fleet entry's `settings`,
+     * already checked by the target's {@link ServeTarget.parseSettings}. Pass them to the
+     * service's own `settings` option so they become every namespace's defaults.
+     */
+    settings?: Record<string, unknown>;
 };
 /**
  * What a service contributes to `serve`: how to build its runtime from CLI flags,
@@ -944,6 +978,13 @@ type ServeTarget = {
     defaultPort: number;
     /** Serve flags beyond the common ones. */
     options?: Record<string, CliOption>;
+    /**
+     * Check the boot settings a caller supplied (`--settings`, `MOCKINGBIRD_SETTINGS`, a fleet
+     * entry's `settings`) against the service's settings schema, returning them normalized
+     * or throwing a message naming the bad field. A target without one takes no boot settings,
+     * and supplying some is refused before a port is bound.
+     */
+    parseSettings?(settings: Record<string, unknown>): Record<string, unknown>;
     create(values: CliValues, common: CommonServeOptions): Promise<ServiceRuntime$1<ServiceInstance$1>> | ServiceRuntime$1<ServiceInstance$1>;
     /** Startup lines after the listen address, e.g. the loaded corpus version. */
     banner?(runtime: ServiceRuntime$1<ServiceInstance$1>): string[];
@@ -1083,6 +1124,12 @@ interface SqliteClient$1 {
     transaction<T>(fn: () => T): T;
 }
 
+/**
+ * What names an id base: a non-negative safe integer (or its decimal string) or `"boot"`,
+ * which derives the base from the wall clock when the runtime is created.
+ */
+type IdBase = number | string;
+
 /** Options every provider constructor accepts. */
 type APIOptions = {
     /** Sync SQLite client. Defaults to `@crvouga/mockingbird-service-sqlite`. */
@@ -1178,6 +1225,15 @@ type FaultRule = {
     requestHeaders?: Record<string, string>;
     /** Fault only requests carrying these query parameters. `"*"` matches any value. */
     query?: Record<string, string>;
+    /**
+     * Fault only requests whose JSON body carries these fields. Each key is a dotted path into
+     * the parsed body (`"patient_details.email"`; a number steps into an array, `"items.0.sku"`)
+     * and each value is what the field must equal: a string, number, boolean or `null`, compared
+     * strictly (`3` is not `"3"`). `"*"` matches any value that is present. A request whose body
+     * is missing, is not JSON, or is not a JSON object never matches. Not `body`, which is the
+     * response a rule injects.
+     */
+    requestBody?: Record<string, RequestBodyValue>;
     /**
      * Fault only this namespace. Omit (or `"*"`) to fault every namespace — which is what
      * an in-process caller usually wants, and what a parallel worker usually does not:
@@ -1244,6 +1300,8 @@ type FaultRule = {
     /** The preset this rule was expanded from, if any. */
     fromPreset?: string;
 };
+/** What a field of the request body must equal in {@link FaultRule.requestBody}. */
+type RequestBodyValue = string | number | boolean | null;
 /** A fault that fired for one request. */
 type FaultHit = {
     id: string;
@@ -1268,6 +1326,11 @@ type FaultCandidate = {
     /** Request headers and query, for rules that match on them. */
     headers?: Headers;
     query?: URLSearchParams;
+    /**
+     * The request body parsed as JSON, read only when a rule matches on `requestBody`. Resolve
+     * `undefined` for a body that is missing or not JSON. It must leave the request readable.
+     */
+    readJson?: () => Promise<unknown>;
     /** The namespace clock, for `from` / `until`. Rules with a window are skipped without it. */
     now?: number;
     /** How to spend a delay for this request. Default: the registry's own sleep. */
@@ -1790,6 +1853,12 @@ type ServiceRuntime<T extends ServiceInstance> = FetchAPI$1 & {
     mount(prefix: string): MountedAPI;
     readonly sqlite: SqliteClient$1;
     readonly clock: Clock;
+    /**
+     * Change the id base ({@link RuntimeOptions.idBase}) for ids generated from now on, and
+     * return the number it resolved to. Set it before the first request so a boot's ids stay
+     * one run.
+     */
+    setIdBase(base: IdBase): number;
     readonly faults: FaultRegistry;
     /** Baseline response time per namespace. */
     readonly latency: LatencyRegistry;
@@ -1897,48 +1966,6 @@ interface SqliteClient {
     transaction<T>(fn: () => T): T;
 }
 
-type LabAccountStatus = "active" | "pending" | "suspended" | "ready_to_launch";
-type LabAccountDelegatedFlow = "order_delegated" | "result_delegated" | "fully_delegated" | "not_delegated";
-/** `billing_type` values the vendored create-order body accepts. */
-declare const BILLING_TYPES: readonly ["client_bill", "commercial_insurance", "patient_bill_passthrough", "patient_bill", "upfront_payment"];
-type BillingType = (typeof BILLING_TYPES)[number];
-type LabAccountOmissionPolicy = "platform" | "reject";
-/**
- * A lab account as a consumer configures it. Mirrors `ClientFacingLabAccount`, with
- * every field but `id` and `lab` optional, plus a `states` shorthand for the common
- * case of an account that client-bills in a fixed set of states.
- */
-type LabAccountInput = {
-    id: string;
-    /** Lab slug, e.g. `"quest"`, `"labcorp"`, `"bioreference"`. */
-    lab: string;
-    status?: LabAccountStatus;
-    delegated_flow?: LabAccountDelegatedFlow;
-    account_name?: string | null;
-    provider_account_id?: string;
-    org_id?: string | null;
-    business_units?: string[] | null;
-    default_clinical_notes?: string | null;
-    /** Billing type → states it is allowed in. Takes precedence over `states`. */
-    allowed_billing?: Record<string, readonly string[]>;
-    /** Shorthand for `allowed_billing: { client_bill: states }`. Default: every state. */
-    states?: readonly string[];
-    /** Teams the account is linked to. Default: the configured team, so it is selectable. */
-    team_id_allowlist?: readonly string[];
-};
-
-type LabAccountProfile = "native" | "expected-contract" | "sandbox-observed";
-type LabAccountSandboxPolicy = {
-    /** Explicit billing refusals observed for this particular fixture/account. */
-    rejectBilling?: Partial<Record<BillingType, string>>;
-    /** Explicit billing/state exceptions observed for this particular fixture/account. */
-    allowBilling?: Partial<Record<BillingType, readonly string[]>>;
-};
-type LabAccountBehavior = {
-    profile: LabAccountProfile;
-    accounts: Record<string, LabAccountSandboxPolicy>;
-};
-
 /** Lab-test catalog mirrored from the Junction sandbox (`GET /v3/lab_test`). */
 type CatalogMarker = {
     id: number;
@@ -1991,6 +2018,204 @@ type LabTestRecord = {
     worst_case_tat_days: number | null;
 };
 
+/**
+ * A-la-carte markers and order-set pricing.
+ *
+ * - `GET /v3/lab_tests/markers`: the markers a team can order one by one.
+ *   https://docs.junction.com/api-reference/lab-testing/biomarkers
+ * - `POST /v3/lab_test/estimate_order_set_pricing`: what an order set costs.
+ *   https://docs.junction.com/api-reference/lab-testing/estimate-order-set-pricing
+ *
+ * Both follow the published contract. Nothing here is checked against the live sandbox (prices
+ * are contract-owned), so the emulator prices from the catalog it holds: a lab test's `price`
+ * and a marker's `price`, or the `pricing` of a configured {@link MarkerCatalogEntry}.
+ */
+
+/** Pricing the way Junction states it: minor units, or why it is not stated. */
+type MarkerPricing = {
+    base_amount_minor: number;
+    modifiers?: readonly Record<string, unknown>[] | null;
+} | {
+    unspecified: "refer_to_contract" | "price_unavailable";
+};
+/**
+ * A marker the mock offers on top of (or in place of) the ones embedded in catalog lab tests:
+ * `createRuntime({ markerCatalog: [...] })`. Fields not given take the vendor's defaults.
+ */
+type MarkerCatalogEntry = {
+    id: number;
+    name: string;
+    slug?: string;
+    description?: string | null;
+    lab_id?: number | null;
+    provider_id?: string | null;
+    type?: "biomarker" | "panel" | null;
+    unit?: string | null;
+    /** Dollars, as the vendor prints them (`"12.50"`); a number is formatted to two decimals. */
+    price?: string | number | null;
+    /** Stated pricing, when `price` cannot say it (modifiers, `refer_to_contract`). */
+    pricing?: MarkerPricing;
+    /** Ask-on-order questions: `{ questions: [...] }`. */
+    aoe?: unknown;
+    /** Default `false`, as at the vendor. */
+    a_la_carte_enabled?: boolean;
+    common_tat_days?: number | null;
+    worst_case_tat_days?: number | null;
+    is_orderable?: boolean | null;
+    /** What the marker reports. Default: none. */
+    expected_results?: readonly ExpectedResult[];
+    components?: readonly MarkerCatalogEntry[] | null;
+};
+
+/**
+ * ZIP overlays: aliases and per-ZIP overrides on top of whatever geo mode answers.
+ *
+ * `createRuntime({ zipOverlays: { aliases: { "07105": "85004" }, overrides: { "07105": {
+ * phlebotomy_served: true, no_pscs: true } } } })`. An alias makes one ZIP answer as another
+ * (coverage, recordings and the synthetic model all use the target); an override then edits the
+ * answer for a ZIP: `phlebotomy.is_served` on `area/info`, and an empty PSC list.
+ */
+
+type ZipOverride = {
+    /** `phlebotomy.is_served` on `GET /v3/order/area/info` (and its `providers`). */
+    phlebotomy_served?: boolean;
+    /** No patient service centers: `psc/info` lists none and `area/info` counts none. */
+    no_pscs?: boolean;
+};
+type ZipOverlays = {
+    /** ZIP → the ZIP it answers as. */
+    aliases?: Record<string, string>;
+    /** ZIP → what to change in its answers. Looked up by the requested ZIP, then by its alias. */
+    overrides?: Record<string, ZipOverride>;
+};
+
+type LabAccountStatus = "active" | "pending" | "suspended" | "ready_to_launch";
+type LabAccountDelegatedFlow = "order_delegated" | "result_delegated" | "fully_delegated" | "not_delegated";
+/** `billing_type` values the vendored create-order body accepts. */
+declare const BILLING_TYPES: readonly ["client_bill", "commercial_insurance", "patient_bill_passthrough", "patient_bill", "upfront_payment"];
+type BillingType = (typeof BILLING_TYPES)[number];
+type LabAccountOmissionPolicy = "platform" | "reject";
+/**
+ * A lab account as a consumer configures it. Mirrors `ClientFacingLabAccount`, with
+ * every field but `id` and `lab` optional, plus a `states` shorthand for the common
+ * case of an account that client-bills in a fixed set of states.
+ */
+type LabAccountInput = {
+    id: string;
+    /** Lab slug, e.g. `"quest"`, `"labcorp"`, `"bioreference"`. */
+    lab: string;
+    status?: LabAccountStatus;
+    delegated_flow?: LabAccountDelegatedFlow;
+    account_name?: string | null;
+    provider_account_id?: string;
+    org_id?: string | null;
+    business_units?: string[] | null;
+    default_clinical_notes?: string | null;
+    /** Billing type → states it is allowed in. Takes precedence over `states`. */
+    allowed_billing?: Record<string, readonly string[]>;
+    /** Shorthand for `allowed_billing: { client_bill: states }`. Default: every state. */
+    states?: readonly string[];
+    /** Teams the account is linked to. Default: the configured team, so it is selectable. */
+    team_id_allowlist?: readonly string[];
+};
+
+type LabAccountProfile = "native" | "expected-contract" | "sandbox-observed" | "observed";
+/** Which vendor environment an `observed` configuration reproduces. */
+type LabAccountOracle = "sandbox" | "production";
+/**
+ * How an order that omits `lab_account_id` and resolves to a Junction-owned (`org_id: null`)
+ * account treats that account's listed `allowed_billing`: `listed` (default) enforces it,
+ * `unchecked` skips the billing/state check (#467). Explicit account selection is unaffected.
+ */
+type OmittedAccountBilling = "listed" | "unchecked";
+type LabAccountSandboxPolicy = {
+    /** Explicit billing refusals observed for this particular fixture/account. */
+    rejectBilling?: Partial<Record<BillingType, string>>;
+    /** Explicit billing/state exceptions observed for this particular fixture/account. */
+    allowBilling?: Partial<Record<BillingType, readonly string[]>>;
+};
+type LabAccountBehavior = {
+    profile: LabAccountProfile;
+    /**
+     * The oracle the observations reproduce. `sandbox-observed` is the alias of `observed`
+     * with `oracle: "sandbox"`; `native` and `expected-contract` have none.
+     */
+    oracle?: LabAccountOracle;
+    accounts: Record<string, LabAccountSandboxPolicy>;
+    /** Lab slug → omitted-account billing policy; unlisted labs are `listed`. */
+    omittedAccountBilling?: Record<string, OmittedAccountBilling>;
+};
+
+/**
+ * Opt-in sandbox quirks: behaviors the vendor sandbox shows that a well-behaved client must
+ * tolerate. Every quirk is off by default, so no existing suite changes.
+ */
+type JunctionQuirks = {
+    /**
+     * #474: a `POST /v3/order/{id}/cancel` that lands in the same wall-clock second as the
+     * order's creation records its `cancelled.<method>.cancelled` event, but the order's
+     * `status`, `last_event` and `updated_at` do not move; a second cancel is a no-op. Reported
+     * from the sandbox (production unverified).
+     */
+    sameSecondCancelStatus?: boolean;
+};
+
+/**
+ * The test backdoor: users and orders put straight into a namespace, with ids a suite
+ * chooses — the Junction `user_id`s a database fixture already carries, or an order
+ * already in some status — plus the lenient identity mode that adopts unknown users.
+ *
+ * Everything inserted here goes through the records `create_user` and `create_order`
+ * build, so no read path can tell a fixture from an API-created resource.
+ */
+
+/** How requests referring to a user the namespace does not hold are answered. */
+type IdentityMode = "strict" | "adopt-users";
+type UserFixture = {
+    /** Default: a fresh id, as `create_user` would mint. */
+    user_id?: string;
+    client_user_id: string;
+    /** ISO-8601. Default: the mock clock's now. */
+    created_on?: string;
+    /** An IANA zone, or the full `{ id, source_slug, updated_at }` object. */
+    fallback_time_zone?: string | UserRecord["fallback_time_zone"];
+    /** `YYYY-MM-DD`, or the full `{ value, source_slug, updated_at }` object. */
+    fallback_birth_date?: string | UserRecord["fallback_birth_date"];
+    ingestion_start?: string | null;
+    ingestion_end?: string | null;
+};
+type OrderFixture = {
+    /** Default: a fresh id, as `create_order` would mint. */
+    order_id?: string;
+    user_id: string;
+    lab_test_id: string;
+    lab_account_id?: string;
+    /** A transition target (`completed`, `at_lab`, or a full status). Default: just ordered. */
+    status?: string;
+    /** Default: the lab test's own method. */
+    collection_method?: string;
+    patient_details?: Record<string, unknown>;
+    patient_address?: Record<string, unknown>;
+    billing_type?: string;
+    icd_codes?: string[] | null;
+    passthrough?: string | null;
+    clinical_notes?: string | null;
+    /** ISO-8601. Default: the mock clock's now. */
+    created_at?: string;
+    /** Results served for the order, as `PUT /__admin/results/{id}` takes them. */
+    result_fixture?: Omit<ResultFixture, "name"> & {
+        name?: string;
+    };
+};
+type JunctionFixtures = {
+    users?: readonly UserFixture[];
+    orders?: readonly OrderFixture[];
+};
+type InsertOptions = {
+    /** Publish the webhooks the equivalent API calls would. Default `false`. */
+    emitWebhooks?: boolean;
+};
+
 type JunctionLimits = {
     /**
      * Live users a team may hold; creating one more answers the sandbox's
@@ -2139,8 +2364,10 @@ type ResultFixture = {
  * - `synthetic`: invent plausible coverage. Right for property tests that walk random ZIPs.
  * - `corpus`: refuse with a documented Mockingbird error. Right for a mock standing in for
  *   the vendor, where invented coverage would silently disagree with production.
+ * - `corpus+synthetic`: replay the recording for the ZIPs it covers (a read it cannot answer
+ *   still refuses), and invent coverage for every other ZIP.
  */
-type GeoMode = "synthetic" | "corpus";
+type GeoMode = "synthetic" | "corpus" | "corpus+synthetic";
 type WebhookPublisher = (event: JunctionWebhookEvent) => void;
 type JunctionWebhookOptions = {
     seed?: number;
@@ -2148,60 +2375,27 @@ type JunctionWebhookOptions = {
     timeoutMs?: number;
 };
 
-/**
- * The test backdoor: users and orders put straight into a namespace, with ids a suite
- * chooses — the Junction `user_id`s a database fixture already carries, or an order
- * already in some status — plus the lenient identity mode that adopts unknown users.
- *
- * Everything inserted here goes through the records `create_user` and `create_order`
- * build, so no read path can tell a fixture from an API-created resource.
- */
-
-/** How requests referring to a user the namespace does not hold are answered. */
-type IdentityMode = "strict" | "adopt-users";
-type UserFixture = {
-    /** Default: a fresh id, as `create_user` would mint. */
-    user_id?: string;
-    client_user_id: string;
-    /** ISO-8601. Default: the mock clock's now. */
-    created_on?: string;
-    /** An IANA zone, or the full `{ id, source_slug, updated_at }` object. */
-    fallback_time_zone?: string | UserRecord["fallback_time_zone"];
-    /** `YYYY-MM-DD`, or the full `{ value, source_slug, updated_at }` object. */
-    fallback_birth_date?: string | UserRecord["fallback_birth_date"];
-    ingestion_start?: string | null;
-    ingestion_end?: string | null;
-};
-type OrderFixture = {
-    /** Default: a fresh id, as `create_order` would mint. */
-    order_id?: string;
-    user_id: string;
-    lab_test_id: string;
-    lab_account_id?: string;
-    /** A transition target (`completed`, `at_lab`, or a full status). Default: just ordered. */
+type CatalogOverlay = {
+    /** The lab test to clone, by id or slug. It must be in the catalog the namespace boots with. */
+    from: string;
+    /** Id of the new lab test (a UUID, as `create_order` expects). */
+    id: string;
+    name?: string;
+    slug?: string;
+    /**
+     * Move the clone to a lab: the slug of a lab the catalog lists, or a lab record
+     * (`{ id, slug, name, ... }`), which is added to `GET /v3/lab_tests/labs` when new.
+     * The clone's markers and expected results take that lab's id.
+     */
+    lab?: string | Record<string, unknown>;
+    /** Drop the ask-on-order questions from every marker of the clone. */
+    stripAoe?: boolean;
+    /** Set `auto_generated` on the clone. Default: as the source. */
+    autoGenerated?: boolean;
+    method?: string;
+    /** Dollars. */
+    price?: number;
     status?: string;
-    /** Default: the lab test's own method. */
-    collection_method?: string;
-    patient_details?: Record<string, unknown>;
-    patient_address?: Record<string, unknown>;
-    billing_type?: string;
-    icd_codes?: string[] | null;
-    passthrough?: string | null;
-    clinical_notes?: string | null;
-    /** ISO-8601. Default: the mock clock's now. */
-    created_at?: string;
-    /** Results served for the order, as `PUT /__admin/results/{id}` takes them. */
-    result_fixture?: Omit<ResultFixture, "name"> & {
-        name?: string;
-    };
-};
-type JunctionFixtures = {
-    users?: readonly UserFixture[];
-    orders?: readonly OrderFixture[];
-};
-type InsertOptions = {
-    /** Publish the webhooks the equivalent API calls would. Default `false`. */
-    emitWebhooks?: boolean;
 };
 
 /**
@@ -2223,6 +2417,13 @@ interface FetchAPI {
  * NY/NJ client-bill shape a consumer asked for, kept because suites depend on it, and
  * listed in `SYNTHETIC_LAB_ACCOUNT_PRESETS`.
  *
+ * The 2026-09-21 `bioreference_platform` preset lists `client_bill` in 47 states, but the
+ * current house BioReference account lists only `patient_bill_passthrough` in NJ and NY, so
+ * treat it as illustrative (#475). The `bioreference_current_platform`,
+ * `quest_sandbox_platform` and `sonora_quest_production_platform` presets follow the listings
+ * an agent reported from `GET /v3/lab_test/lab_account` on 2026-10-18 (a consumer-audit
+ * report, not a repository probe); they are additions, so no existing preset changes.
+ *
  * `*_platform` presets are Junction's own accounts (`org_id: null`, allowlist `[]`); every
  * other active preset is customer-owned (it belongs to an Org and is linked to the team).
  */
@@ -2364,6 +2565,27 @@ type JunctionAPIOptions = APIOptions & {
      * when a corpus is given (refuse, loudly), otherwise `synthetic` (invent coverage).
      */
     geo?: GeoMode;
+    /**
+     * ZIP aliases and per-ZIP overrides on serviceability answers, whatever the geo mode: an
+     * alias makes a ZIP answer as another, an override sets `phlebotomy.is_served` or empties the
+     * PSC list. Per namespace via `PUT /__admin/geo`.
+     */
+    zipOverlays?: ZipOverlays;
+    /**
+     * Lab tests derived from catalog ones (new id, name, slug, lab; AOE questions stripped;
+     * `auto_generated`), added to every namespace after the catalog loads and again on `reset()`.
+     */
+    catalogOverlays?: readonly CatalogOverlay[];
+    /**
+     * Markers `GET /v3/lab_tests/markers` offers on top of those in catalog lab tests, with their
+     * pricing, AOE questions and expected results.
+     */
+    markerCatalog?: readonly MarkerCatalogEntry[];
+    /**
+     * Name the markers behind each biomarker result line of an add-on order
+     * (`source_markers[].marker_id`). Default off: the line then carries `source_markers: null`.
+     */
+    addOnSourceMarkers?: boolean;
     /**
      * The team's lab accounts, replacing the built-in fixtures (and any from the corpus):
      * a list of accounts, or `{ presets: [...], accounts: [...] }`. `create_order` routes,
@@ -2389,6 +2611,8 @@ type JunctionAPIOptions = APIOptions & {
     labAccountOmissionPolicies?: Record<string, LabAccountOmissionPolicy>;
     /** Named policy; native preserves legacy behavior. Sandbox exceptions are account-owned. */
     labAccountBehavior?: Partial<LabAccountBehavior>;
+    /** Opt-in sandbox quirks (#474), every one off by default; see {@link JunctionQuirks}. */
+    quirks?: JunctionQuirks;
     /** Users and orders to load into every namespace, re-applied on every `reset()`. */
     fixtures?: JunctionFixtures;
 };
@@ -2415,6 +2639,7 @@ declare class JunctionAPI implements FetchAPI {
     private readonly rateWindow;
     private corpus;
     private labAccountConfig;
+    private readonly catalogOverlays;
     constructor(options?: JunctionAPIOptions);
     fetch(request: Request): Promise<Response>;
     reset(): Promise<void>;
@@ -2456,6 +2681,9 @@ declare class JunctionAPI implements FetchAPI {
     /** Effective account policy for this namespace; kept across reset. */
     get labAccountBehavior(): LabAccountBehavior;
     set labAccountBehavior(input: LabAccountBehavior);
+    /** Opt-in sandbox quirks for this namespace; kept across reset. */
+    get quirks(): JunctionQuirks;
+    set quirks(input: JunctionQuirks);
     get defaultBillingTypes(): Record<string, BillingType>;
     /** Replace the per-lab default billing types (`{}` restores `client_bill` everywhere). */
     set defaultBillingTypes(input: Partial<Record<string, BillingType>>);
@@ -2473,6 +2701,9 @@ declare class JunctionAPI implements FetchAPI {
         orders: OrderRecord[];
     };
     corpusInfo(): CorpusInfo | undefined;
+    /** ZIP aliases and overrides for this namespace; kept across reset. */
+    get zipOverlays(): ZipOverlays;
+    set zipOverlays(overlays: ZipOverlays);
     get geoMode(): GeoMode;
     set geoMode(mode: GeoMode);
     order(id: string): OrderRecord | undefined;
@@ -2483,6 +2714,16 @@ declare class JunctionAPI implements FetchAPI {
      * only place the mock reports it.
      */
     orderLabAccount(id: string): string | null | undefined;
+    /**
+     * Where `POST /v3/order` carried a lab account id: `labAccountId` at the root (which
+     * selects the account) and `nestedLabAccountId` inside `order_set` (which Junction
+     * ignores). `null` for an order that was not placed through the API (a fixture), and
+     * `undefined` for an unknown order.
+     */
+    orderLabAccountRequest(id: string): {
+        labAccountId: string | null;
+        nestedLabAccountId: string | null;
+    } | null | undefined;
     /** Frozen provider number used by the synthetic requisition; null means unknown. */
     requisitionFixture(id: string): {
         provider_account_id: string | null;
@@ -2516,11 +2757,21 @@ type JunctionRuntimeOptions = {
     corpus?: SealedCorpus;
     /** Default: `corpus` when a corpus is loaded, otherwise `synthetic`. */
     geo?: GeoMode;
+    /** ZIP aliases and per-ZIP overrides on serviceability answers; see {@link JunctionAPIOptions.zipOverlays}. */
+    zipOverlays?: ZipOverlays;
+    /** Lab tests derived from catalog ones at boot; see {@link JunctionAPIOptions.catalogOverlays}. */
+    catalogOverlays?: readonly CatalogOverlay[];
+    /** Markers `GET /v3/lab_tests/markers` offers; see {@link JunctionAPIOptions.markerCatalog}. */
+    markerCatalog?: readonly MarkerCatalogEntry[];
+    /** Name the markers behind add-on result lines; see {@link JunctionAPIOptions.addOnSourceMarkers}. */
+    addOnSourceMarkers?: boolean;
     /** The team's lab accounts, or `{ presets, accounts }`; see {@link JunctionAPIOptions.labAccounts}. */
     labAccounts?: LabAccountLayout;
     /** Per-lab multiple-account omission policy; default platform. */
     labAccountOmissionPolicies?: Record<string, LabAccountOmissionPolicy>;
     labAccountBehavior?: Partial<LabAccountBehavior>;
+    /** Opt-in sandbox quirks, every one off by default (#474). */
+    quirks?: JunctionQuirks;
     /** The team the mock answers as. Default: the corpus's recorded team, else a fixed id. */
     teamId?: string;
     /** Sandbox-only restrictions, every one off by default; per namespace via `PUT /__admin/limits`. */

package/dist/server.js

@@ -3,8 +3,8 @@ import {
   createServer,
   loadCorpus,
   serveTarget
-} from "./chunk-HJJCEIVH.js";
-import "./chunk-VHVGQ3WX.js";
+} from "./chunk-NTGGNJKR.js";
+import "./chunk-27N4VA23.js";
 import "./chunk-2FZJPMTR.js";
 import "./chunk-ISDNA2TU.js";
 export {