@adcp/sdk 7.3.0 → 7.4.0

package/dist/lib/server/test-controller-bridge.d.ts

@@ -17,8 +17,124 @@
  * Sellers provide a `getSeededProducts` callback that returns the list the
  * SDK should merge — which lets the same wiring work whether the backing
  * store is in-memory, Postgres, Redis, or a mock.
+ *
+ * ## Scope of verification (storyboard pass through this bridge)
+ *
+ * A storyboard run that succeeds because seeded fixtures were merged into
+ * the response verifies **protocol conformance against fixture data**:
+ * wire shape, error envelopes, idempotency, signed-request handling,
+ * sandbox stamping. It does **not** verify that the seller's adapter
+ * against the real upstream (e.g., social / search / programmatic
+ * inventory APIs) is working — the upstream response is shadowed by the
+ * post-handler merge.
+ *
+ * Treat this bridge as the conformance equivalent of a recorded-fixtures
+ * unit test, not an end-to-end integration test. Sellers should still
+ * exercise their adapters against a real (or sandbox) upstream OAuth tier
+ * separately; the typical pattern is a CLI runner pointed at a deployed
+ * sandbox URL with live credentials. The two together — storyboard-via-
+ * bridge plus live-OAuth runner — give wire conformance and adapter
+ * health respectively. See adcp-client#1775 for the cross-repo
+ * coordination on making bridge participation visible in storyboard
+ * run records.
+ *
+ * ## Adopter responsibilities
+ *
+ * **`resolveAccount` is the trust boundary.** The dispatcher's sandbox
+ * gate is "request carries a sandbox marker AND (resolved account is
+ * sandbox OR no account was resolved)." If you deploy a server with this
+ * bridge registered but no `resolveAccount` configured, a buyer can stamp
+ * `context.sandbox: true` on a request and trigger the merge. That's the
+ * intended behavior for storyboard runners with no account scoping, but
+ * means **production bindings must always configure `resolveAccount`** —
+ * otherwise the buyer-supplied sandbox marker is the only gate.
+ *
+ * **Multi-tenant isolation is the adopter's job.** Callbacks receive
+ * `ctx.account` and must key their fixture store on it. The SDK does no
+ * defensive cross-check between the account on the response entries and
+ * the `ctx.account` that asked for them. A sloppy session-store keying
+ * can return tenant A's fixtures to tenant B; nothing in this module
+ * will notice. Treat fixture stores like any other multi-tenant data
+ * layer.
+ */
+import type { Product, GetProductsResponse, Account, ListAccountsResponse, ListCreativesResponse, GetMediaBuysResponse, GetMediaBuyDeliveryResponse, ListCreativeFormatsResponse, Format, GetAccountFinancialsResponse, GetAccountFinancialsSuccess, GetAccountFinancialsRequest, PropertyList, ListPropertyListsResponse, GetPropertyListResponse, GetPropertyListRequest, CollectionList, ListCollectionListsResponse, GetCollectionListResponse, GetCollectionListRequest, ContentStandards, ListContentStandardsResponse, GetContentStandardsResponse, GetContentStandardsRequest, GetSignalsResponse, GetCreativeDeliveryResponse, GetCreativeFeaturesResponse, CreativeFeatureResult, SIGetOfferingRequest, SIGetOfferingResponse } from '../types/tools.generated';
+import type { GetBrandIdentityRequest, GetBrandIdentityResponse, GetBrandIdentitySuccess, GetRightsResponse, GetRightsSuccess } from '../types/core.generated';
+/**
+ * Seeded signal entry — the inline element type of `GetSignalsResponse.signals`.
+ * Derived via lookup so it stays in lockstep with the generated wire schema.
+ * Dedup key: `signal_id`.
  */
-import type { Product, GetProductsResponse } from '../types/tools.generated';
+export type SeededSignal = GetSignalsResponse['signals'][number];
+/**
+ * Seeded creative-delivery entry — the inline element type of
+ * `GetCreativeDeliveryResponse.creatives`. Derived via lookup so it stays in
+ * lockstep with the generated wire schema. Dedup key: `creative_id`.
+ */
+export type SeededCreativeDelivery = GetCreativeDeliveryResponse['creatives'][number];
+/**
+ * Seeded creative-feature result — alias for the per-feature evaluation entry.
+ * `get_creative_features` returns a `results: CreativeFeatureResult[]` array
+ * on the success arm; the bridge seeds at the feature granularity (not the
+ * whole envelope) so adopters can override specific feature scores while the
+ * handler computes everything else. Dedup key: `feature_id`.
+ */
+export type SeededCreativeFeature = CreativeFeatureResult;
+/**
+ * Seeded creative entry — the inline element type of `ListCreativesResponse.creatives`.
+ * Derived via lookup so it stays in lockstep with the generated wire schema.
+ */
+export type SeededCreative = ListCreativesResponse['creatives'][number];
+/**
+ * Seeded media-buy entry — the inline element type of `GetMediaBuysResponse.media_buys`.
+ * Derived via lookup so it stays in lockstep with the generated wire schema.
+ */
+export type SeededMediaBuy = GetMediaBuysResponse['media_buys'][number];
+/**
+ * Seeded account-financials entry. The `get_account_financials` response is a
+ * singleton (one account, one envelope), so the bridge callback returns an
+ * array keyed by `account.account_id` and the framework picks the entry
+ * matching the request's `account` reference — replacing the handler response
+ * for that account when matched. Storyboards seeding financials for an account
+ * under test see their fixture; un-seeded accounts pass through to the handler.
+ */
+export type SeededAccountFinancials = GetAccountFinancialsSuccess;
+/**
+ * Seeded media-buy-delivery entry — the inline element type of
+ * `GetMediaBuyDeliveryResponse.media_buy_deliveries`. Derived via lookup so it
+ * stays in lockstep with the generated wire schema.
+ */
+export type SeededMediaBuyDelivery = GetMediaBuyDeliveryResponse['media_buy_deliveries'][number];
+/**
+ * Seeded brand-identity record. The `get_brand_identity` response is a
+ * singleton keyed by `brand_id` (request requires `brand_id`); the bridge
+ * picks the seeded fixture matching `request.brand_id` and replaces the
+ * handler response body, preserving framework-managed `context` / `ext`.
+ */
+export type SeededBrandIdentity = GetBrandIdentitySuccess;
+/**
+ * Seeded rights entry — the inline element type of `GetRightsSuccess.rights`.
+ * `get_rights` is a discovery / search tool (natural-language `query`), so the
+ * response carries an array; the bridge appends seeded entries with dedup by
+ * `rights_id`.
+ */
+export type SeededRight = GetRightsSuccess['rights'][number];
+/**
+ * Seeded SI offering record. The `si_get_offering` response is a singleton
+ * keyed by `offering_id` (request requires `offering_id`). Although the
+ * sponsored-intelligence flow has session-keyed state in subsequent tools
+ * (`si_initiate_session` issues a session, `si_send_message` advances it),
+ * `si_get_offering` itself is a stateless catalog lookup — the response's
+ * `offering_token` SEEDS a future session but the lookup does not consume
+ * one. That's why the singleton-replace pattern fits cleanly here while
+ * the session-stateful SI tools are intentionally out of scope.
+ */
+export type SeededSiOffering = SIGetOfferingResponse;
+/**
+ * The shape of `GetMediaBuyDeliveryResponse.aggregated_totals` (optional on the
+ * wire — recomputed by the bridge from the merged delivery array per the
+ * documented policy).
+ */
+type AggregatedTotals = NonNullable<GetMediaBuyDeliveryResponse['aggregated_totals']>;
 /**
  * Context passed to {@link TestControllerBridge.getSeededProducts}.
  *
@@ -38,6 +154,16 @@ export interface TestControllerBridgeContext<TAccount = unknown> {
  * Set on `AdcpServerConfig.testController`; when absent, behavior is
  * unchanged. The bridge is opt-in via the presence of `getSeededProducts`
  * — omit it to hold seeded state without changing response shape.
+ *
+ * **Construction-time misconfiguration warn.** `createAdcpServer` emits a
+ * one-shot `logger.warn` at construction when this bridge is registered
+ * without either `resolveAccount` or `resolveAccountFromAuth` configured —
+ * the dispatch-time sandbox gate's account-side check has no teeth in that
+ * setup, so caller-supplied `account.sandbox` becomes the only line of
+ * defense against fixture leakage. Storyboard runners without account
+ * scoping can ignore the warning; production bindings should wire a
+ * resolver. See `AdcpServerConfig.testController` JSDoc § "Security —
+ * trust boundary" and `adcp-client#1784`.
  */
 export interface TestControllerBridge<TAccount = unknown> {
     /**
@@ -54,6 +180,220 @@ export interface TestControllerBridge<TAccount = unknown> {
      * bridge when it has a resolved non-sandbox account, belt-and-suspenders).
      */
     getSeededProducts?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<Product[]> | Product[];
+    /**
+     * Retrieve seeded creatives for the current request. Returned entries are
+     * appended to the handler's `list_creatives` response (`creatives` array);
+     * on `creative_id` collision the seeded entry wins. Empty array (or
+     * `undefined`) when nothing is seeded. Same sandbox gating contract as
+     * {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededCreatives?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededCreative[]> | SeededCreative[];
+    /**
+     * Retrieve seeded media buys for the current request. Returned entries are
+     * appended to the handler's `get_media_buys` response (`media_buys` array);
+     * on `media_buy_id` collision the seeded entry wins. Same sandbox gating
+     * contract as {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededMediaBuys?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededMediaBuy[]> | SeededMediaBuy[];
+    /**
+     * Retrieve seeded media-buy delivery snapshots. Returned entries are merged
+     * into the handler's `get_media_buy_delivery` response (`media_buy_deliveries`
+     * array); on `media_buy_id` collision the seeded entry wins, matching the
+     * precedent set by `mergeSeededMediaBuys` / `mergeSeededCreatives` /
+     * `mergeSeededAccounts` — storyboards seed deliberately, so a seeded fixture
+     * for an existing `media_buy_id` is an explicit author override.
+     *
+     * After the merge, the response's `aggregated_totals` block is recomputed
+     * from the merged per-delivery `totals` so `media_buy_count` /
+     * `impressions` / `spend` stay wire-correct. See
+     * {@link recomputeAggregatedTotals} for the recomputation policy. Same
+     * sandbox gating contract as {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededMediaBuyDelivery?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededMediaBuyDelivery[]> | SeededMediaBuyDelivery[];
+    /**
+     * Retrieve seeded accounts for the current request. Returned entries are
+     * appended to the handler's `list_accounts` response (`accounts` array);
+     * on `account_id` collision the seeded entry wins. Same sandbox gating
+     * contract as {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededAccounts?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<Account[]> | Account[];
+    /**
+     * Retrieve seeded account-financials records. Unlike the other seeded
+     * collections, `get_account_financials` returns a singleton response —
+     * one account, one envelope. The bridge callback returns an array of
+     * seeded records keyed by `account.account_id`; the framework picks the
+     * entry whose `account_id` matches the resolved request account and
+     * replaces the handler response's financials payload with that fixture.
+     * Framework-managed `context` and `ext` from the handler response are
+     * PRESERVED across the replace — the seeded fixture is authoritative on
+     * the financials body (spend / period / account / currency / ...) but not
+     * on the response envelope (the fixture can't know the current request's
+     * `request_id` / `adcp_version` echo).
+     *
+     * When no seeded entry matches, the handler response passes through
+     * unchanged. Duplicate seeded entries with the same `account.account_id`
+     * are warn-and-dropped during validation (first occurrence wins).
+     *
+     * Same sandbox gating contract as {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededAccountFinancials?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededAccountFinancials[]> | SeededAccountFinancials[];
+    /**
+     * Retrieve seeded creative formats. Returned entries are appended to the
+     * handler's `list_creative_formats` response (`formats` array); on
+     * collision (matched by canonical `format_id.agent_url` + `format_id.id`)
+     * the seeded entry wins. Same sandbox gating contract as
+     * {@link TestControllerBridge.getSeededProducts}.
+     *
+     * Composes with `SalesPlatform.listCreativeFormats` /
+     * `CreativeBuilderPlatform.listCreativeFormats` — the adapter handler
+     * runs first, then this bridge supplements. Not a replacement for those
+     * handler-side hooks; storyboards use this seam to inject test-only
+     * formats without rewriting the adapter.
+     */
+    getSeededCreativeFormats?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<Format[]> | Format[];
+    /**
+     * Retrieve seeded property lists. The same callback feeds both
+     * `list_property_lists` (append-merge into `lists: PropertyList[]`, dedup
+     * by `list_id` with seeded winning on collision) and `get_property_list`
+     * (singleton — pick the entry whose `list_id` matches the request's
+     * `list_id` and REPLACE the handler response's `list` field; the handler's
+     * auxiliary fields — `identifiers`, `pagination`, `resolved_at`,
+     * `cache_valid_until`, `coverage_gaps`, `context`, `ext` — pass through
+     * verbatim because they depend on request-time pagination / resolve
+     * params that a static fixture can't know).
+     *
+     * Unblocks the `property-lists` and `governance-aware-seller` storyboards
+     * (property catalog seeding) on platform-proxy sellers whose state of
+     * record is upstream. Same sandbox gating contract as
+     * {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededPropertyLists?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<PropertyList[]> | PropertyList[];
+    /**
+     * Retrieve seeded content-standards configurations. The same callback feeds
+     * both `list_content_standards` (success arm `standards: ContentStandards[]`,
+     * append-merge with seeded winning on `standards_id` collision) and
+     * `get_content_standards` (singleton — pick by `standards_id` and replace
+     * the `ContentStandards` body). Seeded fixture is authoritative on the
+     * `ContentStandards` body. Framework-managed envelope fields (`context`,
+     * `ext`) round-trip from the handler — matches the precedent set by
+     * {@link replaceAccountFinancialsIfSeeded}.
+     *
+     * Unblocks the `content-standards` storyboard. Same sandbox gating contract
+     * as {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededContentStandards?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<ContentStandards[]> | ContentStandards[];
+    /**
+     * Retrieve seeded collection lists. The same callback feeds both
+     * `list_collection_lists` (append-merge into `lists: CollectionList[]`,
+     * dedup by `list_id` with seeded winning on collision) and
+     * `get_collection_list` (singleton — pick by `list_id` and replace the
+     * `list` field; the handler's `collections`, `pagination`, `resolved_at`,
+     * `cache_valid_until`, `coverage_gaps`, `context`, `ext` pass through
+     * verbatim).
+     *
+     * Unblocks the `collection-lists` storyboard (program-level brand safety
+     * via IMDb/Gracenote/EIDR IDs). Same sandbox gating contract as
+     * {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededCollectionLists?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<CollectionList[]> | CollectionList[];
+    /**
+     * Retrieve seeded signals for the current request. Returned entries are
+     * appended to the handler's `get_signals` response (`signals` array); on
+     * `signal_id` collision the seeded entry wins. The signal_id-keyed dedup
+     * works uniformly across `signal-marketplace` and `signal-owned`
+     * specialisms — both use the same response envelope; the discriminator
+     * lives on each entry's `signal_type` field.
+     *
+     * `get_signals` does not carry a `query_summary` block (per AdCP 3.0.11).
+     * Pagination is not recomputed on the merge. `PaginationResponse.total_count`
+     * is optional; recomputing it on partial pages would mis-represent the
+     * cross-page total (the handler may have served page 1 of N, and the seeded
+     * fixture sits outside that pagination context). Storyboards asserting on
+     * totals should seed the handler's response, not the post-merge envelope.
+     * Same sandbox gating contract as
+     * {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededSignals?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededSignal[]> | SeededSignal[];
+    /**
+     * Retrieve seeded creative-delivery entries for `get_creative_delivery`.
+     * Returned entries are appended to the handler response's `creatives` array;
+     * on `creative_id` collision the seeded entry wins (storyboards seed
+     * deliberately — a seeded fixture for an existing creative_id is an explicit
+     * author override, matching the precedent set by other list-shaped bridges).
+     *
+     * After the merge, `pagination.total` (when set by the handler) is updated
+     * by the count of new non-colliding seeded entries. `get_creative_delivery`
+     * does not carry a `query_summary` block, and there is no top-level
+     * aggregated-totals envelope (unlike `get_media_buy_delivery`), so no other
+     * recomputation is performed.
+     *
+     * Unblocks the `creative-template` / `creative-generative` /
+     * `creative-ad-server` delivery-readback storyboards. Same sandbox gating
+     * contract as {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededCreativeDelivery?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededCreativeDelivery[]> | SeededCreativeDelivery[];
+    /**
+     * Retrieve seeded creative-feature results for `get_creative_features`.
+     * `get_creative_features` returns a `oneOf` envelope — the success arm
+     * carries `results: CreativeFeatureResult[]` (one entry per evaluated
+     * feature). The bridge seeds at the per-feature granularity: returned
+     * entries are merged into the success arm's `results` array, dedup by
+     * `feature_id`, seeded wins on collision. Adopters can override specific
+     * feature scores (e.g., brand-safety policy outcomes) without rewriting
+     * the entire evaluation handler.
+     *
+     * When the handler returned the error arm (`errors[]`), the bridge is a
+     * no-op — error envelopes pass through unchanged. When the handler
+     * returned the success arm, framework-managed `context` / `ext` round-trip
+     * from the handler verbatim. Same sandbox gating contract as
+     * {@link TestControllerBridge.getSeededProducts}.
+     */
+    getSeededCreativeFeatures?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededCreativeFeature[]> | SeededCreativeFeature[];
+    /**
+     * Retrieve seeded brand-identity records. `get_brand_identity` returns a
+     * singleton response keyed by `brand_id` (request requires `brand_id`).
+     * The callback returns an array of seeded fixtures keyed by their own
+     * `brand_id`; the framework picks the entry matching the request and
+     * REPLACES the handler response body with that fixture. Framework-managed
+     * envelope fields (`context`, `ext`) round-trip from the handler — matches
+     * the precedent set by {@link replaceContentStandardsIfSeeded} and
+     * {@link replaceAccountFinancialsIfSeeded}.
+     *
+     * When no seeded entry matches, the handler response passes through. Same
+     * sandbox gating contract as {@link TestControllerBridge.getSeededProducts}.
+     * Unblocks the `brand-rights` storyboard identity-discovery phase.
+     */
+    getSeededBrandIdentity?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededBrandIdentity[]> | SeededBrandIdentity[];
+    /**
+     * Retrieve seeded rights entries. `get_rights` is a discovery / search tool
+     * (natural-language `query`); the response carries an array of matching
+     * rights, so the bridge follows the array-collection pattern. Returned
+     * entries are appended to the handler's `rights` array (success arm) with
+     * dedup by `rights_id` — on collision the seeded entry wins, matching the
+     * precedent set by `getSeededProducts` (storyboards seed deliberately).
+     *
+     * Same sandbox gating contract as {@link TestControllerBridge.getSeededProducts}.
+     * Unblocks the `brand-rights` storyboard rights-discovery phase.
+     */
+    getSeededRights?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededRight[]> | SeededRight[];
+    /**
+     * Retrieve seeded SI offering records. `si_get_offering` returns a singleton
+     * response keyed by `offering_id` (request requires `offering_id`). The
+     * callback returns an array of seeded fixtures, each carrying an
+     * `offering.offering_id`; the framework picks the entry matching the
+     * request and REPLACES the handler response with that fixture. Handler's
+     * `context` and `ext` round-trip.
+     *
+     * Stateless lookup: although the broader sponsored-intelligence flow has
+     * session-keyed state in `si_initiate_session` / `si_send_message`, the
+     * `si_get_offering` response only PRODUCES an `offering_token` for a
+     * future session — it does not consume one. The singleton-replace pattern
+     * fits here; the session-stateful tools are out of scope by design.
+     *
+     * Same sandbox gating contract as {@link TestControllerBridge.getSeededProducts}.
+     * Unblocks the `sponsored-intelligence` storyboard offering-lookup phase.
+     */
+    getSeededSiOffering?: (ctx: TestControllerBridgeContext<TAccount>) => Promise<SeededSiOffering[]> | SeededSiOffering[];
 }
 /**
  * Sandbox-request predicate. Reads the spec's two canonical sandbox markers:
@@ -81,6 +421,23 @@ export declare function isSandboxRequest(input: Record<string, unknown>): boolea
  * handler explicitly declared `sandbox: false` (which stays authoritative
  * — a handler that has already decided the request is non-sandbox
  * shouldn't be overridden by the bridge).
+ *
+ * **Submitted-arm short-circuit.** `get_products` formally permits an
+ * async Submitted arm per `schemas/cache/3.0.11/media-buy/get-products-async-response-submitted.json`
+ * (queued custom/bespoke curation). The dispatcher routes
+ * `{ status: 'submitted', task_id }` handler returns through
+ * `wrapSubmittedEnvelope`, but the bridge merge then receives the
+ * unwrapped Submitted body from `formatted.structuredContent`. Without
+ * this guard, the merge would spread `products: [...]` into that body
+ * and produce a `{ status: 'submitted', task_id, products: [...], sandbox: true }`
+ * hybrid that violates the wire schema. Detect the Submitted shape and
+ * return the handler response reference-equal so the dispatcher's
+ * skip-on-reference-equality wrap-avoidance kicks in.
+ *
+ * None of the other 12 bridged read tools have a formal Submitted arm
+ * in 3.0.11 per `schemas/cache/3.0.11/core/async-response-data.json`;
+ * this guard is `get_products`-specific defense rather than a uniform
+ * pattern across helpers.
  */
 export declare function mergeSeededProductsIntoResponse(response: GetProductsResponse, seeded: readonly Product[]): GetProductsResponse;
 /**
@@ -96,6 +453,427 @@ export declare function mergeSeededProductsIntoResponse(response: GetProductsRes
 export declare function filterValidSeededProducts(raw: unknown, logger?: {
     warn: (message: string, meta?: Record<string, unknown>) => void;
 }): Product[];
+/**
+ * Validate seeded creatives. Drops entries that are not plain objects or are
+ * missing a non-empty string `creative_id` — matches the products contract
+ * (a missing identifier collides on `undefined === undefined` when deduping).
+ */
+export declare function filterValidSeededCreatives(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededCreative[];
+/**
+ * Validate seeded media buys. Drops entries missing a non-empty string
+ * `media_buy_id`.
+ */
+export declare function filterValidSeededMediaBuys(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededMediaBuy[];
+/**
+ * Validate seeded media-buy-delivery snapshots. Drops entries missing a
+ * non-empty string `media_buy_id` — the dedup key against the handler set.
+ */
+export declare function filterValidSeededMediaBuyDeliveries(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededMediaBuyDelivery[];
+/**
+ * Validate seeded accounts. Drops entries missing a non-empty string `account_id`.
+ */
+export declare function filterValidSeededAccounts(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): Account[];
+/**
+ * Validate seeded account-financials records. Drops entries whose `account`
+ * field is not a `{ account_id: string }`-shaped object (`AccountReference`
+ * carries `account_id` on the operator-resolved variant; the bridge keys on
+ * that field to match against the request's account).
+ *
+ * Also drops duplicate entries by `account.account_id` (first occurrence
+ * wins, matching the array-collection helpers' on-collision-seeded-wins
+ * contract — the "first" seeded entry in iteration order is authoritative).
+ * A fixture array with two entries for the same `account_id` is almost
+ * always a seed-store bug; warn-and-drop surfaces it instead of silently
+ * picking whichever happened to come first in iteration order.
+ */
+export declare function filterValidSeededAccountFinancials(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededAccountFinancials[];
+/**
+ * Validate seeded creative formats. Drops entries whose `format_id` is not a
+ * `{ agent_url: string, id: string }`-shaped object — both fields are
+ * required to dedupe (and to canonicalize per the URL canonicalization rules
+ * in the AdCP spec).
+ */
+export declare function filterValidSeededCreativeFormats(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): Format[];
+/**
+ * Merge seeded creatives into a `list_creatives` response. Existing creatives
+ * come first; seeded entries append after deduping by `creative_id`. On
+ * collision the seeded entry wins. Stamps `sandbox: true` unless the handler
+ * explicitly declared `sandbox: false`. Returns a NEW response object.
+ *
+ * Also updates `query_summary.returned` to match the final array length and
+ * `query_summary.total_matching` to `handler.total_matching + (seeded entries
+ * that did NOT collide with the handler set)`. Storyboards that assert on
+ * counts see the merged totals, not the handler's pre-merge counts. Mirror
+ * field on `pagination.total_count` is updated by the same delta when the
+ * handler set it.
+ */
+export declare function mergeSeededCreativesIntoResponse(response: ListCreativesResponse, seeded: readonly SeededCreative[]): ListCreativesResponse;
+/**
+ * Merge seeded media buys into a `get_media_buys` response. Existing media
+ * buys come first; seeded entries append after deduping by `media_buy_id`.
+ * On collision the seeded entry wins. Returns a NEW response object.
+ *
+ * `get_media_buys` does NOT carry a `query_summary` block (per AdCP 3.0.11);
+ * it exposes its count via `pagination.total_count` (optional). When the
+ * handler set `pagination.total_count`, it's incremented by the count of
+ * new (non-colliding) seeded entries so the merged response stays
+ * internally consistent. Handlers that left `total_count` off pass through
+ * unchanged.
+ */
+export declare function mergeSeededMediaBuysIntoResponse(response: GetMediaBuysResponse, seeded: readonly SeededMediaBuy[]): GetMediaBuysResponse;
+/**
+ * Recompute `aggregated_totals` from a merged `media_buy_deliveries` array.
+ *
+ * The wire schema makes `aggregated_totals.impressions` / `spend` /
+ * `media_buy_count` REQUIRED, so once the bridge changes the delivery list it
+ * MUST rewrite the totals — otherwise `media_buy_count` is stale and the
+ * impressions/spend sums no longer reflect the merged set.
+ *
+ * Policy (see VALIDATE-YOUR-AGENT.md "Platform-proxy sellers"):
+ *   - Sum-derived (required): `impressions`, `spend`, `media_buy_count`.
+ *   - Sum-derived (optional): `clicks`, `completed_views`, `views`,
+ *     `conversions`, `conversion_value` — recomputed ONLY when EVERY merged
+ *     delivery populates the field on its `totals`. Otherwise fall back to
+ *     the handler's value (or omit if the handler omitted).
+ *   - Derived ratios: `roas` (`conversion_value / spend`),
+ *     `completion_rate` (`completed_views / impressions`),
+ *     `cost_per_acquisition` (`spend / conversions`). Recomputed ONLY when
+ *     both input fields recomputed AND the divisor is non-zero. Otherwise
+ *     fall back to the handler's value (or omit).
+ *   - Pass-through (not derivable from per-delivery `totals`): `reach`,
+ *     `reach_unit`, `frequency`, `new_to_brand_rate`. The handler's values
+ *     survive verbatim.
+ *
+ * Empty merged array → `{ impressions: 0, spend: 0, media_buy_count: 0 }` +
+ * any pass-through the handler set. Divide-by-zero guards keep ratios omitted
+ * rather than producing `Infinity` / `NaN` values that would fail validation.
+ *
+ * Pure helper — testable in isolation, no I/O.
+ */
+export declare function recomputeAggregatedTotals(deliveries: readonly SeededMediaBuyDelivery[], handlerAggregated: AggregatedTotals | undefined): AggregatedTotals;
+/**
+ * Merge seeded media-buy-delivery entries into a `get_media_buy_delivery`
+ * response. Existing handler entries come first; seeded entries append after
+ * deduping by `media_buy_id`. On collision the SEEDED entry wins, matching the
+ * precedent set by `mergeSeededMediaBuys` / `mergeSeededCreatives` /
+ * `mergeSeededAccounts` — storyboards seed deliberately, so a seeded fixture
+ * for an existing `media_buy_id` is an explicit author override.
+ *
+ * After merging, `aggregated_totals` is recomputed via
+ * {@link recomputeAggregatedTotals} so `media_buy_count` / `impressions` /
+ * `spend` reflect the merged set instead of the handler's pre-merge values.
+ *
+ * Returns a NEW response object — the handler's singleton envelope fields
+ * (`reporting_period`, `currency`, `attribution_window`, `errors`, `sandbox`,
+ * `context`, `ext`, plus webhook-only `notification_type` / `partial_data` /
+ * `sequence_number` / etc.) pass through verbatim. Stamps `sandbox: true`
+ * unless the handler explicitly declared `sandbox: false`.
+ */
+export declare function mergeSeededMediaBuyDeliveryIntoResponse(response: GetMediaBuyDeliveryResponse, seeded: readonly SeededMediaBuyDelivery[]): GetMediaBuyDeliveryResponse;
+/**
+ * Merge seeded accounts into a `list_accounts` response. Existing accounts
+ * come first; seeded entries append after deduping by `account_id`. On
+ * collision the seeded entry wins. Returns a NEW response object.
+ *
+ * `list_accounts` exposes its count via `pagination.total_count` (optional,
+ * same as `get_media_buys`). When the handler set it, it's incremented by
+ * the count of new (non-colliding) seeded entries.
+ */
+export declare function mergeSeededAccountsIntoResponse(response: ListAccountsResponse, seeded: readonly Account[]): ListAccountsResponse;
+/**
+ * Pick a seeded `get_account_financials` fixture matching the request's
+ * account. Unlike the array-collection helpers, this returns the SINGLE
+ * matched envelope or `undefined` — `get_account_financials` is a singleton
+ * response and "merge" reduces to "replace if the request's account matches
+ * a seeded fixture".
+ *
+ * Matching honors both the raw request and the resolved account from
+ * `resolveAccount`. `AccountReference` is a discriminated union — the
+ * operator-resolved variant carries `account_id` on the request, but the
+ * brand+operator variants do not. When the framework has already resolved
+ * the request to an account, prefer that resolved id so seeded fixtures
+ * find their match regardless of which `AccountReference` variant the
+ * buyer sent.
+ *
+ * @param resolvedAccountId - The `account_id` from `ctx.account` after
+ *   `resolveAccount` ran. Pass `undefined` when no account was resolved
+ *   (singleton-tenant adopters) — the function falls back to the request's
+ *   `account.account_id` field, which preserves the original semantics for
+ *   adopters who don't wire `resolveAccount`.
+ */
+export declare function pickSeededAccountFinancialsForRequest(request: GetAccountFinancialsRequest | Record<string, unknown>, seeded: readonly SeededAccountFinancials[], resolvedAccountId?: string): SeededAccountFinancials | undefined;
+/**
+ * Replace a `get_account_financials` response when a seeded fixture matches
+ * the request's account. The seeded fixture is authoritative on the
+ * financials payload (spend, period, account, currency, ...). The handler's
+ * `context` and `ext` are framework-managed (`context` echoes
+ * `adcp_version` / `request_id`; `ext` carries adopter passthrough) and
+ * MUST be preserved across the replace — wire-correct context echo is the
+ * framework's responsibility, not the seed fixture's.
+ *
+ * When no fixture matches, returns the handler response unchanged.
+ *
+ * @param resolvedAccountId - Optional resolved `account_id` from
+ *   `ctx.account`; passed through to {@link pickSeededAccountFinancialsForRequest}.
+ */
+export declare function replaceAccountFinancialsIfSeeded(request: GetAccountFinancialsRequest | Record<string, unknown>, response: GetAccountFinancialsResponse, seeded: readonly SeededAccountFinancials[], resolvedAccountId?: string): GetAccountFinancialsResponse;
+/**
+ * Merge seeded creative formats into a `list_creative_formats` response.
+ * Existing formats come first; seeded entries append after deduping by
+ * canonical `${agent_url}|${id}`. On collision the seeded entry wins.
+ * Returns a NEW response object.
+ */
+export declare function mergeSeededCreativeFormatsIntoResponse(response: ListCreativeFormatsResponse, seeded: readonly Format[]): ListCreativeFormatsResponse;
+/**
+ * Validate seeded property-list entries. Drops entries missing a non-empty
+ * string `list_id`.
+ */
+export declare function filterValidSeededPropertyLists(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): PropertyList[];
+/**
+ * Validate seeded collection-list entries. Drops entries missing a non-empty
+ * string `list_id`.
+ */
+export declare function filterValidSeededCollectionLists(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): CollectionList[];
+/**
+ * Validate seeded content-standards entries. Drops entries missing a
+ * non-empty string `standards_id`.
+ */
+export declare function filterValidSeededContentStandards(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): ContentStandards[];
+/**
+ * Merge seeded property lists into a `list_property_lists` response.
+ * Existing entries come first; seeded entries append after deduping by
+ * `list_id`. On collision the seeded entry wins. Returns a NEW response
+ * object. When the handler set `pagination.total_count`, it's incremented
+ * by the count of new (non-colliding) seeded entries.
+ *
+ * `list_property_lists` does not carry a `query_summary` block (per AdCP
+ * 3.0.11) — pagination.total_count is the only count field to update.
+ */
+export declare function mergeSeededPropertyListsIntoResponse(response: ListPropertyListsResponse, seeded: readonly PropertyList[]): ListPropertyListsResponse;
+/**
+ * Merge seeded collection lists into a `list_collection_lists` response.
+ * Symmetric with {@link mergeSeededPropertyListsIntoResponse} — same dedup
+ * key (`list_id`), same pagination update policy.
+ */
+export declare function mergeSeededCollectionListsIntoResponse(response: ListCollectionListsResponse, seeded: readonly CollectionList[]): ListCollectionListsResponse;
+/**
+ * Merge seeded content-standards into a `list_content_standards` response
+ * (success arm). Drops to a no-op if the response is the error arm (no
+ * `standards` array). On `standards_id` collision the seeded entry wins.
+ * Updates `pagination.total_count` when the handler set it. Returns a NEW
+ * response object.
+ */
+export declare function mergeSeededContentStandardsIntoResponse(response: ListContentStandardsResponse, seeded: readonly ContentStandards[]): ListContentStandardsResponse;
+/**
+ * Pick the seeded property list whose `list_id` matches the request.
+ * Returns `undefined` when nothing matches.
+ */
+export declare function pickSeededPropertyListForRequest(request: GetPropertyListRequest | Record<string, unknown>, seeded: readonly PropertyList[]): PropertyList | undefined;
+/**
+ * Replace a `get_property_list` response's `list` field with a seeded fixture
+ * when one matches. The handler's auxiliary fields (`identifiers`,
+ * `pagination`, `resolved_at`, `cache_valid_until`, `coverage_gaps`,
+ * `context`, `ext`) pass through verbatim — those depend on request-time
+ * pagination / resolve params that a static fixture can't know. Only `list`
+ * is replaced. When no fixture matches, returns the handler response
+ * unchanged.
+ */
+export declare function replacePropertyListIfSeeded(request: GetPropertyListRequest | Record<string, unknown>, response: GetPropertyListResponse, seeded: readonly PropertyList[]): GetPropertyListResponse;
+/**
+ * Pick the seeded collection list whose `list_id` matches the request.
+ * Returns `undefined` when nothing matches.
+ */
+export declare function pickSeededCollectionListForRequest(request: GetCollectionListRequest | Record<string, unknown>, seeded: readonly CollectionList[]): CollectionList | undefined;
+/**
+ * Replace a `get_collection_list` response's `list` field with a seeded
+ * fixture when one matches. Same envelope-preservation policy as
+ * {@link replacePropertyListIfSeeded}.
+ */
+export declare function replaceCollectionListIfSeeded(request: GetCollectionListRequest | Record<string, unknown>, response: GetCollectionListResponse, seeded: readonly CollectionList[]): GetCollectionListResponse;
+/**
+ * Pick the seeded content-standards entry whose `standards_id` matches the
+ * request. Returns `undefined` when nothing matches.
+ */
+export declare function pickSeededContentStandardsForRequest(request: GetContentStandardsRequest | Record<string, unknown>, seeded: readonly ContentStandards[]): ContentStandards | undefined;
+/**
+ * Replace a `get_content_standards` response with a seeded fixture when one
+ * matches. Seeded fixture is authoritative on the `ContentStandards` body.
+ * Framework-managed envelope fields (`context`, `ext`) round-trip from the
+ * handler — matches the precedent set by {@link replaceAccountFinancialsIfSeeded}.
+ *
+ * When no fixture matches, returns the handler response unchanged. The
+ * caller is responsible for skipping the error arm (the dispatcher gates on
+ * `!isErrorResponse`).
+ */
+export declare function replaceContentStandardsIfSeeded(request: GetContentStandardsRequest | Record<string, unknown>, response: GetContentStandardsResponse, seeded: readonly ContentStandards[]): GetContentStandardsResponse;
+/**
+ * Validate seeded signals. Drops entries whose `signal_id` is not a valid
+ * `SignalID` discriminated-union shape (`{source:'catalog',
+ * data_provider_domain, id}` or `{source:'agent', agent_url, id}`). A missing
+ * or malformed `signal_id` collides on `undefined === undefined` when
+ * deduping, so we drop early.
+ */
+export declare function filterValidSeededSignals(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededSignal[];
+/**
+ * Validate seeded creative-delivery entries. Drops entries missing a non-empty
+ * string `creative_id`.
+ */
+export declare function filterValidSeededCreativeDelivery(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededCreativeDelivery[];
+/**
+ * Validate seeded creative-feature results. Drops entries missing a non-empty
+ * string `feature_id` (the dedup key against the handler's `results` array).
+ */
+export declare function filterValidSeededCreativeFeatures(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededCreativeFeature[];
+/**
+ * Merge seeded signals into a `get_signals` response. Existing handler signals
+ * come first; seeded entries append after deduping by `signal_id`. On
+ * collision the seeded entry wins. Stamps `sandbox: true` unless the handler
+ * explicitly declared `sandbox: false`.
+ *
+ * `get_signals` carries `pagination: PaginationResponse` and no `query_summary`.
+ * Pagination is not recomputed on the merge. `PaginationResponse.total_count`
+ * is optional; recomputing it on partial pages would mis-represent the
+ * cross-page total (the handler may have served page 1 of N, and the seeded
+ * fixture sits outside that pagination context). Storyboards asserting on
+ * totals should seed the handler's response, not the post-merge envelope.
+ */
+export declare function mergeSeededSignalsIntoResponse(response: GetSignalsResponse, seeded: readonly SeededSignal[]): GetSignalsResponse;
+/**
+ * Merge seeded creative-delivery entries into a `get_creative_delivery`
+ * response. Existing handler creatives come first; seeded entries append after
+ * deduping by `creative_id`. On collision the seeded entry wins (matches the
+ * precedent set by `mergeSeededMediaBuyDelivery` — storyboards seed
+ * deliberately, so a seeded fixture for an existing id is an explicit author
+ * override).
+ *
+ * `pagination.total` (optional per the AdCP 3.0.11 schema) is incremented by
+ * the count of new non-colliding seeded entries. There is no top-level
+ * aggregated-totals envelope on this response (unlike `get_media_buy_delivery`),
+ * so no further recomputation is performed. Stamps `sandbox: true` unless the
+ * handler explicitly declared `sandbox: false`. Returns a NEW response object.
+ */
+export declare function mergeSeededCreativeDeliveryIntoResponse(response: GetCreativeDeliveryResponse, seeded: readonly SeededCreativeDelivery[]): GetCreativeDeliveryResponse;
+/**
+ * Merge seeded creative-feature results into a `get_creative_features`
+ * response. The response is a `oneOf` envelope — success arm carries
+ * `results: CreativeFeatureResult[]`, error arm carries `errors: Error[]`.
+ * When the handler returned the error arm, this helper is a no-op; the error
+ * envelope passes through unchanged. When the handler returned the success
+ * arm, seeded results merge into the `results` array (dedup by `feature_id`,
+ * seeded wins on collision).
+ *
+ * Framework-managed envelope fields (`context`, `ext`, `detail_url`,
+ * `pricing_option_id`, `vendor_cost`, `currency`, `consumption`) round-trip
+ * from the handler verbatim — the bridge only augments the per-feature
+ * results array.
+ *
+ * Returns a NEW response object.
+ */
+export declare function mergeSeededCreativeFeaturesIntoResponse(response: GetCreativeFeaturesResponse, seeded: readonly SeededCreativeFeature[]): GetCreativeFeaturesResponse;
+/**
+ * Validate seeded brand-identity entries. Drops entries missing a non-empty
+ * string `brand_id`, and warn-drops duplicates (first occurrence wins) since
+ * a fixture array with two entries for the same `brand_id` is almost always
+ * a seed-store bug.
+ */
+export declare function filterValidSeededBrandIdentity(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededBrandIdentity[];
+/**
+ * Validate seeded rights entries. Drops entries missing a non-empty string
+ * `rights_id` (the dedup key against the handler set).
+ */
+export declare function filterValidSeededRights(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededRight[];
+/**
+ * Validate seeded SI offering entries. Each entry must carry a non-empty
+ * string at `offering.offering_id` — that's the field the bridge matches
+ * against `request.offering_id`. Warn-drops duplicates by that key.
+ *
+ * An entry without `offering` (e.g. an `available: false` fixture from a
+ * different storyboard) can't be matched by the bridge and is dropped — a
+ * seeded fixture that can't address a request would be a dead write.
+ */
+export declare function filterValidSeededSiOffering(raw: unknown, logger?: {
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+}): SeededSiOffering[];
+/**
+ * Merge seeded rights entries into a `get_rights` response (success arm).
+ * Existing entries come first; seeded entries append after deduping by
+ * `rights_id`. On collision the seeded entry wins. Returns a NEW response
+ * object. `get_rights` does not carry `pagination` / `query_summary` blocks
+ * per AdCP 3.0.11 — no count fields to update.
+ *
+ * Drops to a no-op if the response is the error arm (no `rights` array). The
+ * dispatcher gates on `!isErrorResponse` upstream; we re-narrow defensively.
+ */
+export declare function mergeSeededRightsIntoResponse(response: GetRightsResponse, seeded: readonly SeededRight[]): GetRightsResponse;
+/**
+ * Pick the seeded brand-identity entry whose `brand_id` matches the request.
+ * Returns `undefined` when nothing matches.
+ */
+export declare function pickSeededBrandIdentityForRequest(request: GetBrandIdentityRequest | Record<string, unknown>, seeded: readonly SeededBrandIdentity[]): SeededBrandIdentity | undefined;
+/**
+ * Replace a `get_brand_identity` response with a seeded fixture when one
+ * matches the request's `brand_id`. Seeded fixture is authoritative on the
+ * `GetBrandIdentitySuccess` body. Framework-managed envelope fields
+ * (`context`, `ext`) round-trip from the handler — matches the precedent set
+ * by {@link replaceContentStandardsIfSeeded}.
+ *
+ * When no fixture matches, returns the handler response unchanged. Caller
+ * is responsible for skipping the error arm (the dispatcher gates on
+ * `!isErrorResponse`).
+ */
+export declare function replaceBrandIdentityIfSeeded(request: GetBrandIdentityRequest | Record<string, unknown>, response: GetBrandIdentityResponse, seeded: readonly SeededBrandIdentity[]): GetBrandIdentityResponse;
+/**
+ * Pick the seeded SI offering entry whose `offering.offering_id` matches the
+ * request's `offering_id`. Returns `undefined` when nothing matches.
+ */
+export declare function pickSeededSiOfferingForRequest(request: SIGetOfferingRequest | Record<string, unknown>, seeded: readonly SeededSiOffering[]): SeededSiOffering | undefined;
+/**
+ * Replace an `si_get_offering` response with a seeded fixture when one
+ * matches the request's `offering_id`. Seeded fixture is authoritative on
+ * the offering body (`available`, `offering_token`, `offering`, ...);
+ * handler's `context` and `ext` round-trip — same envelope-preservation
+ * policy as {@link replaceBrandIdentityIfSeeded}.
+ *
+ * When no fixture matches, returns the handler response unchanged.
+ *
+ * Note: seeded fixture is authoritative on the entire offering body,
+ * including `offering_token`. The token is intentionally NOT preserved
+ * from the handler — storyboards seed `offering_token` to drive
+ * deterministic session continuation in downstream steps. When/if a
+ * stateful SI session bridge ships (phase 5+; see
+ * adcontextprotocol/adcp-client#1755), the storyboard contract becomes
+ * coupled: seeded `offering_token` here must match the seeded session's
+ * `offering_token`, or `si_initiate_session` will reject as stale-token.
+ */
+export declare function replaceSiOfferingIfSeeded(request: SIGetOfferingRequest | Record<string, unknown>, response: SIGetOfferingResponse, seeded: readonly SeededSiOffering[]): SIGetOfferingResponse;
 /**
  * Bridge the default test-controller store (a `Map<string, unknown>` that
  * holds seeded fixtures by `product_id`, populated by `seed_product` scenarios)
@@ -160,6 +938,111 @@ export interface BridgeFromSessionStoreOptions<TSession> {
      * / pricing / property fields the response schema requires.
      */
     productDefaults?: Partial<Product>;
+    /**
+     * Extract seeded creatives from a resolved session. The returned entries
+     * are passed through `filterValidSeededCreatives` and merged into
+     * `list_creatives` responses on sandbox requests. Each entry MUST carry a
+     * non-empty string `creative_id`. Return `null` / `undefined` when the
+     * session has no seeded creatives.
+     */
+    selectSeededCreatives?: (session: TSession) => Iterable<SeededCreative> | Promise<Iterable<SeededCreative> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded media buys from a resolved session. Each entry MUST carry
+     * a non-empty string `media_buy_id`.
+     */
+    selectSeededMediaBuys?: (session: TSession) => Iterable<SeededMediaBuy> | Promise<Iterable<SeededMediaBuy> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded media-buy-delivery snapshots from a resolved session. Each
+     * entry MUST carry a non-empty string `media_buy_id`. The framework appends
+     * non-colliding seeded entries to the handler's response and recomputes
+     * `aggregated_totals` from the merged set — see
+     * {@link TestControllerBridge.getSeededMediaBuyDelivery}.
+     */
+    selectSeededMediaBuyDelivery?: (session: TSession) => Iterable<SeededMediaBuyDelivery> | Promise<Iterable<SeededMediaBuyDelivery> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded accounts from a resolved session. Each entry MUST carry
+     * a non-empty string `account_id`.
+     */
+    selectSeededAccounts?: (session: TSession) => Iterable<Account> | Promise<Iterable<Account> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded account-financials envelopes from a resolved session.
+     * Each entry MUST carry `account.account_id`. The framework picks the
+     * fixture matching the request's `account` reference (singleton replace,
+     * not append — see {@link TestControllerBridge.getSeededAccountFinancials}).
+     */
+    selectSeededAccountFinancials?: (session: TSession) => Iterable<SeededAccountFinancials> | Promise<Iterable<SeededAccountFinancials> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded creative formats from a resolved session. Each entry MUST
+     * carry a `format_id.agent_url` + `format_id.id` (both non-empty strings).
+     */
+    selectSeededCreativeFormats?: (session: TSession) => Iterable<Format> | Promise<Iterable<Format> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded property lists from a resolved session. Each entry MUST
+     * carry a non-empty string `list_id`. Feeds both `list_property_lists`
+     * (append-merge into `lists`) and `get_property_list` (singleton replace
+     * of the `list` field; handler's `identifiers` / `pagination` / etc. pass
+     * through).
+     */
+    selectSeededPropertyLists?: (session: TSession) => Iterable<PropertyList> | Promise<Iterable<PropertyList> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded content-standards from a resolved session. Each entry MUST
+     * carry a non-empty string `standards_id`. Feeds `list_content_standards`
+     * (append-merge into `standards`) and `get_content_standards` (singleton
+     * replace of the whole response envelope, preserving handler `ext`).
+     */
+    selectSeededContentStandards?: (session: TSession) => Iterable<ContentStandards> | Promise<Iterable<ContentStandards> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded collection lists from a resolved session. Each entry MUST
+     * carry a non-empty string `list_id`. Feeds both `list_collection_lists`
+     * (append-merge into `lists`) and `get_collection_list` (singleton replace
+     * of the `list` field).
+     */
+    selectSeededCollectionLists?: (session: TSession) => Iterable<CollectionList> | Promise<Iterable<CollectionList> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded signals from a resolved session. Each entry MUST carry a
+     * non-empty string `signal_id`. Feeds `get_signals` (append-merge into
+     * `signals`, dedup by `signal_id`, seeded wins). Works uniformly across
+     * `signal-marketplace` and `signal-owned` specialisms.
+     */
+    selectSeededSignals?: (session: TSession) => Iterable<SeededSignal> | Promise<Iterable<SeededSignal> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded creative-delivery entries from a resolved session. Each
+     * entry MUST carry a non-empty string `creative_id`. Feeds
+     * `get_creative_delivery` (append-merge into `creatives`, dedup by
+     * `creative_id`, seeded wins; `pagination.total` updated when set).
+     */
+    selectSeededCreativeDelivery?: (session: TSession) => Iterable<SeededCreativeDelivery> | Promise<Iterable<SeededCreativeDelivery> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded creative-feature results from a resolved session. Each
+     * entry MUST carry a non-empty string `feature_id`. Feeds
+     * `get_creative_features` (merge into success-arm `results` by `feature_id`,
+     * seeded wins; no-op when the handler returned the error arm).
+     */
+    selectSeededCreativeFeatures?: (session: TSession) => Iterable<SeededCreativeFeature> | Promise<Iterable<SeededCreativeFeature> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded brand-identity records from a resolved session. Each entry
+     * MUST carry a non-empty string `brand_id`. Feeds `get_brand_identity` via
+     * singleton replace (pick by `request.brand_id` and replace the response
+     * body, preserving handler `context` / `ext`).
+     */
+    selectSeededBrandIdentity?: (session: TSession) => Iterable<SeededBrandIdentity> | Promise<Iterable<SeededBrandIdentity> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded rights entries from a resolved session. Each entry MUST
+     * carry a non-empty string `rights_id`. Feeds `get_rights` (append-merge
+     * into the `rights` array, seeded wins on `rights_id` collision).
+     */
+    selectSeededRights?: (session: TSession) => Iterable<SeededRight> | Promise<Iterable<SeededRight> | null | undefined> | null | undefined;
+    /**
+     * Extract seeded SI offering records from a resolved session. Each entry
+     * MUST carry a non-empty string at `offering.offering_id`. Feeds
+     * `si_get_offering` via singleton replace (pick by `request.offering_id`
+     * and replace the response body, preserving handler `context` / `ext`).
+     *
+     * Stateless lookup only — the session-keyed SI tools
+     * (`si_initiate_session`, `si_send_message`, `si_terminate_session`) are
+     * intentionally out of scope for the bridge.
+     */
+    selectSeededSiOffering?: (session: TSession) => Iterable<SeededSiOffering> | Promise<Iterable<SeededSiOffering> | null | undefined> | null | undefined;
 }
 /**
  * Session-scoped variant of {@link bridgeFromTestControllerStore}.
@@ -189,4 +1072,5 @@ export interface BridgeFromSessionStoreOptions<TSession> {
  * ```
  */
 export declare function bridgeFromSessionStore<TSession, TAccount = unknown>(opts: BridgeFromSessionStoreOptions<TSession>): TestControllerBridge<TAccount>;
+export {};
 //# sourceMappingURL=test-controller-bridge.d.ts.map