@adcp/sdk 13.0.0-rc.7 → 13.0.0-rc.8

package/dist/lib/testing/storyboard/seeding.d.mts

@@ -20,8 +20,9 @@
  * phases on any seed failure, emitting a cascade skip with reason
  * `controller_seeding_failed`.
  */
-import type { TestClient } from '../client.mjs';
-import type { Storyboard, StoryboardContext, StoryboardFixtures, StoryboardPhaseResult, StoryboardRunOptions } from './types.mjs';
+import { type TestClient } from '../client.mjs';
+import { FixtureBindingRegistry } from './fixture-resolution.mjs';
+import type { FixtureResolutionRecord, Storyboard, StoryboardContext, StoryboardFixtures, StoryboardPhaseResult, StoryboardRunOptions } from './types.mjs';
 /** Synthetic phase id used in `StoryboardResult.phases[]` for the seed pass. */
 export declare const CONTROLLER_SEEDING_PHASE_ID = "__controller_seeding__";
 /** Seed scenario names. Kept local — the server-side `SEED_SCENARIOS`
@@ -68,11 +69,17 @@ export interface ControllerSeedingResult {
      * a failed agent behavior.
      */
     seedUnsupported?: boolean;
+    /** At least one declared strategy ladder exhausted without a binding. */
+    fixtureUnsatisfied?: boolean;
+    /** Run-scoped bindings pinned for all subsequent storyboard phases. */
+    bindings?: FixtureBindingRegistry;
+    /** Machine-readable AdCP 3.2 resolution evidence. */
+    resolutionRecords?: FixtureResolutionRecord[];
 }
 /**
  * Fire every seed call for this storyboard. Returns `null` when seeding is
  * not applicable (opt-out, no declaration, empty fixtures) so the runner can
  * treat a no-op identically to a non-seeding storyboard.
  */
-export declare function runControllerSeeding(client: TestClient, storyboard: Storyboard, options: StoryboardRunOptions, context: StoryboardContext): Promise<ControllerSeedingResult | null>;
+export declare function runControllerSeeding(client: TestClient, storyboard: Storyboard, options: StoryboardRunOptions, context: StoryboardContext, discoveryClient?: TestClient): Promise<ControllerSeedingResult | null>;
 export {};

package/dist/lib/testing/storyboard/seeding.d.ts

@@ -20,8 +20,9 @@
  * phases on any seed failure, emitting a cascade skip with reason
  * `controller_seeding_failed`.
  */
-import type { TestClient } from '../client';
-import type { Storyboard, StoryboardContext, StoryboardFixtures, StoryboardPhaseResult, StoryboardRunOptions } from './types';
+import { type TestClient } from '../client';
+import { FixtureBindingRegistry } from './fixture-resolution';
+import type { FixtureResolutionRecord, Storyboard, StoryboardContext, StoryboardFixtures, StoryboardPhaseResult, StoryboardRunOptions } from './types';
 /** Synthetic phase id used in `StoryboardResult.phases[]` for the seed pass. */
 export declare const CONTROLLER_SEEDING_PHASE_ID = "__controller_seeding__";
 /** Seed scenario names. Kept local — the server-side `SEED_SCENARIOS`
@@ -68,12 +69,18 @@ export interface ControllerSeedingResult {
      * a failed agent behavior.
      */
     seedUnsupported?: boolean;
+    /** At least one declared strategy ladder exhausted without a binding. */
+    fixtureUnsatisfied?: boolean;
+    /** Run-scoped bindings pinned for all subsequent storyboard phases. */
+    bindings?: FixtureBindingRegistry;
+    /** Machine-readable AdCP 3.2 resolution evidence. */
+    resolutionRecords?: FixtureResolutionRecord[];
 }
 /**
  * Fire every seed call for this storyboard. Returns `null` when seeding is
  * not applicable (opt-out, no declaration, empty fixtures) so the runner can
  * treat a no-op identically to a non-seeding storyboard.
  */
-export declare function runControllerSeeding(client: TestClient, storyboard: Storyboard, options: StoryboardRunOptions, context: StoryboardContext): Promise<ControllerSeedingResult | null>;
+export declare function runControllerSeeding(client: TestClient, storyboard: Storyboard, options: StoryboardRunOptions, context: StoryboardContext, discoveryClient?: TestClient): Promise<ControllerSeedingResult | null>;
 export {};
 //# sourceMappingURL=seeding.d.ts.map

package/dist/lib/testing/storyboard/seeding.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"seeding.d.ts","sourceRoot":"","sources":["../../../../src/lib/testing/storyboard/seeding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,WAAW,CAAC;AAE5C,OAAO,KAAK,EACV,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EAErB,MAAM,SAAS,CAAC;AAEjB,gFAAgF;AAChF,eAAO,MAAM,2BAA2B,2BAA2B,CAAC;AAEpE;;yEAEyE;AACzE,KAAK,YAAY,GACb,cAAc,GACd,cAAc,GACd,qBAAqB,GACrB,sBAAsB,GACtB,eAAe,GACf,WAAW,GACX,gBAAgB,CAAC;AACrB,KAAK,sBAAsB,GAAG,kBAAkB,CAAC;AAEjD,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,YAAY,GAAG,sBAAsB,CAAC;IAChD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC;uDACmD;IACnD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AASH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GAAG,QAAQ,EAAE,CAmLnF;AASD,MAAM,WAAW,uBAAuB;IACtC,4EAA4E;IAC5E,KAAK,EAAE,qBAAqB,CAAC;IAC7B,4FAA4F;IAC5F,SAAS,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,iBAAiB,GACzB,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAiGzC"}
+{"version":3,"file":"seeding.d.ts","sourceRoot":"","sources":["../../../../src/lib/testing/storyboard/seeding.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAAwD,KAAK,UAAU,EAAE,MAAM,WAAW,CAAC;AAMlG,OAAO,EAGL,sBAAsB,EAGvB,MAAM,sBAAsB,CAAC;AAC9B,OAAO,KAAK,EAEV,uBAAuB,EACvB,UAAU,EACV,iBAAiB,EACjB,kBAAkB,EAClB,qBAAqB,EACrB,oBAAoB,EAErB,MAAM,SAAS,CAAC;AAEjB,gFAAgF;AAChF,eAAO,MAAM,2BAA2B,2BAA2B,CAAC;AAEpE;;yEAEyE;AACzE,KAAK,YAAY,GACb,cAAc,GACd,cAAc,GACd,qBAAqB,GACrB,sBAAsB,GACtB,eAAe,GACf,WAAW,GACX,gBAAgB,CAAC;AACrB,KAAK,sBAAsB,GAAG,kBAAkB,CAAC;AAEjD,UAAU,QAAQ;IAChB,OAAO,EAAE,MAAM,CAAC;IAChB,KAAK,EAAE,MAAM,CAAC;IACd,QAAQ,EAAE,YAAY,GAAG,sBAAsB,CAAC;IAChD,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAChC;uDACmD;IACnD,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B;AAED;;;;;;GAMG;AASH,wBAAgB,cAAc,CAAC,QAAQ,EAAE,kBAAkB,GAAG,SAAS,GAAG,QAAQ,EAAE,CAmLnF;AASD,MAAM,WAAW,uBAAuB;IACtC,4EAA4E;IAC5E,KAAK,EAAE,qBAAqB,CAAC;IAC7B,4FAA4F;IAC5F,SAAS,EAAE,OAAO,CAAC;IACnB,4DAA4D;IAC5D,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB;;;;;;OAMG;IACH,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B;;;;OAIG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,yEAAyE;IACzE,kBAAkB,CAAC,EAAE,OAAO,CAAC;IAC7B,uEAAuE;IACvE,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAClC,qDAAqD;IACrD,iBAAiB,CAAC,EAAE,uBAAuB,EAAE,CAAC;CAC/C;AAED;;;;GAIG;AACH,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,UAAU,EAClB,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,iBAAiB,EAC1B,eAAe,GAAE,UAAmB,GACnC,OAAO,CAAC,uBAAuB,GAAG,IAAI,CAAC,CAyGzC"}

package/dist/lib/testing/storyboard/seeding.js

@@ -23,7 +23,13 @@ __export(seeding_exports, {
   runControllerSeeding: () => runControllerSeeding
 });
 module.exports = __toCommonJS(seeding_exports);
+var import_client = require('../client.js');
+var import_schema_loader = require('../../validation/schema-loader.js');
+var import_version = require('../../version.js');
+var import_envelope_status_compat = require('../../utils/envelope-status-compat.js');
 var import_test_controller = require('../test-controller.js');
+var import_task_map = require('./task-map.js');
+var import_fixture_resolution = require('./fixture-resolution.js');
 const CONTROLLER_SEEDING_PHASE_ID = "__controller_seeding__";
 function buildSeedCalls(fixtures) {
   if (!fixtures) return [];
@@ -199,11 +205,16 @@ function seedFixtureFromFields(fields) {
   }
   return fields;
 }
-async function runControllerSeeding(client, storyboard, options, context) {
+async function runControllerSeeding(client, storyboard, options, context, discoveryClient = client) {
   if (options.skip_controller_seeding === true) return null;
-  if (storyboard.prerequisites?.controller_seeding !== true) return null;
   const calls = buildSeedCalls(storyboard.fixtures);
   if (calls.length === 0) return null;
+  if (storyboard.fixture_resolution !== void 0) {
+    const resolutionCalls = storyboard.prerequisites?.controller_seeding === true ? calls : calls.filter((call) => call.scenario === "seed_product" || call.scenario === "seed_pricing_option");
+    if (resolutionCalls.length === 0) return null;
+    return runDeclaredFixtureResolution(client, discoveryClient, storyboard, options, context, resolutionCalls);
+  }
+  if (storyboard.prerequisites?.controller_seeding !== true) return null;
   if (options.agentTools && !options.agentTools.includes("comply_test_controller")) {
     return buildMissingControllerResult(storyboard, calls, context);
   }
@@ -284,6 +295,543 @@ async function runControllerSeeding(client, storyboard, options, context) {
     failedCount
   };
 }
+async function runDeclaredFixtureResolution(seedClient, discoveryClient, storyboard, options, context, calls) {
+  const start = Date.now();
+  const authoringErrorResult = buildAuthoringErrorResult(storyboard, calls, context, start);
+  if (authoringErrorResult) return authoringErrorResult;
+  const specs = (0, import_fixture_resolution.buildFixtureResolutionSpecs)(storyboard);
+  const specByKey = /* @__PURE__ */ new Map();
+  for (const spec of specs) {
+    specByKey.set(
+      spec.entityType === "product" ? `seed_product\0${spec.handle}` : `seed_pricing_option\0${spec.parentProductHandle}\0${spec.handle}`,
+      spec
+    );
+  }
+  const declaredCalls = /* @__PURE__ */ new Map();
+  for (const call of calls) {
+    const spec = resolutionSpecForCall(call, specByKey);
+    if (spec) declaredCalls.set(resolutionSpecKey(spec), call);
+  }
+  const orderedDeclaredCalls = specs.map((spec) => declaredCalls.get(resolutionSpecKey(spec))).filter((call) => call !== void 0);
+  let declaredCallIndex = 0;
+  const orderedCalls = calls.map(
+    (call) => resolutionSpecForCall(call, specByKey) ? orderedDeclaredCalls[declaredCallIndex++] : call
+  );
+  const bindings = new import_fixture_resolution.FixtureBindingRegistry();
+  const records = [];
+  const steps = [];
+  const claimedProducts = /* @__PURE__ */ new Map();
+  const claimedPricingOptions = /* @__PURE__ */ new Map();
+  const productStatuses = /* @__PURE__ */ new Map();
+  const seedContext = { correlation_id: `${storyboardCorrelationPrefix(storyboard)}--__seeding__` };
+  const controllerMissing = options.agentTools?.includes("comply_test_controller") === false;
+  let advertisedScenarios = controllerMissing ? /* @__PURE__ */ new Set() : controllerScenarioSetFromOptions(options);
+  let scenarioLookupAttempted = advertisedScenarios !== null;
+  const legacyCalls = calls.filter((call) => resolutionSpecForCall(call, specByKey) === void 0);
+  if (legacyCalls.length > 0) {
+    if (controllerMissing) return buildMissingControllerResult(storyboard, legacyCalls, context);
+    if (!advertisedScenarios) {
+      advertisedScenarios = await fetchControllerScenarioSet(seedClient, options, seedContext);
+      scenarioLookupAttempted = true;
+    }
+    if (advertisedScenarios) {
+      const unsupported = legacyCalls.find((call) => !call.authoring_error && !advertisedScenarios.has(call.scenario));
+      if (unsupported) {
+        return buildUnsupportedSeedResult(
+          storyboard,
+          legacyCalls,
+          context,
+          unsupported.scenario,
+          `list_scenarios did not advertise required seed scenario "${unsupported.scenario}".`
+        );
+      }
+    }
+  }
+  const needsSeedStrategy = orderedCalls.some((call) => {
+    const spec = resolutionSpecForCall(call, specByKey);
+    return !spec || spec.strategies.includes("seed");
+  });
+  if (needsSeedStrategy && !controllerMissing && !advertisedScenarios && !scenarioLookupAttempted) {
+    advertisedScenarios = await fetchControllerScenarioSet(seedClient, options, seedContext);
+  }
+  let catalogPromise;
+  const catalog = () => catalogPromise ??= discoverProductCatalog(discoveryClient, options, context);
+  let passedCount = 0;
+  let failedCount = 0;
+  let fixtureUnsatisfied = false;
+  for (const call of orderedCalls) {
+    const spec = resolutionSpecForCall(call, specByKey);
+    if (!spec) {
+      const legacy = await executeLegacySeedCall(seedClient, storyboard, call, options, context, seedContext);
+      if (legacy.step.skip_reason === "fixture_unsatisfied") {
+        return buildUnsupportedSeedResult(storyboard, legacyCalls, context, call.scenario, legacy.step.skip?.detail);
+      }
+      steps.push(legacy.step);
+      if (legacy.step.passed) passedCount++;
+      else failedCount++;
+      continue;
+    }
+    const attempts = [];
+    let boundIds;
+    let chosenStrategy;
+    let failure;
+    const stepStart = Date.now();
+    const parentStatus = spec.parentProductHandle ? productStatuses.get(spec.parentProductHandle) : void 0;
+    const parentUnavailable = spec.entityType === "product_pricing_option" && parentStatus !== "resolved";
+    if (parentUnavailable) {
+      const strategy = spec.strategies[0];
+      const detail = parentStatus === "failed" ? `parent product handle "${spec.parentProductHandle}" failed resolution` : `parent product handle "${spec.parentProductHandle}" is unavailable`;
+      attempts.push({ strategy, disposition: parentStatus === "failed" ? "failed" : "unavailable", detail });
+      if (parentStatus === "failed") failure = detail;
+    }
+    for (const strategy of parentUnavailable ? [] : spec.strategies) {
+      if (strategy === "seed") {
+        const advertised = advertisedScenarios?.has(call.scenario);
+        if (controllerMissing || advertised === false) {
+          attempts.push({
+            strategy,
+            disposition: "unavailable",
+            detail: controllerMissing ? "comply_test_controller is not advertised" : `list_scenarios did not advertise ${call.scenario}`
+          });
+          continue;
+        }
+        try {
+          const controllerRequest = (0, import_fixture_resolution.applyFixtureBindingsToRequest)(
+            { scenario: call.scenario, params: call.params },
+            "comply_test_controller",
+            bindings,
+            options.adcpVersion ?? import_version.ADCP_VERSION
+          );
+          const raw = await (0, import_test_controller.callControllerRaw)(
+            seedClient,
+            {
+              scenario: call.scenario,
+              params: isPlainRecord(controllerRequest.params) ? controllerRequest.params : call.params,
+              context: seedContext
+            },
+            options
+          );
+          const data = raw.data;
+          if (raw.success && data?.success === true) {
+            boundIds = bindSeededFixture(spec, bindings);
+            if (spec.entityType === "product") {
+              recordIdentityClaim(claimedProducts, boundIds.product_id, spec.allowReuse);
+            } else {
+              recordIdentityClaim(
+                claimedPricingOptions,
+                `${boundIds.product_id}\0${boundIds.pricing_option_id}`,
+                spec.allowReuse
+              );
+            }
+            chosenStrategy = strategy;
+            attempts.push({
+              strategy,
+              disposition: "resolved",
+              detail: `${call.scenario} accepted the authored literal id`
+            });
+            break;
+          }
+          if (raw.success && data?.success === false && data.error === "UNKNOWN_SCENARIO" && advertised !== true) {
+            attempts.push({
+              strategy,
+              disposition: "unavailable",
+              detail: data.error_detail ?? `${call.scenario} returned UNKNOWN_SCENARIO`
+            });
+            continue;
+          }
+          failure = formatControllerError(call.scenario, raw, data);
+          attempts.push({ strategy, disposition: "failed", detail: failure });
+          break;
+        } catch (err) {
+          failure = err instanceof Error ? err.message : String(err);
+          attempts.push({ strategy, disposition: "failed", detail: failure });
+          break;
+        }
+      }
+      if (strategy === "discover") {
+        if (options.agentTools && !options.agentTools.includes("get_products")) {
+          attempts.push({
+            strategy,
+            disposition: "unavailable",
+            detail: "agent did not advertise get_products"
+          });
+          continue;
+        }
+        const discovered = await catalog();
+        if (!discovered.ok) {
+          failure = discovered.error;
+          attempts.push({ strategy, disposition: "failed", detail: failure, response: discovered.evidence });
+          break;
+        }
+        const selected = selectDiscoveredFixture(
+          spec,
+          discovered.catalog.products,
+          bindings,
+          claimedProducts,
+          claimedPricingOptions
+        );
+        if (!selected.ok) {
+          if (selected.failed) {
+            failure = selected.detail;
+            attempts.push({
+              strategy,
+              disposition: "failed",
+              detail: selected.detail,
+              response: discovered.catalog.evidence
+            });
+            break;
+          }
+          attempts.push({
+            strategy,
+            disposition: "unavailable",
+            detail: selected.detail,
+            response: discovered.catalog.evidence
+          });
+          continue;
+        }
+        boundIds = selected.boundIds;
+        chosenStrategy = strategy;
+        attempts.push({
+          strategy,
+          disposition: "resolved",
+          detail: selected.detail,
+          response: { ...discovered.catalog.evidence, selected: selected.boundIds }
+        });
+        break;
+      }
+    }
+    const status = boundIds ? "resolved" : failure ? "failed" : "unsatisfied";
+    if (spec.entityType === "product") productStatuses.set(spec.handle, status);
+    const record = {
+      fixture_type: spec.entityType === "product" ? "product" : "pricing_option",
+      handle: spec.handle,
+      ...spec.parentProductHandle && { product_handle: spec.parentProductHandle },
+      requirements: spec.clauses,
+      strategies_attempted: attempts,
+      status,
+      ...chosenStrategy && { strategy: chosenStrategy },
+      ...boundIds && { seller_ids: boundIds }
+    };
+    records.push(record);
+    if (status !== "unsatisfied") {
+      steps.push({
+        storyboard_id: storyboard.id,
+        step_id: call.step_id,
+        phase_id: CONTROLLER_SEEDING_PHASE_ID,
+        title: call.title,
+        task: chosenStrategy === "discover" ? "get_products" : "comply_test_controller",
+        passed: status !== "failed",
+        duration_ms: Date.now() - stepStart,
+        validations: [],
+        context,
+        extraction: { path: "none" },
+        ...failure && { error: failure }
+      });
+    }
+    if (status === "failed") failedCount++;
+    else if (status === "unsatisfied") fixtureUnsatisfied = true;
+    else passedCount++;
+  }
+  const allPassed = failedCount === 0;
+  return {
+    phase: {
+      phase_id: CONTROLLER_SEEDING_PHASE_ID,
+      phase_title: "Fixture resolution (pre-flight)",
+      passed: allPassed,
+      steps,
+      duration_ms: Date.now() - start
+    },
+    allPassed,
+    passedCount,
+    failedCount,
+    fixtureUnsatisfied,
+    bindings,
+    resolutionRecords: records
+  };
+}
+function resolutionSpecKey(spec) {
+  return spec.entityType === "product" ? `seed_product\0${spec.handle}` : `seed_pricing_option\0${spec.parentProductHandle}\0${spec.handle}`;
+}
+function resolutionSpecForCall(call, specs) {
+  if (call.scenario === "seed_product") {
+    return specs.get(`seed_product\0${String(call.params.product_id ?? "")}`);
+  }
+  if (call.scenario === "seed_pricing_option") {
+    return specs.get(
+      `seed_pricing_option\0${String(call.params.product_id ?? "")}\0${String(call.params.pricing_option_id ?? "")}`
+    );
+  }
+  return void 0;
+}
+function bindSeededFixture(spec, bindings) {
+  if (spec.entityType === "product") {
+    bindings.bindProduct(spec.handle, spec.handle);
+    return { product_id: spec.handle };
+  }
+  const parent = spec.parentProductHandle;
+  bindings.bindPricingOption(parent, spec.handle, spec.handle);
+  return { product_id: bindings.productId(parent) ?? parent, pricing_option_id: spec.handle };
+}
+async function executeLegacySeedCall(client, storyboard, call, options, context, seedContext) {
+  const started = Date.now();
+  try {
+    const raw = await (0, import_test_controller.callControllerRaw)(
+      client,
+      { scenario: call.scenario, params: call.params, context: seedContext },
+      options
+    );
+    const data = raw.data;
+    if (raw.success && data?.success === true) {
+      return {
+        step: {
+          storyboard_id: storyboard.id,
+          step_id: call.step_id,
+          phase_id: CONTROLLER_SEEDING_PHASE_ID,
+          title: call.title,
+          task: "comply_test_controller",
+          passed: true,
+          duration_ms: Date.now() - started,
+          validations: [],
+          context,
+          extraction: { path: "none" }
+        }
+      };
+    }
+    const unknown = raw.success && data?.success === false && data.error === "UNKNOWN_SCENARIO";
+    const detail = unknown ? `fixture_unsatisfied: ${call.scenario} is unavailable and no alternate strategy is declared` : formatControllerError(call.scenario, raw, data);
+    return {
+      step: {
+        storyboard_id: storyboard.id,
+        step_id: call.step_id,
+        phase_id: CONTROLLER_SEEDING_PHASE_ID,
+        title: call.title,
+        task: "comply_test_controller",
+        passed: unknown,
+        ...unknown && {
+          skipped: true,
+          skip_reason: "fixture_unsatisfied",
+          skip: { reason: "not_applicable", detail }
+        },
+        duration_ms: Date.now() - started,
+        validations: [],
+        context,
+        extraction: { path: "none" },
+        ...!unknown && { error: detail }
+      }
+    };
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    return {
+      step: {
+        storyboard_id: storyboard.id,
+        step_id: call.step_id,
+        phase_id: CONTROLLER_SEEDING_PHASE_ID,
+        title: call.title,
+        task: "comply_test_controller",
+        passed: false,
+        duration_ms: Date.now() - started,
+        validations: [],
+        context,
+        extraction: { path: "none" },
+        error: detail
+      }
+    };
+  }
+}
+async function discoverProductCatalog(client, options, context) {
+  const contextAccount = isPlainRecord(context.account) ? context.account : void 0;
+  const baseAccount = contextAccount ?? (0, import_client.resolveAccount)(options);
+  const account = { ...baseAccount };
+  if (!("account_id" in account)) {
+    account.sandbox = options.disable_sandbox === true || options.sandbox === false ? false : true;
+  }
+  const accountBrand = isPlainRecord(account.brand) ? account.brand : void 0;
+  const brand = isPlainRecord(context.brand) ? context.brand : accountBrand ?? (0, import_client.resolveBrand)(options);
+  const products = [];
+  const seenProductIds = /* @__PURE__ */ new Set();
+  const cursors = [];
+  const seenCursors = /* @__PURE__ */ new Set();
+  let cursor;
+  let pageCount = 0;
+  do {
+    if (pageCount >= 1e3) {
+      return { ok: false, error: "fixture discovery pagination exceeded the 1,000-page safety limit" };
+    }
+    const request = {
+      buying_mode: "wholesale",
+      brand,
+      account,
+      pagination: { max_results: 100, ...cursor && { cursor } }
+    };
+    let result;
+    try {
+      result = await (0, import_task_map.executeStoryboardTask)(client, "get_products", request, { signal: options.signal });
+    } catch (err) {
+      return {
+        ok: false,
+        error: `fixture discovery transport failure: ${err instanceof Error ? err.message : String(err)}`
+      };
+    }
+    pageCount++;
+    if (!result.success) {
+      return {
+        ok: false,
+        error: `fixture discovery get_products rejected: ${result.error ?? result.adcp_error?.code ?? "unknown error"}`,
+        evidence: { page_count: pageCount, request }
+      };
+    }
+    let schemaFailure;
+    try {
+      const validator = (0, import_schema_loader.getValidator)("get_products", "sync", options.adcpVersion ?? import_version.ADCP_VERSION);
+      if (validator) {
+        const responseData = result.data;
+        const schemaData = isPlainRecord(responseData) ? (0, import_envelope_status_compat.injectLegacyEnvelopeStatus)(responseData, { toolName: "get_products" }) : responseData;
+        if (!validator(schemaData)) {
+          schemaFailure = (validator.errors ?? []).map((error) => `${error.instancePath || "/"} ${error.message ?? error.keyword}`).join("; ");
+        }
+      } else {
+        const schema = (0, import_client.validateResponseSchema)("get_products", result.data, options.adcpVersion);
+        if (!schema.passed) schemaFailure = schema.error ?? schema.details ?? "schema validation failed";
+      }
+    } catch (err) {
+      schemaFailure = `response schema unavailable: ${err instanceof Error ? err.message : String(err)}`;
+    }
+    if (schemaFailure) {
+      return {
+        ok: false,
+        error: `fixture discovery returned malformed get_products response: ${schemaFailure}`,
+        evidence: { page_count: pageCount }
+      };
+    }
+    if (!isPlainRecord(result.data)) {
+      return { ok: false, error: "fixture discovery returned a non-object get_products response" };
+    }
+    const pageProducts = result.data.products;
+    if (pageProducts !== void 0 && !Array.isArray(pageProducts)) {
+      return { ok: false, error: "fixture discovery get_products.products is not an array" };
+    }
+    for (const product of pageProducts ?? []) {
+      if (!isPlainRecord(product) || typeof product.product_id !== "string" || product.product_id.length === 0) {
+        return { ok: false, error: "fixture discovery returned a product without a non-empty product_id" };
+      }
+      if (seenProductIds.has(product.product_id)) {
+        return {
+          ok: false,
+          error: `fixture discovery returned duplicate product_id "${product.product_id}"; response order cannot resolve duplicate identities`
+        };
+      }
+      seenProductIds.add(product.product_id);
+      if (Array.isArray(product.pricing_options)) {
+        const seenPricingIds = /* @__PURE__ */ new Set();
+        for (const option of product.pricing_options) {
+          if (!isPlainRecord(option) || typeof option.pricing_option_id !== "string") continue;
+          if (seenPricingIds.has(option.pricing_option_id)) {
+            return {
+              ok: false,
+              error: `fixture discovery returned duplicate pricing option identity "${product.product_id}\0${option.pricing_option_id}"`
+            };
+          }
+          seenPricingIds.add(option.pricing_option_id);
+        }
+      }
+      products.push(product);
+      if (products.length > 1e5) {
+        return { ok: false, error: "fixture discovery exceeded the 100,000-product safety limit" };
+      }
+    }
+    const pagination = isPlainRecord(result.data.pagination) ? result.data.pagination : void 0;
+    if (pagination?.has_more === true) {
+      const next = pagination.cursor;
+      if (typeof next !== "string" || next.length === 0) {
+        return { ok: false, error: "fixture discovery pagination is broken: has_more=true without cursor" };
+      }
+      if (seenCursors.has(next)) {
+        return { ok: false, error: `fixture discovery pagination is broken: repeated cursor "${next}"` };
+      }
+      seenCursors.add(next);
+      cursors.push(next);
+      cursor = next;
+    } else {
+      cursor = void 0;
+    }
+  } while (cursor);
+  return {
+    ok: true,
+    catalog: { products, evidence: { page_count: pageCount, product_count: products.length, cursors } }
+  };
+}
+function isPlainRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function utf8Compare(a, b) {
+  return Buffer.compare(Buffer.from(a, "utf8"), Buffer.from(b, "utf8"));
+}
+function selectDiscoveredFixture(spec, products, bindings, claimedProducts, claimedPricingOptions) {
+  if (spec.entityType === "product") {
+    const candidates2 = products.filter((product2) => (0, import_fixture_resolution.matchesFixtureRequirements)(product2, spec.clauses)).filter((product2) => identityCanBeClaimed(claimedProducts, product2.product_id, spec.allowReuse)).sort((a, b) => utf8Compare(a.product_id, b.product_id));
+    const selected2 = candidates2[0];
+    if (!selected2)
+      return { ok: false, failed: false, detail: "no discovered product satisfied the authored requirements" };
+    const productId = selected2.product_id;
+    bindings.bindProduct(spec.handle, productId);
+    recordIdentityClaim(claimedProducts, productId, spec.allowReuse);
+    return {
+      ok: true,
+      boundIds: { product_id: productId },
+      detail: `selected product_id "${productId}" by UTF-8 bytewise order`
+    };
+  }
+  const parentHandle = spec.parentProductHandle;
+  const sellerProductId = bindings.productId(parentHandle);
+  if (!sellerProductId) {
+    return {
+      ok: false,
+      failed: true,
+      detail: `pricing-option discovery requires bound parent product handle "${parentHandle}"`
+    };
+  }
+  const product = products.find((candidate) => candidate.product_id === sellerProductId);
+  if (!product) {
+    return {
+      ok: false,
+      failed: true,
+      detail: `bound parent product_id "${sellerProductId}" was absent from the completed discovery catalog`
+    };
+  }
+  const options = Array.isArray(product.pricing_options) ? product.pricing_options : [];
+  const candidates = options.filter(isPlainRecord).filter((option) => typeof option.pricing_option_id === "string" && option.pricing_option_id.length > 0).filter((option) => (0, import_fixture_resolution.matchesFixtureRequirements)(option, spec.clauses)).filter((option) => {
+    const identity = `${sellerProductId}\0${option.pricing_option_id}`;
+    return identityCanBeClaimed(claimedPricingOptions, identity, spec.allowReuse);
+  }).sort(
+    (a, b) => utf8Compare(
+      `${sellerProductId}\0${a.pricing_option_id}`,
+      `${sellerProductId}\0${b.pricing_option_id}`
+    )
+  );
+  const selected = candidates[0];
+  if (!selected) {
+    return {
+      ok: false,
+      failed: false,
+      detail: "no pricing option on the bound product satisfied the authored requirements"
+    };
+  }
+  const pricingOptionId = selected.pricing_option_id;
+  bindings.bindPricingOption(parentHandle, spec.handle, pricingOptionId);
+  recordIdentityClaim(claimedPricingOptions, `${sellerProductId}\0${pricingOptionId}`, spec.allowReuse);
+  return {
+    ok: true,
+    boundIds: { product_id: sellerProductId, pricing_option_id: pricingOptionId },
+    detail: `selected pricing option "${sellerProductId}\0${pricingOptionId}" by UTF-8 bytewise order`
+  };
+}
+function identityCanBeClaimed(claims, identity, allowReuse) {
+  const existingAllowsReuse = claims.get(identity);
+  return existingAllowsReuse === void 0 || existingAllowsReuse && allowReuse;
+}
+function recordIdentityClaim(claims, identity, allowReuse) {
+  claims.set(identity, (claims.get(identity) ?? true) && allowReuse);
+}
 function storyboardCorrelationPrefix(storyboard) {
   for (const phase of storyboard.phases) {
     for (const step of phase.steps) {