@insiderfinance/totalfinance 0.1.0

package/modules/scenarios/dist/run.js

@@ -0,0 +1,933 @@
+import { CONVENTIONS_VERSION, ErrorCode, InputError, QuantError, UnsupportedError, } from '../../core/dist/index.js';
+import { contentHash, marketSnapshotContentHash, readMarketSnapshot, readScenarioSet, scenarioSetContentHash, } from '../../core/dist/artifacts/index.js';
+import { requirementKey, validateMarketRequirement, } from '../../core/dist/pricing.js';
+import { taylorPnl } from '../../risk/dist/index.js';
+import { buildScenarioAggregates } from './aggregates.js';
+import { convertReportingValue, convertScenarioPositionValues, prepareCurrencyPlan, transformCurrencyPlan, } from './fx.js';
+import { failureSnapshotWorkLimit, snapshotScenarioFailure, throwScenarioFailure, } from './internal/failures.js';
+import { checkedAdd, deepFreezeDetached, describeInputValue, detachCanonicalData, detachProvenCanonicalData, readPlainArrayLength, scanCanonicalData, snapshotDenseArray, } from './internal/data.js';
+import { detachPricingResult, detachTaylorResult } from './internal/results.js';
+import { resolveBuiltInRequirement, resolveRequirementSet, reservedCoordinateCount, } from './market-resolution.js';
+import { validateScenarioTarget } from './targets.js';
+import { instructionMatchKey, MILLISECONDS_PER_YEAR, transformFullRevaluationScenarios, } from './transform.js';
+import { transformTaylorScenarios, validateTaylorBaseCoherence, } from './taylor.js';
+import { DEFAULT_MAXIMUM_VALUATION_CELLS, DEFAULT_MAXIMUM_WORK_UNITS, HARD_MAXIMUM_VALUATION_CELLS, HARD_MAXIMUM_WORK_UNITS, MAXIMUM_REQUIREMENTS_PER_TARGET, assertWithinLiveReservation, callbackObservationWorkLimit, estimateBarrierB, metric, runBarrierA, } from './work.js';
+function requestFailure(message, code, context, cause) {
+    throw new InputError(`runScenarios: ${message}`, {
+        code,
+        context: { function: 'runScenarios', ...context },
+        ...(cause !== undefined ? { cause } : {}),
+    });
+}
+function validateStaticInstructions(scenarioSet) {
+    for (let scenarioIndex = 0; scenarioIndex < scenarioSet.scenarios.length; scenarioIndex++) {
+        const scenario = scenarioSet.scenarios[scenarioIndex];
+        for (let instructionIndex = 0; instructionIndex < (scenario.overrides?.length ?? 0); instructionIndex++) {
+            const instruction = scenario.overrides[instructionIndex];
+            if (instruction.factor === 'time' && instruction.target !== undefined) {
+                requestFailure('time is global and an override may not name target.', ErrorCode.InputOutOfRange, {
+                    scenarioIndex,
+                    scenarioName: scenario.name,
+                    phase: 'override',
+                    instructionIndex,
+                    target: instruction.target,
+                });
+            }
+        }
+        for (let instructionIndex = 0; instructionIndex < scenario.shocks.length; instructionIndex++) {
+            const instruction = scenario.shocks[instructionIndex];
+            if (instruction.factor !== 'time')
+                continue;
+            if (instruction.target !== undefined) {
+                requestFailure('time is global and a shock may not name target.', ErrorCode.InputOutOfRange, {
+                    scenarioIndex,
+                    scenarioName: scenario.name,
+                    phase: 'shock',
+                    instructionIndex,
+                    target: instruction.target,
+                });
+            }
+            if (instruction.kind === 'percent') {
+                requestFailure('percent time shocks are undefined; use an absolute signed ACT/365F year shift.', ErrorCode.InputOutOfRange, { scenarioIndex, scenarioName: scenario.name, phase: 'shock', instructionIndex });
+            }
+        }
+    }
+}
+function validateTargetIdentities(targets) {
+    const seen = new Map();
+    for (let targetIndex = 0; targetIndex < targets.length; targetIndex++) {
+        const id = targets[targetIndex].descriptor.id;
+        const first = seen.get(id);
+        if (first !== undefined) {
+            requestFailure(`targets[${targetIndex}].id duplicates targets[${first}].id (${JSON.stringify(id)}); target IDs must be unique within one run.`, ErrorCode.InputOutOfRange, { field: `targets[${targetIndex}].id`, targetId: id, firstTargetIndex: first, targetIndex });
+        }
+        seen.set(id, targetIndex);
+    }
+}
+function validateSeedDomain(barrier, targets) {
+    const hasSeededPricer = targets.some((target) => target.descriptor.valuationMethod === 'full-revaluation' &&
+        target.descriptor.pricer.capabilities.randomness === 'seeded');
+    if (hasSeededPricer && barrier.seed === null) {
+        requestFailure('options.seed is required because at least one target pricer declares randomness: seeded.', ErrorCode.InputMissingField, { field: 'options.seed' });
+    }
+    if (barrier.seed !== null &&
+        targets.length > 0 &&
+        barrier.seed > Number.MAX_SAFE_INTEGER - (targets.length - 1)) {
+        requestFailure(`options.seed + targets.length - 1 exceeds Number.MAX_SAFE_INTEGER (${barrier.seed} + ${targets.length - 1}); use a smaller seed or split the run.`, ErrorCode.InputOutOfRange, { field: 'options.seed', seed: barrier.seed, targetCount: targets.length });
+    }
+    return hasSeededPricer;
+}
+function callSupports(binding, descriptor) {
+    let answer;
+    try {
+        answer = binding.pricer.supports(binding.instrument);
+    }
+    catch (error) {
+        requestFailure(`pricer ${descriptor.pricer.name}@${descriptor.pricer.version} threw from its one supports call for target ${JSON.stringify(descriptor.id)}.`, ErrorCode.PricerNonconformant, { targetId: descriptor.id, stage: 'supports', pricer: descriptor.pricer }, error);
+    }
+    if (answer === false) {
+        throw new UnsupportedError(`runScenarios: pricer ${descriptor.pricer.name}@${descriptor.pricer.version} does not support target ${JSON.stringify(descriptor.id)}. Bind the instrument to a pricer whose supports() returns true.`, {
+            code: ErrorCode.ScenarioTargetUnsupported,
+            context: { function: 'runScenarios', targetId: descriptor.id, pricer: descriptor.pricer },
+        });
+    }
+    if (answer !== true) {
+        requestFailure(`pricer ${descriptor.pricer.name}@${descriptor.pricer.version} returned ${describeInputValue(answer)} from supports for target ${JSON.stringify(descriptor.id)}; only literal true or false is conformant.`, ErrorCode.PricerNonconformant, { targetId: descriptor.id, stage: 'supports', received: typeof answer });
+    }
+}
+function callRequirements(binding, descriptor, maximumDescriptorWorkUnits) {
+    let raw;
+    try {
+        raw = binding.pricer.requirements(binding.instrument);
+    }
+    catch (error) {
+        requestFailure(`pricer ${descriptor.pricer.name}@${descriptor.pricer.version} threw from its one requirements call for target ${JSON.stringify(descriptor.id)}.`, ErrorCode.PricerNonconformant, { targetId: descriptor.id, stage: 'requirements', pricer: descriptor.pricer }, error);
+    }
+    let requirementCount;
+    try {
+        requirementCount = readPlainArrayLength(raw, 'runScenarios', `requirements(${descriptor.id})`);
+    }
+    catch (error) {
+        requestFailure(`pricer ${descriptor.pricer.name}@${descriptor.pricer.version} requirements for target ${JSON.stringify(descriptor.id)} must return a plain dense array.`, ErrorCode.PricerNonconformant, { targetId: descriptor.id, stage: 'requirements' }, error);
+    }
+    if (requirementCount > MAXIMUM_REQUIREMENTS_PER_TARGET) {
+        requestFailure(`target ${JSON.stringify(descriptor.id)} declares ${requirementCount} market requirements; the hard maximum is ${MAXIMUM_REQUIREMENTS_PER_TARGET}. Split the instrument or use a table handle instead of an unbounded descriptor list.`, ErrorCode.InputOutOfRange, { targetId: descriptor.id, requirementCount });
+    }
+    const members = snapshotDenseArray(raw, 'runScenarios', `requirements(${descriptor.id})`);
+    const requirements = [];
+    const workUnitsByRequirement = [];
+    const seen = new Map();
+    let workUnits = 0;
+    for (let requirementIndex = 0; requirementIndex < members.length; requirementIndex++) {
+        const member = members[requirementIndex];
+        const memberWorkUnits = scanCanonicalData(member, {
+            functionName: 'runScenarios',
+            label: `requirements(${descriptor.id})[${requirementIndex}]`,
+            maximumDepth: 64,
+            maximumWorkUnits: maximumDescriptorWorkUnits - workUnits,
+            requireFiniteNumbers: true,
+        });
+        workUnits = checkedAdd('runScenarios', 'requirement descriptor work', workUnits, memberWorkUnits);
+        workUnitsByRequirement.push(memberWorkUnits);
+        const validated = validateMarketRequirement('runScenarios', `requirements(${descriptor.id})[${requirementIndex}]`, member);
+        const key = requirementKey(validated);
+        const first = seen.get(key);
+        if (first !== undefined) {
+            requestFailure(`target ${JSON.stringify(descriptor.id)} declares duplicate requirement ${key} at indices ${first} and ${requirementIndex}; optional and required forms identify the same coordinate.`, ErrorCode.PricerRequirementInvalid, {
+                targetId: descriptor.id,
+                requirement: key,
+                firstRequirementIndex: first,
+                requirementIndex,
+            });
+        }
+        seen.set(key, requirementIndex);
+        requirements.push(detachProvenCanonicalData(validated));
+    }
+    return {
+        requirements: Object.freeze(requirements),
+        workUnits,
+        workUnitsByRequirement: Object.freeze(workUnitsByRequirement),
+    };
+}
+function prepareTargets(barrier, market, validatedTargets, currencyPlan) {
+    const prepared = [];
+    const supportsReserve = validatedTargets.filter(({ descriptor }) => descriptor.valuationMethod === 'full-revaluation').length;
+    const fixedPreBarrierBWork = checkedAdd('runScenarios', 'pre-Barrier-B fixed work', checkedAdd('runScenarios', 'pre-Barrier-B input and cells', barrier.inputDataWorkUnits, barrier.valuationCells), supportsReserve);
+    let requirementDescriptorWork = 0;
+    for (let targetIndex = 0; targetIndex < validatedTargets.length; targetIndex++) {
+        const validated = validatedTargets[targetIndex];
+        const descriptor = validated.descriptor;
+        const effectiveSeed = descriptor.valuationMethod === 'full-revaluation' &&
+            descriptor.pricer.capabilities.randomness === 'seeded'
+            ? barrier.seed + targetIndex
+            : null;
+        if (descriptor.valuationMethod === 'taylor') {
+            validateTaylorBaseCoherence(descriptor, market);
+            prepared.push({
+                kind: 'taylor',
+                targetIndex,
+                validated,
+                descriptor,
+                binding: null,
+                effectiveSeed,
+                requirements: Object.freeze([]),
+                requirementDescriptorWorkUnits: 0,
+                coordinateCount: Object.keys(descriptor.taylor.factors).length,
+                unresolvedRequirementCount: 0,
+                usedForeignExchangeCoordinates: currencyPlan.targetCoordinateCounts[targetIndex],
+                resolverReturnDataWorkReserve: 0,
+                handlerReturnDataWorkLimit: 0,
+            });
+            continue;
+        }
+        const binding = validated.binding;
+        if (binding === null) {
+            requestFailure(`full-revaluation target ${JSON.stringify(descriptor.id)} has no behavior binding.`, ErrorCode.InputWrongShape, { targetId: descriptor.id });
+        }
+        callSupports(binding, descriptor);
+        const remainingRequirementWork = barrier.maximumWorkUnits - fixedPreBarrierBWork - requirementDescriptorWork;
+        if (remainingRequirementWork <= 0) {
+            requestFailure('options.maximumWorkUnits is exhausted before all requirement descriptors can be validated.', ErrorCode.InputOutOfRange, { stage: 'requirements', targetId: descriptor.id });
+        }
+        const declared = callRequirements(binding, descriptor, remainingRequirementWork);
+        requirementDescriptorWork = checkedAdd('runScenarios', 'all requirement descriptor work', requirementDescriptorWork, declared.workUnits);
+        let coordinateCount = 0;
+        let unresolvedRequirementCount = 0;
+        let resolverReturnDataWorkReserve = 0;
+        let handlerReturnDataWorkLimit = 64;
+        const requirementResultWorkLimits = [];
+        for (let requirementIndex = 0; requirementIndex < declared.requirements.length; requirementIndex++) {
+            const requirement = declared.requirements[requirementIndex];
+            const resolution = resolveBuiltInRequirement(requirement, market, descriptor);
+            const reservedCoordinates = reservedCoordinateCount(requirement, resolution);
+            coordinateCount += reservedCoordinates;
+            const resultWorkLimit = callbackObservationWorkLimit(declared.workUnitsByRequirement[requirementIndex], reservedCoordinates);
+            requirementResultWorkLimits.push(resultWorkLimit);
+            handlerReturnDataWorkLimit = checkedAdd('runScenarios', 'handler result work limit', handlerReturnDataWorkLimit, resultWorkLimit);
+            if (resolution.status === 'unavailable') {
+                unresolvedRequirementCount++;
+                resolverReturnDataWorkReserve = checkedAdd('runScenarios', 'resolver result work reserve', resolverReturnDataWorkReserve, resultWorkLimit * barrier.resolvers.length);
+            }
+        }
+        prepared.push({
+            kind: 'full-revaluation',
+            targetIndex,
+            validated,
+            descriptor,
+            binding,
+            effectiveSeed,
+            requirements: declared.requirements,
+            requirementDescriptorWorkUnits: declared.workUnits,
+            coordinateCount,
+            unresolvedRequirementCount,
+            usedForeignExchangeCoordinates: currencyPlan.targetCoordinateCounts[targetIndex],
+            resolverReturnDataWorkReserve,
+            handlerReturnDataWorkLimit,
+            requirementResultWorkLimits: Object.freeze(requirementResultWorkLimits),
+        });
+    }
+    return Object.freeze(prepared);
+}
+function precomputeRuntime(prepared, barrier, market, scenarioSet, counters) {
+    const runtime = [];
+    for (const target of prepared) {
+        if (target.kind === 'taylor') {
+            const transformed = transformTaylorScenarios({
+                target: target.descriptor,
+                scenarioDefinitions: scenarioSet.scenarios,
+            });
+            counters.transformationWorkUnits += transformed.transformationWorkUnits;
+            runtime.push({ ...target, transformed });
+            continue;
+        }
+        const resolved = resolveRequirementSet({
+            requirements: target.requirements,
+            market,
+            target: target.descriptor,
+            resolvers: barrier.resolvers,
+            maximumResultWorkUnits: target.requirementResultWorkLimits,
+        });
+        counters.resolverCalls += resolved.resolverCalls;
+        if (resolved.coordinateCount > target.coordinateCount) {
+            requestFailure(`resolver results expanded target ${JSON.stringify(target.descriptor.id)} from ${target.coordinateCount} reserved coordinates to ${resolved.coordinateCount}.`, ErrorCode.InputOutOfRange, { targetId: target.descriptor.id, stage: 'resolver-result-shape' });
+        }
+        const transformed = transformFullRevaluationScenarios({
+            target: target.descriptor,
+            baseObservations: resolved.observations,
+            scenarioDefinitions: scenarioSet.scenarios,
+            factorHandlers: barrier.factorHandlers,
+            maximumHandlerResultWorkUnits: target.handlerReturnDataWorkLimit,
+        });
+        counters.factorHandlerCalls += transformed.handlerCalls;
+        // The settled Barrier-B formula charges callback dispatches separately and transformation
+        // work in observation/factor/curve coordinates. Canonical callback-return scans enforce the
+        // reserved shape but are not re-added as a second, incompatible cost unit here.
+        counters.transformationWorkUnits +=
+            resolved.returnedDataWorkUnits +
+                transformed.transformationWorkUnits +
+                transformed.returnedDataWorkUnits;
+        runtime.push({ ...target, resolved, transformed });
+    }
+    return Object.freeze(runtime);
+}
+function mergeMatchedInstructions(runtime, currencyTransformation) {
+    const matched = new Set(currencyTransformation.matchedInstructions);
+    for (const target of runtime) {
+        for (const key of target.transformed.matchedInstructions)
+            matched.add(key);
+    }
+    return matched;
+}
+function assertEveryInstructionMatched(scenarioSet, matched) {
+    for (let scenarioIndex = 0; scenarioIndex < scenarioSet.scenarios.length; scenarioIndex++) {
+        const scenario = scenarioSet.scenarios[scenarioIndex];
+        for (let instructionIndex = 0; instructionIndex < (scenario.overrides?.length ?? 0); instructionIndex++) {
+            const instruction = scenario.overrides[instructionIndex];
+            if (!matched.has(instructionMatchKey(scenarioIndex, 'override', instructionIndex))) {
+                throw new InputError(`runScenarios: scenario ${JSON.stringify(scenario.name)} override[${instructionIndex}] (${instruction.factor}${instruction.target === undefined ? '' : ` target=${instruction.target}`}) matched no used observation, Taylor factor, reporting-currency quote, or custom handler. Fix the factor/target typo or remove the instruction.`, {
+                    code: ErrorCode.ScenarioInstructionUnmatched,
+                    context: {
+                        function: 'runScenarios',
+                        scenarioIndex,
+                        scenarioName: scenario.name,
+                        phase: 'override',
+                        instructionIndex,
+                        factor: instruction.factor,
+                        ...(instruction.target !== undefined ? { target: instruction.target } : {}),
+                    },
+                });
+            }
+        }
+        for (let instructionIndex = 0; instructionIndex < scenario.shocks.length; instructionIndex++) {
+            const instruction = scenario.shocks[instructionIndex];
+            if (!matched.has(instructionMatchKey(scenarioIndex, 'shock', instructionIndex))) {
+                throw new InputError(`runScenarios: scenario ${JSON.stringify(scenario.name)} shock[${instructionIndex}] (${instruction.factor}${instruction.target === undefined ? '' : ` target=${instruction.target}`}) matched no used observation, Taylor factor, reporting-currency quote, or custom handler. Fix the factor/target typo or remove the instruction.`, {
+                    code: ErrorCode.ScenarioInstructionUnmatched,
+                    context: {
+                        function: 'runScenarios',
+                        scenarioIndex,
+                        scenarioName: scenario.name,
+                        phase: 'shock',
+                        instructionIndex,
+                        factor: instruction.factor,
+                        ...(instruction.target !== undefined ? { target: instruction.target } : {}),
+                    },
+                });
+            }
+        }
+    }
+}
+function finiteCellNumber(value, field, coordinates) {
+    if (!Number.isFinite(value)) {
+        throw new QuantError(`runScenarios: ${field} for target ${JSON.stringify(coordinates.targetId)} is not representable as a finite number.`, {
+            code: ErrorCode.ScenarioCellFailed,
+            context: { function: 'runScenarios', stage: 'position-scaling', field, ...coordinates },
+        });
+    }
+    return value;
+}
+function positionValue(valuePerUnit, target, coordinates) {
+    return finiteCellNumber(valuePerUnit * target.quantity * target.contractMultiplier, 'positionValue', coordinates);
+}
+function mergeAppliedInstructions(first, second) {
+    return Object.freeze([...first, ...second].sort((left, right) => {
+        const phase = left.phase === right.phase ? 0 : left.phase === 'override' ? -1 : 1;
+        return phase !== 0 ? phase : left.instructionIndex - right.instructionIndex;
+    }));
+}
+function attemptCell(coordinates, failureMode, counters, failures, task) {
+    try {
+        const value = task();
+        counters.successfulCells++;
+        return { status: 'complete', value };
+    }
+    catch (cause) {
+        const failure = snapshotScenarioFailure(cause, coordinates);
+        const failureWork = scanCanonicalData(failure, {
+            functionName: 'runScenarios',
+            label: 'scenario failure snapshot',
+            maximumDepth: 32,
+            maximumWorkUnits: failureSnapshotWorkLimit(coordinates),
+            requireFiniteNumbers: true,
+        });
+        counters.failureSnapshotWorkUnits += failureWork;
+        if (failureMode === 'fail-fast')
+            throwScenarioFailure(failure, cause);
+        failures.push(failure);
+        counters.failedCells++;
+        return { status: 'failed', failure };
+    }
+}
+function commonSuccessFields(input) {
+    return {
+        targetIndex: input.target.targetIndex,
+        targetId: input.target.descriptor.id,
+        quantity: input.target.descriptor.quantity,
+        contractMultiplier: input.target.descriptor.contractMultiplier,
+        valuationCurrency: input.target.descriptor.currency,
+        reportingCurrency: input.reportingCurrency,
+        valuePerUnit: input.valuePerUnit,
+        positionValue: input.positionValue,
+        reportingPositionValue: input.reportingPositionValue,
+        currencyConversion: input.currencyConversion,
+        observationOrFactorSetHash: input.observationOrFactorSetHash,
+        appliedInstructions: input.appliedInstructions,
+        resolvers: input.resolvers,
+        factorHandlers: input.factorHandlers,
+        effectiveSeed: input.target.effectiveSeed,
+    };
+}
+function buildAxes(scenarioSet, targets) {
+    const scenarioAxis = scenarioSet.scenarios.map((scenario, scenarioIndex) => detachCanonicalData({
+        scenarioIndex,
+        name: scenario.name,
+        scenarioHash: contentHash(scenario),
+        overrideCount: scenario.overrides?.length ?? 0,
+        shockCount: scenario.shocks.length,
+    }, {
+        functionName: 'runScenarios',
+        label: `scenarioAxis[${scenarioIndex}]`,
+        requireFiniteNumbers: true,
+    }));
+    const targetAxis = targets.map((target, targetIndex) => detachCanonicalData({ ...target.descriptor, targetIndex }, {
+        functionName: 'runScenarios',
+        label: `targetAxis[${targetIndex}]`,
+        requireFiniteNumbers: true,
+    }));
+    return { scenarioAxis: Object.freeze(scenarioAxis), targetAxis: Object.freeze(targetAxis) };
+}
+const CELL_ENVELOPE_EXCLUDED_KEYS = new Set([
+    'pricingResult',
+    'taylorResult',
+    'failure',
+    'blockedByBaseFailure',
+    'appliedInstructions',
+    'resolvers',
+    'factorHandlers',
+]);
+function retainedCellWork(cell) {
+    const envelope = {};
+    for (const key of Reflect.ownKeys(cell)) {
+        if (typeof key !== 'string' || CELL_ENVELOPE_EXCLUDED_KEYS.has(key))
+            continue;
+        const descriptor = Object.getOwnPropertyDescriptor(cell, key);
+        if (descriptor !== undefined && 'value' in descriptor)
+            envelope[key] = descriptor.value;
+    }
+    let instructionDetails = 0;
+    let behaviorIdentities = 0;
+    let failure = 0;
+    if (cell.status === 'complete') {
+        instructionDetails = scanCanonicalData(cell.appliedInstructions, {
+            functionName: 'runScenarios',
+            label: 'retained applied instructions',
+            requireFiniteNumbers: true,
+        });
+        behaviorIdentities =
+            scanCanonicalData(cell.resolvers, {
+                functionName: 'runScenarios',
+                label: 'retained resolver identities',
+                requireFiniteNumbers: true,
+            }) +
+                scanCanonicalData(cell.factorHandlers, {
+                    functionName: 'runScenarios',
+                    label: 'retained factor-handler identities',
+                    requireFiniteNumbers: true,
+                });
+    }
+    else {
+        const retainedFailure = cell.kind === 'base'
+            ? cell.failure
+            : cell.status === 'failed'
+                ? cell.failure
+                : cell.blockedByBaseFailure;
+        failure = scanCanonicalData(retainedFailure, {
+            functionName: 'runScenarios',
+            label: 'retained scenario failure',
+            requireFiniteNumbers: true,
+        });
+    }
+    return {
+        envelope: scanCanonicalData(envelope, {
+            functionName: 'runScenarios',
+            label: 'retained result cell envelope',
+            requireFiniteNumbers: true,
+        }),
+        instructionDetails,
+        behaviorIdentities,
+        failure,
+    };
+}
+function scenarioCoordinates(target, scenarioIndex, scenarioName) {
+    return {
+        targetIndex: target.targetIndex,
+        targetId: target.descriptor.id,
+        scenarioIndex,
+        scenarioName,
+        valuationMethod: target.descriptor.valuationMethod,
+    };
+}
+/** Run one validated ScenarioSet over heterogeneous builder-owned targets and one market snapshot. */
+export function runScenarios(rawInput) {
+    const barrier = runBarrierA(rawInput);
+    const { scenarioSet } = readScenarioSet({ scenarioSet: barrier.rawScenarioSet });
+    const { snapshot: market } = readMarketSnapshot({ snapshot: barrier.rawMarket });
+    if (scenarioSet.scenarios.length !== barrier.scenarioCount ||
+        barrier.rawTargets.length !== barrier.targetCount) {
+        requestFailure('the validated input axes drifted after Barrier A; do not mutate a request while runScenarios is executing.', ErrorCode.InputWrongShape, { stage: 'post-read-axis-check' });
+    }
+    validateStaticInstructions(scenarioSet);
+    const validatedTargets = barrier.rawTargets.map((target, targetIndex) => validateScenarioTarget(target, targetIndex));
+    validateTargetIdentities(validatedTargets);
+    const hasSeededPricer = validateSeedDomain(barrier, validatedTargets);
+    const currencyPlan = prepareCurrencyPlan({
+        reportingCurrency: barrier.reportingCurrency,
+        currencyConversions: barrier.rawCurrencyConversions,
+        targets: validatedTargets.map((target) => target.descriptor),
+    });
+    const prepared = prepareTargets(barrier, market, validatedTargets, currencyPlan);
+    const estimate = estimateBarrierB({
+        barrierA: barrier,
+        scenarioSet,
+        targets: prepared,
+        reportingCurrency: currencyPlan.reportingCurrency,
+    });
+    const counters = {
+        pricerCalls: 0,
+        taylorCalls: 0,
+        resolverCalls: 0,
+        factorHandlerCalls: 0,
+        transformationWorkUnits: 0,
+        valuationResultWorkUnits: 0,
+        failureSnapshotWorkUnits: 0,
+        successfulCells: 0,
+        failedCells: 0,
+        blockedCells: 0,
+    };
+    const runtime = precomputeRuntime(prepared, barrier, market, scenarioSet, counters);
+    const currencyTransformation = transformCurrencyPlan({
+        plan: currencyPlan,
+        scenarioDefinitions: scenarioSet.scenarios,
+    });
+    counters.transformationWorkUnits += currencyTransformation.transformationWorkUnits;
+    assertEveryInstructionMatched(scenarioSet, mergeMatchedInstructions(runtime, currencyTransformation));
+    assertWithinLiveReservation(counters.transformationWorkUnits, estimate.transformationReserve, 'transformationWorkUnits');
+    const { scenarioAxis, targetAxis } = buildAxes(scenarioSet, runtime);
+    const failures = [];
+    const base = [];
+    for (const target of runtime) {
+        const coordinates = scenarioCoordinates(target, null, null);
+        const attempted = attemptCell(coordinates, barrier.failureMode, counters, failures, () => {
+            const conversion = currencyPlan.conversionsByTarget[target.targetIndex];
+            if (target.kind === 'full-revaluation') {
+                counters.pricerCalls++;
+                const raw = target.binding.pricer.price({
+                    instrument: target.binding.instrument,
+                    observations: target.resolved.observations,
+                    ...(target.effectiveSeed !== null ? { request: { seed: target.effectiveSeed } } : {}),
+                });
+                const detached = detachPricingResult(raw, coordinates);
+                counters.valuationResultWorkUnits += detached.workUnits;
+                const valuePerUnit = detached.result.value;
+                const localPositionValue = positionValue(valuePerUnit, target.descriptor, coordinates);
+                const reportingPositionValue = convertReportingValue({
+                    amount: localPositionValue,
+                    valuationCurrency: target.descriptor.currency,
+                    reportingCurrency: currencyPlan.reportingCurrency,
+                    currencyConversion: conversion,
+                });
+                return {
+                    kind: 'base',
+                    status: 'complete',
+                    ...commonSuccessFields({
+                        target,
+                        valuePerUnit,
+                        positionValue: localPositionValue,
+                        reportingPositionValue,
+                        reportingCurrency: currencyPlan.reportingCurrency,
+                        currencyConversion: conversion,
+                        observationOrFactorSetHash: contentHash(target.resolved.observations),
+                        appliedInstructions: Object.freeze([]),
+                        resolvers: target.resolved.resolvers,
+                        factorHandlers: Object.freeze([]),
+                    }),
+                    valuationMethod: 'full-revaluation',
+                    pricer: target.descriptor.pricer,
+                    pricingResult: detached.result,
+                };
+            }
+            const valuePerUnit = target.descriptor.taylor.baseValuePerUnit;
+            const localPositionValue = positionValue(valuePerUnit, target.descriptor, coordinates);
+            const reportingPositionValue = convertReportingValue({
+                amount: localPositionValue,
+                valuationCurrency: target.descriptor.currency,
+                reportingCurrency: currencyPlan.reportingCurrency,
+                currencyConversion: conversion,
+            });
+            return {
+                kind: 'base',
+                status: 'complete',
+                ...commonSuccessFields({
+                    target,
+                    valuePerUnit,
+                    positionValue: localPositionValue,
+                    reportingPositionValue,
+                    reportingCurrency: currencyPlan.reportingCurrency,
+                    currencyConversion: conversion,
+                    observationOrFactorSetHash: target.transformed.baseFactorSetHash,
+                    appliedInstructions: Object.freeze([]),
+                    resolvers: Object.freeze([]),
+                    factorHandlers: Object.freeze([]),
+                }),
+                valuationMethod: 'taylor',
+                baseValueSource: 'supplied-base-value-per-unit',
+            };
+        });
+        if (attempted.status === 'complete')
+            base.push(attempted.value);
+        else {
+            base.push({
+                kind: 'base',
+                status: 'failed',
+                targetIndex: target.targetIndex,
+                targetId: target.descriptor.id,
+                valuationMethod: target.descriptor.valuationMethod,
+                valuePerUnit: null,
+                positionValue: null,
+                reportingPositionValue: null,
+                failure: attempted.failure,
+            });
+        }
+    }
+    const cells = [];
+    for (let scenarioIndex = 0; scenarioIndex < scenarioSet.scenarios.length; scenarioIndex++) {
+        const scenario = scenarioSet.scenarios[scenarioIndex];
+        const fxScenario = currencyTransformation.scenarios[scenarioIndex];
+        for (const target of runtime) {
+            const baseCell = base[target.targetIndex];
+            const coordinates = scenarioCoordinates(target, scenarioIndex, scenario.name);
+            if (baseCell.status === 'failed') {
+                counters.blockedCells++;
+                cells.push({
+                    kind: 'scenario',
+                    status: 'blocked',
+                    targetIndex: target.targetIndex,
+                    targetId: target.descriptor.id,
+                    scenarioIndex,
+                    scenarioName: scenario.name,
+                    valuationMethod: target.descriptor.valuationMethod,
+                    valuePerUnit: null,
+                    positionValue: null,
+                    reportingPositionValue: null,
+                    localPnl: null,
+                    reportingPnl: null,
+                    blockedByBaseFailure: baseCell.failure,
+                });
+                continue;
+            }
+            const attempted = attemptCell(coordinates, barrier.failureMode, counters, failures, () => {
+                const scenarioConversion = fxScenario.conversionsByTarget[target.targetIndex];
+                const baseConversion = currencyPlan.conversionsByTarget[target.targetIndex];
+                const fxInstructions = fxScenario.appliedInstructionsByTarget[target.targetIndex];
+                if (target.kind === 'full-revaluation') {
+                    const transformed = target.transformed.scenarios[scenarioIndex];
+                    counters.pricerCalls++;
+                    const raw = target.binding.pricer.price({
+                        instrument: target.binding.instrument,
+                        observations: transformed.observations,
+                        ...(target.effectiveSeed !== null ? { request: { seed: target.effectiveSeed } } : {}),
+                    });
+                    const detached = detachPricingResult(raw, coordinates);
+                    counters.valuationResultWorkUnits += detached.workUnits;
+                    const valuePerUnit = detached.result.value;
+                    const localPositionValue = positionValue(valuePerUnit, target.descriptor, coordinates);
+                    const localPnl = finiteCellNumber(localPositionValue - baseCell.positionValue, 'localPnl', coordinates);
+                    const converted = convertScenarioPositionValues({
+                        basePositionValue: baseCell.positionValue,
+                        scenarioPositionValue: localPositionValue,
+                        valuationCurrency: target.descriptor.currency,
+                        reportingCurrency: currencyPlan.reportingCurrency,
+                        baseCurrencyConversion: baseConversion,
+                        scenarioCurrencyConversion: scenarioConversion,
+                    });
+                    return {
+                        kind: 'scenario',
+                        status: 'complete',
+                        scenarioIndex,
+                        scenarioName: scenario.name,
+                        localPnl,
+                        reportingPnl: converted.reportingPnl,
+                        ...commonSuccessFields({
+                            target,
+                            valuePerUnit,
+                            positionValue: localPositionValue,
+                            reportingPositionValue: converted.scenarioReportingPositionValue,
+                            reportingCurrency: currencyPlan.reportingCurrency,
+                            currencyConversion: scenarioConversion,
+                            observationOrFactorSetHash: contentHash(transformed.observations),
+                            appliedInstructions: mergeAppliedInstructions(transformed.appliedInstructions, fxInstructions),
+                            resolvers: target.resolved.resolvers,
+                            factorHandlers: transformed.factorHandlers,
+                        }),
+                        valuationMethod: 'full-revaluation',
+                        pricer: target.descriptor.pricer,
+                        pricingResult: detached.result,
+                    };
+                }
+                const transformed = target.transformed.scenarios[scenarioIndex];
+                const greekInput = {
+                    value: target.descriptor.taylor.baseValuePerUnit,
+                    ...(target.descriptor.taylor.factors.spot !== undefined
+                        ? { spot: target.descriptor.taylor.factors.spot.level }
+                        : {}),
+                    ...target.descriptor.taylor.sensitivities,
+                };
+                counters.taylorCalls++;
+                const detached = detachTaylorResult(taylorPnl(greekInput, transformed.scenario), coordinates);
+                counters.valuationResultWorkUnits += detached.workUnits;
+                const valuePerUnit = finiteCellNumber(target.descriptor.taylor.baseValuePerUnit + detached.result.total, 'valuePerUnit', coordinates);
+                const localPositionValue = positionValue(valuePerUnit, target.descriptor, coordinates);
+                const localPnl = finiteCellNumber(localPositionValue - baseCell.positionValue, 'localPnl', coordinates);
+                const converted = convertScenarioPositionValues({
+                    basePositionValue: baseCell.positionValue,
+                    scenarioPositionValue: localPositionValue,
+                    valuationCurrency: target.descriptor.currency,
+                    reportingCurrency: currencyPlan.reportingCurrency,
+                    baseCurrencyConversion: baseConversion,
+                    scenarioCurrencyConversion: scenarioConversion,
+                });
+                return {
+                    kind: 'scenario',
+                    status: 'complete',
+                    scenarioIndex,
+                    scenarioName: scenario.name,
+                    localPnl,
+                    reportingPnl: converted.reportingPnl,
+                    ...commonSuccessFields({
+                        target,
+                        valuePerUnit,
+                        positionValue: localPositionValue,
+                        reportingPositionValue: converted.scenarioReportingPositionValue,
+                        reportingCurrency: currencyPlan.reportingCurrency,
+                        currencyConversion: scenarioConversion,
+                        observationOrFactorSetHash: transformed.factorSetHash,
+                        appliedInstructions: mergeAppliedInstructions(transformed.appliedInstructions, fxInstructions),
+                        resolvers: Object.freeze([]),
+                        factorHandlers: Object.freeze([]),
+                    }),
+                    valuationMethod: 'taylor',
+                    taylorResult: detached.result,
+                };
+            });
+            if (attempted.status === 'complete')
+                cells.push(attempted.value);
+            else {
+                cells.push({
+                    kind: 'scenario',
+                    status: 'failed',
+                    targetIndex: target.targetIndex,
+                    targetId: target.descriptor.id,
+                    scenarioIndex,
+                    scenarioName: scenario.name,
+                    valuationMethod: target.descriptor.valuationMethod,
+                    valuePerUnit: null,
+                    positionValue: null,
+                    reportingPositionValue: null,
+                    localPnl: null,
+                    reportingPnl: null,
+                    failure: attempted.failure,
+                });
+            }
+        }
+    }
+    const aggregates = buildScenarioAggregates({
+        targets: targetAxis,
+        scenarioAxis,
+        base,
+        cells,
+        reportingCurrency: currencyPlan.reportingCurrency,
+    });
+    const requirementCount = prepared.reduce((sum, target) => sum + target.requirements.length, 0);
+    const requirementWork = prepared.reduce((sum, target) => sum + target.requirementDescriptorWorkUnits, 0);
+    assertWithinLiveReservation(counters.valuationResultWorkUnits, estimate.valuationResultReserve, 'valuationResultWorkUnits');
+    let resultEnvelopeActual = base.length + cells.length;
+    let instructionDetailActual = 0;
+    let failureSnapshotActual = failures.length;
+    for (const cell of [...base, ...cells]) {
+        const retained = retainedCellWork(cell);
+        resultEnvelopeActual = checkedAdd('runScenarios', 'retained result envelope work', resultEnvelopeActual, retained.envelope + retained.behaviorIdentities);
+        instructionDetailActual = checkedAdd('runScenarios', 'retained instruction detail work', instructionDetailActual, retained.instructionDetails);
+        failureSnapshotActual = checkedAdd('runScenarios', 'retained failure work', failureSnapshotActual, retained.failure);
+    }
+    for (const failure of failures) {
+        failureSnapshotActual = checkedAdd('runScenarios', 'diagnostic failure retention work', failureSnapshotActual, scanCanonicalData(failure, {
+            functionName: 'runScenarios',
+            label: 'diagnostic failure retention',
+            requireFiniteNumbers: true,
+        }));
+    }
+    assertWithinLiveReservation(resultEnvelopeActual, estimate.resultEnvelopeReserve, 'resultEnvelopeWorkUnits');
+    assertWithinLiveReservation(instructionDetailActual, estimate.instructionDetailReserve, 'instructionDetailWorkUnits');
+    assertWithinLiveReservation(failureSnapshotActual, estimate.failureSnapshotReserve, 'failureSnapshotWorkUnits');
+    const axisActual = scanCanonicalData({ scenarioAxis, targetAxis }, {
+        functionName: 'runScenarios',
+        label: 'result axes',
+        requireFiniteNumbers: true,
+    });
+    const aggregateActual = scanCanonicalData(aggregates, {
+        functionName: 'runScenarios',
+        label: 'result aggregates',
+        requireFiniteNumbers: true,
+    });
+    assertWithinLiveReservation(axisActual, estimate.axisReserve, 'axisWorkUnits');
+    assertWithinLiveReservation(aggregateActual, estimate.aggregateResultReserve, 'aggregateResultWorkUnits');
+    const resolverIdentities = barrier.resolvers.map((resolver) => resolver.identity);
+    const handlerIdentities = barrier.factorHandlers.map((handler) => handler.identity);
+    const replayParameters = {
+        reportingCurrency: currencyPlan.reportingCurrency,
+        currencyConversions: currencyPlan.currencyConversions,
+        failureMode: barrier.failureMode,
+        seed: barrier.seed,
+        maximumValuationCells: barrier.maximumValuationCells,
+        maximumWorkUnits: barrier.maximumWorkUnits,
+        resolvers: resolverIdentities,
+        factorHandlers: handlerIdentities,
+        timeShockDayCount: 'ACT/365F',
+        millisecondsPerYear: MILLISECONDS_PER_YEAR,
+        resultLayout: 'scenario-major-v1',
+    };
+    const layout = {
+        order: 'scenario-major-v1',
+        targetCount: runtime.length,
+        scenarioCount: scenarioSet.scenarios.length,
+        cellsPerScenario: runtime.length,
+        cellCount: cells.length,
+        indexFormula: 'scenarioIndex * targetCount + targetIndex',
+    };
+    const assumptions = {
+        conventionsVersion: CONVENTIONS_VERSION,
+        scenarioSetName: scenarioSet.name,
+        scenarioSetHash: scenarioSetContentHash(scenarioSet),
+        marketSnapshotHash: marketSnapshotContentHash(market),
+        marketAsOf: market.asOf,
+        inputRateDayCount: market.conventions.dayCount ?? null,
+        inputRateCompounding: market.conventions.compounding ?? null,
+        resolvedScalarRateDayCount: 'ACT/365F',
+        resolvedScalarRateCompounding: 'continuous',
+        reportingCurrency: currencyPlan.reportingCurrency,
+        currencyConversionPolicy: 'direct-or-inverse-only',
+        tagAggregationPolicy: 'overlapping-non-additive; grand total is target-based',
+        valuationUnitScaling: 'valuePerUnit * quantity * contractMultiplier',
+        timeShockDayCount: 'ACT/365F',
+        millisecondsPerYear: MILLISECONDS_PER_YEAR,
+        failureMode: barrier.failureMode,
+        baseSeed: hasSeededPricer ? barrier.seed : null,
+        seedDerivation: hasSeededPricer
+            ? 'seed + targetIndex; common across base and scenarios'
+            : null,
+        resolvers: resolverIdentities,
+        factorHandlers: handlerIdentities,
+        resultLayout: 'scenario-major-v1',
+        workBudgets: {
+            valuationCells: {
+                configured: barrier.maximumValuationCells,
+                default: DEFAULT_MAXIMUM_VALUATION_CELLS,
+                hardMaximum: HARD_MAXIMUM_VALUATION_CELLS,
+            },
+            workUnits: {
+                configured: barrier.maximumWorkUnits,
+                default: DEFAULT_MAXIMUM_WORK_UNITS,
+                hardMaximum: HARD_MAXIMUM_WORK_UNITS,
+            },
+        },
+        replayParameters,
+    };
+    const metricsFor = (totalActual) => ({
+        valuationCells: metric(barrier.valuationCells, barrier.valuationCells),
+        pricerCalls: metric(estimate.estimatedPricerCalls, counters.pricerCalls),
+        taylorCalls: metric(estimate.estimatedTaylorCalls, counters.taylorCalls),
+        supportsCalls: metric(estimate.supportsDispatches, estimate.supportsDispatches),
+        requirements: metric(requirementCount, requirementCount),
+        resolverCalls: metric(estimate.resolverDispatches, counters.resolverCalls),
+        factorHandlerCalls: metric(estimate.handlerDispatches, counters.factorHandlerCalls),
+        inputDataWorkUnits: metric(barrier.inputDataWorkUnits, barrier.inputDataWorkUnits),
+        transformationWorkUnits: metric(estimate.transformationReserve, counters.transformationWorkUnits),
+        valuationResultWorkUnits: metric(estimate.valuationResultReserve, counters.valuationResultWorkUnits),
+        resultEnvelopeWorkUnits: metric(estimate.resultEnvelopeReserve, resultEnvelopeActual),
+        failureSnapshotWorkUnits: metric(estimate.failureSnapshotReserve, failureSnapshotActual),
+        totalWorkUnits: metric(estimate.workUnits, totalActual),
+        successfulCells: metric(barrier.valuationCells, counters.successfulCells),
+        failedCells: metric(0, counters.failedCells),
+        blockedCells: metric(0, counters.blockedCells),
+    });
+    const metadataActual = scanCanonicalData({
+        layout,
+        scenarioAxis: [],
+        targetAxis: [],
+        base: [],
+        cells: [],
+        aggregates: {},
+        assumptions,
+        diagnostics: {
+            warnings: currencyPlan.warnings,
+            failures: [],
+            unusedCurrencyConversions: currencyPlan.unusedCurrencyConversions,
+            metrics: metricsFor(0),
+        },
+    }, {
+        functionName: 'runScenarios',
+        label: 'ScenarioRunResult metadata',
+        maximumDepth: 64,
+        maximumWorkUnits: estimate.resultMetadataReserve,
+        requireFiniteNumbers: true,
+    });
+    assertWithinLiveReservation(metadataActual, estimate.resultMetadataReserve, 'resultMetadataWorkUnits');
+    const totalActual = barrier.inputDataWorkUnits +
+        requirementWork +
+        barrier.valuationCells +
+        estimate.supportsDispatches +
+        estimate.requirementsDispatches +
+        counters.resolverCalls +
+        counters.factorHandlerCalls +
+        failureSnapshotActual +
+        counters.valuationResultWorkUnits +
+        resultEnvelopeActual +
+        instructionDetailActual +
+        counters.transformationWorkUnits +
+        axisActual +
+        aggregateActual +
+        metadataActual;
+    assertWithinLiveReservation(totalActual, estimate.workUnits, 'totalWorkUnits');
+    const metrics = metricsFor(totalActual);
+    const result = {
+        layout,
+        scenarioAxis,
+        targetAxis,
+        base: Object.freeze(base),
+        cells: Object.freeze(cells),
+        aggregates,
+        assumptions,
+        diagnostics: {
+            warnings: currencyPlan.warnings,
+            failures: Object.freeze(failures),
+            unusedCurrencyConversions: currencyPlan.unusedCurrencyConversions,
+            metrics,
+        },
+    };
+    const retainedResultReserve = estimate.valuationResultReserve +
+        estimate.failureSnapshotReserve +
+        estimate.resultEnvelopeReserve +
+        estimate.instructionDetailReserve +
+        estimate.aggregateResultReserve +
+        estimate.axisReserve +
+        estimate.resultMetadataReserve;
+    scanCanonicalData(result, {
+        functionName: 'runScenarios',
+        label: 'ScenarioRunResult',
+        maximumDepth: 64,
+        maximumWorkUnits: retainedResultReserve,
+        requireFiniteNumbers: true,
+    });
+    return deepFreezeDetached(result);
+}
+//# sourceMappingURL=run.js.map